geutilities.cpp

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

	double sc;

	sc = (pnts1[2]-pnts1[0]).length()/(pnts1[1]-pnts1[0]).length();

	pnts2[2] = pnts2[0] + (pnts2[1]-pnts2[0])*sc;
	
}


bool mapPointTriangle(AcGePoint2dArray& pnts, AcGePoint2dArray& mpnts, bool bIfMapOut)
{
	if (pnts.length()!=4 || mpnts.length()!=4) return false;
	
	int pos;
	
	pos = pointPosToTriangle(pnts[3],pnts);
	if (pos>0) {
		mapPointOnTriangle(pnts,pos,mpnts);
		return true;
	} else if (pos==0) {
		mapPointInTriangle(pnts,mpnts);
		return true;
	} else {
		if (bIfMapOut) {
			mapPointInTriangle(pnts,mpnts);
		}
	}
	
	return false;
}


// 三角形上(内，顶点，边)，得出其映射点
bool mapPointOnTriangle(AcGePoint2dArray& pnts, int pos, AcGePoint2dArray& mpnts)
{
	if (pos<1 || pos>6) return false;
	if (pnts.length()!=4 || mpnts.length()!=4) return false;

	AcGePoint2dArray line,mline;
	line.setLogicalLength(3);
	mline.setLogicalLength(3);

	switch(pos) {
	case 1:
		mpnts[3] = mpnts[0];
		break;
	case 2:
		mpnts[3] = mpnts[1];
		break;
	case 3:
		mpnts[3] = mpnts[2];
		break;
	case 4:
		line[0] = pnts[0];
		line[1] = pnts[1];
		line[2] = pnts[3];
		mline[0] = mpnts[0];
		mline[1] = mpnts[1];
		mapPointInLine(line,mline);
		mpnts[3] = mline[2];
		break;
	case 5:
		line[0] = pnts[1];
		line[1] = pnts[2];
		line[2] = pnts[3];
		mline[0] = mpnts[1];
		mline[1] = mpnts[2];
		mapPointInLine(line,mline);
		mpnts[3] = mline[2];
		break;
	case 6:
		line[0] = pnts[2];
		line[1] = pnts[0];
		line[2] = pnts[3];
		mline[0] = mpnts[2];
		mline[1] = mpnts[0];
		mapPointInLine(line,mline);
		mpnts[3] = mline[2];
		break;
	}

	return true;
}

Adesk::Boolean isOnCurve(const AcGePoint2d& pnt, const AcGeNurbCurve2d& curve,const double& tol)
{
	AcGePoint2d tmpp;
	AcGeVector2dArray derivs;
	AcGeVector2d vec;
	tmpp = curve.closestPointTo(pnt);
	if(tmpp.distanceTo(pnt)<tol) return true;

	return false;
}

Adesk::Boolean isOnCurve(const AcGePoint2d& pnt, const AcGePolyline2d& ply,const double& tol)
{
	double dist;
	int i,len;
	AcGeLineSeg2d line;

	len = ply.numFitPoints();

	for (i=0; i<len-1; i++) {
		line.set(ply.fitPointAt(i),ply.fitPointAt(i+1));
		dist = line.distanceTo(pnt);
		if (dist < tol) return true;
	}
	
	return false;
}

