geutilities.cpp

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

	int i,len;
	len = pnts.length();
	AcGePoint3dArray tmpPnts;
	tmpPnts.append(pnts.first());
	for (i=1; i<len; i++) {
		if (!tmpPnts.last().isEqualTo(pnts[i])) {
			tmpPnts.append(pnts[i]);
		}
	}

	len = tmpPnts.length();
	params.setLogicalLength(len);
	AcGePoint3d pnt3d;
	for (i=0; i<len; i++) {
		pnt3d = surf.closestPointTo(tmpPnts[i]);
		surf.isOn(pnt3d,params[i]);
//		params[i] = surf.paramOf(pnt3d);
	}

	if (len>2) {
		// 判断曲面的奇异性，是否有边退化为点
		AcGeInterval intrvlX,intrvlY;
		surf.getEnvelope(intrvlX,intrvlY);
		int nSigularity=0;
		AcGePoint3d p1,p2,p3,p4,oSigularity;
		AcGePoint2d param;
		p1 = surf.evalPoint(param.set(intrvlX.lowerBound(),intrvlY.lowerBound()));
		p2 = surf.evalPoint(param.set(intrvlX.upperBound(),intrvlY.lowerBound()));
		p3 = surf.evalPoint(param.set(intrvlX.upperBound(),intrvlY.upperBound()));
		p4 = surf.evalPoint(param.set(intrvlX.lowerBound(),intrvlY.upperBound()));
		if (p1.isEqualTo(p2)) {
			nSigularity = 1;
			oSigularity = p1;
		} else if (p2.isEqualTo(p3)) {
			nSigularity = 2;
			oSigularity = p2;
		} else if (p3.isEqualTo(p4)) {
			nSigularity = 3;
			oSigularity = p3;
		} else if (p4.isEqualTo(p1)) {
			nSigularity = 4;
			oSigularity = p4;
		}

		if (nSigularity) {
			AcGeLine2d l2;
			AcGeLineSeg2d l1;
			AcGePoint2d tp1,tp2;
			switch(nSigularity) {
			case 1:
				tp1.set(intrvlX.lowerBound(),intrvlY.lowerBound());
				tp2.set(intrvlX.upperBound(),intrvlY.lowerBound());
				l1.set(tp1,tp2);
				break;
			case 2:
				tp1.set(intrvlX.upperBound(),intrvlY.lowerBound());
				tp2.set(intrvlX.upperBound(),intrvlY.upperBound());
				l1.set(tp1,tp2);
				break;
			case 3:
				tp1.set(intrvlX.upperBound(),intrvlY.upperBound());
				tp2.set(intrvlX.lowerBound(),intrvlY.upperBound());
				l1.set(tp1,tp2);
				break;
			case 4:
				tp1.set(intrvlX.lowerBound(),intrvlY.upperBound());
				tp2.set(intrvlX.lowerBound(),intrvlY.lowerBound());
				l1.set(tp1,tp2);
				break;
			}

			// 针对数组的首位进行判断
			if (tmpPnts.first().isEqualTo(oSigularity)) {
				l2.set(params.at(1),params.at(2));
				if (!l1.intersectWith(l2,params.first())) {
					double s1;
					s1 = (tmpPnts[0]-tmpPnts[1]).length() / (tmpPnts[1]-tmpPnts[2]).length();
					params[0] = params[1] + (params[1]-params[2])*s1;
					params[0] = l1.closestPointTo(params[0]);
				}
			}
			// 针对数组的第二位进行判断
			if (tmpPnts.at(1).isEqualTo(oSigularity)) {
				l2.set(params.at(0),params.at(2));
				if (!l1.intersectWith(l2,params[1])) {
					double s1;
					s1 = (tmpPnts[1]-tmpPnts[0]).length() / (tmpPnts[2]-tmpPnts[0]).length();
					params[1] = params[0] + (params[2]-params[0])*s1;
					params[1] = l1.closestPointTo(params[1]);
				}
			}

			// 针对其他
			for (i=2; i<len; i++) {
				if (tmpPnts.at(i).isEqualTo(oSigularity)) {
					l2.set(params.at(i-1),params.at(i-2));
					if (!l1.intersectWith(l2,params.first())) {
						double s1;
						s1 = (tmpPnts[i-1]-tmpPnts[i-2]).length() / (tmpPnts[i-1]-tmpPnts[i-2]).length();
						params[i] = params[i-1] + (params[i-1]-params[i-2])*s1;
						params[i] = l1.closestPointTo(params[i]);
					}
				}
			}
		}
	}

	return true;
}


