geutilities.cpp

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

			edP = param;
		} else {
			bRev = false;
			stP = param;
			edP = param2;
		}
		if (!bExt) {
			AcGeInterval intrVal;
			curve.getInterval(intrVal);
			if (!intrVal.contains(param)) return false;
			if (!intrVal.contains(param2)) return false;
		}
	}

	AcGeKnotVector cknots;
	AcGeDoubleArray params;
	int i,pos,pos2;
	cknots = curve.knots();
	cknots.getDistinctKnots(params);
	pos = insertKnot(params,stP);
	pos2 = insertKnot(params,edP);

	AcGePoint3dArray dummy;
	int startPos,endPos;
	startPos = pos;
	endPos = pos2;

	for (i=startPos; i<endPos+1; i++) {
		dummy.append(curve.evalPoint(params[i]));
	}

	if (bRev) {
		dummy.reverse();
	}
	pnts = dummy;

	return true;
}


bool isPartOfCurve(const AcGePoint3dArray& crv1,const AcGePoint3dArray& crv2, const double& tol)
{
	if (!crv1.length() || !crv2.length()) return false;

	double dist;
	AcGeNurbCurve3d dummy(crv2);

	int i,num;
	num = crv1.length();

	for (i=0; i<num; i++) {
		dist = dummy.distanceTo(crv1[i]);
		if (dist>tol) return false;
	}

	return true;
}


bool isPartOfCurve(const AcGePoint3dArray& crv1,const AcGeCurve3d& crv2, const double& tol)
{
	double dist;

	int i,num;
	num = crv1.length();
	if (num==0) return false;

	for (i=0; i<num; i++) {
		dist = crv2.distanceTo(crv1[i]);
		if (dist>tol) return false;
	}

	return true;
}

bool isPartOfCurve(const AcGeNurbCurve3d& crv1,const AcGeCurve3d& crv2, const double& tol)
{
	AcGePoint3dArray pnts1;
	getPntsFromSpline(crv1,pnts1);
	double dist;

	int i,num;
	num = pnts1.length();
	if (num==0) return false;

	for (i=0; i<num; i++) {
		dist = crv2.distanceTo(pnts1[i]);
		if (dist>tol) return false;
	}

	return true;
}


bool isPartOfCurve(const AcGePoint2dArray& crv1,const AcGePoint2dArray& crv2, const double& tol)
{
	if (!crv1.length() || !crv2.length()) return false;

	double dist;
	AcGeNurbCurve2d dummy(crv2);

	int i,num;
	num = crv1.length();

	for (i=0; i<num; i++) {
		dist = dummy.distanceTo(crv1[i]);
		if (dist>tol) return false;
	}

	return true;
}


bool isPartOfCurve(const AcGePoint2dArray& crv1,const AcGeCurve2d& crv2, const double& tol)
{
	double dist;

	int i,num;
	num = crv1.length();
	if (num==0) return false;

	for (i=0; i<num; i++) {
		dist = crv2.distanceTo(crv1[i]);
		if (dist>tol) return false;
	}

	return true;
}

bool isPartOfCurve(const AcGeNurbCurve2d& crv1,const AcGeCurve2d& crv2, const double& tol)
{
	AcGePoint2dArray pnts1;
	getPntsFromSpline(crv1,pnts1);
	double dist;

	int i,num;
	num = pnts1.length();
	if (num==0) return false;

	for (i=0; i<num; i++) {
		dist = crv2.distanceTo(pnts1[i]);
		if (dist>tol) return false;
	}

	return true;
}

// 在节点数组中添加节点参数，形成新的节点数组，从小到大的顺序，返回其在新节点数组中的位置
int insertKnot(AcGeDoubleArray& knots,const double& val)
{
	int i,len;
	if (knots.find(val,i)) return i;

	len = knots.length();
	for (i=0; i<len; i++) {
		if (val < knots[i]) {
			knots.insertAt(i,val);
			return i;
		}
	}
	knots.insertAt(i,val);
	return i;
}

void getJoinedCurveFromPntsArray(const ChGeCurve2dPntsArray& curves, AcGeNurbCurve2d& curve)
{
	AcGePoint2dArray pnts;
	AcGeNurbCurve2d tmpCrv;

	int i,len;
	len = curves.length();
	if (len) {
		curve = AcGeNurbCurve2d(curves[0]);
	}
	for (i=1; i<len; i++) {
		tmpCrv = AcGeNurbCurve2d(curves[i]);
		curve.joinWith(tmpCrv);
	}
}

void getJoinedCurveFromPntsArray(const ChGeCurve3dPntsArray& curves, AcGeNurbCurve3d& curve)
{
	AcGePoint3dArray pnts;
	AcGeNurbCurve3d tmpCrv;

	int i,len;
	len = curves.length();
	if (len) {
		curve = AcGeNurbCurve3d(curves[0]);
	}
	for (i=1; i<len; i++) {
		tmpCrv = AcGeNurbCurve3d(curves[i]);
		curve.joinWith(tmpCrv);
	}
}

