#include "stdafx.h"




//自定义函数
extern int GetContourDivNum(double dPerimeter);
extern XPoint GetWeightCenter(const XPoly2D& poly);


const Adesk::UInt8 TDbPolyMesh::g_nVersion = 1;

ACRX_DXF_DEFINE_MEMBERS(ATSPolyMesh, ATSCurveMesh, AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent, 1, ATS_POLYMESH, "ATS_POLYMESH图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbPolyMesh);


TDbPolyMesh::TDbPolyMesh()
{
}

TDbPolyMesh::~TDbPolyMesh()
{
}


//三点的夹角
double TDbPolyMesh::
Angle(const XPoint& from,const XPoint& to1,const XPoint& to2) const
{
	XVector3D vt1 = to1 - from;
	XVector3D vt2 = to2 - from;
	AcGeVector3d v1 = vt1;
	AcGeVector3d v2 = vt2;
	AcGeVector3d vRef = v1.crossProduct(v2);

	return v1.angleTo(v2, vRef);
}

//二次插值(Z2、R2为中间的值)
double TDbPolyMesh::Parabola(double Z,double Z1,double Z2,
				double Z3,double R1,double R2,double R3) const
{
	if (fabs(Z1-Z2)<1.0E-9)	return Z1;
	if (fabs(Z1-Z3)<1.0E-9)	return (Z1+Z3)/2.0;
	if (fabs(Z2-Z3)<1.9E-9)	return Z3;

	double a = R1 / ( (Z1-Z2) * (Z1-Z3) ) +
			   R2 / ( (Z2-Z1) * (Z2-Z3) ) +
			   R3 / ( (Z3-Z1) * (Z3-Z2) );
	double b = (R1-R2) / (Z1-Z2) - (Z1+Z2) * a;
	double c = R1 - a*Z1*Z1 - b*Z1;

	double dRadius = a*Z*Z + b*Z + c;
	return dRadius;
}

BOOL TDbPolyMesh::AppendToMesh(const XContour3D& shape,
								const int	nTotalVertex,
								XVector3D&	 vtAlignment,
								XPoint*&	    pPtArray,
								int&  nPtArrayIndex) const
{
	XContour3D shapeTemp = shape;
	int nCount = shapeTemp.Length();
	if (nCount <= 0)   return FALSE;

	XVector3D vtStartVert = *shapeTemp[0] - shapeTemp.m_ptCenter;
	AcGeVector3d vtAlignmentProjectOnContour = 
		((AcGeVector3d)vtAlignment).orthoProject((AcGeVector3d)shapeTemp.m_vtNormal);
	double angle = ((AcGeVector3d)vtStartVert).angleTo(vtAlignmentProjectOnContour,
		((AcGeVector3d)shapeTemp.m_vtNormal));

	//shapeTemp.RotateBy(angle, shapeTemp.m_vtNormal, shapeTemp.m_ptCenter);
	vtAlignment = *shapeTemp[0] - shapeTemp.m_ptCenter;
	
	for (int i=0; i<nCount; i++,nPtArrayIndex++) {
		if (nPtArrayIndex < nTotalVertex) {
			pPtArray[nPtArrayIndex] = *shapeTemp[i];
		}
		else   return FALSE;
	}
	pPtArray[nPtArrayIndex++] = *shapeTemp[0];

	return TRUE;
}

static BOOL IsExit(const DList<double>& lstAngle,double dAngle)
{
	int nCount = lstAngle.Length();
	for (int i=0; i<nCount; i++) {
		double dTemp = fabs(lstAngle[i]-dAngle);
		if (dTemp<1.0E-3)
			return TRUE;
	}
	return FALSE;
}

static void GetShapeAngle(const DList<XPoly2D>& lstShape,
						  DList<double>& lstAngle)
{
	int nCount = lstShape.Length();
	for (int i=0; i<nCount; i++) {
		XPoly2D polyTemp = lstShape[i];
		XPoint ptWeightCenter=GetWeightCenter(polyTemp);
		int nVertex = polyTemp.Length();
		for (int j=0; j<nVertex; j++) {
			XPoint& ptVertex = *polyTemp[j];
			double dAngle = ads_angle(ptWeightCenter,ptVertex);
			if (!IsExit(lstAngle,dAngle))
				lstAngle.Append(new double(dAngle));
		}
	}
}

static int CompareSize(const double *p1, const double *p2)
{
    if(*p1 > *p2)
        return 1;
    return -1;
}


//取得网格参数(行、列和点链表)
BOOL TDbPolyMesh::
GetSurfaceMesh(int &nRows,int &nCols,XPoint* &pPtArray) const
{
	if (pPtArray) delete [] pPtArray;

	//截面、基点和位置（距离）
	DList<XPoly2D> lstShape;
	DList<XPoint>  lstBase;
	DList<double>  lstDistScale;
	XPoly2D	polyPath(m_polyBase);
	GetAllShapeBases(lstBase);
	GetAllShapePolys(lstShape);
	GetDistScales(lstDistScale);

	int nShapeNum = lstShape.Length();
	if (nShapeNum<2 || polyPath.Length()<1 ||
		lstBase.Length()!=nShapeNum || 
		lstDistScale.Length()!=nShapeNum-2) {
		nRows = 0,	nCols = 0;
		return FALSE;
	}

	//截面顶点数
	int nVertexNum = 90;
	double dPolyDisance = (*lstShape[0]).Distance3d();
	for (int k=1; k<nShapeNum; k++) {
		dPolyDisance += (*lstShape[k]).Distance3d();
	}
	nVertexNum = GetContourDivNum(dPolyDisance/nShapeNum);
	if (nVertexNum < 3) {
		adsout << _T("\n顶点数太少！请重新设置参数或者增大该实体。");
		return FALSE;
	}


	//所有截面的的顶点的角度
	DList<double> lstOtherAngle;
	GetShapeAngle(lstShape,lstOtherAngle);
	//排序（有小到大）
	lstOtherAngle.QuickSort(CompareSize);

	//路径在两个截面时不用离散直线
	TPolyPath	pathExtrude(polyPath,(nShapeNum!=2?TRUE:FALSE));
	XContour2D	contourStart(*lstShape[0],*lstBase[0],nVertexNum,lstOtherAngle);
	XContour2D	contourEnd(*lstShape[nShapeNum-1],*lstBase[nShapeNum-1],nVertexNum,lstOtherAngle);
	const XContour3D shapeStart(contourStart,XVector3D(0,0,1));
	const XContour3D shapeEnd(contourEnd,XVector3D(0,0,1));

	if (shapeStart.Length()!=shapeEnd.Length() ||
		pathExtrude.Length()<nShapeNum || shapeStart.Length()<3) {
		nRows = 0,	nCols = 0;
		return FALSE;
	}

	//截面半径，和相应的角度,基点半径和角度
	DList<double> lstAngle, lstRadiusStart, lstRadiusEnd;
	contourStart.GetAngles(lstAngle);
	contourStart.GetRadius(lstRadiusStart);
	contourEnd.GetRadius(lstRadiusEnd);
	double dBaseAngleStart = contourStart.GetBaseAngle();
	double dBaseAngleEnd = contourEnd.GetBaseAngle();
	double dBaseScaleStart = contourStart.GetBaseScale();
	double dBaseScaleEnd = contourEnd.GetBaseScale();

	int nNumOnPath     = pathExtrude.Length();
	int nNumOnContour  = contourStart.Length();
	int nVertNumOnMesh = nNumOnPath*(nNumOnContour+1);
	nRows = nNumOnPath;
	nCols = nNumOnContour+1;

	double dPathLength = pathExtrude.GetDistAtVertex(nNumOnPath-1);
	if ( dPathLength <= 0 ) {
		nRows = 0,	nCols = 0;
		return FALSE;
	}
	pPtArray = new XPoint[nVertNumOnMesh];
	int nPtArrayIndex = 0;

	XVector3D vtAlignment;
	XPoint pt0, pt1, pt2, pt3;

	XContour3D shapeThis = shapeStart;
	vtAlignment = *shapeThis[0] - shapeThis.m_ptCenter;
	pt0 = *pathExtrude[0];
	pt1 = *pathExtrude[1];

	// sg add 080902，解决变截面体首、末截面没有垂直的问题(论坛问题1017)
	AcDbPolyline pline;
	PolyConvert(polyPath, pline);
	AcGeVector3d vec;
	pline.getFirstDeriv(pt0.AsAcGePoint3d(), vec); // 求切线向量

// 	shapeThis.AttachOn(pt0, pt1-pt0); // sg modify 080902
	shapeThis.AttachOn(pt0, XVector3D(vec));
	AppendToMesh(shapeThis, nVertNumOnMesh, vtAlignment, pPtArray, nPtArrayIndex);

	//构造中间截面的步数
	int nStep = nNumOnPath-1;
	//两个截面时，采用线性插值
	if (nShapeNum == 2) {
		for (int j=1; j<nStep; j++ ) {
			XContour2D contourThis = contourStart;
			//构造截面顶点
			double dAngle=0, dRadius=0;
			double dDist = pathExtrude.GetDistAtVertex(j);
			double dDistScale = dDist/dPathLength;
			XPoint ptCenter = contourThis.GetWeightCenter();
			for (int i=0; i<nNumOnContour; i++ ) {
				dAngle  = *lstAngle[i];
				dRadius = *lstRadiusStart[i] +
					(*lstRadiusEnd[i] - *lstRadiusStart[i])*dDistScale;
				XPoint& ptTemp = *contourThis[i];
				ptTemp.x = ptCenter.x + dRadius*cos(dAngle);
				ptTemp.y = ptCenter.y + dRadius*sin(dAngle);
			}
			//构造截面基点
			dAngle  = dBaseAngleStart +
				(dBaseAngleEnd-dBaseAngleStart)*dDistScale;
			double dBaseScale = dBaseScaleStart +
				(dBaseScaleEnd-dBaseScaleStart)*dDistScale;
			dRadius = contourThis.GetRadius(dAngle);
			dRadius *= dBaseScale;
			XPoint& ptTemp = contourThis.m_ptBase;
			ptTemp.x = ptCenter.x + dRadius*cos(dAngle);
			ptTemp.y = ptCenter.y + dRadius*sin(dAngle);
			
			pt1 = *pathExtrude[j-1];
			pt2 = *pathExtrude[j];
			pt3 = *pathExtrude[j+1];
			
			shapeThis = XContour3D(contourThis,XVector3D(0,0,1));
			double dEdgeHalfAngle = 0.5*Angle(pt2, pt1, pt3);
			double dScale = sin(dEdgeHalfAngle);
			if (fabs(dScale)<1.0E-9) // ZJQ Modify here
				continue;
			dScale = 1/dScale;
			shapeThis.ScaleBy(dScale, shapeThis.m_ptCenter);
			
			XVector3D vt3Sub1 = pt3-pt1;
			XVector3D vt2Sub1 = pt2-pt1;
			XVector3D vt3Sub2 = pt3-pt2;
			XVector3D vtRotateAxis = ((AcGeVector3d)vt3Sub1).crossProduct((AcGeVector3d)vt2Sub1);
			double dRotateAngle = 0.5*PI - dEdgeHalfAngle;
			AcGeVector3d vtContourNormal = vt3Sub2;
			vtContourNormal.rotateBy(dRotateAngle, (AcGeVector3d)vtRotateAxis);
			shapeThis.AttachOn(pt2, vtContourNormal);
			
			AppendToMesh(shapeThis, nVertNumOnMesh, vtAlignment, pPtArray, nPtArrayIndex);
		}
	}
	//三个截面时，采用二次插值
	else if (nShapeNum == 3) {
		//第二个截面
		XContour2D	contourShape2(*lstShape[1],*lstBase[1],nVertexNum,lstOtherAngle);
		if (contourStart.Length() != contourShape2.Length()) {
			if (pPtArray) delete [] pPtArray;
			nRows = 0,	nCols = 0;
			return FALSE;
		}
		DList<double> lstRadiusShape2;
		contourShape2.GetRadius(lstRadiusShape2);
		double dBaseRadiusShape2 = contourShape2.GetBaseRadius();
		double dBaseAngleShape2  = contourShape2.GetBaseAngle();
		double dBaseScaleShape2  = contourShape2.GetBaseScale();
		double Z2 = dPathLength * (*lstDistScale[0]);
		
		for (int j=1; j<nStep; j++ ) {
			XContour2D contourThis = contourStart;
			//构造截面顶点
			double dAngle=0, dRadius=0;
			double dDist = pathExtrude.GetDistAtVertex(j);
			XPoint ptCenter = contourThis.GetWeightCenter();
			for (int i=0; i<nNumOnContour; i++ ) {
				dAngle  = *lstAngle[i];
				dRadius = Parabola(dDist,0,Z2,dPathLength,
					*lstRadiusStart[i],*lstRadiusShape2[i],*lstRadiusEnd[i]);				
				XPoint& ptTemp = *contourThis[i];
				ptTemp.x = ptCenter.x + dRadius*cos(dAngle);
				ptTemp.y = ptCenter.y + dRadius*sin(dAngle);
			}
			//构造截面基点
			dAngle = Parabola(dDist,0,Z2,dPathLength,
				dBaseAngleStart,dBaseAngleShape2,dBaseAngleEnd);	
			double dBaseScale = Parabola(dDist,0,Z2,dPathLength,
				dBaseScaleStart,dBaseScaleShape2,dBaseScaleEnd);
			dRadius = contourThis.GetRadius(dAngle);
			dRadius *= dBaseScale;
			XPoint& ptTemp = contourThis.m_ptBase;
			ptTemp.x = ptCenter.x + dRadius*cos(dAngle);
			ptTemp.y = ptCenter.y + dRadius*sin(dAngle);
			
			pt1 = *pathExtrude[j-1];
			pt2 = *pathExtrude[j];
			pt3 = *pathExtrude[j+1];
			
			shapeThis = XContour3D(contourThis,XVector3D(0,0,1));
			//转角处由转角决定截面的放大或缩小
			double dEdgeHalfAngle = 0.5*Angle(pt2, pt1, pt3);
			double dScale = sin(dEdgeHalfAngle);
			if (fabs(dScale)<1.0E-9)  // ZJQ Modify here
				continue;
			dScale = 1/dScale;
			shapeThis.ScaleBy(dScale, shapeThis.m_ptCenter);
			
			XVector3D vt3Sub1 = pt3-pt1;
			XVector3D vt2Sub1 = pt2-pt1;
			XVector3D vt3Sub2 = pt3-pt2;
			XVector3D vtRotateAxis = ((AcGeVector3d)vt3Sub1).crossProduct((AcGeVector3d)vt2Sub1);
			double dRotateAngle = 0.5*PI - dEdgeHalfAngle;
			//截面法线向量
			AcGeVector3d vtContourNormal = vt3Sub2;
			vtContourNormal.rotateBy(dRotateAngle, (AcGeVector3d)vtRotateAxis);
			shapeThis.AttachOn(pt2, vtContourNormal);
			
			AppendToMesh(shapeThis, nVertNumOnMesh, vtAlignment, pPtArray, nPtArrayIndex);
		}
	}
	//三个以上截面时
	else {
		;
	}

	shapeThis = shapeEnd;
	pt0 = *pathExtrude[nStep-1];
	pt1 = *pathExtrude[nStep];

	// sg add 080902，解决变截面体首、末截面没有垂直的问题(论坛问题1017)
	pline.getFirstDeriv(pt1.AsAcGePoint3d(), vec); // 求切线向量

// 	shapeThis.AttachOn(pt1, pt1-pt0); // sg modify 080902
	shapeThis.AttachOn(pt1, XVector3D(vec));
	AppendToMesh(shapeThis, nVertNumOnMesh, vtAlignment, pPtArray, nPtArrayIndex);

	return TRUE;
}


//是否正确（有效）
BOOL TDbPolyMesh::IsValid() const
{
	assertReadEnabled();
	if (!TDbCurveMesh::IsValid())  return FALSE;

	assert(m_polyShape.IsClosed());
	if (m_polyShape.Length() <= 0) return FALSE;

	int nShapeNum = m_lstShapePoly.Length();
	int nBaseNum  = m_lstShapeBase.Length();
	int nDistNum  = m_lstDistScale.Length();
	assert(nShapeNum == nBaseNum);
	nShapeNum++;
	if (nShapeNum > 1)
		assert(nShapeNum-2 == nDistNum);

	nShapeNum--;
    for (int i=0; i<nShapeNum; i++) {
		XPoly2D polyShape = m_lstShapePoly[i];
		assert(polyShape.IsClosed());
		if (polyShape.Length() <= 0) return FALSE;
	}
	for (i=0; i<nDistNum; i++) {
		assert(m_lstDistScale[i] < 1);
		assert(m_lstDistScale[i] > 0);
	}

    return TRUE;
}


Acad::ErrorStatus 
TDbPolyMesh::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}