Adesk::Boolean isClockwise(const AcGePoint2d& pnt, const AcGePolyline2d& ply)
{
	AcGePoint2d closestPnt,tmpPnt;
	AcGeVector2d vec,vec2,vec3;

	double dist,min;
	int i,len,minIndex;
	AcGeLineSeg2d lineseg;
	len = ply.numFitPoints();
	closestPnt = ply.fitPointAt(0);
	min = pnt.distanceTo(closestPnt);
	minIndex = 0;
	for (i=0; i<len-1; i++) {
		lineseg.set(ply.fitPointAt(i),ply.fitPointAt(i+1));
		tmpPnt = lineseg.closestPointTo(pnt);
		dist = pnt.distanceTo(tmpPnt);
		if (dist < min) {
			minIndex = i;
			min = dist;
			closestPnt = tmpPnt;
		}
	}
	vec = pnt - closestPnt;

	if (len == 2) {
		vec2 = ply.fitPointAt(1) - ply.fitPointAt(0);
		return isClockwise(vec2,vec);
	}

	if (!closestPnt.isEqualTo(ply.fitPointAt(minIndex))
		&& !closestPnt.isEqualTo(ply.fitPointAt(minIndex+1))) {
		// 最近点不是顶点
		vec2 = ply.fitPointAt(minIndex+1) - ply.fitPointAt(minIndex);
		return isClockwise(vec2,vec);
	}

	if (closestPnt.isEqualTo(ply.fitPointAt(minIndex+1))) {
		minIndex = minIndex + 1;
	}

	if (   minIndex == 0 || minIndex == len-1 ) {
		if (ply.fitPointAt(0).isEqualTo(ply.fitPointAt(len-1))) {
			vec2 = closestPnt - ply.fitPointAt(len-2);
			vec3 = ply.fitPointAt(1) - closestPnt;
		} else {
			if (minIndex == 0) {
				vec2 = ply.fitPointAt(1) - closestPnt;
			} else {
				vec2 = closestPnt - ply.fitPointAt(len-2);
			}
			return isClockwise(vec2,vec);
		}
	} else {
		vec2 = ply.fitPointAt(minIndex) - ply.fitPointAt(minIndex-1);
		vec3 = ply.fitPointAt(minIndex+1) - ply.fitPointAt(minIndex);
	}

	if (isClockwise(vec2,vec3)) {
		if (isClockwise(vec2,vec) && isClockwise(vec3,vec)) {
			return Adesk::kTrue;
		} else {
			return Adesk::kFalse;
		}
	} else {
		if (isClockwise(vec2,vec) || isClockwise(vec3,vec)) {
			return Adesk::kTrue;
		} else {
			return Adesk::kFalse;
		}
	}
}


Adesk::Boolean isClockwise(const AcGePoint2d& pnt, const AcGeNurbCurve2d& spl)
{
	AcGePoint2d closedPnt;
	double param;
	AcGePointOnCurve2d pntOncrv;
	AcGeVector2d vec,vec2,vec3;

	spl.getClosestPointTo(pnt,pntOncrv);
	param = pntOncrv.parameter();
	closedPnt = pntOncrv.point();
	vec = pnt-closedPnt;

	if (   param == spl.startParam()
		|| param == spl.endParam()) {
		if (spl.startPoint().isEqualTo(spl.endPoint())) {
			vec2 = pntOncrv.deriv(1,spl.endParam());
			vec3 = pntOncrv.deriv(1,spl.startParam());
		} else {
			vec2 = pntOncrv.deriv(1);
			return isClockwise(vec2,vec);
		}
	} else {
		AcGeDoubleArray params;
		spl.getParamsOfG1Discontinuity(params);
		
		if (params.contains(param)) {
			// 该点为方向矢量不连续点
			vec3 = pntOncrv.deriv(1);
			AcGeNurbCurve2d splCopy(spl);
			splCopy.hardTrimByParams(splCopy.startParam(),param);
			pntOncrv.setCurve(splCopy);
			vec2 = pntOncrv.deriv(1,param);
		} else {
			vec2 = pntOncrv.deriv(1);
			return isClockwise(vec2,vec);
		}
	}

	if (isClockwise(vec2,vec3)) {
		if (isClockwise(vec2,vec) && isClockwise(vec3,vec)) {
			return Adesk::kTrue;
		} else {
			return Adesk::kFalse;
		}
	} else {
		if (isClockwise(vec2,vec) || isClockwise(vec3,vec)) {
			return Adesk::kTrue;
		} else {
			return Adesk::kFalse;
		}
	}
}

/*
// verify if point is on the right of curve
Adesk::Boolean isClockwise(const AcGePoint2d& pnt, const AcGeCurve2d& crv)
{
	AcGePoint2d tmpp;
	AcGeVector2d deriv;
	AcGeVector2d vec;
	AcGePointOnCurve2d pntOnCrv;

	crv.getClosestPointTo(pnt,pntOnCrv);
	tmpp = pntOnCrv.point();

	double param1,len;
	AcGeInterval intrvl;
	crv.getInterval(intrvl);
	param1 = pntOnCrv.parameter();
	vec = pnt-tmpp;
	len = crv.length(intrvl.lowerBound(),intrvl.upperBound())/1000;
	double param2,param3;
	if (   crv.length(param1,intrvl.upperBound()) < len
		|| crv.length(intrvl.lowerBound(),param1) < len) {
		// 最近点在曲线尾或头
		if ( !crv.evalPoint(intrvl.lowerBound()).isEqualTo(
			  crv.evalPoint(intrvl.upperBound()))) {
			deriv = pntOnCrv.deriv(1);
			return isClockwise(deriv,vec);
		} else {
			param1 = intrvl.lowerBound();
			param2 = crv.paramAtLength(intrvl.upperBound(),len,Adesk::kFalse);
			param3 = crv.paramAtLength(param1,len);
		}
	} else {
		param2 = crv.paramAtLength(param1,len,Adesk::kFalse);
		param3 = crv.paramAtLength(param1,len);
	}

	AcGeVector2d vec2,vec3;
	vec2 = tmpp - crv.evalPoint(param2);
	vec3 = crv.evalPoint(param3) - tmpp;

	if (isClockwise(vec2,vec3)) {
		if (!isClockwise(vec2,vec) || !isClockwise(vec3,vec)) {
			return Adesk::kFalse;
		} else {
			return Adesk::kTrue;
		}
	} else {
		if (isClockwise(vec2,vec) || isClockwise(vec3,vec)) {
			return Adesk::kTrue;
		} else {
			return Adesk::kFalse;
		}
	}
}
*/

