csdareamethod.cpp

能在MDT5/6环境下对已经存在地曲面进行全部和局部区域展开

	pnts2d1[2] = pnts1[2].convert2d(pln1);
	// 曲面上点正交投影到平面上转化为平面坐标
	pnts2d1[3] = op.orthoProject(pln1).convert2d(pln1);
	mpnts1[0] = dPntArr[i*(nV+1)+j];
	mpnts1[1] = dPntArr[(i+1)*(nV+1)+j];
	mpnts1[2] = dPntArr[i*(nV+1)+j+1];
	bMapped = mapPointTriangle(pnts2d1,mpnts1,true);
	dp = mpnts1[3];

	return bMapped;
}

// 映射右上三角形内的点到展开平面
bool CSDAreaISO::mapRightUpToD(int posu,int posv, const AcGePoint3d& op, AcGePoint2d& dp)
{
	AcGePoint3dArray pnts1;
	AcGePoint2dArray pnts2d1,mpnts1;
	AcGePlane pln1;
	bool bMapped=false;
	
	pnts1.setLogicalLength(3);
	pnts2d1.setLogicalLength(4);
	mpnts1.setLogicalLength(4);
	
	int i,j;
	i = posu;
	j = posv;
	
	// 由P(i,j+1)P(i+1,j)P(i+1,j+1)三点组成的空间三角形pnts，转换成平面三角形pnts1
	pnts1[0] = oPntArr[i*(nV+1)+j+1];
	pnts1[1] = oPntArr[(i+1)*(nV+1)+j];
	pnts1[2] = oPntArr[(i+1)*(nV+1)+j+1];
	
	getPlaneFrom3Pnts(pnts1,pln1); // 得到平面
	pnts2d1[0] = pnts1[0].convert2d(pln1);
	pnts2d1[1] = pnts1[1].convert2d(pln1);
	pnts2d1[2] = pnts1[2].convert2d(pln1);
	// 曲面上点正交投影到平面上转化为平面坐标
	pnts2d1[3] = op.orthoProject(pln1).convert2d(pln1);
	mpnts1[0] = dPntArr[i*(nV+1)+j+1];
	mpnts1[1] = dPntArr[(i+1)*(nV+1)+j];
	mpnts1[2] = dPntArr[(i+1)*(nV+1)+j+1];
	bMapped = mapPointTriangle(pnts2d1,mpnts1,true);
	dp = mpnts1[3];
	
	return bMapped;
}


// 映射左下三角形内的点到原始平面
bool CSDAreaISO::mapLeftBottToO(int posu,int posv, const AcGePoint2d& dp, AcGePoint3d& op)
{
	bool bMapped;
	AcGePoint3dArray mpnts1;
	AcGePoint2dArray mpnts2d1,pnts1;
	AcGePlane pln1;
	int i,j;

	pnts1.setLogicalLength(4);
	mpnts2d1.setLogicalLength(4);
	mpnts1.setLogicalLength(3);
	i = posu;		j = posv;

	// 由P(i,j)P(i+1,j)P(i,j+1)三点组成的平面三角形pnts
	pnts1[0] = dPntArr[i*(nV+1)+j];
	pnts1[1] = dPntArr[(i+1)*(nV+1)+j];
	pnts1[2] = dPntArr[i*(nV+1)+j+1];
	pnts1[3] = dp;
	mpnts1[0] = oPntArr[i*(nV+1)+j];
	mpnts1[1] = oPntArr[(i+1)*(nV+1)+j];
	mpnts1[2] = oPntArr[i*(nV+1)+j+1];
	getPlaneFrom3Pnts(mpnts1,pln1); // 得到平面
	mpnts2d1[0] = mpnts1[0].convert2d(pln1);
	mpnts2d1[1] = mpnts1[1].convert2d(pln1);
	mpnts2d1[2] = mpnts1[2].convert2d(pln1);

	bMapped = mapPointTriangle(pnts1,mpnts2d1,true);
	op.set(pln1,mpnts2d1[3]);		// 将得到的映射点转换成空间点坐标
	op = oBaseSurf.closestPointTo(op);
	
	return bMapped;
}