// 输入来自于DWG文件的文档数据:
Acad::ErrorStatus TDbPolyMesh::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	es = TDbCurveMesh::dwgInFields(pFiler);
	if(es != Acad::eOk)	  return es;

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer > g_nVersion) return Acad::eMakeMeProxy;	
	
	//截面链表
	m_lstShapePoly.Reset();
	Adesk::UInt16 nShapeCount=0;
	pFiler->readItem(&nShapeCount);
	for(Adesk::UInt16 i = 0; i < nShapeCount; i++) {
		XPoly2D polyShape(1);
		Adesk::UInt16 nLength=0;
		pFiler->readItem(&nLength);
		for(Adesk::UInt16 j = 0; j < nLength; j++) {
			AcGePoint3d ptOnShape;
			double dBulge=0.0;
			pFiler->readItem(&ptOnShape);
			pFiler->readItem(&dBulge);
			polyShape.AppendNode(XPoint(ptOnShape), dBulge);
		}
		m_lstShapePoly.Append(new XPoly2D(polyShape));
	}
	//截面位置
	m_lstDistScale.Reset();
	Adesk::UInt16 nDistCount=0;
	pFiler->readItem(&nDistCount);
	for(i = 0; i < nDistCount; i++) {
		double dTemp=0;
		pFiler->readItem(&dTemp);
		m_lstDistScale.Append(new double(dTemp));
	}
	//基点链表
	m_lstShapeBase.Reset();
	Adesk::UInt16 nBaseCount=0;
	pFiler->readItem(&nBaseCount);
	for(i = 0; i < nBaseCount; i++) {
		AcGePoint3d ptShapeBase;
		pFiler->readItem(&ptShapeBase);
		m_lstShapeBase.Append(new XPoint(ptShapeBase));
	}
	
	return pFiler->filerStatus();
}

