geutilities.cpp

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

			}
		} else {
			for (j=0; j<LenArr; j++) {
				pntsArr.insertAt(pos,pntsArr2[j]);
				pntsArr[pos].reverse();
			}
		}
	}
	return pos;
}


void Loop2dTo3d(const ChGeLoop2d& loop2d, ChGeLoop3d& loop3d, double z)
{
	int i,len;

	len = loop2d.length();
	loop3d.setLogicalLength(len);
	for (i=0; i<len; i++) {
		points2dTo3d(loop2d[i],loop3d[i],z);
	}
}

void Loop3dTo2d(const ChGeLoop3d& loop3d, ChGeLoop2d& loop2d)
{
	int i,len;
	
	len = loop3d.length();
	loop2d.setLogicalLength(len);
	for (i=0; i<len; i++) {
		points3dTo2d(loop3d[i],loop2d[i]);
	}
}

void Loops2dTo3d(const ChGeLoop2dArray& loops2d, 
				 ChGeLoop3dArray& loops3d, double z)
{
	int i,len;
	
	len = loops2d.length();
	loops3d.setLogicalLength(len);
	for (i=0; i<len; i++) {
		Loop2dTo3d(loops2d[i],loops3d[i],z);
	}
}

void Loops3dTo2d(const ChGeLoop3dArray& loops3d, 
				 ChGeLoop2dArray& loops2d)
{
	int i,len;
	
	len = loops3d.length();
	loops2d.setLogicalLength(len);
	for (i=0; i<len; i++) {
		Loop3dTo2d(loops3d[i],loops2d[i]);
	}
}

// 整理Loop, 去掉数组中前后相等的点, 去掉点数为1的数组, 
// 如果最终不能形成loop则返回kFalse
Adesk::Boolean regenLoop(ChGeLoop2d& loop)
{
	if (loop.isEmpty()) return Adesk::kFalse;
	if (!loop.first().first().isEqualTo(loop.last().last())) return false;

	int i,len,j,jlen;
	len = loop.length();
	for (i=0; i<len; i++) {
		jlen = loop[i].length();
		for (j=jlen-1; j>0; j--) {
			if (loop[i].at(j).isEqualTo(loop[i].at(j-1))) {
				loop[i].removeAt(j);
			}
		}
	}

	for (i=0; i<len-1; i++) {
		if (!loop[i].last().isEqualTo(loop[i+1].first())) {
			return Adesk::kFalse;
		}
	}

	return Adesk::kTrue;	
}

Acad::ErrorStatus 
getLoopsFromRegion(AcDbRegion *pRg, ChGeLoop3dArray& loops)
{
	short marker;
	AcGePoint3d pickpnt;
	AcGeMatrix3d vxform;
	int numIds;
	AcDbFullSubentPath *subentIds;
	AcDbFullSubentPathArray subentIdArr;
	AcBrFace *pBrFace;
	AcBrLoopPointerArray pBrLoops;

	loops.setLogicalLength(0);
	marker = 0;
	do {
		marker++;
		pRg->getSubentPathsAtGsMarker(AcDb::kFaceSubentType,marker,
			pickpnt,vxform,numIds,subentIds);
		if (numIds==0) break;
		for (register j=0; j<numIds; j++) {
			if ( !subentIdArr.contains(subentIds[j]) ) {
				subentIdArr.append(subentIds[j]);
			}
		}
		delete [] subentIds;
	} while(true);

	numIds = subentIdArr.length();
	if (numIds==0) return Acad::eWrongObjectType;

	int i;
	ChGeLoop3dArray retLoops;
	for (i=0; i<numIds; i++) {
		pBrFace = new AcBrFace;
		pBrFace->setSubentPath(subentIdArr[i]);
		getBrLoopsFromBrFace(pBrFace,pBrLoops);
		getGeLoopsFromBrLoops(pBrLoops,retLoops);
		loops.append(retLoops);
		int j,jlen;
		jlen = pBrLoops.length();
		for (j=0; j<jlen; j++) {
			delete (AcBrLoop*)(pBrLoops[j]);
		}
		pBrLoops.setLogicalLength(0);
		retLoops.setLogicalLength(0);
		delete pBrFace;
	}

	int len;
	len = loops.length();
	for (i=0; i<len; i++) {
		int j,jlen,klen;
		jlen = loops[i].length();
		for (j=jlen-1; j>-1; j--) {
			klen = loops[i].at(j).length();
			if (klen<2) loops[i].removeAt(j);
		}
	}


	return Acad::eOk;
}