// 映射右上三角形内的点到原始平面
bool CSDAreaISO::mapRightUpToO(int posu,int posv, const AcGePoint2d& dp, AcGePoint3d& op)
{
	bool bMapped;
	AcGePoint3dArray mpnts1;
	AcGePoint2dArray mpnts2d1,pnts1;
	AcGePlane pln1;
	int i,j;
	
	pnts1.setLogicalLength(4);
	mpnts2d1.setLogicalLength(4);
	mpnts1.setLogicalLength(3);
	i = posu;		j = posv;
	
	// 由P(i,j+1)P(i+1,j)P(i+1,j+1)三点组成的平面三角形pnts
	pnts1[0] = dPntArr[i*(nV+1)+j+1];
	pnts1[1] = dPntArr[(i+1)*(nV+1)+j];
	pnts1[2] = dPntArr[(i+1)*(nV+1)+j+1];
	pnts1[3] = dp;
	mpnts1[0] = oPntArr[i*(nV+1)+j+1];
	mpnts1[1] = oPntArr[(i+1)*(nV+1)+j];
	mpnts1[2] = oPntArr[(i+1)*(nV+1)+j+1];
	getPlaneFrom3Pnts(mpnts1,pln1); // 得到平面
	mpnts2d1[0] = mpnts1[0].convert2d(pln1);
	mpnts2d1[1] = mpnts1[1].convert2d(pln1);
	mpnts2d1[2] = mpnts1[2].convert2d(pln1);
	
	bMapped = mapPointTriangle(pnts1,mpnts2d1,true);
	op.set(pln1,mpnts2d1[3]);		// 将得到的映射点转换成空间点坐标
	op = oBaseSurf.closestPointTo(op);
	
	return bMapped;
}

bool CSDAreaISO::mapPointToD(const AcGePoint3d& op3d,AcGePoint2d& dp)
{
	if (!oSurfLoops.length()) return false;
	
	AcGePoint3d op;
	op = oBaseSurf.closestPointTo(op3d);

	// 重合点时映射
	if (nSingularity) {
		if (op.isEqualTo(oSingularity)) {
			dp = dSingularity;
			return true;
		}
	}
	
	AcGePoint2d param;
	double paramUStep, paramVStep;
	int i,j,posU,posV;
	bool uEnd=false,vEnd=false;
	
	paramUStep = oEvalU.length()/nU;
	paramVStep = oEvalV.length()/nV;
	oBaseSurf.isOn(op,param);
//	param = oBaseSurf.paramOf(op);
	
	posU = int((param.x-oEvalU.lowerBound())/paramUStep);
	posV = int((param.y-oEvalV.lowerBound())/paramVStep);
	
	if (posU<0) posU = 0;
	if (posU>nU) posU = nU;
	if (posV<0) posV = 0;
	if (posV>nV) posV = nV;

//	if (posU<0 || posU>nU || posV<0 || posV>nV) return false;
	
	if (oPntArr[posU*(nV+1)+posV].isEqualTo(op)) {
		dp = dPntArr[posU*(nV+1)+posV];
		return true;
	}
	
	i = posU;	j=posV;
	if (i == nU) {
		uEnd = true;
		i = i-1;
	}
	if (j == nV) {
		vEnd = true;
		j = j-1;
	}
	
	// 点在空间四边形P(i,j)P(i+1,j)P(i+1,j+1)P(i,j+1)上

	// 重合计算
	if ((i==0 && nSingularity==4) || (j==0 && nSingularity==1)) {
		// U=0 为奇异边（退化为一点）或V=0 为奇异边
		// 此时应该使用右上三角形进行计算
		mapRightUpToD(i,j,op,dp);
		return true;
	}

	if ((i==nU-1 && nSingularity==2) || (j==nV-1 && nSingularity==3)) {
		// U=nU 为奇异边（退化为一点）或V=0 为奇异边
		// 此时应该使用左下三角形进行计算
		mapLeftBottToD(i,j,op,dp);
		return true;
	}

	bool bMapped;
	if( !(uEnd || vEnd) ) {
		// 由P(i,j)P(i+1,j)P(i,j+1)三点组成的空间三角形pnts，转换成平面三角形pnts1
		bMapped = mapLeftBottToD(i,j,op,dp);
		if (bMapped) return true;
	}

	// 由P(i,j+1)P(i+1,j)P(i+1,j+1)三点组成的空间三角形pnts，转换成平面三角形pnts1
	AcGePoint2d dp2;
	bMapped = mapRightUpToD(i,j,op,dp2);
	if (bMapped || uEnd || vEnd) {
		dp = dp2;
	} else {
		// 由两个平面三角形代替空间四边形产生误差，故将曲面点判断为四边形外，
		// 此时认为曲面点在三角形内强制转换，分别用两个平面三角形进行，然后求平均
		dp = (dp+dp2.asVector())/2;
	}

	return true;

/*
	// 由P(i,j+1)P(i+1,j)P(i+1,j+1)三点组成的空间三角形pnts，转换成平面三角形pnts1
	pnts2[0] = oPntArr[i*(nV+1)+j+1];
	pnts2[1] = oPntArr[(i+1)*(nV+1)+j];
	pnts2[2] = oPntArr[(i+1)*(nV+1)+j+1];
	getPlaneFrom3Pnts(pnts2,pln2); // 得到平面
	pnts2d2[0] = pnts2[0].convert2d(pln2);
	pnts2d2[1] = pnts2[1].convert2d(pln2);
	pnts2d2[2] = pnts2[2].convert2d(pln2);
	// 曲面上点正交投影到平面上转化为平面坐标
	pnts2d2[3] = op.orthoProject(pln2).convert2d(pln2);
	mpnts2[0] = dPntArr[i*(nV+1)+j+1];
	mpnts2[1] = dPntArr[(i+1)*(nV+1)+j];
	mpnts2[2] = dPntArr[(i+1)*(nV+1)+j+1];
	bMapped = mapPointTriangle(pnts2d2,mpnts2);
	if(bMapped) {
		dp = mpnts2[3];
		return true;
	}		// 曲面点在三角形P(i,j+1)P(i+1,j)P(i+1,j+1)上，边上或与顶点重合
	
	// 由两个平面三角形代替空间四边形产生误差，故将曲面点判断为四边形外，
	// 此时认为曲面点在三角形内强制转换，分别用两个平面三角形进行，然后求平均
	if(uEnd || vEnd) {
		mapPointInTriangle(pnts2d2,mpnts2);
		dp = mpnts2[3];
	} else {
		mapPointInTriangle(pnts2d1,mpnts1);
		mapPointInTriangle(pnts2d2,mpnts2);
		dp = (mpnts1[3]+mpnts2[3].asVector())/2.0;
	}
	
	return true;
*/
}


