csdareamethod.cpp

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

		}
	}

	if (uStart) {
		if (vStart) {
			op = oPntArr.first();
			return true;
		}
		if (vEnd) {
			op = oPntArr[nV];
			return true;
		}
	}
	if (uEnd) {
		if (vStart) {
			op = oPntArr[nU*(nV+1)];
			return true;
		}
		if (vEnd) {
			op = oPntArr.last();
			return true;
		}
	}

	if (uStart || uEnd) {
		AcGePoint3dArray mpnts;
		AcGeLineSeg2d line;
		int pos;
		if (uStart)	pos = 0;
		else		pos = nU;
		pnts.setLogicalLength(3);
		mpnts.setLogicalLength(3);
		pnts[0] = dPntArr[pos*(nV+1)+posV];
		pnts[1] = dPntArr[pos*(nV+1)+posV+1];
		line.set(pnts[0],pnts[1]);
		pnts[2] = line.closestPointTo(dp);
		mpnts[0] = oPntArr[pos*(nV+1)+posV];
		mpnts[1] = oPntArr[pos*(nV+1)+posV+1];
		mapPointInLine(pnts,mpnts);
		op = oBaseSurf.closestPointTo(mpnts[2]);
		return true;
	}

	if (vStart || vEnd) {
		AcGePoint3dArray mpnts;
		AcGeLineSeg2d line;
		int pos;
		if (vStart) pos = 0;
		else		pos = nV;
		pnts.setLogicalLength(3);
		mpnts.setLogicalLength(3);
		pnts[0] = dPntArr[posU*(nV+1)+pos];
		pnts[1] = dPntArr[(posU+1)*(nV+1)+pos];
		line.set(pnts[0],pnts[1]);
		pnts[2] = line.closestPointTo(dp);
		mpnts[0] = oPntArr[posU*(nV+1)+pos];
		mpnts[1] = oPntArr[(posU+1)*(nV+1)+pos];
		mapPointInLine(pnts,mpnts);
		op = oBaseSurf.closestPointTo(mpnts[2]);
		return true;
	}

	if (posU==nU) posU=nU-1;
	if (posV==nV) posV=nV-1;

	i = posU;
	j = posV;
	
	// 点在空间四边形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 为奇异边
		// 此时应该使用右上三角形进行计算
		mapRightUpToO(i,j,dp,op);
		return true;
	}
	
	if ((i==nU-1 && nSingularity==2) || (j==nV-1 && nSingularity==3)) {
		// U=nU 为奇异边（退化为一点）或V=0 为奇异边
		// 此时应该使用左下三角形进行计算
		mapLeftBottToO(i,j,dp,op);
		return true;
	}

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

	// 由P(i,j+1)P(i+1,j)P(i+1,j+1)三点组成的平面三角形pnts
	AcGePoint3d op2;
	bMapped = mapRightUpToO(i,j,dp,op2);
	if (bMapped || uEnd || vEnd) {
		op = op2;
	} else {
		AcGePoint3dArray op3;
		AcGeDoubleArray DDists, ODists, deltas;
		op3.setLogicalLength(3);
		deltas.setLogicalLength(3);
		op3[0] = op;
		op3[1] = op2;
		op3[2] = oBaseSurf.closestPointTo((op+op2.asVector())/2);

		DDists.setLogicalLength(4);
		ODists.setLogicalLength(4);
		DDists[0] = dp.distanceTo(dPntArr[i*(nV+1)+j]);
		DDists[1] = dp.distanceTo(dPntArr[(i+1)*(nV+1)+j]);
		DDists[2] = dp.distanceTo(dPntArr[i*(nV+1)+j+1]);
		DDists[3] = dp.distanceTo(dPntArr[(i+1)*(nV+1)+j+1]);

		int k;
		for (k=0; k<2; k++) {
			ODists[0] = op3[k].distanceTo(oPntArr[i*(nV+1)+j]) - DDists[0];
			ODists[1] = op3[k].distanceTo(oPntArr[(i+1)*(nV+1)+j]) - DDists[1];
			ODists[2] = op3[k].distanceTo(oPntArr[i*(nV+1)+j+1]) - DDists[2];
			ODists[3] = op3[k].distanceTo(oPntArr[(i+1)*(nV+1)+j+1]) - DDists[3];
			deltas[k] = ODists[0]*ODists[0] + ODists[1]*ODists[1]
				+ ODists[2]*ODists[2] + ODists[3]*ODists[3];
		}
		int minIndex;
		minIndex = 0;
		if (deltas[1]<deltas[minIndex]) {
			minIndex = 1;
		}
		if (deltas[2]<deltas[minIndex]) {
			minIndex = 2;
		}

		op = op3[minIndex];
	}

	return true;
}

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

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

	return true;
}


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

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

	return true;
}