Adesk::Boolean isCurveStartPoint(const AcGePoint2d& pnt, const AcGeCurve2d& curve,const double& tol)
{
	AcGePoint2d stPoint;
	curve.hasStartPoint(stPoint);

	if(pnt.distanceTo(stPoint)<tol) return true;
	return false;
}

Adesk::Boolean isCurveEndPoint(const AcGePoint2d& pnt, const AcGeCurve2d& curve,const double& tol)
{
	AcGePoint2d edPoint;
	curve.hasEndPoint(edPoint);

	if(pnt.distanceTo(edPoint)<tol) return true;
	return false;
}

int pointPosToExLoop(const AcGePoint2d& point,const ChGeLoop2d& loop,const double& tol)
{
	int len=loop.length();
	AcGeNurbCurve2d curve;
	for(int i=0;i<len;i++) {
		curve = AcGeNurbCurve2d(loop[i]);
		if(isCurveStartPoint(point,curve,tol)) return (i+1);
	}
	for(i=0;i<len;i++) {
		curve = AcGeNurbCurve2d(loop[i]);
		if(isOnCurve(point,curve,tol)) return len+(i+1);
		if(isClockwise(point,curve)) return -1;
	}

	return 0;
}

int pointPosToInLoop(const AcGePoint2d& point,const ChGeLoop2d& loop,const double& tol)
{
	int len=loop.length();
	AcGeNurbCurve2d curve;
	for(int i=0;i<len;i++) {
		curve = AcGeNurbCurve2d(loop[i]);
		if(isCurveStartPoint(point,curve,tol)) return (i+1);
	}
	for(i=0;i<len;i++) {
		curve = AcGeNurbCurve2d(loop[i]);
		if(isOnCurve(point,curve,tol)) return len+(i+1);
		if(!isClockwise(point,curve)) return -1;
	}

	return 0;
}


// 当param=param2=0时，表示全部段
bool getPntsFromSpline(const AcGeNurbCurve3d& curve,AcGePoint3dArray& pnts, 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;
		} else 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(stP)) return false;
			if (!intrVal.contains(edP)) return false;
		}
	}

	AcGeKnotVector cknots;
	AcGeDoubleArray params;
	int i,j,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;

	double step,tmpVal;
	for (i=startPos; i<endPos; i++) {
		step = (params[i+1]-params[i])/(intNum+1);
		tmpVal = params[i];
		dummy.append(curve.evalPoint(tmpVal));
		for (j=1; j<intNum+1; j++) {
			tmpVal = tmpVal + step;
			dummy.append(curve.evalPoint(tmpVal));
		}
	}
	dummy.append(curve.evalPoint(params[endPos]));
	if (bRev) {
		dummy.reverse();
	}
	pnts = dummy;

	return true;
}


// 当param=param2=0时，表示全部段
bool getPntsFromSpline(const AcGeNurbCurve2d& curve,AcGePoint2dArray& pnts, 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;
		}
	}

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

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

	double step,tmpVal;
	for (i=startPos; i<endPos; i++) {
		step = (params[i+1]-params[i])/(intNum+1);
		tmpVal = params[i];
		dummy.append(curve.evalPoint(tmpVal));
		for (j=1; j<intNum+1; j++) {
			tmpVal = tmpVal + step;
			dummy.append(curve.evalPoint(tmpVal));
		}
	}
	dummy.append(curve.evalPoint(params[endPos]));
	if (bRev) {
		dummy.reverse();
	}
	pnts = dummy;

	return true;
}


bool getPntsFromSpline(AcGePoint2dArray& pnts,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
	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;
		}
	}

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

	AcGePoint2dArray 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 getPntsFromSpline(AcGePoint3dArray& pnts,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
	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;