Acad::ErrorStatus 
booleanOper(const ChGeLoop2d& loop1, const ChGeLoop2d& loop2,
			ChGeLoop2dArray& retLoops,AcDb::BoolOperType op)
{
	AcDbRegion *pRg1,*pRg2;
	Acad::ErrorStatus es;

	es = createRegion(loop1,pRg1);
	if (es != Acad::eOk) return es;

	es = createRegion(loop2,pRg2);
	if (es != Acad::eOk) {
		delete pRg1;
		return es;
	}

	AcGePoint3dArray pnts3d;
	pRg1->intersectWith(pRg2,AcDb::kOnBothOperands,pnts3d,0,0);

	es = pRg1->booleanOper(op,pRg2);
	if (es != Acad::eOk) return es;

	acdbHostApplicationServices()->workingDatabase()->
		addAcDbObject(pRg1);

	ChGeLoop3dArray loops;
	es = getLoopsFromRegion(pRg1,loops);
	pRg1->erase ();
	pRg1->close();

	if (es != Acad::eOk) return es;
	Loops3dTo2d(loops,retLoops);

	if (retLoops.length() == 1) {
		if (   (retLoops[0].length()==loop1.length())
			&& pnts3d.length()==0 ) {
			return Acad::eNotHandled;
			}
	}


	return Acad::eOk;
}


