任意对象最小包容块

思路：通过在XYZ三坐标个维度下旋转坐标，并以该坐标创建零件的包容盒，取包容盒体积最小的那个结果，（优点是可以非常精确，缺点是UF_MODL_ask_bounding_box_exatc这个函数效率不高，需要尽量减少调用次数） 

//第一版，频繁改变坐标在大图档中效率很低
//核心::获取最小包容块
void ProductFunnel::getMinBoundingBox(tag_t objTag){
	UF_initialize();
	//记录工作坐标的起始位置
	if(startWcsTag==NULL_TAG){
		UF_CSYS_ask_wcs(&startWcsTag);
	}else{
		//将工作坐标设置到绝对坐标
		setWcsToAbs();
	}
	//.for循环，循环条件正负0到90度角，获取指定旋转轴下的最小包容块体积
		//获取当前工作坐标的矩阵参数和原点
		tag_t wcsTag=NULL;
		UF_CSYS_ask_wcs(&wcsTag);
		tag_t wcsMatrixTag=NULL_TAG;;
		double wcsOrigin[3];
		UF_CSYS_ask_csys_info(wcsTag,&wcsMatrixTag,wcsOrigin);
		double wcsMatrixVal[9]={0};
		UF_CSYS_ask_matrix_values(wcsMatrixTag,wcsMatrixVal);
	
		//minBoxMatrixVal[9]存储最小包容块参考坐标系的矩阵--初始化为工作坐标系的矩阵
		double minBoxMatrixVal[9]={wcsMatrixVal[0],wcsMatrixVal[1],wcsMatrixVal[2],wcsMatrixVal[3],wcsMatrixVal[4],wcsMatrixVal[5],wcsMatrixVal[6],wcsMatrixVal[7],wcsMatrixVal[8]};
		
		//开关
		int flag[3]={1,1,1};
		//循环
		int i=0;
		while(true){

			i=i%3;
			
			if(flag[0]||flag[1]||flag[2]){
					
					//计算最小包容块
					for(double n=90;n>=0.001;n/=10){

						rotateM2(flag,minBoxMatrixVal,wcsOrigin,objTag,i,n);
					}

					//关闭当前开关
					flag[i]=0;
				
			}else{
				
				break;
			}
			i++;
		}

		
	//3.创建包容块
		createBlock(minBoxMatrixVal,objTag);
	//4.清空容器
		minBoxV.clear();


		

		UF_terminate();
}
//按指定坐标创建目标对象的包容块,返回包容块的体积
double ProductFunnel::createBoundingBox(tag_t csysTag,tag_t objTag){
	
	double min_corner [ 3 ] ;
	double directions [ 3 ] [ 3 ] ;
	double distances [ 3 ];

	UF_MODL_ask_bounding_box_exact(objTag,csysTag,min_corner,directions,distances);
	distances[0]=distances[0]<1?1:distances[0];
	distances[1]=distances[1]<1?1:distances[1];
	distances[2]=distances[2]<1?1:distances[2];
	return distances[0]*distances[1]*distances[2];
}
//刺探最佳旋转方向
double ProductFunnel::isClockwise (double minBoxMatrixVal[9],double wcsOrigin[3],double rotateCsysAxis[3],tag_t objTag,double angle){
	//通过minBoxMatrixVal[9]-创建旋转坐标
	tag_t minBoxMatrixTag=NULL_TAG;
	UF_CSYS_create_matrix(minBoxMatrixVal,&minBoxMatrixTag);
	tag_t rotateCsysTag=NULL_TAG;
	double rotateCsysOrigin[3]={wcsOrigin[0],wcsOrigin[1],wcsOrigin[2]};
	UF_CSYS_create_temp_csys(rotateCsysOrigin,minBoxMatrixTag,&rotateCsysTag);
	
	double vol1= createBoundingBox(rotateCsysTag,objTag);

	double degrees_rotation=angle/100.0;
	double matrix[12];
	int status1=0;
	uf5945(rotateCsysOrigin,rotateCsysAxis,&degrees_rotation,matrix,&status1);

	//变换矩阵
	tag_t objects [] ={rotateCsysTag};
	int  n_objects=1;
	int  move_or_copy=1;
	int  dest_layer=0;
	int  trace_curves=2;
	tag_t  copies=NULL_TAG;
	tag_t  trace_curve_group=NULL_TAG;
	int  status2=0;
	uf5947(matrix,objects,&n_objects,&move_or_copy,&dest_layer,&trace_curves,&copies,&trace_curve_group,&status2);

	//获取rotateCsysTag坐标下包容块的体积
	double vol2= createBoundingBox(rotateCsysTag,objTag);

	if((vol2-vol1)>0.001){
		return -1;
	}

	return 1;	
}
//微调模块
void  ProductFunnel::rotateM2(int flag[3],double minBoxMatrixVal[9],double wcsOrigin[3],tag_t objTag,int i,double angle){
	//通过minBoxMatrixVal[9]-创建旋转坐标
	tag_t minBoxMatrixTag=NULL_TAG;
	UF_CSYS_create_matrix(minBoxMatrixVal,&minBoxMatrixTag);
	tag_t rotateCsysTag=NULL_TAG;
	double rotateCsysOrigin[3]={wcsOrigin[0],wcsOrigin[1],wcsOrigin[2]};
	UF_CSYS_create_temp_csys(rotateCsysOrigin,minBoxMatrixTag,&rotateCsysTag);
	//旋转坐标轴
	double rotateCsysAxis[3][3]={{minBoxMatrixVal[0],minBoxMatrixVal[1],minBoxMatrixVal[2]},{minBoxMatrixVal[3],minBoxMatrixVal[4],minBoxMatrixVal[5]},{minBoxMatrixVal[6],minBoxMatrixVal[7],minBoxMatrixVal[8]}};
	
	//刺探最优旋转方向
	double degrees_rotation=(angle/10)*isClockwise(minBoxMatrixVal,wcsOrigin,rotateCsysAxis[i],objTag,angle);
// 	test0("degrees_rotation::");
// 	test1(degrees_rotation);
	for(double j=0;j<angle;j+=(angle/10)){

		//绕指定轴旋转矩阵

		
		double matrix[12];
		int status1=0;
		uf5945(rotateCsysOrigin,rotateCsysAxis[i],&degrees_rotation,matrix,&status1);

		//变换矩阵
		tag_t objects [ ] ={rotateCsysTag};
		int  n_objects=1;
		int  move_or_copy=1;
		int  dest_layer=0;
		int  trace_curves=2;
		tag_t  copies=NULL_TAG;
		tag_t  trace_curve_group=NULL_TAG;
		int  status2=0;
		uf5947(matrix,objects,&n_objects,&move_or_copy,&dest_layer,&trace_curves,&copies,&trace_curve_group,&status2);

		//获取rotateCsysTag坐标下包容块的体积
		double vol1= createBoundingBox(rotateCsysTag,objTag);
		//test1(vol1);
		if(minBoxV.size()==0){
			minBoxV.push_back(vol1);

		}else if((minBoxV.back()-vol1)>0.001){
			
			//开启所有开关
			flag[0]=1;
			flag[1]=1;
			flag[2]=1;

			//保存更小的包容块体积
			minBoxV.push_back(vol1);
			//保存最小包容块的参考坐标矩阵
			tag_t tempMatrixTag=NULL_TAG;
			double tempOrigin[3];
			UF_CSYS_ask_csys_info(rotateCsysTag,&tempMatrixTag,tempOrigin);
			//变换minBoxMatrixVal为最小包容块的参考坐标矩阵
			UF_CSYS_ask_matrix_values(tempMatrixTag,minBoxMatrixVal);
			//test3(minBoxMatrixVal);

		}else{
			break;
		}
	}
}
//.创建包容块
void ProductFunnel::createBlock(double minBoxMatrixVal[9],tag_t objTag){
	//根据minBoxMatrixVal创建临时坐标
	tag_t minMatrixTag=NULL_TAG;
	UF_CSYS_create_matrix(minBoxMatrixVal,&minMatrixTag);
	
	tag_t minBoxCsysTag=NULL_TAG;
	double origin1[3]={10,10,0};

	UF_CSYS_create_temp_csys(origin1,minMatrixTag,&minBoxCsysTag);
	
	double min_corner [ 3 ] ;
	double directions [ 3 ] [ 3 ] ;
	double distances [ 3 ];
	char *edges[3];

	UF_MODL_ask_bounding_box_exact(objTag,minBoxCsysTag,min_corner,directions,distances);
	
	//限制包容块长宽高的最小长度为1
 	distances[0]=distances[0]<1?1:distances[0];
 	distances[1]=distances[1]<1?1:distances[1];
 	distances[2]=distances[2]<1?1:distances[2];
	
	//数据类型转换
	char b1[256];
	sprintf(b1,"%f",distances[0]);
	edges[0]=b1;
	char b2[256];
	sprintf(b2,"%f",distances[1]);
	edges[1]=b2;
	char b3[256];
	sprintf(b3,"%f",distances[2]);
	edges[2]=b3;	
	double min_corner2[3];
	UF_CSYS_map_point(UF_CSYS_ROOT_COORDS ,min_corner,UF_CSYS_WORK_COORDS ,min_corner2);
	//设置工作坐标
	UF_CSYS_set_origin(minBoxCsysTag,min_corner2);
	UF_CSYS_set_wcs(minBoxCsysTag);
	
	//初始化
	if(minBlockTag1!=NULL_TAG){
		UF_OBJ_delete_object(minBlockTag1);
	}
	minBlockTag1=NULL_TAG;
	UF_MODL_create_block1(UF_NULLSIGN,min_corner2,edges,&minBlockTag1);
	tag_t bodyTag11=NULL_TAG;
	UF_MODL_ask_feat_body(minBlockTag1,&bodyTag11);
	UF_OBJ_set_color(bodyTag11,108);
	UF_OBJ_set_translucency(bodyTag11,70);

	//加载漏斗
	//获取最长边
	
	double orientation1[9];
	 maxEdge=distances[0]>distances[1]?(distances[0]>distances[2]?distances[0]:distances[2]):(distances[1]>distances[2]?distances[1]:distances[2]);
	if(maxEdge==distances[0]){

		double basePoint1[3]={distances[0]/2,0,0};

		//动态坐标原点--wcs
		modelPoint[0]=basePoint1[0];
		modelPoint[1]=basePoint1[1];
		modelPoint[2]=basePoint1[2];

		double basePoint2[3];
		UF_CSYS_map_point(UF_CSYS_ROOT_WCS_COORDS ,basePoint1,UF_CSYS_WORK_COORDS ,basePoint2);
		Point3d basePoint3(basePoint2[0],basePoint2[1],basePoint2[2]);
		Matrix3x3 orientation1(minBoxMatrixVal[3],minBoxMatrixVal[4],minBoxMatrixVal[5],-minBoxMatrixVal[0],-minBoxMatrixVal[1],-minBoxMatrixVal[2],minBoxMatrixVal[6],minBoxMatrixVal[7],minBoxMatrixVal[8]);
		
		addPart(basePoint3,orientation1);
	}else if(maxEdge==distances[1]){
		double basePoint1[3]={0,distances[1]/2,0};

		//动态坐标原点--wcs
		modelPoint[0]=basePoint1[0];
		modelPoint[1]=basePoint1[1];
		modelPoint[2]=basePoint1[2];

		double basePoint2[3];
		UF_CSYS_map_point(UF_CSYS_ROOT_WCS_COORDS,basePoint1,UF_CSYS_WORK_COORDS,basePoint2);
		Point3d basePoint3(basePoint2[0],basePoint2[1],basePoint2[2]);
		Matrix3x3 orientation1(minBoxMatrixVal[0],minBoxMatrixVal[1],minBoxMatrixVal[2],minBoxMatrixVal[3],minBoxMatrixVal[4],minBoxMatrixVal[5],minBoxMatrixVal[6],minBoxMatrixVal[7],minBoxMatrixVal[8]);
		addPart(basePoint3,orientation1);
	}else if(maxEdge==distances[2]){

		double basePoint1[3]={0,0,distances[2]/2};
		//动态坐标原点--wcs
		modelPoint[0]=basePoint1[0];
		modelPoint[1]=basePoint1[1];
		modelPoint[2]=basePoint1[2];

		double basePoint2[3];
		UF_CSYS_map_point(UF_CSYS_ROOT_WCS_COORDS,basePoint1,UF_CSYS_WORK_COORDS,basePoint2);
		Point3d basePoint3(basePoint2[0],basePoint2[1],basePoint2[2]);
		Matrix3x3 orientation1(minBoxMatrixVal[0],minBoxMatrixVal[1],minBoxMatrixVal[2],minBoxMatrixVal[6],minBoxMatrixVal[7],minBoxMatrixVal[8],minBoxMatrixVal[3],minBoxMatrixVal[4],minBoxMatrixVal[5]);
		addPart(basePoint3,orientation1);
	}else{
		uc1601("woring!!",1); 
	}
//第二版，用矩阵计算代替了旋转坐标，避免了频繁改变对象的性能消耗，但是在面对几千个面的复杂对象的时候依然无法避免UF_MODL_ask_bounding_box_exact效率低的问题，目前已经将循环次数控制在40次左右但是依然需要3到4秒的计算时间
//核心::获取包容块
void ProductFunnel::getMinBoundingBox(tag_t objTag,double massCenterABS[3]){
	UF_initialize();
	//double t0=clock();
	//记录工作坐标的起始位置
	if(startWcsTag==NULL_TAG){
		UF_CSYS_ask_wcs(&startWcsTag);
	}
	//将工作坐标设置到...玄学
	setWcsTo();

	tag_t maxLengthCsysTag=NULL_TAG;
	minBoxV.push_back(1.0);
	//开关
	int flag[2]={1,1};
	//循环       
	int i=0;
	int times=0;
	while(true){
		
		i=i%2;
		//计算X轴方向最大尺寸
		if(flag[0]||flag[1]){
			for(double n=PI;n>PI/180;n/=6){
				//旋转矩阵
				rotateM3(i,flag,objTag,maxLengthCsysTag,n,times);
			}
			flag[i]=0;
		}else{
			break;
		}
		i++;
		times++;
	}
	
 	test0("count");
  	test1(count);
	count=0;
	//3.创建包容块
		createBlock(maxLengthCsysTag,objTag,massCenterABS);
	//4.清空容器
		minBoxV.clear();

		UF_terminate();
}
//旋转矩阵获取选中对象的最大尺寸
void ProductFunnel::rotateM3(int i,int flag[2],tag_t objTag,tag_t& maxLengthCsysTag,double angle,int times){
	if(maxLengthCsysTag!=NULL_TAG){
		//将工作坐标设置到当前最佳坐标轴下，开始下一轮运算
		UF_CSYS_set_wcs(maxLengthCsysTag);
	}


	double axisV[2][3]={{0,0,1},{0,1,0}};

	double v=isClockwise(maxLengthCsysTag,axisV[i],objTag,angle);
	//uc1601("ok",1);
	double d1=0;
	for(double j=(angle/6)*v;abs(j)<angle;j+=(angle/6)*v){
		count++;
		//得到工作坐标下的旋转矩阵
		double roateMtxValWCS[9];	
		UF_MTX3_rotate_about_axis(axisV[i],j,roateMtxValWCS);
		//映射成绝对坐标下的矩阵
		double roateMtxValABS[9];
		mapMatrix(roateMtxValWCS,roateMtxValABS);
		//创建临时坐标tempCsysTag
		tag_t roateMtxAbsTag=NULL_TAG;
		UF_CSYS_create_matrix(roateMtxValABS,&roateMtxAbsTag);
		tag_t tempCsysTag=NULL_TAG;
		double origin[3]={0,0,0};
		UF_CSYS_create_csys(origin,roateMtxAbsTag,&tempCsysTag);
		//获取rotateCsysTag坐标下包容块X轴方向最长尺寸
		double distance1= createBoundingBox(tempCsysTag,objTag);
		if(minBoxV.size()==0){
			
			minBoxV.push_back(distance1);
			maxLengthCsysTag=tempCsysTag;
		}else if((distance1-minBoxV.back())>0.001){
			flag[0]=1;
			flag[1]=1;
			//保存更长的x方向尺寸
			minBoxV.push_back(distance1);
			//保存最小包容块的参考坐标矩阵
			maxLengthCsysTag=tempCsysTag;
		}
		else if(times>=2){
			break;
		}

	}
}
//将矩阵从工作坐标中映射到绝对坐标
void ProductFunnel::mapMatrix(double roateMtxValWCS[9],double roateMtxValABS[9]){
	UF_initialize();
	//旋转矩阵

	double wcsMtxVal[3][3]={{roateMtxValWCS[0],roateMtxValWCS[1],roateMtxValWCS[2]},{roateMtxValWCS[3],roateMtxValWCS[4],roateMtxValWCS[5]},{roateMtxValWCS[6],roateMtxValWCS[7],roateMtxValWCS[8]}};
	double absMtxVal[3][3]={0};
	double wcsOrigin0[3]={0,0,0};
	for(int i=0;i<3;i++){
		double temp[3];
		UF_CSYS_map_point(UF_CSYS_ROOT_WCS_COORDS,wcsMtxVal[i],UF_CSYS_WORK_COORDS,temp);
		
		double wcsOrigin1[3];
		UF_CSYS_map_point(UF_CSYS_ROOT_WCS_COORDS,wcsOrigin0,UF_CSYS_WORK_COORDS,wcsOrigin1);
		absMtxVal[i][0]=temp[0]-wcsOrigin1[0];
		absMtxVal[i][1]=temp[1]-wcsOrigin1[1];
		absMtxVal[i][2]=temp[2]-wcsOrigin1[2];
	}
	 //返回映射后的矩阵
	 roateMtxValABS[0]=absMtxVal[0][0];
	 roateMtxValABS[1]=absMtxVal[0][1];
	 roateMtxValABS[2]=absMtxVal[0][2];
	 roateMtxValABS[3]=absMtxVal[1][0];
	 roateMtxValABS[4]=absMtxVal[1][1];
	 roateMtxValABS[5]=absMtxVal[1][2];
	 roateMtxValABS[6]=absMtxVal[2][0];
	 roateMtxValABS[7]=absMtxVal[2][1];
	 roateMtxValABS[8]=absMtxVal[2][2];
	UF_terminate();
}
//刺探最佳旋转方向
double ProductFunnel::isClockwise (tag_t &maxLengthCsysTag,double rotateCsysAxis[3],tag_t objTag,double angle){

	double degrees=angle/6; 
	//得到工作坐标下的旋转矩阵
	double roateMtxValWCS[9];
	UF_MTX3_rotate_about_axis(rotateCsysAxis,degrees,roateMtxValWCS);
	//映射成绝对坐标下的矩阵
	double roateMtxValABS[9];
	mapMatrix(roateMtxValWCS,roateMtxValABS);
	//创建临时坐标tempCsysTag
	tag_t roateMtxAbsTag=NULL_TAG;
	UF_CSYS_create_matrix(roateMtxValABS,&roateMtxAbsTag);
	tag_t tempCsysTag=NULL_TAG;
	double origin[3]={0,0,0};
	UF_CSYS_create_temp_csys(origin,roateMtxAbsTag,&tempCsysTag);
	//获取rotateCsysTag坐标下包容块X轴方向最长尺寸
	double distance2= createBoundingBox(tempCsysTag,objTag);
	

 	if((distance2-minBoxV.back())>0.001){
 		return 1;
 	}

	return -1;	
}