bool CSDAreaISO::mapPointsToD(const AcGePoint3dArray& oc,AcGePoint2dArray& dc,bool bIfForcedMap)
{
	if (!oSurfLoops.length()) return false;
	bool suc=false;
	int i,len;

	dc.setLogicalLength(0);
	len = oc.length();
	AcGePoint2d dummy;
	for(i=0;i<len;i++) {
		suc = mapPointToD(oc[i],dummy);
		if (suc) {
			dc.append(dummy);
		} else {
			if (!bIfForcedMap) {
				dc.setLogicalLength(0);
				return false;
			}
		}
	}

	return true;
}


bool CSDAreaISO::mapPointsToD(const AcGePoint3dArray& oc,AcGePoint3dArray& dc,bool bIfForcedMap)
{
	if (!oSurfLoops.length()) return false;
	bool suc=false;
	int i,len;

	dc.setLogicalLength(0);
	len = oc.length();
	AcGePoint3d dummy;
	for(i=0;i<len;i++) {
		suc = mapPointToD(oc[i],dummy);
		if (suc) {
			dc.append(dummy);
		} else {
			if (!bIfForcedMap) {
				dc.setLogicalLength(0);
				return false;
			}
		}
	}
	return true;
}


bool CSDAreaISO::mapPointToO(const AcGePoint3d& dp,AcGePoint3d& op)
{
	AcGePoint2d dp2d;
	dp2d = AcGePoint2d(dp.x,dp.y);
	return mapPointToO(dp2d,op);
}