Acad::ErrorStatus 
trimLoopByCurve(const ChGeLoop2d& loop,const ChGePnts2dArray& curve,
				ChGeLoop2d& retLoop, Adesk::Boolean bTrimRight, Adesk::Boolean bAntiClock)
{
	retLoop.setLogicalLength(0);
	Acad::ErrorStatus es;

	ChGePnts2dArray retCurve;
	es = trimCurveByLoop(curve,loop,retCurve);
	if (es != Acad::eOk) {
		return es;
	}

	AcGeNurbCurve2d loopCrv;
	getJoinedCurveFromPntsArray(loop,loopCrv);

	double param1,param2;
	loopCrv.isOn(retCurve.first().first(),param1);
	loopCrv.isOn(retCurve.last().last(),param2);
	retCurve.first().first() = loopCrv.evalPoint(param1);
	retCurve.last().last() = loopCrv.evalPoint(param2);

	ChGePnts2dArray retPntsArray;
	if (bAntiClock) {
		if (bTrimRight) {
			if (param1<param2) {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,loopCrv.startParam(),param1);
				retLoop.append(retPntsArray);
				retLoop.append(retCurve);
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param2,loopCrv.endParam());
				retLoop.append(retPntsArray);
			} else {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param2,param1);
				retLoop.append(retPntsArray);
				retLoop.append(retCurve);
			}
		} else {
			if (param1<param2) {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param1,param2);
				retLoop.append(retPntsArray);
				reverse(retCurve);
				retLoop.append(retCurve);
			} else {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,loopCrv.startParam(),param2);
				retLoop.append(retPntsArray);
				reverse(retCurve);
				retLoop.append(retCurve);
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param1,loopCrv.endParam());
				retLoop.append(retPntsArray);
			}
		}
	} else {
		if (bTrimRight) {
			if (param1<param2) {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param1,param2);
				retLoop.append(retPntsArray);
				reverse(retCurve);
				retLoop.append(retCurve);
			} else {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,loopCrv.startParam(),param2);
				retLoop.append(retPntsArray);
				reverse(retCurve);
				retLoop.append(retCurve);
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param1,loopCrv.endParam());
				retLoop.append(retPntsArray);
			}
		} else {
			if (param1<param2) {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,loopCrv.startParam(),param1);
				retLoop.append(retPntsArray);
				retLoop.append(retCurve);
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param2,loopCrv.endParam());
				retLoop.append(retPntsArray);
			} else {
				getPntsArrayFromJoinedCurve(retPntsArray,loopCrv,param2,param1);
				retLoop.append(retPntsArray);
				retLoop.append(retCurve);
			}
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus 
trimCurveByLoop(const ChGePnts2dArray& curve,const ChGeLoop2d& loop,
				ChGePnts2dArray& retCurve)
{
	retCurve.setLogicalLength(0);
	Acad::ErrorStatus es;
	
	AcDbRegion *pRg;
	es = createRegion(loop,pRg);
	if (es != Acad::eOk) 
		return es;
	
	AcGeNurbCurve2d crv;
	getJoinedCurveFromPntsArray(curve,crv);
	AcDbSpline *pSpl;
	createSpline(crv,pSpl);
	AcGePoint3dArray pnts3d;
	pRg->intersectWith(pSpl,AcDb::kOnBothOperands,pnts3d,0,0);
	delete pSpl;
	
	int len;
	len = pnts3d.length(); // 交点个数
	if ( len > 2) {
		delete pRg;
		return Acad::eNotHandled;
	}
	
	double param1,param2;
	
	
	acdbHostApplicationServices()->workingDatabase()->
		addAcDbObject(pRg);
	
	AcBrFace *pBrFace;
	getBrFaceFromRegion(pRg,pBrFace);
	AcBr::Relation rel;
	
	AcGePoint2d pnt2d;
	
	if (len==0) {
		double tol;
		AcGeNurbCurve2d loopCrv;
		getJoinedCurveFromPntsArray(loop,loopCrv);
		pnt2d = crv.evalPoint(crv.endParam()/2);
		pBrFace->getPointRelationToFace(AcGePoint3d(pnt2d.x,pnt2d.y,0),rel);
		if (rel == AcBr::kInside) {
			retCurve = curve;
		} else {
			tol = loopCrv.distanceTo(pnt2d);
			if (tol < TOL5) {
				retCurve = curve;
			}
		}
		pRg->erase();
		pRg->close();
		delete pBrFace;
		return Acad::eNotHandled;
	}
	
	if (len==1) {
		pnt2d = curve.first().first();
		pBrFace->getPointRelationToFace(AcGePoint3d(pnt2d.x,pnt2d.y,0),rel);
		if (rel == AcBr::kInside) {
			param1 = crv.startParam();
			crv.isOn(AcGePoint2d(pnts3d[0].x,pnts3d[0].y),param2);
		} else {
			crv.isOn(AcGePoint2d(pnts3d[0].x,pnts3d[0].y),param1);
			param2 = crv.endParam();
		}
		if (param1 == param2) {
			// 全部被剪切
			pRg->erase();
			pRg->close();
			delete pBrFace;
			return Acad::eOk;
		}
	} else if (len==2) {
		crv.isOn(AcGePoint2d(pnts3d[0].x,pnts3d[0].y),param1);
		crv.isOn(AcGePoint2d(pnts3d[1].x,pnts3d[1].y),param2);
		pnt2d = crv.evalPoint((param1+param2)/2);
		pBrFace->getPointRelationToFace(AcGePoint3d(pnt2d.x,pnt2d.y,0),rel);
		if (rel != AcBr::kInside) {
			pRg->erase();
			pRg->close();
			delete pBrFace;
			return Acad::eNotHandled;
		}
		if (param1>param2) {
			double tmp;
			tmp = param1;
			param1 = param2;
			param2 = tmp;
		}
	}
	
	pRg->erase();
	pRg->close();
	delete pBrFace;
	getPntsArrayFromJoinedCurve(retCurve,crv,param1,param2);

	return Acad::eOk;
}