// 文档数据输出到一个DWG文件：
Acad::ErrorStatus TDbPolyMesh::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	if (!IsValid())	return Acad::eInvalidInput;

	Acad::ErrorStatus es = Acad::eOk;
	es = TDbCurveMesh::dwgOutFields(pFiler);
	if(es != Acad::eOk) return es;

	pFiler->writeItem(g_nVersion);

	//截面链表
	Adesk::UInt16 nShapeCount = m_lstShapePoly.Length();
	pFiler->writeItem(nShapeCount);
	for(Adesk::UInt16 i = 0; i < nShapeCount; i++) {
		XPoly2D polyShape = m_lstShapePoly[i];
		Adesk::UInt16 nLength = polyShape.Length();
		pFiler->writeItem(nLength);
		for(Adesk::UInt16 j = 0; j < nLength; j++) {
			pFiler->writeItem((AcGePoint3d &)*polyShape[j]);
			pFiler->writeItem(polyShape.GetBulge(j));
		}
	}
	//截面位置
	Adesk::UInt16 nDistCount = m_lstDistScale.Length();
	pFiler->writeItem(nDistCount);
	for(i = 0; i < nDistCount; i++) {
		pFiler->writeItem(m_lstDistScale[i]);
	}
	//基点链表
	Adesk::UInt16 nBaseCount = m_lstShapeBase.Length();
	pFiler->writeItem(nBaseCount);
	for(i = 0; i < nBaseCount; i++) {
		pFiler->writeItem((AcGePoint3d &)m_lstShapeBase[i]);
	}

	return pFiler->filerStatus();
}

//  从DXF文件读入文档数据：
Acad::ErrorStatus TDbPolyMesh::dxfInFields (AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;	
	es = TDbCurveMesh::dxfInFields(pFiler);
    if(es != Acad::eOk)
		return es;	
    if (!pFiler->atSubclassData(_T("TDbPolyMesh")))
        return Acad::eBadDxfSequence;
    /*
	m_lstShapePoly.Reset();
	m_lstShapeBase.Reset();
	m_lstDistScale.Reset();

	DList<Adesk::UInt16> lstVertexNum;
	DList<XPoint>		 lstVertexPt;
    DList<double>		 lstBulge;
	resbuf				 rb;
    while ((es == Acad::eOk)
		&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
        switch (rb.restype) {
		case AcDb::kDxfInt16://截面顶点数链表
			lstVertexNum.Append(new Adesk::UInt16(rb.resval.rint));
			break;
		case AcDb::kDxfXCoord://截面链表
            lstVertexPt.Append(new XPoint(rb.resval.rpoint));
            break;
		case AcDb::kDxfYCoord://基点链表
            m_lstShapeBase.Append(new XPoint(rb.resval.rpoint));
            break;
		case AcDb::kDxfAngle://截面Bulge
			lstBulge.Append(new double(rb.resval.rreal));
			break;
		case AcDb::kDxfReal://截面位置
			m_lstDistScale.Append(new double(rb.resval.rreal));
			break;
        default:
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }
    if (es != Acad::eEndOfFile)
		return Acad::eInvalidResBuf;

	//截面链表
	Adesk::UInt16 nShapeCount = lstVertexNum.Length();
	Adesk::UInt16 nTotalVertex=0;
	for(Adesk::UInt16 i = 0; i < nShapeCount; i++) {
		Adesk::UInt16 nVertex = *lstVertexNum[i];
		if (nVertex < 2) {
			pFiler->setError(_T("\nError DXF group code: 10, 50"));
			return Acad::eMissingDxfField;
		}
		nTotalVertex += nVertex;
	}
	if(nTotalVertex!=lstVertexPt.Length() || nTotalVertex!=lstBulge.Length()) {
        pFiler->setError(_T("\nError DXF group code: 10, 50"));
        return Acad::eMissingDxfField;
	}

	int nVertexBefore = 0;
	for(i = 0; i < nShapeCount; i++) {
		Adesk::UInt16 nVertex = *lstVertexNum[i];
		XPoly2D polyShape(1);
		for (Adesk::UInt16 j = 0; j < nVertex; j++) {
			polyShape.AppendNode(*lstVertexPt[nVertexBefore+j],
				*lstBulge[nVertexBefore+j]);
		}
		m_lstShapePoly.Append(new XPoly2D(polyShape));
		nVertexBefore += nVertex;
	} */
    return pFiler->filerStatus();
}

//  保存文档数据，输出到一个DXF文件：
Acad::ErrorStatus TDbPolyMesh::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	//if (!IsValid())	return Acad::eInvalidInput;

	Acad::ErrorStatus es = Acad::eOk;
	es = TDbCurveMesh::dxfOutFields(pFiler);
	if (es != Acad::eOk) return es;
	es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPolyMesh"));
	if (es != Acad::eOk) return es;
	/*
	//截面链表
	int nShapeLength = m_lstShapePoly.Length();
	for(int i=0; i<nShapeLength; i++) {
		XPoly2D polyShape = m_lstShapePoly[i];
		int nLength = polyShape.Length();
		pFiler->writeInt16(AcDb::kDxfInt16,nLength);
		for (int j=0; j<nLength; j++) {
			pFiler->writePoint3d(AcDb::kDxfXCoord,(AcGePoint3d&)*polyShape[j]);
			pFiler->writeDouble(AcDb::kDxfAngle,*polyShape.bulges[j]);
		}
	}
	//截面位置
	int nDistNum = m_lstDistScale.Length();
	for(i=0; i<nDistNum; i++) {
		pFiler->writeDouble(AcDb::kDxfReal,m_lstDistScale[i]);
	}
	//基点链表
	int nBaseCount = m_lstShapeBase.Length();
	for(i=0; i<nBaseCount; i++) {
		pFiler->writePoint3d(AcDb::kDxfYCoord,(AcGePoint3d&)m_lstShapeBase[i]);
	}
	*/
	return es;
}