bool CSDAreaISO::mapPointToO(const AcGePoint2d& dp,AcGePoint3d& op)
{
	if (!oSurfLoops.length()) return false;

	AcGePoint3d dp3d(dp.x,dp.y,dCenterZ);
	dp3d = dBaseSurf.closestPointTo(dp3d);
	if (nSingularity) {
		AcGePoint2d dp2d(dp3d.x,dp3d.y);
		if (dp2d.isEqualTo(dSingularity) || dp.isEqualTo(dSingularity)) {
			op = oSingularity;
			return true;
		}
	}

	int i,j,posU,posV;
	AcGePoint2d param;
	AcGeInterval intrv;
	dBaseSurf.isOn(dp3d,param);
//	param = dBaseSurf.paramOf(dp3d);
	posU = dBaseSurfParamU.getInterval(1,param.x,intrv);
	posV = dBaseSurfParamV.getInterval(1,param.y,intrv);

	AcGePoint2dArray pnts,pnts22;
	AcGePolyline2d curve,curve2;
//	AcGeNurbCurve2d curve,curve2;
	pnts.setLogicalLength(nV+1);
	j = posU;
	for (i=0; i<nV+1; i++) {
		pnts[i] = dPntArr[j*(nV+1)+i];
	}
	curve = AcGePolyline2d(pnts);
	if (isOnCurve(dp,curve,dTol)) {
		posU = j;
	} else if (isClockwise(dp,curve)) {
		do {
			j++;
			if (j==nU && nSingularity==2) break; // 具有奇异性时
			if (j>nU) break;
			for (i=0; i<nV+1; i++) {
				pnts[i] = dPntArr[j*(nV+1)+i];
			}
			curve = AcGePolyline2d(pnts);
			if (isOnCurve(dp,curve,dTol) || !isClockwise(dp,curve)) {
				posU = j-1;
				break;
			}			
		} while(true);
	} else {
		do {
			j--;
			if (j==0 && nSingularity==4) break; // 具有奇异性时
			if (j<0) break;
			for (i=0; i<nV+1; i++) {
				pnts[i] = dPntArr[j*(nV+1)+i];
			}
			curve = AcGePolyline2d(pnts);
			if (isOnCurve(dp,curve,dTol) || isClockwise(dp,curve)) {
				posU = j;
				break;
			}			
		} while(true);
	}

	pnts22.setLogicalLength(nU+1);
	i = posV;
	for (j=0; j<nU+1; j++) {
		pnts22[j] = dPntArr[j*(nV+1)+i];
	}
	curve2 = AcGePolyline2d(pnts22);
	if (isOnCurve(dp,curve2,dTol)) {
		posV = i;
	} else if (isClockwise(dp,curve2)) {
		do {
			i--;
			if (i==0 && nSingularity==1) break; // 具有奇异性时
			if (i<0) break;
			for (j=0; j<nU+1; j++) {
				pnts22[j] = dPntArr[j*(nV+1)+i];
			}
			curve2 = AcGePolyline2d(pnts22);
			if (isOnCurve(dp,curve2,dTol) || !isClockwise(dp,curve2)) {
				posV = i;
				break;
			}			
		} while(true);
	} else {
		do {
			i++;
			if (i==nV && nSingularity==3) break; // 具有奇异性时
			if (i>nV) break;
			for (j=0; j<nU+1; j++) {
				pnts22[j] = dPntArr[j*(nV+1)+i];
			}
			curve2 = AcGePolyline2d(pnts22);
			if (isOnCurve(dp,curve2,dTol)) {
				posV = i;
			} else if (isClockwise(dp,curve2)) {
				posV = i-1;
				break;
			}
		} while(true);
	}

	bool uEnd=false,vEnd=false;
	bool uStart=false,vStart=false;

	// v=0
	if (nSingularity!=1 && (posV<2)) {
		pnts22.setLogicalLength(nU+1);
		for (j=0; j<nU+1; j++) {
			pnts22[j] = dPntArr[j*(nV+1)];
		}
		curve2 = AcGePolyline2d(pnts22);
		if (isOnCurve(dp,curve2,dTol)) {
			vStart = true;
			posV = 0;
		}
	}
	// 奇异边 u=nU
	if (nSingularity!=2 && (posU>nU-2)) {
		pnts22.setLogicalLength(nV+1);
		for (j=0; j<nV+1; j++) {
			pnts22[j] = dPntArr[nU*(nV+1)+j];
		}
		curve2 = AcGePolyline2d(pnts22);
		if (isOnCurve(dp,curve2,dTol)) {
			uEnd = true;
			posU = nU-1;
		}
		if (posU == nU) {
			posU = nU-1;
		}
	}
	// v=nV
	if (nSingularity!=3 && (posV>nV-2)) {
		pnts22.setLogicalLength(nU+1);
		for (j=0; j<nU+1; j++) {
			pnts22[j] = dPntArr[j*(nV+1)+nV];
		}
		curve2 = AcGePolyline2d(pnts22);
		if (isOnCurve(dp,curve2,dTol)) {
			vEnd = true;
			posV = nV-1;
		}
		if (posV == nV) {
			posV = nV-1;
		}
	}
	// 奇异边 u=0
	if (nSingularity!=4 && (posU>nU-2)) {
		pnts22.setLogicalLength(nV+1);
		for (j=0; j<nV+1; j++) {
			pnts22[j] = dPntArr[j];
		}
		curve2 = AcGePolyline2d(pnts22);
		if (isOnCurve(dp,curve2,dTol)) {
			uStart = true;
			posU = 0;