void getPolylineFromPntsArray(const ChGeCurve2dPntsArray& curves, AcGePolyline2d& curve)
{
	AcGePoint2dArray pnts;

	int i,len;
	len = curves.length();
	if (len>0) {
		pnts.append(curves.first());
	}
	for (i=1; i<len; i++) {
		pnts.removeLast();
		pnts.append(curves[i]);
	}

	curve = AcGePolyline2d(pnts);
}


void getPolylineFromPntsArray(const ChGeCurve3dPntsArray& curves, AcGePolyline3d& curve)
{
	AcGePoint3dArray pnts;
	
	int i,len;
	len = curves.length();
	if (len>0) {
		pnts.append(curves.first());
	}
	for (i=1; i<len; i++) {
		pnts.removeLast();
		pnts.append(curves[i]);
	}
	
	curve = AcGePolyline3d(pnts);
}

bool getPntsArrayFromJoinedCurve(const AcGeNurbCurve2d& curve, 
								 ChGeCurve2dPntsArray& curves, 
								 const int& intNum,
								 const double& param,
								 const double& param2,
								 const bool& bExt)
{
	double tol = AcGeContext::gTol.equalPoint();
	double stP,edP;
	bool bRev = false;  // 是否参数1大于参数2，缺省false
	if (fabs(param-param2)<=tol && fabs(param2)<=tol) {
		stP = curve.startParam();
	    edP = curve.endParam();
	} else {
		if (fabs(param-param2)<=tol) return false;
		if (param > param2) {
			bRev = true;
			stP = param2;
			edP = param;
		} else {
			bRev = false;
			stP = param;
			edP = param2;
		}
		if (!bExt) {
			AcGeInterval intrVal;
			curve.getInterval(intrVal);
			if (!intrVal.contains(param)) return false;
			if (!intrVal.contains(param2)) return false;
		}
	}

	AcGePoint2dArray pnts;
	AcGeDoubleArray params;
	curve.getParamsOfC1Discontinuity(params);
	curves.setLogicalLength(0);
	if (!bExt) {
		insertKnot(params,curve.startParam());
		insertKnot(params,curve.endParam());
	}

	int pos;
	pos = insertKnot(params,stP);
	if (pos>0) {
		params.removeSubArray(0,pos-1);
	}
	pos = insertKnot(params,edP);
	if (pos<params.length()-1) {
		params.removeSubArray(pos+1,params.length()-1);
	}

	int i,len;
	len = params.length();
	for (i=0; i+1<len; i++) {
		pnts.setLogicalLength(0);
		getPntsFromSpline(curve,pnts,intNum,params[i],params[i+1],bExt);
		if (pnts.length()) {
			if (bRev) pnts.reverse();
			curves.append(pnts);
		}
	}
	if (bRev) curves.reverse();
	return true;
}


bool getPntsArrayFromJoinedCurve(ChGeCurve2dPntsArray& curves, 
								 const AcGeNurbCurve2d& curve, 
								 const double& param,
								 const double& param2,
								 const bool& bExt)
{
	double tol = AcGeContext::gTol.equalPoint();
	double stP,edP;
	bool bRev = false;  // 是否参数1大于参数2，缺省false
	
	curves.setLogicalLength(0);
/*
	AcGe::EntityId entId;
	if (curve.isDegenerate(entId)) {
		if (entId == AcGe::kPointEnt2d) {
			return false;
		}
	}
*/

	if (fabs(param-param2)<=tol && fabs(param2)<=tol) {
		AcGeInterval intrvl;
		curve.getInterval(intrvl);
		stP = intrvl.lowerBound();
		edP = intrvl.upperBound();
//		stP = curve.startParam();
//	    edP = curve.endParam();
	} else {
		if (fabs(param-param2)<=tol) return false;
		if (param > param2) {
			bRev = true;
			stP = param2;
			edP = param;
		} else {
			bRev = false;
			stP = param;
			edP = param2;
		}
		if (!bExt) {
			AcGeInterval intrVal;
			curve.getInterval(intrVal);
			if (!intrVal.contains(param)) return false;
			if (!intrVal.contains(param2)) return false;
		}
	}

	AcGePoint2dArray pnts;
	AcGeDoubleArray params;
	curve.getParamsOfC1Discontinuity(params);
	curves.setLogicalLength(0);
	if (!bExt) {
		insertKnot(params,curve.startParam());
		insertKnot(params,curve.endParam());
	}

	int pos;
	pos = insertKnot(params,stP);
	if (pos>0) {
		params.removeSubArray(0,pos-1);
	}
	pos = insertKnot(params,edP);
	if (pos<params.length()-1) {
		params.removeSubArray(pos+1,params.length()-1);
	}

	int i,len;
	len = params.length();
	for (i=0; i+1<len; i++) {
		pnts.setLogicalLength(0);
		getPntsFromSpline(pnts,curve,params[i],params[i+1],bExt);
		if (pnts.length()) {
			if (bRev) pnts.reverse();
			curves.append(pnts);
		}
	}
	if (bRev) curves.reverse();
	return true;
}