// Active when being rotated, scaled, moved, etc.
Acad::ErrorStatus TDbPolyMesh::subTransformBy(const AcGeMatrix3d& xform)
{
	extern XString GetCurCommand();
    assertWriteEnabled();
    if(IsBind()) {
		TDbEntity::subTransformBy(xform);
		return Acad::eOk;
	}

	ads_matrix mat;
	GetLocalMatrix(xform, mat);
	XVector3D vtNormalOld=GetNormal();
	TDbCurveMesh::subTransformBy(xform);
	XVector3D vtNormalNew=GetNormal();

	int nShapeNum = m_lstShapePoly.Length();
	if (nShapeNum != m_lstShapeBase.Length())
		return Acad::eNotApplicable;
	for (int i = 0; i < nShapeNum; i++) {
		XPoly2D &polyShape   = *m_lstShapePoly[i];
		XPoint  &ptShapeBase = *m_lstShapeBase[i];
		
		//基点变换
		XPoint ptOldBase = ptShapeBase;
        ptShapeBase.TransformBy(mat);
        ptShapeBase.z=0;
		//截面变换
		if(vtNormalNew.AsAcGeVector3d()==vtNormalOld.AsAcGeVector3d() &&
			_tcsicmp(GetCurCommand(), _T("ROTATE"))==0) {
			XVector3D vt = ptShapeBase - ptOldBase;
			int nVertexNum = polyShape.Length();
			for(int i=0; i<nVertexNum; i++) {
				XPoint& ptShape = *polyShape[i];
				ptShape += vt;
			}
			polyShape.SetElevation(0.0);
		} else {
			int nVertexNum = polyShape.Length();
			for(int i=0; i<nVertexNum; i++) {
				XPoint& ptShape = *polyShape[i];
				ptShape.TransformBy(mat);
			}
			polyShape.SetElevation(0.0);
		}
	}
    return Acad::eOk;
}

// 功能: 夹点操作
Acad::ErrorStatus
TDbPolyMesh::subMoveGripPointsAt(const AcDbIntArray& indices,
							   const AcGeVector3d& offset)
{
    assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	es = TDbCurveMesh::subMoveGripPointsAt(indices, offset);
	if (es != Acad::eOk) return es;
	if (!IsShapeShow())  return Acad::eOk;

	XPoint vtOffset=Wcs2Ecs(*(XPoint *)&offset, m_vtNormal);
	//vtOffset.z=0;

	int nIndexNum = indices.length();
	int nCurveMesh = m_polyShape.Length() + 1;
	if(!IsBind())
		nCurveMesh += m_polyBase.Length()+m_polyBase.TotalSegments();
	
	for (int i = 0; i < nIndexNum; i++) {
		//当前指数
		int idx = indices[i] - nCurveMesh;
		//截面基点
		int nBaseNum = m_lstShapeBase.Length();
		if (idx >= 0 && idx < nBaseNum) {
			*m_lstShapeBase[idx] += vtOffset;
		}
		else {
			idx -= nBaseNum;
			//截面顶点
			int nShapeNum = m_lstShapePoly.Length();
			for (int i = 0; i < nShapeNum; i++) {
				XPoly2D& polyShape = *m_lstShapePoly[i];
				int nShapeNum = polyShape.Length();
				if (idx >= 0 && idx < nShapeNum) {
					*polyShape[idx] += vtOffset;
					break;
				}
				idx -= nShapeNum;
			}
		}
	}
    return Acad::eOk;
}


Acad::ErrorStatus
TDbPolyMesh::subGetGripPoints(AcGePoint3dArray& gripPoints,
						    AcDbIntArray&	  osnapModes,
						    AcDbIntArray&	  geomIds) const
{
	assertReadEnabled();

	Acad::ErrorStatus es = Acad::eOk;
	es = TDbCurveMesh::subGetGripPoints(gripPoints, osnapModes, geomIds);
	if (es != Acad::eOk) return es;

    //截面的夹点
    if(IsShapeShow()) {
		//截面基点
		int nBaseNum = m_lstShapeBase.Length();
		for (int i = 0; i < nBaseNum; i++) {
			XPoint ptWcs = Ecs2Wcs(m_lstShapeBase[i], m_vtNormal);
			gripPoints.append(ptWcs);
		}
		//截面顶点
		int nShapeNum = m_lstShapePoly.Length();
		for (i = 0; i < nShapeNum; i++) {
			XPoly2D polyShape = m_lstShapePoly[i];
			int nVertexNum = polyShape.Length();
			for(int i = 0; i < nVertexNum; i++){
				XPoint ptWcs = Ecs2Wcs(*polyShape[i], m_vtNormal);
				gripPoints.append(ptWcs);
			}
		}
    }
    return Acad::eOk;
}


// 取得夹点说明
Acad::ErrorStatus TDbPolyMesh::GetGripText(int idx, CString &cs) const
{
    Acad::ErrorStatus es = Acad::eOk;
	es = TDbCurveMesh::GetGripText(idx, cs);
    if(es != Acad::eOk) return es;
	
	//当前指数
	int nIndex = 0;
	int nCurveMesh = m_polyShape.Length()+1;
	if(!IsBind()) 
		nCurveMesh += m_polyBase.Length()+m_polyBase.TotalSegments();
	nIndex += idx - nCurveMesh;

	//截面基点数
	int nBaseNum = m_lstShapeBase.Length();
	if (nIndex >= 0 && nIndex < nBaseNum) {
		cs = _T("改变形状基点");
	}
	else {
		nIndex -= nBaseNum;
		//截面顶点数
		int nShapeVertex=0;
		int nShapeNum = m_lstShapePoly.Length();
		for (int i = 0; i < nShapeNum; i++) {
			nShapeVertex += (m_lstShapePoly[i]).Length();
		}
		if (nIndex >= 0 && nIndex < nShapeVertex)
			cs = _T("改变断面形状线");
	}
	return Acad::eOk;
}

//   取动态属性显示数据的函数 
void TDbPolyMesh::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
	int nShapeNum = m_lstShapePoly.Length();
	if (nShapeNum < 1) {
		TDbCurveMesh::GetTips(lstInfo);
		return;
	}

	DList<double> lstArea,lstPerimeter;
	GetAllShapeArea(lstArea);		   //截面面积
	GetAllShapePerimeter(lstPerimeter);//截面周长
	int nAreaNum = lstArea.Length();

	lstInfo.Append(new TObjInfoUnit(_T("对象类型"),
		XString(_T("%d截面变截面体"),nShapeNum+1)));
	lstInfo.Append(new TObjInfoUnit(_T("路径长度"),
		Dist2Str(GetPathLength())));
	if (nAreaNum == lstPerimeter.Length()) {
		for (int i=0; i<nAreaNum; i++) {
			lstInfo.Append(new TObjInfoUnit(XString(_T("截面%d周长"),i+1), 
				Dist2Str(*lstPerimeter[i])));
			lstInfo.Append(new TObjInfoUnit(_T("面积"), 
				XString(_T("%.2f"), _AS_SQMETER(*lstArea[i]))));
		}
	}
//	lstInfo.Append(new TObjInfoUnit(_T("侧面面积"),
//		XString(_T("%.2f"), _AS_SQMETER(GetSideArea()))));
//	lstInfo.Append(new TObjInfoUnit(_T("体积"),
//		XString(_T("%.3f"), AS_CUMETER(GetVolume()))));
}