bool getPntsFromParams(const AcGeNurbSurface& surf,const AcGePoint2dArray& params,AcGePoint3dArray& pnts)
{
	if (!params.length()) return false;

	int i,len;
	len = params.length();
	pnts.setLogicalLength(len);
	for (i=0; i<len; i++) {
		pnts[i] = surf.evalPoint(params[i]);
	}

	return true;
}

bool getParamsArrayFromPntsArray(const AcGeNurbSurface& surf,const ChGePnts3dArray& pntsArr,ChGePnts2dArray& paramsArr, bool bLoop)
{
	if (!pntsArr.length()) return false;

	int i,len,j,jlen;
	AcGePoint2d param;
	len = pntsArr.length();
	paramsArr.setLogicalLength(len);
	AcGePoint3d pnt3d;
	for (i=0; i<len; i++) {
		jlen = pntsArr[i].length();
/*
		if (jlen == 1) {
			paramsArr[i].setLogicalLength(1);
			continue;
		}
*/
		for (j=0; j<jlen; j++) {
			pnt3d = surf.closestPointTo(pntsArr[i].at(j));
			surf.isOn(pnt3d,param);
//			param = surf.paramOf(pnt3d);
			paramsArr[i].append(param);
		}
	}

	// 判断曲面的奇异性，是否有边退化为点
	AcGeInterval intrvlX,intrvlY;
	surf.getEnvelope(intrvlX,intrvlY);
	int nSigularity=0;
	AcGePoint3d p1,p2,p3,p4,oSigularity;
//	AcGePoint2d param;
	p1 = surf.evalPoint(param.set(intrvlX.lowerBound(),intrvlY.lowerBound()));
	p2 = surf.evalPoint(param.set(intrvlX.upperBound(),intrvlY.lowerBound()));
	p3 = surf.evalPoint(param.set(intrvlX.upperBound(),intrvlY.upperBound()));
	p4 = surf.evalPoint(param.set(intrvlX.lowerBound(),intrvlY.upperBound()));
	if (p1.isEqualTo(p2)) {
		nSigularity = 1;
		oSigularity = p1;
	} else if (p2.isEqualTo(p3)) {
		nSigularity = 2;
		oSigularity = p2;
	} else if (p3.isEqualTo(p4)) {
		nSigularity = 3;
		oSigularity = p3;
	} else if (p4.isEqualTo(p1)) {
		nSigularity = 4;
		oSigularity = p4;
	}
		
	if (nSigularity) {
		AcGeLine2d l2;
		AcGeLineSeg2d l1;
		AcGePoint2d tp1,tp2;
		switch(nSigularity) {
		case 1:
			tp1.set(intrvlX.lowerBound(),intrvlY.lowerBound());
			tp2.set(intrvlX.upperBound(),intrvlY.lowerBound());
			l1.set(tp1,tp2);
			break;
		case 2:
			tp1.set(intrvlX.upperBound(),intrvlY.lowerBound());
			tp2.set(intrvlX.upperBound(),intrvlY.upperBound());
			l1.set(tp1,tp2);
			break;
		case 3:
			tp1.set(intrvlX.upperBound(),intrvlY.upperBound());
			tp2.set(intrvlX.lowerBound(),intrvlY.upperBound());
			l1.set(tp1,tp2);
			break;
		case 4:
			tp1.set(intrvlX.lowerBound(),intrvlY.upperBound());
			tp2.set(intrvlX.lowerBound(),intrvlY.lowerBound());
			l1.set(tp1,tp2);
			break;
		}

		AcGePoint3dArray tmpPnts;
		AcGePoint2dArray params;
		for (i=0; i<len; i++) {
			// 针对数组的首位进行判断
			tmpPnts = pntsArr[i];
			params = paramsArr[i];
			if (tmpPnts[0].isEqualTo(oSigularity)) {
				l2.set(params[1],params[2]);
				if (!l1.intersectWith(l2,params[0])) {
					double s1;
					s1 = (tmpPnts[0]-tmpPnts[1]).length() / (tmpPnts[1]-tmpPnts[2]).length();
					params[0] = params[1] + (params[1]-params[2])*s1;
					params[0] = l1.closestPointTo(params[0]);
				}
			}
			// 针对数组的第二位进行判断
			if (tmpPnts[1].isEqualTo(oSigularity)) {
				l2.set(params[0],params[1]);
				if (!l1.intersectWith(l2,params[1])) {
					double s1;
					s1 = (tmpPnts[1]-tmpPnts[0]).length() / (tmpPnts[2]-tmpPnts[0]).length();
					params[1] = params[0] + (params[2]-params[0])*s1;
					params[1] = l1.closestPointTo(params[1]);
				}
			}
			
			jlen = tmpPnts.length();
			// 针对其他
			for (j=2; j<jlen; j++) {
				if (tmpPnts[j].isEqualTo(oSigularity)) {
					l2.set(params[j-1],params[j-2]);
					if (!l1.intersectWith(l2,params[j])) {
						double s1;
						s1 = (tmpPnts[j-1]-tmpPnts[j-2]).length() / (tmpPnts[j-1]-tmpPnts[j-2]).length();
						params[j] = params[j-1] + (params[j-1]-params[i-2])*s1;
						params[j] = l1.closestPointTo(params[j]);
					}
				}
			}
			paramsArr[i] = params;
		}
	}

	if (bLoop) {
		len = paramsArr.length();
		if (len<1) return false;
		AcGePoint2dArray params;
		params.setLogicalLength(2);
		if (!paramsArr.first().first().isEqualTo(paramsArr.last().last())) {
			if (pntsArr.first().first().isEqualTo(oSigularity)) {
				params[0] = paramsArr.last().last();
				params[1] = paramsArr.first().first();
				paramsArr.append(params);
			} else {
				paramsArr.last().append(paramsArr.first().first());
			}
		}
		for (i=0; i<len-1; i++) {
			if (!paramsArr[i].last().isEqualTo(paramsArr[i+1].first())) {
				if (pntsArr[i].last().isEqualTo(oSigularity)) {
					params[0] = paramsArr[i].last();
					params[1] = paramsArr[i+1].first();
					paramsArr.insertAt(i+1,params);
					i++;
					len++;
				} else {
					paramsArr[i].append(paramsArr[i+1].first());
				}
			}
		}
	}

	return true;
}