bool getPntsArrayFromJoinedCurve(ChGeCurve3dPntsArray& curves, 
								 const AcGeNurbCurve3d& curve, 
								 const double& param,
								 const double& param2,
								 const bool& bExt)
{
	double tol = AcGeContext::gTol.equalPoint();
	double stP,edP;
	bool bRev = false;  // 是否参数1大于参数2，缺省false

	curves.setLogicalLength(0);
/*
	AcGe::EntityId entId;
	if (curve.isDegenerate(entId)) {
		if (entId == AcGe::kPointEnt3d) {
			return false;
		}
	}
*/

	if (fabs(param-param2)<=tol && fabs(param2)<=tol) {
		AcGeInterval intrvl;
		curve.getInterval(intrvl);
		stP = intrvl.lowerBound();
		edP = intrvl.upperBound();
//		stP = curve.startParam();
//	    edP = curve.endParam();
	} else {
		if (fabs(param-param2)<=tol) return false;
		if (param > param2) {
			bRev = true;
			stP = param2;
			edP = param;
		} else {
			bRev = false;
			stP = param;
			edP = param2;
		}
		if (!bExt) {
			AcGeInterval intrVal;
			curve.getInterval(intrVal);
			if (!intrVal.contains(param)) return false;
			if (!intrVal.contains(param2)) return false;
		}
	}

	AcGePoint3dArray pnts;
	AcGeDoubleArray params;
	curve.getParamsOfC1Discontinuity(params);
	curves.setLogicalLength(0);
	if (!bExt) {
		insertKnot(params,curve.startParam());
		insertKnot(params,curve.endParam());
	}

	int pos;
	pos = insertKnot(params,stP);
	if (pos>0) {
		params.removeSubArray(0,pos-1);
	}
	pos = insertKnot(params,edP);
	if (pos<params.length()-1) {
		params.removeSubArray(pos+1,params.length()-1);
	}

	int i,len;
	len = params.length();
	for (i=0; i+1<len; i++) {
		pnts.setLogicalLength(0);
		getPntsFromSpline(pnts,curve,params[i],params[i+1],bExt);
		if (pnts.length()) {
			if (bRev) pnts.reverse();
			curves.append(pnts);
		}
	}
	if (bRev) curves.reverse();
	return true;
}


// 转换3d点数组为2d点数组
void points3dTo2d(const AcGePoint3dArray& pnts3d,AcGePoint2dArray& pnts2d)
{
	int i,len;
	len = pnts3d.length();
	pnts2d.setLogicalLength(len);

	for (i=0; i<len; i++) {
		pnts2d[i] = AcGePoint2d(pnts3d[i].x,pnts3d[i].y);
	}
}

// 转换2d点数组为3d点数组
void points2dTo3d(const AcGePoint2dArray& pnts2d,AcGePoint3dArray& pnts3d,const double& z)
{
	int i,len;
	len = pnts2d.length();
	pnts3d.setLogicalLength(len);

	for (i=0; i<len; i++) {
		pnts3d[i] = AcGePoint3d(pnts2d[i].x,pnts2d[i].y,z);
	}
}

void curve3dTo2d(const AcGeNurbCurve3d& crv,AcGeNurbCurve2d& crv2d)
{
	int degree;
	Adesk::Boolean rational,periodic;
	AcGeKnotVector knots;
	AcGePoint3dArray controlPoints;
	AcGePoint2dArray controlPoints2d;
	AcGeDoubleArray weights;
	
	crv.getDefinitionData(degree,rational,periodic,knots,controlPoints,weights);
	points3dTo2d(controlPoints,controlPoints2d);
	crv2d = AcGeNurbCurve2d(degree,knots,controlPoints2d,weights,periodic);
}

int joinPntsArrayWithPnts(ChGePnts2dArray& pntsArr, const AcGePoint2dArray& pnts)
{
	int pos = -1;
	
	for (int j=0,LenArr=pntsArr.length(); j<LenArr; j++) {
		if (pnts.first().isEqualTo(pntsArr[j].last())) {
			pos = j+1;
			break;
		}
	}
	if (pos != -1) {
		pntsArr.insertAt(pos,pnts);
	}
	return pos;
}

int joinPntsArrayWithPntsArray(ChGePnts2dArray& pntsArr, const ChGePnts2dArray& pntsArr2)
{
	AcGePoint2d fp,lp;
	int pos = -1;
	fp = pntsArr2.first().first();
	lp = pntsArr2.last().last();
	
	bool bRev=false;
	int j,LenArr;
	LenArr = pntsArr.length();
	for (j=0; j<LenArr; j++) {
		if (fp.isEqualTo(pntsArr[j].last())) {
			pos = j+1;
			break;
		}
		if (lp.isEqualTo(pntsArr[j].last())) {
			bRev = true;
			pos = j+1;
			break;
		}
	}
	if (pos != -1) {
		LenArr = pntsArr2.length();
		if (!bRev) {
			for (j=LenArr-1; j>-1; j--) {
				pntsArr.insertAt(pos,pntsArr2[j]);