Acad::ErrorStatus TDbPolyMesh::DrawShapeBases(XExplodeDraw &dc) const
{
	double dSize = m_polyShape.Distance2d()/30.0;

	DList<XPoint>  lstShapeBase;
	GetAllShapeBases(lstShapeBase);

	int nBaseNum = lstShapeBase.Length();
	for (int i=0; i<nBaseNum; i++) {
		XPoint ptStart, ptEnd;
		XLine  lineBase1,lineBase2;
		XPoint ptShapeBase = *lstShapeBase[i];
		ptStart = Ecs2Wcs(ptShapeBase+XPoint(dSize, dSize), m_vtNormal);
		ptEnd   = Ecs2Wcs(ptShapeBase-XPoint(dSize, dSize), m_vtNormal);
		lineBase1.SetPoints(ptStart,ptEnd);
		ptStart = Ecs2Wcs(ptShapeBase+XPoint(dSize, -dSize), m_vtNormal);
		ptEnd   = Ecs2Wcs(ptShapeBase+XPoint(-dSize, dSize), m_vtNormal);
		lineBase2.SetPoints(ptStart,ptEnd);
		dc << lineBase1 << lineBase2;
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbPolyMesh::DrawShapePolys(XExplodeDraw &dc) const
{
	XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;

	DList<XPoly2D> lstShapePoly;
	DList<XPoint>  lstShapeBase;
	GetAllShapePolys(lstShapePoly);
	GetAllShapeBases(lstShapeBase);

	int nShapeNum = lstShapePoly.Length();
	if (lstShapeBase.Length() != nShapeNum) 
		return Acad::eNotApplicable;
	
	for (int i = 0; i < nShapeNum; i++) {
		AcDbPolyline pline;
		PolyConvert(*lstShapePoly[i], pline);
		pline.setElevation((*lstShapeBase[i]).z);
		pline.setNormal(m_vtNormal);
		if(viewDraw.m_pWd)
			pline.worldDraw(viewDraw.m_pWd);
		else 
			pline.viewportDraw(viewDraw.m_pVd);
	}
	return Acad::eOk;
}

// 绘制2D的显示, 二维显示网格
Acad::ErrorStatus TDbPolyMesh::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    assertReadEnabled();
	if (!IsValid())	 return Acad::eInvalidInput;
    if (!Has2D() || m_vtNormal!=AcGeVector3d(0,0,1))
		return ExplodeOrDraw3d(dc);

	int nShapeNum = m_lstShapePoly.Length();
	if (nShapeNum<1)
		return TDbCurveMesh::ExplodeOrDraw2d(dc);

	XPoly2D polyOutline;
	GetOutlinePoly(0,polyOutline);
	dc << polyOutline;
	
	// 绘制断面形状
	if(IsShapeShow() && _tcsicmp(dc.Desc(),XAcGiViewDraw::Descriptor())==0) {
		Adesk::UInt16 nColor=dc.GetColor();
		dc.SetColor(1);
		DrawShapeBases(dc);
		DrawShapePolys(dc);
		dc.SetColor(nColor);
	}
    return Acad::eOk;
}

// 绘制3d的显示
Acad::ErrorStatus TDbPolyMesh::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	assertReadEnabled();
	if (!IsValid())	return Acad::eInvalidInput;

	int nShapeNum = m_lstShapePoly.Length();
	if (nShapeNum < 1)
		return TDbCurveMesh::ExplodeOrDraw3d(dc);

	XPoint *pPtArray=NULL;     //Mesh顶点
	int nRows=0, nCols=0; //行数和列数

	if (GetSurfaceMesh(nRows,nCols,pPtArray)) {
		//设置向量
		int nVertexNum=nCols*nRows;
        for(int k=0; k<nVertexNum; k++)
            pPtArray[k]=Ecs2Wcs(pPtArray[k], m_vtNormal);

		//显示网格
		dc.DrawMesh(nRows, nCols, (AcGePoint3d *)pPtArray);

		//显示两端面
		XPoly2D polyStart(1), polyEnd(1);
		int nIncrease = nRows*nCols - nCols;
		for(int col=0; col<nCols-1; col++) {
			polyStart.AppendNode(pPtArray[col]);
			polyEnd.AppendNode(pPtArray[nIncrease+col]);
		}
		dc.DrawShell(polyStart, DList<XPoly2D>());
		dc.DrawShell(polyEnd, DList<XPoly2D>());
    }
	if (pPtArray)  delete []pPtArray;


	// 绘制断面形状
	if(IsShapeShow() && _tcsicmp(dc.Desc(),XAcGiViewDraw::Descriptor())==0) {
		Adesk::UInt16 nColor=dc.GetColor();
		dc.SetColor(1);
		DrawShapeBases(dc);
		DrawShapePolys(dc);
		dc.SetColor(nColor);
	}

    return Acad::eOk;
}

int	TDbPolyMesh::GetShapeNum() const
{
	assertReadEnabled();
	return m_lstShapePoly.Length()+1;
}

//在XY平面上的轮廓
void TDbPolyMesh::GetOutlinePoly(ads_real dZ, XPoly2D &poly) const
{
	assertReadEnabled();
	poly.Reset();
	if (m_vtNormal!=AcGeVector3d(0,0,1))
		return;

	//截面、路径
	DList<XPoly2D> lstShape;
	GetAllShapePolys(lstShape);
	XPoly2D	polyPath(m_polyBase);
	polyPath.SetElevation(0);

	int nShapeNum = lstShape.Length();
	if (nShapeNum <= 0)
		return;

	//一个截面时,即路径曲面
	if (nShapeNum == 1) {
		if (m_polyShape.Length() > 0) {
			XPoint ptLow, ptUp;
            m_polyShape.GetExtend(ptLow, ptUp);
            double nOffset1 = ptLow.x - m_ptShapeBase.x;
            double nOffset2 = ptUp.x  - m_ptShapeBase.x;
            polyPath.SetElevation(0.0);
            XPoly2D poly1, poly2;
            polyPath.QuickOffset(nOffset1, poly1);
            polyPath.QuickOffset(nOffset2, poly2);
			if (m_polyBase.IsClosed()) {
				if (poly1.Distance2d()>=poly2.Distance2d()) 
					poly = poly1;
				else
					poly = poly2;
			} else {
				poly = poly1;
				poly.SetBulge(poly.Length() - 1, 0);
				poly2.Reverse();
				int nCount = poly2.Length();
				for (int i=0; i<nCount; i++)
					poly.AppendNode(*poly2[i],poly2.GetBulge(i));
				poly.SetBulge(poly.Length() - 1, 0);
			}
		}
		poly.SetFlag(1);
		poly.SetElevation(dZ);
		return;//返回
	}

	//二维边界点链表
	DList<XPoint> lstLeftPoint(FALSE),lstRightPoint(FALSE);

	//基点和位置（距离）
	DList<XPoint>  lstBase;
	DList<double>  lstDistScale;
	GetAllShapeBases(lstBase);
	GetDistScales(lstDistScale);

	//路径在两个截面时不用离散直线
	TPolyPath	pathExtrude(polyPath,(nShapeNum!=2?TRUE:FALSE));
	if (pathExtrude.Length()<nShapeNum)
		return;
	XExtendEnd endStart(*lstShape[0],*lstBase[0]);
	XExtendEnd endEnd(*lstShape[nShapeNum-1],*lstBase[nShapeNum-1]);
	const  XPoint ptCenterStart = endStart.GetCenter();
	const  XPoint ptCenterEnd = endEnd.GetCenter();

	double dBaseDistStart = endStart.m_ptBase.x-ptCenterStart.x;
	double dBaseDistEnd = endEnd.m_ptBase.x-ptCenterEnd.x;
	double dDistanceEnd = endEnd.GetDistance();
	double dDistanceStart = endStart.GetDistance();
	int nNumOnPath = pathExtrude.Length();

	endStart.RotateBy(-PI/2,AcGeVector3d(0,0,1),ptCenterStart);
	endEnd.RotateBy(-PI/2,AcGeVector3d(0,0,1),ptCenterEnd);

	XPoint pt0, pt1, pt2, pt3;
	double dPathLength = pathExtrude.GetDistAtVertex(nNumOnPath-1);
	if (dPathLength<=0 || dDistanceEnd<=0 || dDistanceStart<=0) 
		return;

	XExtendEnd endThis = endStart;
	pt0 = *pathExtrude[0];
	pt1 = *pathExtrude[1];

	// sg add 080902，解决变截面体首、末截面没有垂直的问题(论坛问题1017)
	AcDbPolyline pline;
	PolyConvert(polyPath, pline);
	AcGeVector3d vec;
	pline.getFirstDeriv(pt0.AsAcGePoint3d(), vec); // 求切线向量

//	endThis.AttachOn(pt0, pt1-pt0); // sg modify 080902
	endThis.AttachOn(pt0, XVector3D(vec));
	lstLeftPoint.Append(new XPoint(endThis.m_ptLeft));
	lstRightPoint.Append(new XPoint(endThis.m_ptRight));

	//构造中间截面的步数
	int nStep = nNumOnPath-1;
	//两个截面时，采用线性插值
	if (nShapeNum == 2) {
		for (int j=1; j<nStep; j++ ) {
			endThis = endStart;
			double dLength = pathExtrude.GetDistAtVertex(j);
			double dLengthScale = dLength/dPathLength;
			double dDistance = dDistanceStart +
				(dDistanceEnd-dDistanceStart)*dLengthScale;
			endThis.ScaleBy(dDistance/dDistanceStart,endThis.GetCenter(),FALSE);
			double dBaseDist = dBaseDistStart +
				(dBaseDistEnd-dBaseDistStart)*dLengthScale;
			endThis.m_ptBase.y = ptCenterStart.y - dBaseDist;
			
			pt1 = *pathExtrude[j-1];
			pt2 = *pathExtrude[j];
			pt3 = *pathExtrude[j+1];
			
			double dEdgeHalfAngle = 0.5*Angle(pt2, pt1, pt3);
			double dScale = sin(dEdgeHalfAngle);
			if (fabs(dScale)<1.0E-9) // ZJQ Modify here
				continue;
			dScale = 1/dScale;
			endThis.ScaleBy(dScale, endThis.GetCenter());
			
			XVector3D vt3Sub1 = pt3-pt1;
			XVector3D vt2Sub1 = pt2-pt1;
			XVector3D vt3Sub2 = pt3-pt2;
			XVector3D vtRotateAxis = ((AcGeVector3d)vt3Sub1).crossProduct((AcGeVector3d)vt2Sub1);
			double dRotateAngle = 0.5*PI - dEdgeHalfAngle;
			AcGeVector3d vtContourNormal = vt3Sub2;
			vtContourNormal.rotateBy(dRotateAngle, (AcGeVector3d)vtRotateAxis);

			endThis.AttachOn(pt2, vtContourNormal);
			lstLeftPoint.Append(new XPoint(endThis.m_ptLeft));
			lstRightPoint.Append(new XPoint(endThis.m_ptRight));
		}
	}
	//三个截面时，采用二次插值
	else if (nShapeNum == 3) {
		//第二个截面
		XExtendEnd endShape2(*lstShape[1],*lstBase[1]);
		double dBaseDistShape2 = endShape2.m_ptBase.x-endShape2.GetCenter().x;
		double dDistanceShape2 = endShape2.GetDistance();
		double Z2 = dPathLength * (*lstDistScale[0]);
		endShape2.RotateBy(PI/2,AcGeVector3d(0,0,1),endShape2.GetCenter());
		
		for (int j=1; j<nStep; j++ ) {
			endThis = endStart;
			double dLength = pathExtrude.GetDistAtVertex(j);
			double dDistance = Parabola(dLength,0,Z2,dPathLength,
				dDistanceStart,dDistanceShape2,dDistanceEnd);
			endThis.ScaleBy(dDistance/dDistanceStart,endThis.GetCenter(),FALSE);
			double dBaseDist = Parabola(dLength,0,Z2,dPathLength,
				dBaseDistStart,dBaseDistShape2,dBaseDistEnd);			
			endThis.m_ptBase.y = ptCenterStart.y - dBaseDist;
			
			pt1 = *pathExtrude[j-1];
			pt2 = *pathExtrude[j];
			pt3 = *pathExtrude[j+1];
			
			//转角处由转角决定截面的放大或缩小
			double dEdgeHalfAngle = 0.5*Angle(pt2, pt1, pt3);
			double dScale = sin(dEdgeHalfAngle);
			if (fabs(dScale)<1.0E-9) // ZJQ Modify here
				continue;
			dScale = 1/dScale;
			endThis.ScaleBy(dScale, endThis.GetCenter());
			
			XVector3D vt3Sub1 = pt3-pt1;
			XVector3D vt2Sub1 = pt2-pt1;
			XVector3D vt3Sub2 = pt3-pt2;
			XVector3D vtRotateAxis = ((AcGeVector3d)vt3Sub1).crossProduct((AcGeVector3d)vt2Sub1);
			double dRotateAngle = 0.5*PI - dEdgeHalfAngle;
			AcGeVector3d vtContourNormal = vt3Sub2;
			vtContourNormal.rotateBy(dRotateAngle, (AcGeVector3d)vtRotateAxis);

			endThis.AttachOn(pt2, vtContourNormal);
			lstLeftPoint.Append(new XPoint(endThis.m_ptLeft));
			lstRightPoint.Append(new XPoint(endThis.m_ptRight));
		}
	}
	//三个以上截面时
	else {
		;
	}

	endThis = endEnd;
	pt0 = *pathExtrude[nStep-1];
	pt1 = *pathExtrude[nStep];

	// sg add 080902，解决变截面体首、末截面没有垂直的问题(论坛问题1017)
	pline.getFirstDeriv(pt1.AsAcGePoint3d(), vec); // 求切线向量
// 	endThis.AttachOn(pt1, pt1-pt0); // sg modify 080902
	endThis.AttachOn(pt1, XVector3D(vec));
	lstLeftPoint.Append(new XPoint(endThis.m_ptLeft));
	lstRightPoint.Append(new XPoint(endThis.m_ptRight));

	int nLeftCount = lstLeftPoint.Length();
	int nRightCount = lstRightPoint.Length();
	for (int i=0; i<nLeftCount; i++)
		poly.AppendNode(*lstLeftPoint[i]);
	for (i=nRightCount-1; i>=0; i--)
		poly.AppendNode(*lstRightPoint[i]);

	poly.SetFlag(1);
	poly.SetElevation(dZ);
}