bool getPntsArrayFromParamsArray(const AcGeNurbSurface& surf,const ChGePnts2dArray& paramsArr,ChGePnts3dArray& pntsArr)
{
	if (!paramsArr.length()) return false;

	int i,len,j,jlen;
	len = paramsArr.length();
	pntsArr.setLogicalLength(len);
	for (i=0; i<len; i++) {
		jlen = paramsArr[i].length();
		pntsArr[i].setLogicalLength(jlen);
		for (j=0; j<jlen; j++) {
			(pntsArr[i])[j] = surf.evalPoint(paramsArr[i].at(j));
		}
	}

	return true;
}

bool getLoopFromIntervalXY(const AcGeInterval& intrvX, const AcGeInterval& intrvY,ChGeLoop2d& loop, int nX, int nY)
{
	if (!intrvX.isBounded() || !intrvY.isBounded()) return false;
	if (nX<1 || nY<1) return false;
	
	AcGePoint2dArray pnts2d;
	AcGePoint2d	tmpPnt;
	double minX,maxX,minY,maxY,stepX,stepY;
	int i;
	minX = intrvX.lowerBound();
	maxX = intrvX.upperBound();
	minY = intrvY.lowerBound();
	maxY = intrvY.upperBound();
	stepX = intrvX.length()/nX;
	stepY = intrvY.length()/nY;

	loop.setLogicalLength(0);
	
	pnts2d.setLogicalLength(nX+1);
	tmpPnt.y = minY;
	for (i=0; i<nX+1; i++) {
		tmpPnt.x = minX+i*stepX;
		pnts2d[i] = tmpPnt;
	}
	loop.append(pnts2d);
	pnts2d.setLogicalLength(nY+1);
	tmpPnt.x = maxX;
	for (i=0; i<nY+1; i++) {
		tmpPnt.y = minY+i*stepY;
		pnts2d[i] = tmpPnt;
	}
	loop.append(pnts2d);
	pnts2d.setLogicalLength(nX+1);
	tmpPnt.y = maxY;
	for (i=0; i<nX+1; i++) {
		tmpPnt.x = maxX-i*stepX;
		pnts2d[i] = tmpPnt;
	}
	loop.append(pnts2d);
	pnts2d.setLogicalLength(nY+1);
	tmpPnt.x = minX;
	for (i=0; i<nY+1; i++) {
		tmpPnt.y = maxY-i*stepY;
		pnts2d[i] = tmpPnt;
	}
	loop.append(pnts2d);

/*
	pnts2d[0].set(intrvX.lowerBound(),intrvY.upperBound());
	pnts2d[1].set(intrvX.lowerBound(),intrvY.lowerBound());
	loop[0] = pnts2d;
	pnts2d[0].set(intrvX.lowerBound(),intrvY.lowerBound());
	pnts2d[1].set(intrvX.upperBound(),intrvY.lowerBound());
	loop[1] = pnts2d;
	pnts2d[0].set(intrvX.upperBound(),intrvY.lowerBound());
	pnts2d[1].set(intrvX.upperBound(),intrvY.upperBound());
	loop[2] = pnts2d;
	pnts2d[0].set(intrvX.upperBound(),intrvY.upperBound());
	pnts2d[1].set(intrvX.lowerBound(),intrvY.upperBound());
	loop[3] = pnts2d;
*/

	return true;
}