/*
bool trimLoopByLoops(const ChGeLoop2d& loop, const ChGeLoop2dArray& loops,ChGeLoop2dArray& retLoops,bool bAnticlock,bool bTrimRight)
{
	if (loop.length()==0 || loops.length()==0) return false;

	retLoops.setLogicalLength(0);

	bool ret;
	ChGePnts2dArray retPntsArr;
	ChGeLoop2dArray trimmedLoops,trimmedLoops2,innerLoops,tmpLoops;
	int i,len,j,jlen;
	len = loops.length();
	trimmedLoops.append(loop);
	for (i=0; i<len; i++) {
		jlen = trimmedLoops.length();
		trimmedLoops2.setLogicalLength(0);
		for (j=0; j<jlen; j++)  {
			ret = trimClosedCurvebyClosedCurve(
				trimmedLoops[j],loops[i],retPntsArr,bTrimRight,bAnticlock);
			if (ret) {
				if (retPntsArr.length()!=0) {
					// 部分被剪切
					getLoopsFromPntsArr(tmpLoops,retPntsArr);
					trimmedLoops2.append(tmpLoops);
				}
			} else {
				if (retPntsArr.length() == trimmedLoops[j].length()) {
					// 未被剪切
					AcGeNurbCurve2d crv;
					getJoinedCurveFromPntsArray(trimmedLoops[j],crv);
					Adesk::Boolean bTmp;
					bTmp = isClockwise(loops[i].first().first(),crv);
					if (bAnticlock) {
						if (!bTmp) {
							innerLoops.append(loops[i]);
						}
					} else {
						if (bTmp) {
							innerLoops.append(loops[i]);
						}
					}
					trimmedLoops2.append(trimmedLoops[j]);
				} else {
					// 输入参数错误
					return false;
				}
			}
		}
		trimmedLoops = trimmedLoops2;
		if (trimmedLoops.length()==0) {
			return true;
		}
	}

	retLoops = trimmedLoops;
	if (innerLoops.length()) {
		retLoops.append(innerLoops);
	}

	return true;
}
*/

// 从点数组的数组提取loops
bool getLoopsFromPntsArr(ChGeLoop2dArray& loops2d,const ChGeCurve2dPntsArray& pntsArr)
{
	int i,len;
	len = pntsArr.length();
	loops2d.setLogicalLength(0);
	if (len==0) {
		return false;
	} else if (len==1) {
		if (pntsArr[0].length()>1 && pntsArr[0].first().isEqualTo(pntsArr[0].last())) {
			loops2d.append(pntsArr);
			return true;
		} else {
			return false;
		}
	} else {
		ChGeLoop2d loop;
		loop.append(pntsArr[0]);
		for (i=1; i<len; i++) {
			while(pntsArr[i-1].last().isEqualTo(pntsArr[i].first())) {
				loop.append(pntsArr[i]);
				i++;
				if (i>=len) break;
			}
			if (loop.length())	loops2d.append(loop);
			loop.setLogicalLength(0);
			if (i!=len) {
				loop.append(pntsArr[i]);
			}
		}
		if (loop.length()) {
			loops2d.append(loop);
		}
		if (loops2d.length()>1) {
			if (loops2d.first().first().first().isEqualTo(loops2d.last().last().last())) {
				loops2d[loops2d.length()].append(loops2d.first());
//				loops2d.last().append(loops2d.first());
				loops2d.removeFirst();
			}
		}
	}

	len = loops2d.length();
	for (i=len-1; i>-1; i--) {
		if (!loops2d[i].first().first().isEqualTo(loops2d[i].last().last())) {
			loops2d.removeAt(i);
		}
	}

	if (loops2d.length())	return true;
	else					return false;
}

bool isEqual(const ChGeLoop2d& loop1,const ChGeLoop2d& loop2)
{
	int i,len;
	len = loop1.length();
	if (loop2.length() != len) return false;
	for (i=0; i<len; i++) {
		if (!isEqual(loop1[i],loop2[i])) return false;
	}
	return true;
}

bool isEqual(const AcGePoint2dArray& pnts1,const AcGePoint2dArray& pnts2)
{
	int i,len;
	len = pnts1.length();
	if (pnts2.length() != len) return false;
	for (i=0; i<len; i++) {
		if (!pnts1[i].isEqualTo(pnts2[i])) return false;
	}
	return true;
}


bool isEqual(const ChGeLoop2dArray& loops1,const ChGeLoop2dArray& loops2)
{
	int i,len;
	len = loops1.length();
	if (loops2.length() != len) return false;
	for (i=0; i<len; i++) {
		if (!isEqual(loops1[i],loops2[i])) return false;
	}
	return true;
}

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