//*********************  Methos  ***********************//
//除第一个截面以外的截面(截面要封闭)
void TDbPolyMesh::
SetShapePolys(const DList<XPoly2D>& lstShapePoly)
{
	assertWriteEnabled();
	m_lstShapePoly.Reset();
	int nShapeNum = lstShapePoly.Length();
	for (int i = 0; i < nShapeNum; i++) {
		m_lstShapePoly.Append(new XPoly2D(lstShapePoly[i]));
	}
}

void TDbPolyMesh::
GetShapePolys(DList<XPoly2D>& lstShapePoly) const
{
	assertReadEnabled();
	lstShapePoly.Reset();
	int nShapeNum = m_lstShapePoly.Length();
	for (int i = 0; i < nShapeNum; i++) {
		lstShapePoly.Append(new XPoly2D(m_lstShapePoly[i]));
	}
}

void TDbPolyMesh::
SetAllShapePolys(const DList<XPoly2D>& lstShapePoly)
{
	assertWriteEnabled();
	m_lstShapePoly.Reset();
	int nShapeNum = lstShapePoly.Length();
	if (nShapeNum > 0)
		m_polyShape = lstShapePoly[0];

	for (int i = 1; i < nShapeNum; i++) {
		m_lstShapePoly.Append(new XPoly2D(lstShapePoly[i]));
	}
}

//所有的的截面(截面要封闭)
void TDbPolyMesh::
GetAllShapePolys(DList<XPoly2D>& lstShapePoly) const
{
	assertReadEnabled();
	lstShapePoly.Reset();
	lstShapePoly.Append(new XPoly2D(m_polyShape));

	int nShapeNum = m_lstShapePoly.Length();
	for (int i = 0; i < nShapeNum; i++) {
		lstShapePoly.Append(new XPoly2D(m_lstShapePoly[i]));
	}
}

//设置重心为截面基点
void TDbPolyMesh::SetWeightCenterAsShapeBases()
{
	assertWriteEnabled();
	m_lstShapeBase.Reset();
	//第一个基点
	m_ptShapeBase = GetWeightCenter(m_polyShape);
	//基点链表
	int nShapeNum = m_lstShapePoly.Length();
	for (int i = 0; i < nShapeNum; i++) {
		XPoint ptCenter = GetWeightCenter(*m_lstShapePoly[i]);
		m_lstShapeBase.Append(new XPoint(ptCenter));
	}
}

//设置形心(GetExtend的中点)为截面的基点
void TDbPolyMesh::SetCenterAsShapeBases()
{
	assertWriteEnabled();
	m_lstShapeBase.Reset();
	XPoint	ptLow,ptUp,ptCenter;

	//用XPoly2D::Center()不行,采用GetExtend()
	//第一个基点
	m_polyShape.GetExtend(ptLow,ptUp);
	Midpoint(ptLow,ptUp,m_ptShapeBase);
	//基点链表
	int nShapeNum = m_lstShapePoly.Length();
	for (int i = 0; i < nShapeNum; i++) {
		XPoly2D& polyShape = *m_lstShapePoly[i];
		polyShape.GetExtend(ptLow,ptUp);
		Midpoint(ptLow,ptUp,ptCenter);
		m_lstShapeBase.Append(new XPoint(ptCenter));
	}
}

void TDbPolyMesh::
SetShapeBases(const DList<XPoint>& lstShapeBase)
{
	assertWriteEnabled();
	m_lstShapeBase.Reset();
	int nBaseNum = lstShapeBase.Length();
	for (int i = 0; i < nBaseNum; i++) {
		m_lstShapeBase.Append(new XPoint(lstShapeBase[i]));
	}
}

void TDbPolyMesh::
GetShapeBases(DList<XPoint>& lstShapeBase) const
{
	assertReadEnabled();
	lstShapeBase.Reset();
	int nBaseNum = m_lstShapeBase.Length();
	for (int i = 0; i < nBaseNum; i++) {
		lstShapeBase.Append(new XPoint(m_lstShapeBase[i]));
	}
}

void TDbPolyMesh::
SetAllShapeBases(const DList<XPoint>& lstShapeBase)
{
	assertWriteEnabled();
	m_lstShapeBase.Reset();
	int nBaseNum = lstShapeBase.Length();
	if (nBaseNum > 0)
		m_ptShapeBase = lstShapeBase[0];

	for (int i = 1; i < nBaseNum; i++) {
		m_lstShapeBase.Append(new XPoint(lstShapeBase[i]));
	}
}