bool isHead(const AcGePoint3dArray& curve, const AcGePoint3d& dirPnt)
{
	AcGeNurbCurve3d crv(curve);
	AcGePoint3d pnt;

	pnt = crv.closestPointTo(dirPnt);
	double p1;
	crv.isOn(pnt,p1);
	if (p1 < crv.endParam()/2 ) {
		return true;
	} else {
		return false;
	}

}

bool evalShapeCenterAndArea(const ChGeLoop2d& loop, AcGePoint2d& center, double& area)
{
	if (loop.length()==0) return false;

	double dA,Sx=0,Sy=0,A=0;
	AcGePoint2d p1,p2;

	int i,len,jlen;

	len = loop.length();
	for (i=0; i<len; i++) {
		jlen = loop[i].length();
		for (register j=1; j<jlen; j++) {
			p2 = loop[i].at(j);
			p1 = loop[i].at(j-1);

			dA = (p2.x - p1.x) * (p2.y + p1.y) / 2;
			A += dA;
			Sy += dA * (p2.x + p1.x) / 2;
			Sx += dA * (p2.y + p1.y) / 4;
		}
	}
	if (fabs(A) < TOL5) return false;

	center.set(Sy/A,Sx/A);
	area = fabs(A);

	return true;
}

bool evalShapeCenterAndArea(const AcGePoint2dArray& vertexs, AcGePoint2d& center, double& area)
{
	if (vertexs.length()==0) return false;

	double dA,Sx=0,Sy=0,A=0;

	int i,len;

	len = vertexs.length();
	for (i=1; i<len; i++) {
		dA = (vertexs[i].x - vertexs[i-1].x) 
			* (vertexs[i].y + vertexs[i-1].y) / 2;
		A += dA;
		Sy += dA * (vertexs[i].x + vertexs[i-1].x) / 2;
		Sx += dA * (vertexs[i].y + vertexs[i-1].y) / 4;
	}
	dA = (vertexs.first().x - vertexs.last().x) 
		* (vertexs.first().y + vertexs.last().y) / 2;
	A += dA;
	Sy += dA * (vertexs.first().x + vertexs.last().x) / 2;
	Sx += dA * (vertexs.first().y + vertexs.last().y) / 4;

	if (fabs(A) < TOL5) return false;

	center.set(Sy/A,Sx/A);
	area = fabs(A);

	return true;
}