void CSDAreaISO::genDSurf()
{
	int i,j;

	AcGePoint2dArray pnts;

	
/*
	AcDbSpline *pSpl;
	pnts.setLogicalLength(nU+1);
	for (j=0; j<nV+1; j++) {
		for (i=0; i<nU+1; i++) {
			pnts[i] = dPntArr[i*(nV+1)+j];
		}
		createSpline(pnts,pSpl);
		postToDb(pSpl);
		pSpl->close();
	}
	pnts.setLogicalLength(nV+1);
	for (j=0; j<nU+1; j++) {
		for (i=0; i<nV+1; i++) {
			pnts[i] = dPntArr[j*(nV+1)+i];
		}
		createSpline(pnts,pSpl);
		postToDb(pSpl);
		pSpl->close();
	}*/





	AcGePoint3dArray dPnt3dArr;
	AcGeDoubleArray weights;
	AcGeKnotVector uKnots,vKnots;
	points2dTo3d(dPntArr,dPnt3dArr,dCenterZ);


	//  计算权重因子，节点矢量
	weights.setLogicalLength(dPntArr.length());
	weights.setAll(1.7e+300);

	double dist;
	dBaseSurfParamU.setLogicalLength(nV+1);
	dBaseSurfParamU[0] = 0.0;
	for (i=0; i<nV; i++) {
		dist = dPntArr[posCU*(nV+1)+i].distanceTo(dPntArr[posCU*(nV+1)+i+1]);
		dBaseSurfParamU[i+1] = dBaseSurfParamU[i] + dist;
	}
	dBaseSurfParamV.setLogicalLength(nU+1);
	dBaseSurfParamV[0] = 0.0;
	for (i=0; i<nU; i++) {
		dist = dPntArr[i*(nV+1)+posCV].distanceTo(dPntArr[(i+1)*(nV+1)+posCV]);
		dBaseSurfParamV[i+1] = dBaseSurfParamV[i] + dist;
	}

	uKnots.setLogicalLength(nV+1+4);
	for (i=1; i<nV-2; i++) {
		uKnots[i+3] = dBaseSurfParamU[i+1];
	}
	uKnots[i+3] = dBaseSurfParamU[i+2];
	uKnots[i+6] = uKnots[i+5] = uKnots[i+4] = uKnots[i+3];
	uKnots[0] = uKnots[1] = uKnots[2] = uKnots[3] = 0.0;

	vKnots.setLogicalLength(nU+1+4);
	for (i=1; i<nU-2; i++) {
		vKnots[i+3] = dBaseSurfParamV[i+1];
	}
	vKnots[i+3] = dBaseSurfParamV[i+2];
	vKnots[i+6] = vKnots[i+5] = vKnots[i+4] = vKnots[i+3];
	vKnots[0] = vKnots[1] = vKnots[2] = vKnots[3] = 0.0;

	// 生成展开基面
	dBaseSurf.set(3,3,AcGe::kRational,AcGe::kRational,nV+1,nU+1,dPnt3dArr.asArrayPtr(),
		weights.asArrayPtr(),uKnots,vKnots);

	// 得到uv方向的节点矢量
	dBaseSurfParamU.removeAt(nV-1);
	dBaseSurfParamU.removeAt(1);
	dBaseSurfParamV.removeAt(nU-1);
	dBaseSurfParamV.removeAt(1);

	//映射原曲面oSurfTrimmedLoops2d对应的点到展开面上，形成展开面loop
	AcGePoint3d dummy;
	AcGePoint2d dummy2d;
	ChGeLoop2d loop;
	ChGeLoop2d loop2d;
//	AcGePoint2dArray pnts;
	AcGePoint2dArray pnts2d;
	AcGePoint3dArray dummyPnts;
	int len1,len2,len3,k;
	len1 = oSurfTrimmedLoops2d.length();
	dSurfLoops.setLogicalLength(len1);
	for (i=0; i<len1; i++) {
		loop = oSurfTrimmedLoops2d[i];
		len2 = loop.length();
//		loop2d.setLogicalLength(0);
		loop2d.setLogicalLength(len2);
		for (j=0; j<len2; j++) {
			pnts = loop[j];
			len3 = pnts.length();
			dummyPnts.setLogicalLength(0);
			dummyPnts.append(oBaseSurf.evalPoint(pnts.first()));

			for (k=1; k<len3; k++) {
				dummy = oBaseSurf.evalPoint(pnts[k]);
				if (!dummy.isEqualTo(dummyPnts.last())) {
					dummyPnts.append(dummy);
				}
			}
			len3 = dummyPnts.length();
//			if (len3 < 2) continue;

			pnts2d.setLogicalLength(0);
			for (k=0; k<len3; k++) {
				if (mapPointToD(dummyPnts[k],dummy2d))
					pnts2d.append(dummy2d);
			}

//			loop2d.append(pnts2d);
			loop2d[j] = pnts2d;
		}
		dSurfLoops[i] = loop2d;
	}

	// 保证生成的展开曲面为封闭轮廓
	len1 = dSurfLoops.length();
	AcGePoint2d tmpPnt;
	for (i=len1-1; i>-1; i--) {
		len2 = dSurfLoops[i].length();
		for (j=len2-1; j>-1; j--) {
			len3 = dSurfLoops[i].at(j).length();
			if (len3 == 1) {
				tmpPnt = dSurfLoops[i].at(j).first();
				// ? 取三点的加权值或通过判断三点之间的距离来确定出一个值
				if (j==len2-1) {
					(dSurfLoops[i])[j-1].last() = tmpPnt;
					dSurfLoops[i].first().first() = tmpPnt;
				} else if (j==0) {
					dSurfLoops[i].last().last() = tmpPnt;
					(dSurfLoops[i])[j+1].first() = tmpPnt;
				} else {
					(dSurfLoops[i])[j-1].last() = tmpPnt;
					(dSurfLoops[i])[j+1].first() = tmpPnt;
				}
				dSurfLoops[i].removeAt(j);
			}
		}

		len2 = dSurfLoops[i].length();
		for (j=0; j<len2-1; j++) {
			if (!dSurfLoops[i].at(j).last().isEqualTo(
				dSurfLoops[i].at(j+1).first())) {
				(dSurfLoops[i])[j].last() = ((dSurfLoops[i])[j].last()+(dSurfLoops[i])[j+1].first().asVector())/2;
				(dSurfLoops[i])[j+1].first() = (dSurfLoops[i])[j].last();
			}
		}
		if (!dSurfLoops[i].first().first().isEqualTo(dSurfLoops[i].last().last())) {
			dSurfLoops[i].first().first() = (dSurfLoops[i].first().first()+dSurfLoops[i].last().last().asVector())/2;
			dSurfLoops[i].last().last() = dSurfLoops[i].first().first();
		}
	}


	AcGePoint2d org;
	AcGeVector3d xAxis,yAxis,zAxis(0,0,1);
	org = dPntArr[posCU*(nV+1)+posCV];
	tmpPnt = dPntArr[(posCU+1)*(nV+1)+posCV] - org.asVector();
	xAxis.set(tmpPnt.x,tmpPnt.y,0);
	tmpPnt = dPntArr[posCU*(nV+1)+posCV+1] - org.asVector();
	yAxis.set(tmpPnt.x,tmpPnt.y,0);

}