void TDbPolyMesh::
GetAllShapeBases(DList<XPoint>& lstShapeBase) const
{
	assertReadEnabled();
	lstShapeBase.Reset();
	lstShapeBase.Append(new XPoint(m_ptShapeBase));

	int nBaseNum = m_lstShapeBase.Length();
	for (int i = 0; i < nBaseNum; i++) {
		lstShapeBase.Append(new XPoint(m_lstShapeBase[i]));
	}
}

//除第一个截面和最后一个截面以外的其他截面在路径上的位置
void TDbPolyMesh::
SetDistScales(const DList<double>& lstDist)
{
	assertWriteEnabled();
	m_lstDistScale.Reset();
	int nCount = lstDist.Length();
	for (int i = 0; i < nCount; i++) {
		m_lstDistScale.Append(new double(lstDist[i]));
	}

}

void TDbPolyMesh::
GetDistScales(DList<double>& lstDist) const
{
	assertReadEnabled();
	lstDist.Reset();
	int nCount = m_lstDistScale.Length();
	for (int i = 0; i < nCount; i++) {
		lstDist.Append(new double(m_lstDistScale[i]));
	}
}



// 工程量
void TDbPolyMesh::
GetAllShapeArea(DList<double>& lstArea) const
{
	assertReadEnabled();
	lstArea.Reset();

	double dArea = TDbCurveMesh::GetShapeArea();
	lstArea.Append(new double(dArea));
	int nShapeNum = m_lstShapePoly.Length();
	for (int i=0; i<nShapeNum; i++) {
		dArea = (m_lstShapePoly[i]).Area();
		lstArea.Append(new double(dArea));
	}
}

void TDbPolyMesh::
GetShapeArea(DList<double>& lstArea) const
{
	assertReadEnabled();
	lstArea.Reset();

	int nShapeNum = m_lstShapePoly.Length();
	for (int i=0; i<nShapeNum; i++) {
		double dArea = (m_lstShapePoly[i]).Area();
		lstArea.Append(new double(dArea));
	}
}

void TDbPolyMesh::
GetAllShapePerimeter(DList<double>& lstPerimeter) const
{
	assertReadEnabled();
	lstPerimeter.Reset();

	double dPerimeter = TDbCurveMesh::GetShapePerimeter();
	lstPerimeter.Append(new double(dPerimeter));
	int nShapeNum = m_lstShapePoly.Length();
	for (int i=0; i<nShapeNum; i++) {
		dPerimeter = (m_lstShapePoly[i]).Distance2d();
		lstPerimeter.Append(new double(dPerimeter));
	}
}

void TDbPolyMesh::
GetShapePerimeter(DList<double>& lstPerimeter) const
{
	assertReadEnabled();
	lstPerimeter.Reset();

	int nShapeNum = m_lstShapePoly.Length();
	for (int i=0; i<nShapeNum; i++) {
		double dPerimeter = (m_lstShapePoly[i]).Distance2d();
		lstPerimeter.Append(new double(dPerimeter));
	}
}

#if (ADS == 17)
XPoint TDbPolyMesh::GetAllShapeBasesByIndex(int idx)
{
	DList<XPoint> listPoint;
	GetAllShapeBases(listPoint);
	return *listPoint[idx];
}

double TDbPolyMesh::GetAllShapePerimeterByIndex(int idx)
{
	DList<double> listLen;
	GetAllShapePerimeter(listLen);
	return *listLen[idx];
}

double TDbPolyMesh::GetAllShapeAreaByIndex(int idx)
{
	DList<double> listArea;
	GetAllShapeArea(listArea);
	return *listArea[idx];
}

void TDbPolyMesh::SetAllShapeBasesByIndex(int idx, XPoint pt)
{
	DList<XPoint> listPoint;
	GetAllShapeBases(listPoint);
	listPoint[idx]->x=pt.x;
	listPoint[idx]->y=pt.y;
	SetAllShapeBases(listPoint);
}
#endif
/*
double TDbPolyMesh::GetSideArea() const
{
	assertReadEnabled();
	double dSideArea=0;
	return dSideArea;
}

double TDbPolyMesh::GetVolume() const
{
	assertReadEnabled();
	double dVolume=0;
	return dVolume;
}
*/

//  编辑TDbPolyMesh实体
int EditPolyMesh0(AcDbObjectId id)
{
    XVector3D vtNormal=Ucs2Wcs(XVector3D(0,0,1), TRUE);
    ((AcGeVector3d &)vtNormal).normalize();
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPolyMesh, pStep);
    if(!pStep)
        return RTERROR;
    while(1) {
        int bBind=FALSE; //pStep->IsBind();
        XString sPrompts, sKeywords;
        if(bBind) {
            sPrompts << _T("\n选择 [解除绊定(B)/截面显示(W)");
            sKeywords << _T("B W G C");
        } else {
            sPrompts << _T("\n选择 [加顶点(A)/减顶点(D)/设置顶点(S)/截面显示(W)");
            sKeywords <<  _T("A D S W G C");
        }
        if(pStep->Has2D())
            sPrompts << _T("/关闭二维(G)/设置重心为截面基点(C)]<退出>:");
        else
            sPrompts << _T("/开启二维(G)/设置重心为截面基点(C)]<退出>:");
        XString sKeyword;
        int nRet=0;
        INITGET_BEG(0, sKeywords);
        nRet=ads_getkword(sPrompts, sKeyword);
        INITGET_END();

        if(nRet!=RTNORM)
            break;
        TCHAR cKey=sKeyword[0];
        if(cKey==_T('A') || cKey==_T('D') || cKey==_T('S')) {
            if(vtNormal.AsAcGeVector3d()!=pStep->GetNormal().AsAcGeVector3d()) {
                adsout << _T("\n当前构造平面与对象的构造平面不一致!");
                continue;
            }
        }

        if(sKeyword[0]==_T('A')) {
            XPoint ptAdd;
            if(XGetPoint(NULL, _T("\n点取新的顶点位置"), ptAdd)==RTNORM) {
                ptAdd = Ucs2Ecs(ptAdd, vtNormal);
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                if(!pStep->AddVertex(ptAdd)) {
                    adsout << _T("\n请正确点取!");
                }
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('D')) {
            XPushVar<int> osmode(_T("OSMODE"), OS_NOD);
            XPoint ptVert;
            while(ads_getpoint(NULL, _T("\n选取顶点: "), ptVert)==RTNORM) {
                ptVert=Ucs2Ecs(ptVert, vtNormal);
                int nPos=pStep->HitTestOnBase2d(ptVert);
                if(nPos>0) {
                    nPos--;
                    if(pStep->upgradeOpen()!=Acad::eOk)
                        return RTERROR;
                    pStep->RemoveVertexAt(nPos);
                    pStep->downgradeOpen();
                }
            }
        } else if(sKeyword[0]==_T('S')) {
            XPushVar<int> osmode(_T("OSMODE"), OS_NOD);
            XPoint ptVert;
            while(ads_getpoint(NULL, _T("\n选取顶点: "), ptVert)==RTNORM) {
                int nPos=pStep->HitTestOnBase2d(ptVert);
                if(nPos>0) {
                    nPos--;
                    double nElev=pStep->GetElevationAt(nPos);
                    adsout << _T("\n改夹角[A]/点取[P]/输入顶点标高<") 
                           << Dist2Str(nElev)
                           << _T(">: ");
                    int nCode;
                    INITGET_BEG(0, _T("A P"));
                    nCode=ads_getreal(_T(""), &nElev);
                    INITGET_END();
                    if(nCode==RTKWORD) {
                        TCHAR szKey[80]=_T("");
                        ads_getinput(szKey);
                        if(szKey[0]==_T('P')) {
                            XPushVar<int> osMode(_T("OSMODE"), OS_NEA);
                            XPoint ptElev;
                            nCode=ads_getpoint(NULL, _T("\n点取参照物:"), ptElev);
                            if(nCode==RTNORM) {
                                ptElev = Ucs2Ecs(ptElev, vtNormal);
                                nElev=ptElev.z;
                                if(pStep->upgradeOpen()!=Acad::eOk)
                                    return RTERROR;
                                pStep->SetElevationAt(nPos, nElev);
                                pStep->downgradeOpen();
                            }
                        } else if(szKey[0]==_T('A')) {
                            double nOldAng=pStep->GetSweepAngleAt(nPos)*180.0/PI;
                            nCode=GetReal(_T("\n输入夹角"), nOldAng);
                            if(nCode==RTNORM) {
                                nOldAng *= PI/180.0;
                                if(pStep->upgradeOpen()!=Acad::eOk)
                                    return RTERROR;
                                pStep->SetSweepAngleAt(nPos, nOldAng);
                                pStep->downgradeOpen();
                            }
                        }
                    } else if(nCode==RTNORM) {
                        if(pStep->upgradeOpen()!=Acad::eOk)
                            return RTERROR;
                        pStep->SetElevationAt(nPos, nElev);
                        pStep->downgradeOpen();
                    }
                } else {
                    adsout << _T("\n请正确点取!");
                }
            }
        } else if(sKeyword[0]==_T('W')) {
            if(pStep->upgradeOpen()!=Acad::eOk)
                return RTERROR;
            pStep->ShowShape(!pStep->IsShapeShow());
            pStep->downgradeOpen();
        } else if(sKeyword[0]==_T('B')) {
            if(pStep->IsBind()) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->UnBind();
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('G')) { 
            if(pStep->upgradeOpen()==Acad::eOk) {
                pStep->SetHas2D(!pStep->Has2D());
                pStep->downgradeOpen();
            }
        } else if (sKeyword[0]==_T('C')) {
            if(pStep->upgradeOpen()==Acad::eOk) {
                pStep->SetWeightCenterAsShapeBases();
                pStep->downgradeOpen();
            }
		}
    }
    OPENOBJ_END();

    return RTNORM;
}