// 图形是否以某条线为轴对称
bool isAxialSymmetric(const AcGePoint2dArray& vertexs, const AcGeLine2d& line)
{
	if (vertexs.length()<2) return false;

	AcGePoint2d symPnt;
	int i,len;
	AcGePoint2dArray vertexsCopy;

	len = vertexs.length();
	for (i=0; i<len; i++) {
		vertexsCopy = vertexs;
		symPnt = vertexs[i];
		symPnt.mirror(line);
		vertexsCopy.removeAt(i);
		if (!vertexs.contains(symPnt)) {
			return false;
		}
	}

	return true;
}


Acad::ErrorStatus 
getBaseSurface(AcDbEntity* pSurf,
			   AcGeNurbSurface& baseSurf,
			   Adesk::Boolean* pbIsSame)
{
	
	// 得到曲面的BrFace
	AcBr::ErrorStatus brEs;
	AcBrFace *pFace;
	brEs = getBrEntityFromEnt(pSurf,
		AcDb::kFaceSubentType,(AcBrEntity*&)pFace);
	
	if (brEs != AcBr::eOk) 
		return Acad::eInvalidInput;
	
	// 得到曲面的ExternalBoundedSurface
	Adesk::UInt32 num;
	AcGeExternalBoundedSurface exsurf,**ppNurbs=NULL;
	if (pbIsSame) {
		Adesk::Boolean bIsSame;
		pFace->getOrientToSurface(bIsSame);
		*pbIsSame = bIsSame;
	}
	
	pFace->getSurfaceAsTrimmedNurbs(num,ppNurbs);
	if (num>1) {
		delete [] ppNurbs;
		return Acad::eWrongObjectType;
	} else if (num==0) {
		return Acad::eWrongObjectType;		
	}
	delete pFace;
	exsurf = *ppNurbs[0];
	delete [] ppNurbs;
	
	// 得到曲面的BaseSurface
	AcGeNurbSurface *pBaseSurf=NULL;
	exsurf.getBaseSurface((AcGeSurface*&)pBaseSurf);
	baseSurf = *pBaseSurf;
	delete pBaseSurf;
	
	return Acad::eOk;
}



Acad::ErrorStatus 
getBaseSurfaceAndLoops(AcDbEntity* pSurf,
					   AcGeNurbSurface& baseSurf, 
					   ChGeLoop3dArray& loops,
					   Adesk::Boolean* pbIsSame)
{
	
	// 得到曲面的BrFace
	AcBr::ErrorStatus brEs;
	AcBrFace *pFace;
	brEs = getBrEntityFromEnt(pSurf,
		AcDb::kFaceSubentType,(AcBrEntity*&)pFace);

	if (brEs != AcBr::eOk) 
		return Acad::eInvalidInput;

	// 得到原曲面的loops
	AcBrLoopPointerArray Loops;
	getBrLoopsFromBrFace(pFace,Loops);
	loops.setLogicalLength(0);
	getGeLoopsFromBrLoops(Loops,loops);
	int i,len;
	len = Loops.length();
	for (i=0; i<len; i++) {
		delete (AcBrLoop*)(Loops[i]);
	}


	// 得到