bool CSDAreaISO::getDSurfLoops(ChGeLoop3dArray& loops)
{ 
	if (!oSurfLoops.length()) return false;

	ChGeLoop3d loop;
	ChGeLoop2d loop2d;
	AcGePoint3dArray dummy;
	AcGePoint2dArray dummy2d;
	
	loops.setLogicalLength(0);
	int i,j,len1,len2;
	len1 = dSurfLoops.length();
	loops.setLogicalLength(len1);
	for (i=0; i<len1; i++) {
		loop2d = dSurfLoops[i];
		len2 = loop2d.length();
		loop.setLogicalLength(len2);
		for (j=0; j<len2; j++) {
			dummy2d = loop2d[j];
			points2dTo3d(dummy2d,dummy,dCenterZ);
			loop[j] = dummy;
		}
		loops[i] = loop;
	}

	return true;
}

bool CSDAreaISO::getDBaseSurfLoop(ChGeLoop2d& loop)
{
	if (!oSurfLoops.length()) return false;

	AcGePoint2dArray pnts;
	int i;
	loop.setLogicalLength(4);
	// u=0; reverse
	pnts.setLogicalLength(nV+1);
	for (i=0; i<nV+1; i++) {
		pnts[i] = dPntArr[i];
	}
	loop[0] = pnts.reverse();

	// v=0;
	pnts.setLogicalLength(nU+1);
	for (i=0; i<nU+1; i++) {
		pnts[i] = dPntArr[i*(nV+1)];
	}
	loop[1] = pnts;

	// u=nU;
	pnts.setLogicalLength(nV+1);
	for (i=0; i<nV+1; i++) {
		pnts[i] = dPntArr[nU*(nV+1)+i];
	}
	loop[2] = pnts;

	// v=nV; reverse
	pnts.setLogicalLength(nU+1);
	for (i=0; i<nU+1; i++) {
		pnts[i] = dPntArr[i*(nV+1)+nV];
	}
	loop[3] = pnts.reverse();

	return true;
}

bool CSDAreaISO::getCSDData(CSDData& data)
{
	if (!oSurfLoops.length()) return false;

	data.oBaseSurf = oBaseSurf;
	data.oSurfLoops = oSurfLoops;
	data.oCenter = oCenter;
	data.dCenter = dCenter;
	data.dCenterZ = dCenterZ;
	data.nU = nU;
	data.nV = nV;
	data.oEvalU = oEvalU;
	data.oEvalV = oEvalV;
	data.bFullD = bFullD;
	data.bAutoOCenter = bAutoOCenter;
	data.bDevInner = bDevInner;
	data.nTol = nTol;
//	data.bIsReversed = bIsReversed;

	return true;
}