void InitDbPolyMesh(BOOL bTrue)
{
    if(bTrue) {
        TDbPolyMesh::rxInit();
        TDbPolyMesh::SetEditMethod(EditPolyMesh0);
        acrxBuildClassHierarchy();
        TDbPolyMesh::InitMatchProtocol(TRUE);
    } else {
        TDbPolyMesh::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbPolyMesh::desc());
    }
}


void CreatePolyMesh()
{
	//截面和截面基点和截面位置
	DList<XPoly2D>	lstShapePloy;
	DList<XPoint>	lstShapeBase;
	DList<double>	lstDistScale;
	
	RBList	rbPathMask(RTDXF0, _T("POLYLINE,LWPOLYLINE,CIRCLE"), NULL);
	RBList	rbShapeMask=ads_buildlist(-4, _T("<or"),
									-4, _T("<and"), 
										RTDXF0, _T("POLYLINE,LWPOLYLINE"), 
										70, 1,
									-4, _T("and>"),
									RTDXF0, _T("CIRCLE"),
									-4, _T("or>"), NULL);

	Entity	entPath,entShape;
	PickSet m_ssSelect(SS_FREE);
	XPoint ptPick;

	if (SelectEntity(_T("\n请选取路径曲线(点取位置作为起始端)<退出>:"),entPath, ptPick, rbPathMask) != RTNORM) {
		adsout << _T("\n选取路径曲线失败");
		return;
	}
	entPath.Redraw(3);
	m_ssSelect += entPath;
	XPoly2D polyPath(entPath);//路径
	XVector3D vtEcs(0,0,1);
	entPath.GetData(210, &vtEcs);
	if(vtEcs.AsAcGeVector3d()!=Ucs2Wcs(XVector3D(0,0,1), TRUE).AsAcGeVector3d()) {
		adsout << _T("\n路径的法向和当前UCS的Z向不一致!");
		return;
	}
	XPoint ptPickEcs=Ucs2Ecs(ptPick, vtEcs);
	if(polyPath.Head()->Distance(ptPickEcs) > polyPath.Tail()->Distance(ptPickEcs))
		polyPath.Reverse();

	int nShapeNum=0;
	while (nShapeNum<3) {
		XString sShapePrompt(_T("\n请选择第%d个封闭曲线<%s>:"),
			nShapeNum+1,(nShapeNum>=2?_T("结束"):_T("退出")));
		XString sShapeFail(_T("\n选取第%d个封闭曲线失败!"),nShapeNum+1);

		int nCode = SelectEntity(sShapePrompt,entShape,rbShapeMask);
		if (nCode == RTCAN) {
			m_ssSelect.Redraw(4);
			return;
		} else if(nCode!=RTNORM) {
			if(nShapeNum<2) {
				adsout << sShapeFail;
				m_ssSelect.Redraw(4);
				return;
			} else
				break;
		}

		XPoly2D *polyShape=new XPoly2D(entShape);
		if(polyShape->IsSelfIntersect()) {
			adsout << _T("\n曲线不能自己相交，请重新选择：");
			delete polyShape;
			continue;
		} else {
			nShapeNum++;
			entShape.Redraw(3);
			m_ssSelect += entShape;
			lstShapePloy.Append(polyShape);

			XString sPrompts, sKeywords,sKeyword;
			XPoint	ptWeightCenter,ptBase, ptCen;	//截面基点
			ptWeightCenter = GetWeightCenter(*polyShape);
			//adsout << _T("\nWeight Cen=") << ptWeightCenter;
			polyShape->Center(ptCen);
			XString sBasePrompt(_T("\n请指定第%d个截面基点或 [重心(W)/退出(X)]<形心>:"),nShapeNum);
			XString sBaseFail(_T("\n指定第%d个截面基点失败!"),nShapeNum);
			INITGET_BEG(0, _T("W X C"));
			nCode = ads_getpoint(ptCen, sBasePrompt, ptBase);
			INITGET_END();
			if(nCode==RTNONE) {
				nCode=RTKWORD;
				sKeyword=_T("C");
			} else if(nCode==RTKWORD) {
				ads_getinput(sKeyword);
			}
			if (nCode!=RTKWORD && nCode!=RTNORM) {
				adsout << sBaseFail;
				m_ssSelect.Redraw(4);
				return;
			} else if (nCode==RTKWORD) {
				if (sKeyword[0] == _T('W')) {
					ptBase = ptWeightCenter;
				}	else if (sKeyword[0] == _T('C')) {
					ptBase=ptCen;
				}
			}
			lstShapeBase.Append(new XPoint(ptBase));
		}
	}

	//截面位置
	nShapeNum = lstShapePloy.Length();
	if (nShapeNum<2 /*|| nShapeNum>3*/ || nShapeNum!=lstShapeBase.Length())
		return;
	for (int i=1; i<nShapeNum-1; i++) {
		XPushVar<int> tVar(_T("OSMODE"), OS_NEA);
		XString sPrompt(_T("\n指定第%d个截面在路径曲线的位置:"),i+1);
		while (1 ) {
			XPoint ptSelect;
			if (ads_getpoint(NULL, sPrompt, ptSelect) != RTNORM) {
				m_ssSelect.Redraw(4);
				return;
			}
			ptSelect = /*Ucs2Wcs*/(ptSelect);
			//BOOL bOnPath = (ptSelect&polyPath)==PR_EDGE;
			if (polyPath.HitTestOnCurve(ptSelect)) {
				double dDist = 0.5;
				double dDistAll = polyPath.Distance3d();
				if (dDistAll > 0) {
					double dDistThis = 0;
					int nLength = polyPath.TotalSegments();
					for (int j=0; j<nLength; j++) {
						XCurveSegment cvTemp;
						polyPath.Nth(j,cvTemp);
						BOOL bOnCurve=(ptSelect&cvTemp)==PR_EDGE ||
									  (ptSelect&cvTemp)==PR_INSIDE;
						if (bOnCurve) {
							dDistThis += cvTemp.PathDistance(ptSelect);
							break;
						} else {
							dDistThis += cvTemp.PathDistance(cvTemp.EndPoint());
						}
					}
					if (dDistThis < dDistAll && dDistThis > 0) {
						dDist = dDistThis/dDistAll;
					}
				}
				lstDistScale.Append(new double(dDist));
				break;
			} else {
				sPrompt = _T("\n所指定点不在路径曲线上，请重新指定：");
			}
		}
	}

	if ((nShapeNum >= 2 /*&& nShapeNum <= 3*/) &&
		nShapeNum   == lstShapeBase.Length() &&
		nShapeNum-2 == lstDistScale.Length()) {	
		TDbPolyMesh *pMesh = new TDbPolyMesh;
		pMesh->SetNormal(Ucs2Wcs(XVector3D(0,0,1), TRUE));
		pMesh->SetBasePoly(polyPath);
		pMesh->SetAllShapePolys(lstShapePloy);
		//pMesh->SetWeightCenterAsShapeBases(); //重心为基点
		//pMesh->SetCenterAsShapeBases();		//中心基点
		pMesh->SetAllShapeBases(lstShapeBase);  //指定基点
		pMesh->SetDistScales(lstDistScale);
		pMesh->AddToMSpace(Adesk::kTrue);
		pMesh->close();
	}
	m_ssSelect.Redraw(4);//还原
}