//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   导出全局函数头文件
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   全局函数的声明
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+

#include "StdAfx.h"
#include "XGlobalFunc.h"
#include "XPoly.h"
#include "XCircle.h"
#include "XRectAngle.h"
#include "XScreenDc.h"
#include "XPushVar.h"
#include "XPushMemVar.h"
#include "XSearchRegionFromCurve.h"
#include "XSearchRegionFromCurve.h"
#include "XRegion.h"
#include "XDbObject.h"
#include "DStack.h"
#include "XBlockTableRecPtr.h"
#include "XDirectionCurve.h"
#include "XCurveSegInters.h"
#include "XCurveIntersection.h"
#include "CTempTol.h"
#include "XConfigBase.h"
#include "XHoleModel.h"
#include "AEntityBase.h"

#include "XGlobalFunc.h"
#include "XGlobalCurveFunc.h"
#include "XPrivateGlobalFunc.h"

#if ARX > 17
#include "AcStatusBar.h"
#include "AecDbGrip.h"
#include "AecDbGripDistDim.h"
#include "AecDbGripAngleDim.h"
#include "AecDbGripRadiusDim.h"
#endif

#include "XCurveInline.h"

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

static int CompareDouble(double x1, double x2)
{
    if (fabs(x1 - x2) < _DIST_SNAP)
	{
		return 0;
	}
    
	if (x1 < x2)
	{
		return -1;
	}
    
	return 1;
}

static void GetPolyRect(const XPoint &ptCorn1, double nAngle, const XPoint &ptCorn2, XPoly2D &poly)
{
	poly.Reset();
	poly.SetFlag(1);
	
	XPoint pt1, pt2;
	
	XLine lnSide1(ptCorn1, nAngle);
	XLine lnSide2(ptCorn2, nAngle + PI / 2.0);
	lnSide1.Intersection(&lnSide2, pt1);

	XLine lnSide3(ptCorn1, nAngle + PI / 2.0);
	XLine lnSide4(ptCorn2, nAngle);
	lnSide3.Intersection(&lnSide4, pt2);

	poly.AppendNode(ptCorn1);
	poly.AppendNode(pt1);
	poly.AppendNode(ptCorn2);
	poly.AppendNode(pt2);
}

static XPoly2D		g_polyRect;
static double				g_nRot;
static XPoint		g_ptCorn1;

#if ARX > 22
static bool MouseMoveMonitor(MSG* msg)
#else
static BOOL MouseMoveMonitor(MSG* msg)
#endif
{
	if (!acdbCurDwg())
	{
		return FALSE;
	}
	BOOL bRet = FALSE;
	switch(msg->message)
	{
	case WM_MOUSEMOVE:
		{
			CPoint ptClient = msg->pt;
			acedGetAcadDwgView()->ScreenToClient(&ptClient);
			int nVpNum = acedGetWinNum(ptClient.x, ptClient.y);
			int nCurVp = 0;
			VERIFY(xg_getvar(_T("CVPORT"), &nCurVp) == RTNORM);
			if (nVpNum == nCurVp) 
			{
				XPoint ptDwgWcs, ptDwgDcs;
				BOOL nRetCode = TRUE;
				if (acedCoordFromPixelToWorld(nVpNum, ptClient, ptDwgWcs)) 
				{
					XScreenDc dc(-1);
					if (g_polyRect.Length()) 
					{
						dc << g_polyRect;
					}
					
					XPoint ptDwgUcs = Wcs2Ucs(ptDwgWcs);
					ptDwgUcs.z = g_ptCorn1.z;
					GetPolyRect(g_ptCorn1, g_nRot, ptDwgUcs, g_polyRect);
					dc << g_polyRect;
				}
			}
		}
		break;
	default: break;
	}
	return bRet;
}

static int GetRectAngle(const XPoint &ptCorn1, double nAngle, XPoint &ptCorn2)
{
	int nRet = RTNORM;
	g_polyRect.Reset();
	g_polyRect.SetFlag(1);
	g_nRot = nAngle;
	g_ptCorn1 = ptCorn1;
	acedRegisterFilterWinMsg(MouseMoveMonitor);
	nRet = ads_getpoint(NULL, _T(""), ptCorn2);
	acedRemoveFilterWinMsg(MouseMoveMonitor);
	g_polyRect.Reset();
	ads_redraw(NULL,0);
	return nRet;
}

int XExport2::GetRectAngleStatic(const XPoint &ptCorn1, double nAngle, XPoint &ptCorn2)
{
	return GetRectAngle(ptCorn1, nAngle, ptCorn2);
}

int XExport2::XGetCorner(const XPoint &ptCorn1, const TCHAR *pszMsg, XPoint &ptCorn2)
{
    if (pszMsg)
	{
        XGeLib::adsout << pszMsg;
	}
    return GetRectAngle(ptCorn1, 0.0, ptCorn2);
}

XCell* XExport2::GetShape(const Point& pickPt)
{
	XPushVar<int> vOsMode(_T("OSMODE"), 0);
	
	Entity eL, entPline;
	eL.GetLast();
	if (SHads_command(RTSTR, _T("-BOUNDARY"), RTPOINT, &pickPt, RTSTR, _T(""), RTNONE) == RTNORM)
	{
		Entity entNew;
		entNew.GetLast();
		if (entNew == eL)
		{
			NULL;
		}
		else
		{
			entPline = entNew;
		}
	}
	if (!entPline)
	{
		return NULL;
	}
	else
	{
		XCell* presult;
		XPoly* pPoly = new XPoly(entPline);
		ads_point ptcen;
		double dw, dh;
		if (pPoly->Length() == 2)
		{
			presult = new XCircle(*(*pPoly)[0], *(*pPoly)[1]);
		}
		else if (pPoly->IsRectAngle(ptcen, &dw, &dh))
		{
			presult = new XRectAngle(ptcen, dw, dh);
		}
		else
		{
			presult = NULL;
		}
		entPline.Delete();
		
		PickSet ss(SS_FREE);
		RBList fence = pPoly->Fence();
		if (ss.Get(_T("F"), fence) == RTNORM)
		{
			ads_redraw(NULL, 0);
		}
		if (presult)
		{
			delete pPoly;
			return presult;
		}
		return pPoly;
	}
	return NULL;
}

Acad::ErrorStatus XExport2::ExplodeBlockRef(AcDbBlockTableRecord &blockRec, ads_matrix matForInsert, DList<AcDbEntity> &entSet)
{
    AcGeMatrix3d mat;
    memcpy(&mat, matForInsert, sizeof(ads_matrix));
	
    AcDbBlockTableRecordIterator* pBlockIterator;
    Acad::ErrorStatus es = blockRec.newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
    ASSERT(es == Acad::eOk);
	
    for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step())     
	{
        AcDbEntity *pEntity;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
        ASSERT(es == Acad::eOk);
		
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            pEntity->close();
            continue;
        }
		
        if (pEntity->isKindOf(AcDbLine::desc())) 
		{
            //显示LINE
            AcDbLine *pLine = AcDbLine::cast(pEntity);
            AcGePoint3d ptStart = pLine->startPoint(), ptEnd = pLine->endPoint();
            ptStart.transformBy(mat);
            ptEnd.transformBy(mat);
            entSet.Append(new AcDbLine(ptStart, ptEnd));
        } 
		else if (pEntity->isKindOf(AcDbArc::desc())) 
		{
            AcDbArc *pArc = AcDbArc::cast(pEntity);
            XPoint ptCen;
            (AcGePoint3d &)ptCen = pArc->center();
            XArc ar(ptCen, pArc->radius(), pArc->startAngle(), pArc->endAngle());
            XPoint ptStart, ptEnd, ptMid;
			ar.GetStartPoint(ptStart);
			ar.GetEndPoint(ptEnd);
            ar.MidPoint(ptMid);
            ((AcGePoint3d &)ptStart).transformBy(mat);
            ((AcGePoint3d &)ptEnd).transformBy(mat);
            ((AcGePoint3d &)ptMid).transformBy(mat);
            XArc arNew(ptStart, ptMid, ptEnd);
            entSet.Append(new AcDbArc(arNew.GetCenterPt(), arNew.GetRadius(), arNew.GetStarAngle(), arNew.GetEndAngle()));
        } 
		else  
		{ 
            AcDbEntity *pEntCopy = NULL;
            if (pEntity->getTransformedCopy(mat, pEntCopy) == Acad::eOk && pEntCopy) 
			{
                entSet.Append(pEntCopy);
            }
        }
		
        pEntity->close();
    }
    delete pBlockIterator;
    return Acad::eOk;
}

// 由二维曲线, 求若干个最外边界轮廓线
int XExport2::GetExternalBoundaryFromCurves(const DList<XCurveSegment> &lstSegs, DList<XPoly2D> &lstPolys)
{
    if (!lstSegs.Length())
	{
        return RTERROR;
	}
	
    DList<XCurveSegment> ss;
    for (int i = 0; i<lstSegs.Length(); i++) 
	{
        XCurveSegment seg = lstSegs[i];
        seg.SetElevation(0.0);
        ss.Append(new XCurveSegment(seg));
    }
		
    if (ss.Length()) 
	{
        RemoveDupCurves(ss); 
        IntersectCurves(ss, _DIST_SNAP);
		
        lstPolys.Reset();
        SearchOutRegions(ss, lstPolys);
        
        if (!!lstPolys) 
		{
            return RTNORM;
        }
    }
    return RTERROR;
}

//extern int CompareDouble(const double *p1, const double *p2);
void XExport2::IntersectCurves(DList<XCurveSegment> &lstCurves, double dPrec)
{
	DList<XCurveSegment> ss1;
	int nCount = lstCurves.Length();
	for (int nn = 0; nn < nCount; nn++) 
	{
		XCurveSegment *pSeg = lstCurves[nn];
		if (!pSeg->Is(CURVE_CIRCLE) && pSeg->GetLength() > _DIST_SNAP) 
		{
			XCurveSegment *pNewSeg = new XCurveSegment(*pSeg);
			pNewSeg->SetLineFlag(LS_FINITE);
			ss1.Append(pNewSeg);
		}
	}
	
	int len1 = ss1.Length();
	if (g_bEchoSearch)
	{
		acedSetStatusBarProgressMeter(_T("求交线"), 0, len1);
	}
	
	int nStep = len1/100;
	if (nStep<1)
	{
		nStep = 1;
	}
	DList<double> *lstDistArray = new DList<double> [len1];
	for (int nn = 0; nn<len1-1; nn++)
	{
		if (g_bEchoSearch && nStep>1 && !(nn%nStep)) 
		{
			acedSetStatusBarProgressMeterPos(nn);
		}
		XCurveSegment &line1 = *ss1[nn];
		
		for (int kk = nn+1; kk<len1; kk++) 
		{
			XCurveSegment &line2 = *ss1[kk];
			XPoint ptInt[2]; 
			int nInt = line1.Intersection(line2, ptInt[0], ptInt[1]);
			for (int mm = 0; mm<nInt; mm++) 
			{
				double nDist1 = line1.PathDistance(ptInt[mm]);
				double nDist2 = line2.PathDistance(ptInt[mm]);
				if (nDist1 < -_DIST_SNAP || nDist2 < -_DIST_SNAP) 
				{
#ifndef NDEBUG
					XGeLib::adsout << _T("\nError found");
#endif
				}
				else 
				{
					if (nDist1>_DIST_SNAP)
					{
						lstDistArray[nn].Append(new double(nDist1));
					}
					if (nDist2>_DIST_SNAP)
					{
						lstDistArray[kk].Append(new double(nDist2));
					}
				}
			}
		}
	}
	lstCurves.Reset();
	for (int nn = 0; nn<len1; nn++) 
	{
		DList<double> &lstDistSeg = lstDistArray[nn];
		XCurveSegment &line1 = *ss1[nn];
		double nDist0 = line1.GetLength();
		lstDistSeg.QuickSort(CompareDouble);
		lstDistSeg.Append(new double(nDist0)); 
		XPoint &ptStart = line1.StartPoint();
		XPoint ptS = ptStart;
		for (int kk = 0; kk<lstDistSeg.Length(); kk++) 
		{
			XPointDir2d ptE;
			line1.Polar(*lstDistSeg[kk], ptE);
			if (ptS.Distance2d(ptE)>_DIST_SNAP) 
			{
				XCurveSegment *pSeg = new XCurveSegment(line1);
				pSeg->SetPoints(ptS, ptE);
				lstCurves.Append(pSeg);
			}
			ptS = ptE;
		}
	}
	
	delete [] lstDistArray;
	if (g_bEchoSearch) 
	{
		acedRestoreStatusBar();
	}
}

void XExport2::RemoveDupCurves(DList<XCurveSegment> &lstCurves)
{
	DList<XCurveSegment> lstLines, lstCirArcs;
	ASSERT(lstCurves.GetDelFlag() != FALSE);
	lstCurves.SetDelFlag(FALSE);
	int nCount = lstCurves.Length();
	for (int i = 0; i<nCount; i++) 
	{
		XCurveSegment *pSeg = lstCurves[i];
		if (pSeg->Is(CURVE_LINE)) 
		{
			lstLines.Append(pSeg);
		}
		else
		{
			lstCirArcs.Append(pSeg);
		}
	}
	lstCurves.Reset();
	lstCurves.SetDelFlag(TRUE);

	{
		XPushMemVar<BOOL> vTemp(g_bEchoSearch, FALSE);
		_RemoveDupCurves(lstCirArcs);
		
		lstCirArcs.SetDelFlag(FALSE);
		nCount = lstCirArcs.Length();
		for (int i = 0; i<nCount; i++)
		{
			lstCurves.Append(lstCirArcs[i]);
		}
	}
	
	xdRemoveDupCurves(lstLines, FALSE, FALSE);
	lstLines.SetDelFlag(FALSE);
	nCount = lstLines.Length();
	for (int i = 0; i<nCount; i++)
	{
		lstCurves.Append(lstLines[i]);
	}
}

// 由二维曲线, 求最外边界轮廓线
int XExport2::GetExternalBoundaryFromCurves(const DList<XCurveSegment> &ss, XPoly2D &polyOutline)
{
    DList<XCurveSegment> lstSegs;
    for (int i = 0; i<ss.Length(); i++)
	{
        XCurveSegment seg = ss[i];
        seg.SetElevation(0.0);
        lstSegs.Append(new XCurveSegment(seg));
    }
	
    RemoveDupCurves(lstSegs);
    IntersectCurves(lstSegs,_DIST_SNAP);
	
	XSearchRegionFromCurve aSearch;
	try
	{
		aSearch.InitStart(lstSegs);
	} 
	catch(...) 
	{
		XGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
		return RTERROR;
	}
	
    XRegion *pExt = aSearch.SearchRegions();
    if (pExt)
	{
        pExt->CenterPoly2D(polyOutline);
        polyOutline.Compress();
        return RTNORM;
    }
    return RTERROR;
}

// 用区域裁剪实体
void XExport2::ClipEntitiesByPoly(XPoly2D & polyOutline, PickSet &ssBack)
{
    PickSet ssBackInsert(SS_FREE), ssIn(SS_FREE), ssOut(SS_FREE), ssEdge(SS_FREE);
    ssBackInsert += ssBack;
	RBList rr((RTDXF0, _T("POLYLINE,LWPOLYLINE,INSERT,AEC_BLOCK_INSERT"), NULL));
    ssBackInsert.BaseFilter(rr);
    ssBack -=  ssBackInsert;
    
    // 裁剪曲线
    PolyClip(ssBack, polyOutline, ssIn, ssOut, ssEdge);
    if (ssIn.Length())
	{
        ssIn.Erase();
	}
    if (ssEdge.Length())
	{
        ssEdge.Erase();
	}

    // 裁剪图块
    long lCount = ssBackInsert.Length();
    for (long idx = 0L; idx<lCount; idx++) 
	{
        Entity entBack = ssBackInsert[idx];

        PickSet ss(SS_FREE);
        BOOL bBlock = FALSE;
        if (entBack.Is(_T("AEC_BLOCK_INSERT")) || entBack.Is(_T("INSERT")))
		{
			XExport::GetCurveFromInsert2D(entBack, ss);
            bBlock = TRUE;
        }
		else//多段线
		{
			ss.IncludeBegin();

			OPENOBJ_BEGIN(entBack,AcDb::kForRead,AcDbEntity,pEntity)
			if (pEntity != NULL)
			{
				AcDbVoidPtrArray entSet;
				pEntity->explode(entSet);
				for (long i = 0;i<entSet.length();i++)
				{
					AcDbEntity*pNewEnt = (AcDbEntity*)entSet[i];
					if (XExport::AddToCurrentSpace(pNewEnt,Adesk::kTrue) == AcDbObjectId::kNull)
					{
						delete pNewEnt;
					}
				}
			}
			OPENOBJ_END();

			ss.IncludeEnd();
		}

		if (ss.Length()>0)
		{   
			PickSet ssIn(SS_FREE), ssOut(SS_FREE), ssEdge(SS_FREE);
            PolyClip(ss,polyOutline, ssIn, ssOut,ssEdge);
			if (ssOut.Length() > 0)//裁剪发生
			{
				if (ssIn.Length() > 0)
				{
					ssIn.Erase();
				}
				if (ssEdge.Length() > 0)
				{
					ssEdge.Erase();
				}

				if (bBlock)
				{
					XPoint ptInsert;
					entBack.GetData(10, &ptInsert);
					XString sNewBlockName(256);
					if (ssOut.MakeAnonymous(ptInsert, sNewBlockName, FALSE) == RTNORM) 
					{
						OPENOBJ_BEGIN(entBack, AcDb::kForWrite, AcDbBlockReference, pInsert);
						if (pInsert)
						{
							pInsert->setBlockTableRecord(GetBlockIdFromString(sNewBlockName));
							pInsert->setScaleFactors(AcGeScale3d(1.0,1.0,1.0));
							pInsert->setRotation(0.0);
						}
						OPENOBJ_END();			
					}
				}
				else
				{
					entBack.Erase();
				}
			}
			else
			{
				ss.Erase();
			}
        }
    }
}


int XExport2::GetClipBoundary(XPoly2D &poly2d)
{
    const TCHAR *szPrompts[2] = {_T("\n矩形的第一个角点或 [多边形裁剪(P)]<退出>:"),
								 _T("\n多边形的第一点或 [矩形裁剪(R)]<退出>:")};
    const TCHAR *szKeywords[2] = {_T("P"), _T("R")};
    int nClipType = 0;

    XPoint ptStart;
    while(1) 
	{
        XGeLib::adsout << szPrompts[nClipType];
        int nCode;
        INITGET_BEG(0, szKeywords[nClipType]);
        nCode = ads_getpoint(NULL, _T(""), ptStart);
        INITGET_END();
        if (nCode == RTKWORD)
		{
            nClipType = 1 - nClipType;
		}
        else 
		{
            if (nCode == RTNORM)
			{
                break;
			}
            else
			{
                return nCode;
			}
        }
    }

    if (nClipType == 0) 
	{
        XPoint ptOther;
        int nCode = XGetCorner(ptStart, _T("\n另一个角点<退出>:"), ptOther);
        if (nCode != RTNORM)
		{
            return nCode;
		}
        XRectAngle rect(ptStart, ptOther);
        rect.AsPoly2D(poly2d);
    } 
	else 
	{
        XPoint pt2;
        XScreenDc dc;
        dc.m_nDrawMode = 1;
        DStack<XPoint> aStack;
        aStack.Push(new XPoint(ptStart));
        while(1)
		{
            XPoint &ptFrom = *aStack.Top();
            if (aStack.Length() >= 3)
			{
                XGeLib::adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
			}
            else
			{
                XGeLib::adsout << _T("\n下一点或 [回退(U)]<退出>: ");
			}
            int rc;
            INITGET_BEG(0, _T("U"));
            rc = ads_getpoint(ptFrom, _T(""), pt2);
            INITGET_END();
            if (rc == RTCAN) 
			{
                aStack.Reset();
                return rc;
            } 
			else if (rc == RTKWORD)
			{
                if (*aStack.Top() != ptStart) 
				{// Not on first state
                   XPoint *pPt2 = aStack.Pop();
                   XPoint *pPt1 = aStack.Top();
                   dc.SetColor(-1);
                   dc << XLine(*pPt1, *pPt2);
                   delete pPt2;
                }
            }
			else
			{
                if (rc == RTNONE) 
				{
                    if (aStack.Length() < 3)
					{
                        return RTERROR;
					}
                    else
					{
                        pt2 = ptStart;
					}
                }

                 XLine ln(*aStack.Top(), pt2);
                 if (ln.GetLength() > _DIST_SNAP) 
				 {
                    dc.SetColor(7);
                    dc << ln;
                    if (!(rc == RTNONE))
					{
                       aStack.Push(new XPoint(pt2));
					}
                    else
					{
						break;
					}
                 }
            }
        }
        poly2d.Reset();
        XPoint *ptCur = NULL;
        while((ptCur = aStack.Pop()) != NULL) 
		{
           poly2d.AppendNode(*ptCur);
           delete ptCur;
        }
        poly2d.Compress();
        if (!poly2d || poly2d.Length() < 3)
		{
            return RTERROR;
		}
    }
    return RTNORM;
}

// 从块表中取所有的曲线: 包括LINE,ARC,CIRCLE,POLYLINE,LWPOLYLINE,以及在INSERT中的前述实体
void XExport2::Get2DCurveFromBlock(AcDbBlockTableRecord &blockRec, ads_matrix matForInsert, DList<XCurveSegment> &lstResult)
{
    AcGeMatrix3d mat;
    memcpy(&mat, matForInsert, sizeof(ads_matrix));

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = blockRec.newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
    ASSERT(es == Acad::eOk && !!pBlockIterator);

    for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step())     
	{
        AcDbEntity *pEntity;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
        ASSERT(es == Acad::eOk);
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            pEntity->close();
            continue;
        }

        if (pEntity->isKindOf(AcDbLine::desc())) 
		{
            //显示LINE
            AcDbLine *pLine = AcDbLine::cast(pEntity);
            XPoint ptStart = pLine->startPoint(),ptEnd = pLine->endPoint();
            ptStart.TransformBy(matForInsert);
            ptEnd.TransformBy(matForInsert);
            lstResult.Append(new XCurveSegment(ptStart, ptEnd, 0.0));
        } 
		else if (pEntity->isKindOf(AcDbArc::desc())) 
		{
            AcDbArc *pArc = AcDbArc::cast(pEntity);
            XPoint ptCen;
            (AcGePoint3d &)ptCen = pArc->center();
            XArc ar(ptCen, pArc->radius(), pArc->startAngle(), pArc->endAngle());
            XPoint ptStart, ptEnd, ptMid;
			ar.GetStartPoint(ptStart);
			ar.GetEndPoint(ptEnd);
            ar.MidPoint(ptMid);
            ((AcGePoint3d &)ptStart).transformBy(mat);
            ((AcGePoint3d &)ptEnd).transformBy(mat);
            ((AcGePoint3d &)ptMid).transformBy(mat);
            XCurveSegment *pSeg = new XCurveSegment;
            *pSeg = XArc(ptStart, ptMid, ptEnd);
            lstResult.Append(pSeg);
        } 
		else if (pEntity->isKindOf(AcDbCircle::desc())) 
		{ //圆的变换为近似, 不变半径
            AcDbCircle *pCir = AcDbCircle::cast(pEntity);
            XPoint ptCen = pCir->center();
            ptCen.TransformBy(matForInsert);
            XCurveSegment *pSeg = new XCurveSegment;
            *pSeg = XCircle(ptCen, pCir->radius());
            lstResult.Append(pSeg);
        } 
		else if (pEntity->isKindOf(AcDbPolyline::desc()) || pEntity->isKindOf(AcDb2dPolyline::desc())) 
		{
			AcDbPolyline pline;
            Entity ent;
            acdbGetAdsName(ent.name, pEntity->objectId());
            if (!(!ent)) 
			{
                XPoly2D poly(ent);
                if (!poly) 
				{
					;
				}
                else 
				{
                    poly.TransUCS(matForInsert);
                    for (int i = 0; i<poly.TotalSegments(); i++)
					{
                        XCurveSegment *pSeg = new XCurveSegment;
                        poly.Nth(i, *pSeg);
                        lstResult.Append(pSeg);
                    }
               	}
            }
        } 
		else if (pEntity->isKindOf(AcDbBlockReference::desc())) 
		{ //嵌套图块
            AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
            ASSERT(pInsert);
            XPoint ptLoc = pInsert->position();
            double nRot = pInsert->rotation();
            AcGeScale3d scale = pInsert->scaleFactors();
            AcDbObjectId idBlock = pInsert->blockTableRecord();
            XDbObject objBlock(idBlock, AcDb::kForRead);
            ASSERT(!!objBlock);
            AcDbBlockTableRecord *pRec = AcDbBlockTableRecord::cast(objBlock.m_pObject);
            ASSERT(pRec);
            XPoint ptBase = pRec->origin();
            ads_matrix mat1, mat2;
            get_matrix(ptBase, ptLoc, scale[0], scale[1], scale[2], nRot, mat1);
            AT_multiply_matrix(matForInsert, mat1, mat2);
            Get2DCurveFromBlock(*pRec, mat2, lstResult);
        }

        pEntity->close();
    }
    delete pBlockIterator;
}

// 由二维图块提取二维曲线段
int XExport2::GetCurveFromInsert2D(Entity &ent, DList<XCurveSegment> &lstSegs)
{
    if (!ent.Is(_T("INSERT")) && !ent.Is(_T("AEC_BLOCK_INSERT")) && !ent.Is(_T("AEC_MVINSERT")))
	{
        return RTERROR;
	}

    ads_matrix mat;
    GetInsertMatrix(ent, mat);
    XString sBlockName(256);
	int nCode = (ent.Is(_T("AEC_MVINSERT"))? 1 : 2);
    VERIFY(ent.GetData(nCode, (TCHAR *)sBlockName) == RTNORM);
    XBlockTableRecPtr rec(sBlockName, AcDb::kForRead);
    ASSERT(!!rec);

    Get2DCurveFromBlock(*rec.m_pBlockTableRec, mat, lstSegs);
    return RTNORM;
}

// 有若干线搜索区域
int XExport2::SearchOutRegions(const DList<XCurveSegment> &lstSeg1In, DList<XPoly2D> &lstDest)
{
    XSearchRegionFromCurve aSearch;
    try 
	{
		aSearch.InitStart(lstSeg1In);
    }
	catch(...) 
	{
		XGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
		return RTERROR;
    }
	
	
    if (aSearch.SearchRegions())
	{
        DList<int> lstOut;
        if (aSearch.GetOutsideRegions1(lstOut) && !!lstOut)
		{
            for (int n = 0; n<lstOut.Length(); n++) 
			{
                XPoly2D *pNewPoly = new XPoly2D(1);
                VERIFY(aSearch.m_regions[*lstOut[n]]->CenterPoly2D(*pNewPoly) == RTNORM);
                pNewPoly->Compress();
                lstDest.Append(pNewPoly);
            }
        }
    }
    return RTNORM;
}

// 把Poly2D分解为若干段曲线
void XExport2::ExplodePoly2D(const XPoly2D &poly, DList<XCurveSegment> &lstSegs)
{
    for (int i = 0; i<poly.TotalSegments(); i++) 
	{
        XCurveSegment *pSeg = new XCurveSegment;
        poly.Nth(i, *pSeg);
        lstSegs.Append(pSeg);
    }
}

//  把XPoly2D转换成AcDbPolyline
void XExport2::PolyConvert(const XPoly2D &poly, AcDbPolyline &pline)
{
	pline.assertWriteEnabled(); //支持UNDO

	AcGeVector3d vtNormal = pline.normal();
	double nThick = pline.thickness();
	double nWidth = 0;

	Acad::ErrorStatus es = pline.getConstantWidth(nWidth);
	pline.reset(Adesk::kFalse, 0);

	for (int i = 0; i<poly.Length(); i++)
	{
		pline.addVertexAt(i, poly[i].AsAcGePoint2d(), tan(poly.GetBulge(i)/4));
	}

	pline.setClosed(poly.IsClosed());
	if (poly.Length())
	{
		pline.setElevation(poly[0].z);
	}

	pline.setNormal(vtNormal);
	pline.setThickness(nThick);
	if (es == Acad::eOk)
	{
		pline.setConstantWidth(nWidth);
	}
}

//  把AcDbPolyline转换成XPoly2D
void XExport2::PolyConvert(const AcDbPolyline &pline, XPoly2D &poly)
{
	poly.Reset();

	for (Adesk::UInt16 i = 0; i<pline.numVerts(); i++)
	{
		AcGePoint2d ptVert;
		double nBulge = 0.0;
		pline.getPointAt(i, ptVert);
		pline.getBulgeAt(i, nBulge);

		XPoint pt;
		pt = ptVert;
		nBulge = atan(nBulge)*4;
		poly.AppendNode(pt, nBulge);
	}

	if (pline.isClosed())
	{
		poly.SetFlag(poly.GetFlag() | 0x01);
	}
	else
	{
		poly.SetFlag(0);
	}

	poly.SetElevation(pline.elevation());
}

// 支持3D
AcDbRegion* XExport2::AsRegion(const XPoly2D &poly)
{
	if (!poly.IsClosed())
	{
		return NULL;
	}

	XPoly2D polyCopy(1);
	poly.Disperse1(polyCopy, _AS_SYS_UNIT(g_nCirDeviation));

	AcDbVoidPtrArray curveSegments;
	for (int j = 0; j<polyCopy.Length();j++)
	{
		XCurveSegment seg;
		polyCopy.Nth(j, seg);
		if (seg.GetLength()>_DIST_SNAP)
		{
			curveSegments.append(new AcDbLine(seg.GetStartPoint(), seg.GetEndPoint()));
		}
	}

	AcDbVoidPtrArray regions;	 
	if (AcDbRegion::createFromCurves(curveSegments, regions) == Acad::eOk && regions.length()>0)
	{
		AcDbRegion *regioni = (AcDbRegion *)regions[0];
		regions.removeAt(0);
		
		XExport::ReleaseEntSet(regions);
		XExport::ReleaseEntSet(curveSegments);
		return regioni;
	}

	XExport::ReleaseEntSet(curveSegments);
	return NULL;
}

int XExport2::FindNearestEdge(const XPoly2D &poly, const XPoint &ptEdge)
{
    int nEdge = -1;
    double nNearDist = 0.0;
    for (int i = 0; i<poly.TotalSegments(); i++) 
	{
        XCurveSegment seg;
        poly.Nth(i, seg);
        XPoint ptOnEdge;
        if (seg.ProjectToMe(ptEdge, ptOnEdge) == RTNORM && (ptOnEdge&seg) == PR_INSIDE) 
		{
            double nDist = ptEdge.Distance2d(ptOnEdge); 
            if (nEdge == -1) 
			{
                nEdge = i;
                nNearDist = nDist;
            } 
			else if (nDist<nNearDist) 
			{
                nEdge = i;
                nNearDist = nDist;
            }
        }
    }
    return nEdge;
}


AcDbHatch * XExport2::NewHatchFromPoly2D(const XPoly2D &poly)
{
    ASSERT(poly.IsClosed());

    AcGeDoubleArray bulges;
	AcGePoint2dArray vertices;
 
    int nVert = poly.Length();

	AcDbHatch *pHatch = new AcDbHatch();
	pHatch->setAssociative(Adesk::kFalse);
	pHatch->setPattern(AcDbHatch::kPreDefined,_T("SOLID"));
	pHatch->setHatchStyle(AcDbHatch::kNormal);
	bulges.setPhysicalLength(0).setLogicalLength(nVert + 1);
	vertices.setPhysicalLength(0).setLogicalLength(nVert + 1);
	
	int i(0);
    for (i = 0; i<nVert; i++) 
	{
	    vertices[i] =  poly[i];
        bulges[i] = tan(poly.GetBulge(i)/4);
    }

    vertices[i] = vertices[0];
    bulges[i] = bulges[0];

    pHatch->appendLoop(AcDbHatch::kExternal|AcDbHatch::kPolyline|AcDbHatch::kDerived,vertices,bulges);
    pHatch->evaluateHatch(true);

	return pHatch;
}

AcDbHatch * XExport2::NewHatchFromPoly2D(const XPoly2D &poly, const TCHAR *pszPattern0, double nScl)
{
    XString sPattern;
    sPattern = pszPattern0;
    TCHAR *pScale = sPattern.StrChr(_T(':'));
    if (pScale) 
	{
        *pScale = EOS;
        pScale++;
        double nScaleAdd = _tstof(pScale);
        if (nScaleAdd > 1.0E-6)
		{
            nScl *= nScaleAdd;
		}
    }

    AcGeDoubleArray bulges;
	AcGePoint2dArray vertices;
 
    int nVert = poly.Length();

	AcDbHatch *pHatch = new AcDbHatch();
	pHatch->setAssociative(Adesk::kFalse);
    pHatch->setPatternScale(nScl);
	pHatch->setHatchStyle(AcDbHatch::kNormal);
    if (pHatch->setPattern(AcDbHatch::kPreDefined, sPattern) != Acad::eOk) 
	{
        delete pHatch;
        return NULL;
    }

	bulges.setPhysicalLength(0).setLogicalLength(nVert+1);
	vertices.setPhysicalLength(0).setLogicalLength(nVert+1);
	
	int i(0);
    for (i = 0; i<nVert; i++) 
	{
	    vertices[i] =  poly[i];
        bulges[i] = tan(poly.GetBulge(i)/4);
    }
    vertices[i] = vertices[0];
    bulges[i] = bulges[0];

	pHatch->appendLoop(AcDbHatch::kExternal | AcDbHatch::kPolyline | AcDbHatch::kDerived, vertices, bulges);
	Acad::ErrorStatus es;
    if ((es = pHatch->evaluateHatch(true)) != Acad::eOk) 
	{
        delete pHatch;
        return NULL;
    }

	return pHatch;
}

AcDbHatch * XExport2::NewHatchFromPoly2D(const XPoly2D &poly, const TCHAR *pszPattern0, double nScl,double rotation)
{
    XString sPattern;
    sPattern = pszPattern0;
    TCHAR *pScale = sPattern.StrChr(_T(':'));
    if (pScale) 
	{
        *pScale = EOS;
        pScale++;
        double dScaleAdd = _tstof(pScale);
        if (dScaleAdd > 1.0E-6)
		{
            nScl *= dScaleAdd;
		}
    }

    AcGeDoubleArray bulges;
	AcGePoint2dArray vertices;
 
    int nVert = poly.Length();

	AcDbHatch *pHatch = new AcDbHatch();
	pHatch->setAssociative(Adesk::kFalse);
    pHatch->setPatternScale(nScl);
	pHatch->setPatternAngle(rotation);
	pHatch->setHatchStyle(AcDbHatch::kNormal);
    if (pHatch->setPattern(AcDbHatch::kPreDefined, sPattern) != Acad::eOk) 
	{
        delete pHatch;
        return NULL;
    }

	bulges.setPhysicalLength(0).setLogicalLength(nVert + 1);
	vertices.setPhysicalLength(0).setLogicalLength(nVert + 1);
	
	int  i(0);
    for (i = 0; i<nVert; i++) 
	{
	    vertices[i] =  poly[i];
        bulges[i] = tan(poly.GetBulge(i)/4);
    }
    vertices[i] = vertices[0];
    bulges[i] = bulges[0];

	pHatch->appendLoop(AcDbHatch::kExternal|AcDbHatch::kPolyline|AcDbHatch::kDerived,vertices,bulges);
	Acad::ErrorStatus es;
    if ((es = pHatch->evaluateHatch(true)) != Acad::eOk) 
	{
        delete pHatch;
        return NULL;
    }

	return pHatch;
}

Acad::ErrorStatus XExport2::ReadPoly2D(AcDbDwgFiler *pFiler, XPoly2D &poly)
{
   Adesk::UInt8 bIsClosed = 0;
   pFiler->readItem(&bIsClosed);
   Adesk::UInt16 nVertexCount = 0;
   pFiler->readItem(&nVertexCount);
   poly.Reset();
   poly.SetFlag(bIsClosed);
   for (Adesk::UInt16 i = 0; i<nVertexCount; i++) 
   {
       AcGePoint2d pt;
       double bulge;
       pFiler->readItem(&pt);
       pFiler->readItem(&bulge);
       poly.AppendNode(XPoint(pt[0],pt[1], 0.0), bulge);
   }
   return pFiler->filerStatus();
}

Acad::ErrorStatus XExport2::WritePoly2D(AcDbDwgFiler *pFiler, const XPoly2D &poly)
{
   pFiler->writeItem((Adesk::UInt8)poly.GetFlag());
   Adesk::UInt16 nVertexCount = poly.Length();  
   pFiler->writeItem(nVertexCount);
   for (Adesk::UInt16 i = 0; i<nVertexCount; i++) 
   {
       pFiler->writeItem(poly[i].AsAcGePoint2d());
       pFiler->writeItem(poly.GetBulge(i));
   }
   return pFiler->filerStatus();
}

int XExport2::_SplitPoly2D(const XPoly2D &poly, const XPoint &pt1, const XPoint &pt2, XPoly2D &res1, XPoly2D &res2)
{
    ASSERT(poly.IsClosed());
    XPoint ptBreak[2]  = {pt1, pt2};
    XPoint ptOnPoly[2] = {pt1, pt2};
    int nBreakIndex[2] = {-1,-1};
    double minDist[2]  = {-1.0, -1.0};

    int nSeg = poly.TotalSegments();
    for (int i = 0; i<nSeg; i++) 
	{
        XCurveSegment seg;
        poly.Nth(i, seg);
        for (int n = 0; n<2; n++) 
		{
            XPoint ptPrj;
            if (seg.ProjectToMe(ptBreak[n], ptPrj) == RTNORM) 
			{
                int nPrFlag = (ptPrj&seg);
                if (nPrFlag == PR_INSIDE || nPrFlag == PR_ONPT1 || nPrFlag == PR_ONPT2) 
				{
                    double nDist = ads_distance(ptBreak[n], ptPrj);
                    if (minDist[n]<-1.0E-3) 
					{
                        minDist[n] = nDist;
                        nBreakIndex[n] = i;
                        ptOnPoly[n] = ptPrj;
                    }
					else if (nDist<minDist[n]) 
					{
                        minDist[n] = nDist;
                        nBreakIndex[n] = i;
                        ptOnPoly[n] = ptPrj;
                    }
                }
            }
        }
    }

    if (nBreakIndex[0]<0 || nBreakIndex[1]<0)
	{
        return RTERROR;  //找不到切断点
	}

    int minIndex, maxIndex;
    XPoint ptMin, ptMax;
    if (nBreakIndex[0] == nBreakIndex[1]) 
	{
        //在同一段，靠近起点为小，靠近终点为大
        XDirectionCurve cvTemp;
        poly.Nth(nBreakIndex[0], cvTemp);
        double nDist0 = cvTemp.PathDistance(ptOnPoly[0]);
        double nDist1 = cvTemp.PathDistance(ptOnPoly[1]);
        if (fabs(nDist0-nDist1) < _DIST_SNAP)
		{
            return RTERROR; //重合
		}
        minIndex = nBreakIndex[0];
        maxIndex = nBreakIndex[1];
        if (nDist0 < nDist1) 
		{
            ptMin = ptOnPoly[0];
            ptMax = ptOnPoly[1];
        }
		else
		{
            ptMin = ptOnPoly[1];
            ptMax = ptOnPoly[0];
        }
    } 
	else if (nBreakIndex[0]<nBreakIndex[1]) 
	{
        minIndex = nBreakIndex[0];
        maxIndex = nBreakIndex[1];
        ptMin = ptOnPoly[0];
        ptMax = ptOnPoly[1];
    }
	else
	{
        minIndex = nBreakIndex[1];
        maxIndex = nBreakIndex[0];
        ptMin = ptOnPoly[1];
        ptMax = ptOnPoly[0];
    }

    // 取得res1
    for (int i = minIndex; i <= maxIndex; i++) 
	{
        XDirectionCurve seg;
        poly.Nth(i, seg);
        if (i == minIndex) 
		{
            // get ptBreak->ptEnd
            if (ads_distance(ptMin, seg.GetEndPoint()) < _DIST_SNAP) 
			{
                continue;  //忽略这一段
			}
            double nBulge = 0.0;
            if (seg.IsMinusArc()) 
			{
                XArc ar = seg.GetArc();
                ar.SetAngleByPoints(seg.GetEndPoint(), ptMin);
                nBulge = -ar.Bulge();
            }
			else
			{
                seg.SetPoints(ptMin, seg.GetEndPoint());
                nBulge = seg.GetBulge();
            }
            res1.AppendNode(ptMin, nBulge);
        } 
        if (i == maxIndex)
		{
            // get ptStart->ptBreak
            if (ads_distance(ptMax, seg.GetStartPoint()) < _DIST_SNAP) 
			{
                res1.AppendNode(ptMax, 0.0); 
                continue;  //忽略这一段
            }
            double nBulge = 0.0;
            if (seg.IsMinusArc()) 
			{
                XArc ar = seg.GetArc();
                ar.SetAngleByPoints(ptMax, seg.StartPoint());
                nBulge = -ar.Bulge();
            }
			else 
			{
                seg.SetPoints(seg.StartPoint(), ptMax);
                nBulge = seg.GetBulge();
            }
            res1.AppendNode(seg.StartPoint(), nBulge);
            res1.AppendNode(ptMax, 0.0);
        } 
        if (i != minIndex && i != maxIndex) 
		{
            res1.AppendNode(seg.StartPoint(), seg.GetBulge());
        }
    }

    // 取得res2
    for (int i = maxIndex; i <= minIndex+nSeg; i++) 
	{
        int idx = XExport::DePeriod(nSeg, i);
        XDirectionCurve seg;
        poly.Nth(idx, seg);

        if (idx == maxIndex) 
		{
            // get ptBreak->ptEnd
            if (ads_distance(ptMax, seg.GetEndPoint()) < _DIST_SNAP) 
			{
                continue;  //忽略这一段
			}
            double nBulge = 0.0;
            if (seg.IsMinusArc()) 
			{
                XArc ar = seg.GetArc();
                ar.SetAngleByPoints(seg.GetEndPoint(), ptMax);
                nBulge = -ar.Bulge();
            } 
			else
			{
                seg.SetPoints(ptMax, seg.GetEndPoint());
                nBulge = seg.GetBulge();
            }
            res2.AppendNode(ptMax, nBulge);
        } 
        if (idx == minIndex) 
		{
            // get ptStart->ptBreak
            if (ads_distance(ptMin, seg.GetStartPoint()) < _DIST_SNAP)
			{
                res2.AppendNode(ptMin, 0.0);
                continue; 
            }
            double nBulge = 0.0;
            if (seg.IsMinusArc()) 
			{
                XArc ar = seg.GetArc();
                ar.SetAngleByPoints(ptMin, seg.StartPoint());
                nBulge = -ar.Bulge();
            } 
			else 
			{
                seg.SetPoints(seg.StartPoint(), ptMin);
                nBulge = seg.GetBulge();
            }
            res2.AppendNode(seg.StartPoint(), nBulge);
            res2.AppendNode(ptMin, 0.0);
        } 
        if (i != minIndex && i != maxIndex) 
		{
            res2.AppendNode(seg.StartPoint(), seg.GetBulge());
        }
    }
    return RTNORM;
}

int XExport2::SplitPoly2D(const XPoly2D &poly, const XPoint &pt1, const XPoint &pt2, XPoly2D &res1, XPoly2D &res2)
{
    ASSERT(poly.IsClosed());
  
    AcDbPolyline pline;
    XPoint ptOnCurve1, ptOnCurve2;
	XExport2::PolyConvert(poly, pline);

    if (pline.getClosestPointTo(pt1, ptOnCurve1) != Acad::eOk || pline.getClosestPointTo(pt2, ptOnCurve2) != Acad::eOk)
	{
        return RTERROR;
	}

    // ARX的SplitCurve有错误，因此自己编写
    int nIndex1 = poly.HitTestOnCurve(ptOnCurve1);
    int nIndex2 = poly.HitTestOnCurve(ptOnCurve2);
    if (!nIndex1 || !nIndex2)
	{
        return RTERROR;
	}

    int nPeriod = poly.Length();
    if (nIndex1>0 && nIndex2>0) 
	{ //顶点到顶点
        int nVert1 = nIndex1-1;
        int nVert2 = nIndex2-1;
        if (nVert1 == nVert2)
		{
            return RTERROR;
		}
        // nVert1到nVert2
        int nTo = (nVert2>nVert1) ? nVert2 : nVert2+nPeriod;
        for (int iVert = nVert1; iVert <= nTo; iVert++) 
		{
            int idx = XExport::DePeriod(nPeriod, iVert);
            res1.AppendNode(poly[idx], poly.GetBulge(idx));
        }
        // nVert2到nVert1
        nTo = (nVert1>nVert2) ? nVert1 : nVert1+nPeriod;
        for (int iVert = nVert2; iVert <= nTo; iVert++) 
		{
            int idx = XExport::DePeriod(nPeriod, iVert);
            res2.AppendNode(poly[idx], poly.GetBulge(idx));
        }
    }
	else if (nIndex1<0 && nIndex2<0) 
	{ // 边到边
        int nEdge1 = abs(nIndex1)-1;
        int nEdge2 = abs(nIndex2)-1;

        // Edge1到Edge2
        XDirectionCurve seg;
        if (nEdge1 == nEdge2)
		{
            poly.Nth(nEdge1, seg);
			if (seg.PathDistance(ptOnCurve1)>seg.PathDistance(ptOnCurve2)&&seg.Is(CURVE_ARC))//add by w on 070302,解决两点在同一弧边的问题
			{
				seg.SetPoints(ptOnCurve2, ptOnCurve1);
				seg.Reverse();
			}
			else
			{
				seg.SetPoints(ptOnCurve1, ptOnCurve2);
			}

			res1.AppendNode(seg.StartPoint(), seg.GetBulge());
			res1.AppendNode(seg.EndPoint(),0.0);
        } 
		else 
		{
            // 第一段
            poly.Nth(nEdge1, seg);
            seg.SetPoints(ptOnCurve1, seg.GetEndPoint());
            res1.AppendNode(seg.StartPoint(), seg.GetBulge());

            // 中间段
            int nToEdge = (nEdge2>nEdge1)? nEdge2 : nEdge2+nPeriod;
            for (int iVert = nEdge1+1; iVert <= nToEdge-1; iVert++)
			{
                int idx = XExport::DePeriod(nPeriod, iVert);
                res1.AppendNode(poly[idx], poly.GetBulge(idx));
            }

            // 最后一段
            poly.Nth(nEdge2, seg);
            seg.SetPoints(seg.StartPoint(), ptOnCurve2);
            res1.AppendNode(seg.StartPoint(), seg.GetBulge());

            // 最后一点
            res1.AppendNode(ptOnCurve2, 0.0);
        }

        // Edge2到Edge1
        // 第一段
        poly.Nth(nEdge2, seg);
        seg.SetPoints(ptOnCurve2, seg.EndPoint());
        res2.AppendNode(seg.StartPoint(), seg.GetBulge());
        // 中间段
        int nToEdge = (nEdge1>nEdge2) ? nEdge1 : nEdge1+nPeriod;
        for (int iVert = nEdge2+1; iVert <= nToEdge-1; iVert++) 
		{
            int idx = XExport::DePeriod(nPeriod, iVert);
            res2.AppendNode(poly[idx], poly.GetBulge(idx));
        }
        // 最后一段
        poly.Nth(nEdge1, seg);
        seg.SetPoints(seg.StartPoint(), ptOnCurve1);
        res2.AppendNode(seg.StartPoint(), seg.GetBulge());
        // 最后一点
        res2.AppendNode(ptOnCurve1, 0.0);
    }
	else if (nIndex1>0 && nIndex2<0) 
	{ //顶点到边
        int nVert1 = nIndex1-1;
        int nEdge2 = abs(nIndex2)-1;
        // nVert1到Edge2
        XDirectionCurve seg;
        // 中间段
        int nToEdge = (nEdge2 >= nVert1)? nEdge2 : nEdge2+nPeriod;
        for (int iVert = nVert1; iVert <= nToEdge-1; iVert++) 
		{
            int idx = XExport::DePeriod(nPeriod, iVert);
            res1.AppendNode(poly[idx], poly.GetBulge(idx));
        }

        // 最后一段
        poly.Nth(nEdge2, seg);
        seg.SetPoints(seg.StartPoint(), ptOnCurve2);
        res1.AppendNode(seg.StartPoint(), seg.GetBulge());

        // 最后一点
        res1.AppendNode(ptOnCurve2, 0.0);

        // Edge2到nVert1
        // 第一段
        poly.Nth(nEdge2, seg);
        seg.SetPoints(ptOnCurve2, seg.EndPoint());
        res2.AppendNode(seg.StartPoint(), seg.GetBulge());
        // 中间段
        nToEdge = (nVert1 >= nEdge2) ? nVert1 : nVert1+nPeriod;
        for (int iVert = nEdge2+1; iVert <= nVert1-1; iVert++) 
		{
            int idx = XExport::DePeriod(nPeriod, iVert);
            res2.AppendNode(poly[idx], poly.GetBulge(idx));
        }
        // 最后一点
        res2.AppendNode(ptOnCurve1, 0.0);
    } 
	else 
	{ // 边到顶点
        int nEdge1 = abs(nIndex1)-1;
        int nVert2 = nIndex2-1;

        // nEdge1到nVert2
        XDirectionCurve seg;
        // 第一段
        poly.Nth(nEdge1, seg);
        seg.SetPoints(ptOnCurve1, seg.EndPoint());
        res1.AppendNode(seg.StartPoint(), seg.GetBulge());

        // 中间段
        int nToEdge = (nVert2>nEdge1) ? nVert2 : nVert2+nPeriod;
        for (int iVert = nEdge1+1; iVert <= nToEdge-1; iVert++) 
		{
            int idx = XExport::DePeriod(nPeriod, iVert);
            res1.AppendNode(poly[idx], poly.GetBulge(idx));
        }
        // 最后一点
        res1.AppendNode(ptOnCurve2, 0.0);

        // nVert2到nEdge1
        if (nEdge1 == nVert2) 
		{
            poly.Nth(nEdge1, seg);
            seg.SetPoints(ptOnCurve2, ptOnCurve1);
            res1.AppendNode(seg.StartPoint(), seg.GetBulge());
            res1.AppendNode(seg.EndPoint(),0.0);
        } 
		else
		{
            // 中间段
            int nToEdge = (nEdge1>nVert2) ? nEdge1 : nEdge1+nPeriod;
            for (int iVert = nVert2; iVert <= nToEdge-1; iVert++)
			{
                int idx = XExport::DePeriod(nPeriod, iVert);
                res2.AppendNode(poly[idx], poly.GetBulge(idx));
            }
            // 最后一段
            poly.Nth(nEdge1, seg);
            seg.SetPoints(seg.StartPoint(), ptOnCurve1);
            res2.AppendNode(seg.StartPoint(), seg.GetBulge());
            //最后一点
            res2.AppendNode(ptOnCurve1, 0.0);
        }
    }
    return RTNORM;
}

void XExport2::SplitPoly2D(const XPoly2D &poly, AcDbVoidPtrArray &entSet)
{
    for (int i = 0; i < poly.TotalSegments(); i++) 
	{
        XCurveSegment cv;
        if (poly.Nth(i, cv) == RTNORM) 
		{
            if (cv.Is(CURVE_LINE)) 
			{
                XLine ln = cv.GetLine();
                entSet.append(new AcDbLine(ln.GetStartPoint(), ln.GetEndPoint()));
            }
			else if (cv.Is(CURVE_ARC)) 
			{
                XArc ar = cv.GetArc();
                entSet.append(new AcDbArc(ar.GetCenterPt(), ar.GetRadius(), ar.GetStarAngle(), ar.GetEndAngle()));
            }
        }
    }
}

// 把区域分解为曲线段
void XExport2::Region2Curves(const AcDbRegion *pClone, DList<XCurveSegment>&lstSegs)
{
	AcDbVoidPtrArray entSet;
	pClone->explode(entSet);
    int nLen = entSet.length();
	for (int j = 0; j < nLen; j++)	
	{
	    AcDbEntity *pEnt = (AcDbEntity *)entSet[j];
        AcRxClass *pClass = pEnt->isA();
        if (pClass == AcDbLine::desc()) 
		{
            AcDbLine *pLine = (AcDbLine *)pEnt;
			lstSegs.Append(new XCurveSegment(XPoint(pLine->startPoint()), XPoint(pLine->endPoint()), 0.0, LS_FINITE));
        }
		else if (pClass == AcDbArc::desc()) 
		{
            AcDbArc *pLine = (AcDbArc *)pEnt;
            XPoint ptCen;
            (AcGePoint3d &)ptCen = pLine->center();
            XVector3D vtNormal;
            (AcGeVector3d &)vtNormal = pLine->normal();
            ptCen = Wcs2Ecs(ptCen, vtNormal);
            XArc ar(ptCen, pLine->radius(), pLine->startAngle(), pLine->endAngle());
            XCurveSegment *pSeg = new XCurveSegment;
            *pSeg = ar;
            lstSegs.Append(pSeg);
        }
		else if (pClass == AcDbPolyline::desc()) 
		{
            XPoly2D polyTemp;
            XExport2::PolyConvert(*(AcDbPolyline *)pEnt, polyTemp);
            XExport2::ExplodePoly2D(polyTemp, lstSegs);
        }
		else if (pClass = AcDbRegion::desc()) 
		{
            XExport2::Region2Curves((AcDbRegion *)pEnt, lstSegs);
        }
	}
    XExport::ReleaseEntSet(entSet);
}

int XExport2::HandleCurveInters(PickSet &ss, double dPrec)
{
	//_angSnap = 0.001; _DIST_SNAP = 0.1; // for Debug
	PickSet ssNew(SS_FREE|SS_CREATE), ssCir(SS_FREE|SS_CREATE), ssDel(SS_FREE|SS_CREATE);

	XCurveSegInters::minLen = dPrec;
	ssNew.IncludeBegin();

	XCurveSegInters::GlobalCurveList.Reset();
	long len = ss.Length();
	DList<XCurveSegInters> &curves = XCurveSegInters::GlobalCurveList;
	for (long i = 0; i<len; i++) 
	{
		Entity e1 = ss[i];
		XCurveSegInters * curve = new XCurveSegInters(e1);
		if (curve->GetLength() < _DIST_SNAP) 
		{
			delete curve;
			ssDel += ss[i];
		}
		else
		{
			curves.Append(curve);
		}
	}

	len = curves.Length();
	for (int i = 0; i<len; i++) 
	{
		XCurveSegInters *curve = curves[(int)i];
		curve->DivideToSegments();
		if (curve->Update() == RTNORM && curve->Is(CURVE_CIRCLE))
		{
			ssCir += curve->acadEnt; 
		}
	}

	ssNew.IncludeEnd();

	ss -=  ssDel;
	ss -=  ssCir;
	ss += ssNew;
	XCurveSegInters::GlobalCurveList.Reset();
	ssDel.Erase();
	ads_redraw(NULL, 0);
	return RTNORM;
}

// 连接桥的确定有问题
// 新的桥接算法
// 2D only
int XExport2::ConnectPolygon(const XPolygonEx &poly1, const XPolygonEx &poly2, const XPolyDist &polyDist, XPolygonEx &res)
{
    ASSERT(poly1.Length()>1 && poly2.Length()>1);

    int nIndex1 = polyDist.nIndex1;
    int num1 = poly1.Length();
    int nIndex2 = polyDist.nIndex2; //poly2与pt最近的顶点
    int num2 = poly2.Length();
    res.Reset();

	BOOL bOnVertex1 = FALSE, bOnVertex2 = FALSE;
	if (polyDist.ptLocation1.Distance2d(poly1.GetVertex(polyDist.nIndex1))<_DIST_SNAP) 
	{
		bOnVertex1 = TRUE;
	} 
	else if (polyDist.ptLocation1.Distance2d(poly1.GetVertex(polyDist.nIndex1+1))<_DIST_SNAP) 
	{
		bOnVertex1 = TRUE;
		nIndex1++;
	}

	if (polyDist.ptLocation2.Distance2d(poly2.GetVertex(polyDist.nIndex2))<_DIST_SNAP) 
	{
		bOnVertex2 = TRUE;
	} 
	else if (polyDist.ptLocation2.Distance2d(poly2.GetVertex(polyDist.nIndex2+1))<_DIST_SNAP) 
	{
		bOnVertex2 = TRUE;
		nIndex2++;
	}

	int j = 0, i = 0;
	if (bOnVertex1)
	{
		for (j = nIndex1; j<nIndex1+num1; j++) 
		{
		   res.AppendNode(poly1.GetVertex(j), poly1.IsVisible(j));
		}
		res.AppendNode(poly1.GetVertex(nIndex1), FALSE);
	} 
	else
	{
		res.AppendNode(polyDist.ptLocation1, poly1.IsVisible(nIndex1));
		for (j = nIndex1+1; j <= nIndex1+num1; j++)
		{
			res.AppendNode(poly1.GetVertex(j), poly1.IsVisible(j));
		}
		res.AppendNode(polyDist.ptLocation1, FALSE);
	}

	if (bOnVertex2)
	{
	    for (i = nIndex2; i<nIndex2+num2; i++) 
		{
		   res.AppendNode(poly2.GetVertex(i), poly2.IsVisible(i));
		}
	    res.AppendNode(poly2.GetVertex(nIndex2), FALSE);
	}
	else 
	{
		res.AppendNode(polyDist.ptLocation2, poly2.IsVisible(nIndex2));
	    for (i = nIndex2+1; i <= nIndex2+num2; i++) 
		{
		   res.AppendNode(poly2.GetVertex(i), poly2.IsVisible(i));
		}
		res.AppendNode(polyDist.ptLocation2, FALSE);
	}

    return RTNORM;
} 

int XExport2::ConnectPolygon(const XPolygonEx &poly1, const XPolygonEx &poly2, XPolygonEx &res)
{
	ASSERT(poly1.Length()>1 && poly2.Length()>1);

	int nIndex1 = 0;
	int num1 = poly1.Length();
	int nIndex2 = 0; //poly2与pt最近的顶点
	double dMinDist = 0.0;
	int num2 = poly2.Length();
	for (int j = 0; j<num1; j++) 
	{
		XPoint pt = poly1[j];
		for (int i = 0; i<num2; i++) 
		{
			double dDist = pt.Distance(poly2[i]);
			if (i == 0 && j == 0) 
			{
				dMinDist = dDist;
			} 
			else if (dDist < dMinDist) 
			{
				dMinDist = dDist;
				nIndex2 = i;
				nIndex1 = j;
			}
		}
	}

	res.Reset();
	for (int j = nIndex1; j<nIndex1+num1; j++) 
	{
		res.AppendNode(poly1.GetVertex(j), poly1.IsVisible(j));
	}
	res.AppendNode(poly1.GetVertex(nIndex1), FALSE);

	for (int i = nIndex2; i<nIndex2+num2; i++) 
	{
		res.AppendNode(poly2.GetVertex(i), poly2.IsVisible(i));
	}
	res.AppendNode(poly2.GetVertex(nIndex2), FALSE);

	return RTNORM;
} 

void XExport2::_IntersectCurves(DList<XCurveSegment> &lstCurves, double dPrec)
{
	XCurveIntersection::minLen = dPrec;
	XCurveIntersection::GlobalCurveList.Reset();
	
	int len = lstCurves.Length();
	for (int i = 0; i<len; i++) 
	{
		XCurveSegment &e1 = *lstCurves[i];
		if (e1.GetLength()<max(_DIST_SNAP,dPrec))
		{
			continue;
		}
		XCurveIntersection::GlobalCurveList.Append(new XCurveIntersection(e1));
	}            
	
	len = XCurveIntersection::GlobalCurveList.Length();
	if (g_bEchoSearch)
	{
		XString sMsg(256);
		sMsg << _T("对") << len << _T("条线进行处理交线");
		acedSetStatusBarProgressMeter(sMsg, 0, len);
	}
	int nStep = len/100;
	if (nStep<1)
	{
		nStep = 1;
	}
	
	lstCurves.Reset();
	for (int i = 0; i<len; i++)
	{
		if (g_bEchoSearch && !(i%nStep)) 
		{
			acedSetStatusBarProgressMeterPos(i);
		}
		
		XCurveIntersection *curve = XCurveIntersection::GlobalCurveList[i];
		curve->DivideToSegments();
		XPoly2D poly;
		curve->segments.AsPoly2D(poly);
		for (int n = 0; n<poly.TotalSegments(); n++) 
		{
			XCurveSegment seg;
			poly.Nth(n, seg);
			if (seg.GetLength() > max(_DIST_SNAP,dPrec))
			{
				lstCurves.Append(new XCurveSegment(seg));
			}
		}
	}
	
	XCurveIntersection::GlobalCurveList.Reset();
	if (g_bEchoSearch) 
	{
		acedRestoreStatusBar();
	}
}

// poly的坐标为当前UCS下的坐标
// ss1--inside;  ss2--outside
// Status:  Only use in WCS
int XExport2::PolyClip(const DList<XCurveSegment> &ss, XPoly2D &poly, DList<XCurveSegment> &ss1, DList<XCurveSegment> &ss2)
{
	int len = ss.Length();
	for (int i = 0; i<len; i++) 
	{
		XCurveSegment seg = ss[i];
		seg.SetElevation(poly[0]->z); // Z坐标相等
		
		PointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
		IntersectWith(seg, poly, pts); // 先求出所有的交点,并排序
		int listLen = pts.Length();
		
		if (pts.curveType == CURVE_CIRCLE) 
		{
			if (listLen <= 2)  
			{ // circle, but not cut to arcs
				XPoint mpt = seg.GetCircle().GetCenterPt();
				if ((mpt&poly) == PR_INSIDE)
				{
					ss1.Append(new XCurveSegment(ss[i]));
				}
				else
				{
					ss2.Append(new XCurveSegment(ss[i]));
				}
				continue;
			}
			
			for (int i = 1; i<listLen; i++) 
			{
				XPoint pt2;
				if (i == listLen-1) pt2 = *pts[1];
				else pt2 = *pts[i+1];
				XArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]), ads_angle(pts.center, pt2));
				XPoint mpt;
				arcSeg.MidPoint(mpt);
				XCurveSegment *pCurve = new XCurveSegment;
				*pCurve = arcSeg;
				if ((mpt&poly) == PR_INSIDE) 
				{
					ss1.Append(pCurve);
				}
				else 
				{
					ss2.Append(pCurve);
				}
			}
		}
		else
		{
			for (int j = 0; j<listLen-1; j++)
			{    // arc and line
				XPoint &pt1 = *pts[j];
				XPoint &pt2 = *pts[j+1];
				if (pts.curveType == CURVE_LINE)
				{
					XLine lineSeg(pt1, pt2);
					XPoint mpt = lineSeg.MidPoint();
					XCurveSegment *pCurve = new XCurveSegment;
					*pCurve = lineSeg;
					if ((mpt & poly) == PR_INSIDE)
					{
						ss1.Append(pCurve);
					}
					else 
					{
						ss2.Append(pCurve);
					}
				}
				else 
				{
					XArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center,pt1),ads_angle(pts.center, pt2));
					XPoint mpt;
					arcSeg.MidPoint(mpt);
					XPoint cen = arcSeg.GetCenterPt();
					XCurveSegment *pCurve = new XCurveSegment;
					*pCurve = arcSeg;
					if ((mpt&poly) == PR_INSIDE) 
					{
						ss1.Append(pCurve);
					}
					else 
					{
						ss2.Append(pCurve);
					}
				}
			}
		}
	}
	
	return RTNORM;
}

// poly的坐标为当前UCS下的坐标
// ss1--inside;  ss2--outside;  ssOnEdge--On Edge
int XExport2::PolyClip(const DList<XCurveSegment> &ss, const XPoly2D &poly1, DList<XCurveSegment> &ss1, DList<XCurveSegment> &ss2, DList<XCurveSegment> &ssOnEdge)
{
	XPoly2D &poly = (XPoly2D &)poly1;
	ASSERT(!!poly);
	int len = ss.Length();
	for (int i = 0; i<len; i++) 
	{
		XCurveSegment seg = ss[i];
		seg.SetElevation(poly[0]->z); // Z坐标相等
		
		PointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
		IntersectWith(seg, poly, pts); // 先求出所有的交点,并排序
		int listLen = pts.Length();
		
		if (pts.curveType == CURVE_CIRCLE) 
		{
			if (listLen <= 2)  
			{ // circle, but not cut to arcs
				XPoint mpt = seg.GetCircle().GetCenterPt();
				if ((mpt&poly) == PR_INSIDE)
				{
					ss1.Append(new XCurveSegment(ss[i]));
				}
				else 
				{
					ss2.Append(new XCurveSegment(ss[i]));
				}
				continue;
			}
			
			for (int i = 1; i<listLen; i++) 
			{
				XPoint pt2;
				if (i == listLen-1)
				{
					pt2 = *pts[1];
				}
				else 
				{
					pt2 = *pts[i+1];
				}

				XArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]), ads_angle(pts.center, pt2));
				XPoint mpt;
				arcSeg.MidPoint(mpt);

				XCurveSegment *pCurve = new XCurveSegment;
				*pCurve = arcSeg;
				
				int nPrFlag = (mpt&poly);
				if (nPrFlag == PR_INSIDE) 
				{
					ss1.Append(pCurve);
				}
				else if (nPrFlag == PR_OUTSIDE)
				{
					ss2.Append(pCurve);
				}
				else
				{
					ssOnEdge.Append(pCurve);
				}
			}
		}
		else 
		{
			for (int j = 0; j<listLen-1; j++)
			{    // arc and line
				XPoint  &pt1 = *pts[j];
				XPoint  &pt2 = *pts[j+1];
				if (pts.curveType == CURVE_LINE) 
				{
					XLine lineSeg(pt1, pt2);
					XPoint mpt = lineSeg.MidPoint();
					XCurveSegment *pCurve = new XCurveSegment;
					*pCurve = lineSeg;

					int nPrFlag = (mpt&poly);
					if (nPrFlag == PR_INSIDE)
					{
						ss1.Append(pCurve);
					}
					else if (nPrFlag == PR_OUTSIDE) 
					{
						ss2.Append(pCurve);
					}
					else
					{
						ssOnEdge.Append(pCurve);
					}
				}
				else
				{
					XArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center,pt1), ads_angle(pts.center, pt2));
					XPoint mpt;
					arcSeg.MidPoint(mpt);
					XPoint cen = arcSeg.GetCenterPt();
					XCurveSegment *pCurve = new XCurveSegment;
					*pCurve = arcSeg;
					int nPrFlag = (mpt&poly);
					if (nPrFlag == PR_INSIDE)
					{
						ss1.Append(pCurve);
					}
					else if (nPrFlag == PR_OUTSIDE)
					{
						ss2.Append(pCurve);
					}
					else
					{
						ssOnEdge.Append(pCurve);
					}
				}
			}
		}
	}
	
	return RTNORM;
}

// poly的坐标为当前UCS下的坐标
// ss1--inside;  ss2--OnEdge and Outside
// Status:  Only use in WCS
int XExport2::PolyClip(PickSet &ss, XPoly2D &poly, PickSet &ss1, PickSet &ss2)
{
	RBList mask(RTDXF0,_T("ARC,LINE,CIRCLE"), NULL);
	ss.BaseFilter(mask);
	long len = ss.Length();
	for (long i = 0; i<len; i++) 
	{
		Entity ent = ss[i];
		XCurveSegment seg(ent);
		seg.SetElevation(poly[0]->z); // Z坐标相等
		
		PointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
		IntersectWith(seg, poly, pts); // 先求出所有的交点,并排序
		int listLen = pts.Length();
		
		Entity entRef = ent;
		if (pts.curveType == CURVE_CIRCLE) 
		{
			if (listLen <= 2)  
			{ // circle, but not cut to arcs
				XPoint mpt = seg.GetCircle().GetCenterPt();
				if ((mpt&poly) == PR_INSIDE)
				{
					ss1 += ent;
				}
				else 
				{
					ss2 += ent;
				}
				continue;
			}
			// 圆被裁为弧
			TCHAR lay[80] = _T("0");
			entRef.GetData(8, lay);
			for (int i = 1; i<listLen; i++) 
			{
				XPoint pt2;
				if (i == listLen-1) pt2 = *pts[1];
				else pt2 = *pts[i+1];
				XArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]),
					ads_angle(pts.center, pt2));
				XPoint mpt;
				arcSeg.MidPoint(mpt);
				if (arcSeg.Make(lay) == RTNORM) 
				{
					Entity eL;
					eL.GetLast();
					if ((mpt&poly) == PR_INSIDE)
					{
						ss1 += eL;
					}
					else
					{
						ss2 += eL;
					}
				}
			}
		}
		else  for (int j = 0; j < listLen-1; j++)
		{    // arc and line
			XPoint &pt1 = *pts[j];
			XPoint &pt2 = *pts[j+1];
			if (pts.curveType == CURVE_LINE)
			{
				XLine lineSeg(pt1, pt2);
				XPoint mpt = lineSeg.MidPoint();
				if (lineSeg.MakeEntity(&entRef) == RTNORM) 
				{
					Entity eL;
					eL.GetLast();
					if ((mpt&poly) == PR_INSIDE)
					{
						ss1 += eL;
					}
					else
					{
						ss2 += eL;
					}
				}
				
			}
			else 
			{
				XArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center,pt1),ads_angle(pts.center, pt2));
				XPoint mpt;
				arcSeg.MidPoint(mpt);
				XPoint cen = arcSeg.GetCenterPt();
				if (arcSeg.MakeEntity(&entRef) == RTNORM)
				{
					Entity eL;
					eL.GetLast();
					if ((mpt&poly) == PR_INSIDE) 
					{
						ss1 += eL;
					}
					else 
					{
						ss2 += eL;
					}
				}
			}
		}
		ent.Delete();
	}
	
	return RTNORM;
}

// poly的坐标为当前UCS下的坐标
// ss1--inside;  ss2--outSide, ss3--OnEdge
// Status:  Only use in WCS
int XExport2::PolyClip(PickSet &ss, XPoly2D &poly, PickSet &ss1, PickSet &ss2, PickSet &ss3)
{
	RBList mask(RTDXF0,_T("ARC,LINE,CIRCLE"), NULL);
	ss.BaseFilter(mask);
	long len = ss.Length();
	for (long i = 0; i<len; i++)
	{
		Entity ent = ss[i];
		XCurveSegment seg(ent);
		seg.SetElevation(poly[0]->z); // Z坐标相等
		
		PointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
		IntersectWith(seg, poly, pts); // 先求出所有的交点,并排序
		int listLen = pts.Length();
		
		Entity entRef = ent;
		if (pts.curveType == CURVE_CIRCLE) 
		{
			if (listLen <= 2) 
			{ // circle, but not cut to arcs
				XPoint mpt = seg.GetCircle().GetCenterPt();
				if ((mpt&poly) == PR_INSIDE)
				{
					ss1 += ent;
				}
				else
				{
					ss2 += ent;
				}
				continue;
			}
			// 圆被裁为弧
			TCHAR lay[80] = _T("0");
			entRef.GetData(8, lay);
			for (int i = 1; i<listLen; i++) 
			{
				XPoint pt2;
				if (i == listLen-1)
				{
					pt2 = *pts[1];
				}
				else 
				{
					pt2 = *pts[i+1];
				}

				XArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]), ads_angle(pts.center, pt2));
				XPoint mpt;
				arcSeg.MidPoint(mpt);
				if (arcSeg.Make(lay) == RTNORM) 
				{
					Entity eL;
					eL.GetLast();
					int nPrFlag = (mpt&poly);
					if (nPrFlag == PR_INSIDE) 
					{
						ss1 += eL;
					}
					else if (nPrFlag == PR_OUTSIDE)
					{
						ss2 += eL;
					}
					else 
					{
						ss3 += eL;
					}
				}
			}
		}
		else  for (int j = 0; j<listLen-1; j++) 
		{    // arc and line
			XPoint &pt1 = *pts[j];
			XPoint &pt2 = *pts[j+1];
			if (pts.curveType == CURVE_LINE) 
			{
				XLine lineSeg(pt1, pt2);
				XPoint mpt = lineSeg.MidPoint();

				if (lineSeg.MakeEntity(&entRef) == RTNORM)
				{
					Entity eL;
					eL.GetLast();
					int nPrFlag = (mpt&poly);
					if (nPrFlag == PR_INSIDE) 
					{
						ss1 += eL;
					}
					else if (nPrFlag == PR_OUTSIDE) 
					{
						ss2 += eL;
					}
					else 
					{
						ss3 += eL;
					}
				}
				
			}
			else
			{
				XArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center,pt1), ads_angle(pts.center, pt2));
				XPoint mpt;
				arcSeg.MidPoint(mpt);

				XPoint cen = arcSeg.GetCenterPt();
				if (arcSeg.MakeEntity(&entRef) == RTNORM) 
				{
					Entity eL;
					eL.GetLast();

					int nPrFlag = (mpt&poly);
					if (nPrFlag == PR_INSIDE)
					{
						ss1 += eL;
					}
					else if (nPrFlag == PR_OUTSIDE)
					{
						ss2 += eL;
					}
					else
					{
						ss3 += eL;
					}
				}
			}
		}
		ent.Delete();
	}
	
	return RTNORM;
}

// 把区域分解为逆时针排列的XPoly2D
void XExport2::Region2XPoly2D(const AcDbRegion *pClone, XPoly2D &poly2D)
{
	//  091119，临时将精确度改为g_globleSnap
	CTempTol globleTol(g_globleSnap);
	
	// 清空
	poly2D.Reset();
	
	// 将区域分解
	Acad::ErrorStatus es = Acad::eOk;
	AcDbVoidPtrArray arpCurve;
	if ((es = pClone->explode(arpCurve)) != Acad::eOk)
	{
		return;
	}
	
	int nLen = arpCurve.length();
	if (nLen < 1)
	{
		XExport::ReleaseEntSet(arpCurve);
		return;
	}
	
	// 求由一组曲线组成的边界，返回polyline线
	AcDbVoidPtrArray arpResult;
	AcDbCurve* pBound = ConvertCurves2Loops(arpCurve, arpResult);
	if (pBound == NULL)
	{
		XExport::ReleaseEntSet(arpCurve);
		return;
	}
	
	AcRxClass *pClass = pBound->isA();
	if (pClass = AcDbPolyline::desc())
	{
		// 将AcDbPolyline转化为XPoly2D
		XExport2::PolyConvert(*(AcDbPolyline *)pBound, poly2D);
	}
	
	XExport::ReleaseEntSet(arpCurve);
	if (pBound != NULL)
	{
		delete pBound;
	}
	
	// 设置闭合
	poly2D.SetFlag(1);
}

// 布尔运算，与PolyBoolOper函数接口不变，但使用AcDbRegion::booleanOper函数，内部计算时，将标高设置为0
void XExport2::RegionBoolOper(const XPoly2D &poly1, const XPoly2D &poly2, DList<XPoly2D> &lstResult, AcDb::BoolOperType operation)
{
	//  091119，临时将精确度改为g_globleSnap
	CTempTol globleTol(g_globleSnap);
	
	// 清空
	lstResult.Reset();
	
	XPoly2D pline1 = poly1,
		pline2 = poly2;
	
	// 强制设置PLine封闭
	pline1.SetFlag(1);
	pline2.SetFlag(1);
	
	// 强制将标高设置为0
	pline1.SetElevation(0.0);
	pline2.SetElevation(0.0);
	
	// 将PLine转化为Region
	AcDbRegion *pRegion1 = pline1.AsRegion(), 
			   *pRegion2 = pline2.AsRegion();

	if (pRegion1 != NULL && pRegion2 != NULL)
	{
		// 对两区域进行布尔运算
		if (pRegion1->booleanOper(operation, pRegion2) == Acad::eOk)
		{
			// 把区域分解为逆时针排列的XPoly2D
			XPoly2D *pNewPoly = new XPoly2D(1);
			XExport2::Region2XPoly2D(pRegion1, *pNewPoly);
			
			if (pNewPoly->Length() > 0)
			{
				lstResult.Append(pNewPoly);
			}
			else
			{
				delete pNewPoly;
			}
		}
	}
	
	if (pRegion1 != NULL)
	{
		delete pRegion1;
	}
	
	if (pRegion2 != NULL)
	{
		delete pRegion2;
	}
}


// 8.0先解决角度不大于MIN_PL_ANGEL的情况
// 自动处理封闭的XPoly2D，只处理外轮廓线
// 若某段长度不大于MIN_PL_DISTANCE，或者相临两段夹角不大于MIN_PL_ANGEL度，则自动减点
 void XExport2::AutoDelExPoly2DPt(XPoly2D &poly)
{
	int nLen = poly.Length(); // 总点数
	if (nLen < 3)
	{
		return;
	}
	
	XPoly2D dest(1);		// 设置闭合
	double dAngle = 0.0,	// 以当前点为顶点，前后点连线为边的夹角
		dBulge = 0.0;		// 当前点应该有的Bulge值

	BOOL bAdd2Dest = TRUE;	// 标记是否将当前点添加到dest中
	int nPrev(0), nNext(0); // 前、后点标号
	XPoint ptCur, ptPrev, ptNext;
	
	for (int i = 0; i < nLen; i++)
	{
		bAdd2Dest = TRUE;	// 标记是否将当前点添加到dest中
		
		// 封闭路径，周期查找
		nPrev = XExport::DePeriod(nLen, i - 1);
		nNext = XExport::DePeriod(nLen, i + 1);
		
		ptCur	= *poly[i];		// 当前点
		ptPrev  = *poly[nPrev];	// 前一点
		ptNext	= *poly[nNext];	// 后一点
		
		dBulge = poly.GetBulge(i); // 默认取当前点的Bulge值

		AcGeVector3d vec1 = ptPrev.AsAcGePoint3d() - ptCur.AsAcGePoint3d(),
					 vec2 = ptNext.AsAcGePoint3d() - ptCur.AsAcGePoint3d();

		dAngle = vec1.angleTo(vec2); // 角度在[0，PI]范围内
		if (dAngle < MIN_PL_ANGEL + _angSnap) // 角度不大于1
		{
			double dPrevBulge = poly.GetBulge(nPrev);
			if (fabs(dBulge)<_angSnap && fabs(dPrevBulge)<_angSnap)
			{
				bAdd2Dest = FALSE;
				continue;
			}
		}

		// 将当前点添加到dest中
		if (bAdd2Dest)
		{
			dest.AppendNode(ptCur, dBulge);
		}
	}

	poly.Reset();
	poly = dest;
}

void XExport2::GetGripPoints(const XPoly2D &poly, AcGePoint3dArray &gripPoints)
{
	int nVertexCount = poly.Length();
	for (int i = 0; i<nVertexCount; i++)
	{
		const XPoint &pt = poly[i];
		gripPoints.append(pt);
	}
	//边上的夹点
	int nEdgeNum = poly.TotalSegments();
	for (int i = 0; i<nEdgeNum; i++) 
	{
		XCurveSegment seg;
		poly.Nth(i, seg);
		XPoint ptMid = seg.MidPoint();
		gripPoints.append(ptMid);
	}
}

Acad::ErrorStatus XExport2::MoveGripPointsAt(XPoly2D &poly, const AcDbIntArray& indices, const AcGeVector3d& offset)
{
	int nVertexCount = poly.Length();
	
	XPoint vtOffset = *(XPoint *)&offset;
	vtOffset.z = 0;
	
	for (int i = 0; i < indices.length(); i++) 
	{
		int idx = indices[i];
		if (idx < nVertexCount) 
		{ // Move vertex
			*poly[idx] += vtOffset;
			continue;
		} 
		// Move Edge or Shape
		int nEdgeIndex = idx-nVertexCount;
		int nTotalEdge = poly.TotalSegments();
		if (nEdgeIndex >= nTotalEdge) 
		{
			return Acad::eInvalidInput;
		}
		
		//移动边
		XDirectionCurve cv;
		poly.Nth(nEdgeIndex, cv);
		ASSERT(!!cv);
		if (cv.Is(CURVE_LINE)) 
		{ // Move
			XLine ln = cv.GetLine();
			ln.SetStartPoint(ln.GetStartPoint() + vtOffset);
			ln.SetEndPoint(ln.GetEndPoint() + vtOffset);
			ln.SetLineFlag(LS_INFINITE);
			XDirectionCurve prevSeg, nextSeg;
			int nPrev = nEdgeIndex-1, nNext = nEdgeIndex+1;
			if (poly.IsClosed()) 
			{
				nPrev = XExport::DePeriod(nTotalEdge, nPrev);
				nNext = XExport::DePeriod(nTotalEdge, nNext);
			}
			
			XPoint ptStart, ptEnd;
			BOOL bUpdateIt = TRUE;
			//更新起点
			if (nPrev >= 0 && nPrev<nTotalEdge) 
			{ 
				poly.Nth(nPrev, prevSeg);
				prevSeg.SetLineFlag(LS_INFINITE);
				XPoint ptInt[2];
				int nIntNum = prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
				if (nIntNum == 1)
				{
					ptStart = ptInt[0];
				}
				else if (nIntNum == 2) 
				{
					ptStart = XLine(ptInt[0], ptInt[1]).NearPoint(ln.GetStartPoint());
				}
				else
				{
					bUpdateIt = FALSE;
				}
			} 
			else
			{
				ptStart = *poly[nEdgeIndex] + vtOffset;
			}
			
			// 更新下一点
			if (nNext >= 0 && nNext<nTotalEdge) 
			{ 
				poly.Nth(nNext, nextSeg);
				nextSeg.SetLineFlag(LS_INFINITE);
				XPoint ptInt[2];
				int nIntNum = nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
				if (nIntNum == 1) 
				{
					ptEnd = ptInt[0];
				}
				else if (nIntNum == 2) 
				{
					ptEnd = XLine(ptInt[0], ptInt[1]).NearPoint(ln.GetEndPoint());
				} 
				else
				{
					bUpdateIt = FALSE;
				}
			} 
			else 
			{
				ptEnd = *poly[nEdgeIndex+1] + vtOffset;
			}
			
			if (bUpdateIt) 
			{
				double nPrevBulge = 0.0, nNextBulge = 0.0;
				if (fabs(prevSeg.GetBulge()) > 1.0E-5) 
				{
					XArc prevArc = prevSeg.GetArc();
					double nAngBeg = ads_angle(prevArc.GetCenterPt(), prevSeg.GetStartPoint());
					double nAngEnd = ads_angle(prevArc.GetCenterPt(), ptStart);
					if (prevSeg.IsMinusArc()) 
					{
						nPrevBulge = -XExport::CT_std_angle(nAngBeg-nAngEnd);
					}
					else
					{
						nPrevBulge = XExport::CT_std_angle(nAngEnd-nAngBeg);
					}
				}
				if (fabs(nextSeg.GetBulge()) > 1.0E-5)
				{
					XArc nextArc = nextSeg.GetArc();
					double nAngBeg = ads_angle(nextArc.GetCenterPt(), ptEnd);
					double nAngEnd = ads_angle(nextArc.GetCenterPt(), nextSeg.GetEndPoint());
					if (nextSeg.IsMinusArc()) 
					{
						nNextBulge = -XExport::CT_std_angle(nAngBeg-nAngEnd);
					}
					else
					{
						nNextBulge = XExport::CT_std_angle(nAngEnd-nAngBeg);
					}
				}
				
				*poly[nEdgeIndex] = ptStart;
				if (nNext >= 0 && nNext < poly.Length())
				{
					*poly[nNext] = ptEnd;
					poly.SetBulge(nNext, nNextBulge);
				}
				if (nPrev >= 0 && nPrev < poly.Length())
				{
					poly.SetBulge(nPrev, nPrevBulge);
				}
			}
		}
		else 
		{ // Change Arc Segment--bulge
			XPoint ptMid = cv.MidPoint();
			XPoint ptMidNew =  ptMid + vtOffset;
			XArc arNew(cv.GetStartPoint(), ptMidNew, cv.GetEndPoint());
			if (!!arNew) 
			{ //新的弧有效
				XCurveSegment cvLine(cv.GetStartPoint(), cv.GetEndPoint(), 0.0);
				int nSideOld = cvLine.OnWhichSide(ptMid);
				int nSideNew = cvLine.OnWhichSide(ptMidNew);
				double dSignal = cv.GetBulge() / fabs(cv.GetBulge());
				if (nSideOld == nSideNew)
				{
					poly.SetBulge(nEdgeIndex, dSignal * arNew.Bulge());
				} 
				else 
				{
					poly.SetBulge(nEdgeIndex, -dSignal * arNew.Bulge());
				}
			}
		} 
	}
	poly.Compress(false);
	return Acad::eOk;
}

void XExport2::GetGripPoints(const XPoly2D &poly,AcGeVector3d &normal,AcGePoint3dArray &gripPoints)
{
	int nVertexCount = poly.Length();
	for (int i = 0; i < nVertexCount; i++)
	{
		const XPoint &pt = poly[i];
		gripPoints.append(Ecs2Wcs(pt,normal).AsAcGePoint3d());
	}
	//边上的夹点
	int nEdgeNum = poly.TotalSegments();
	for (int i = 0; i < nEdgeNum; i++) 
	{
		XCurveSegment seg;
		poly.Nth(i, seg);
		XPoint ptMid = seg.MidPoint();
		gripPoints.append(Ecs2Wcs(ptMid,normal).AsAcGePoint3d());
	}
}

Acad::ErrorStatus XExport2::MoveGripPointsAt(XPoly2D &polyPath,
								   AcGeVector3d &vtNormal,
								   const AcDbIntArray& indices,
								   const AcGeVector3d& offset)
{
	int nVertexCount = polyPath.Length();
	
	XPoint vtOffset = Wcs2Ecs(*(XPoint *)&offset, vtNormal);
	for (int i = 0; i < indices.length(); i++) 
	{
		int idx = indices[i];
		if (idx<nVertexCount) 
		{ // Move vertex
			*polyPath[idx] += vtOffset;
		}
		else
		{ // Move Edge or Shape
			XPoly2D poly2d(polyPath);
			poly2d.SetElevation(0.0);
			
			int nEdgeIndex = idx-nVertexCount;
			int nTotalEdge = poly2d.TotalSegments();
			if (nEdgeIndex<nTotalEdge)
			{ //移动边
				XDirectionCurve cv;
				poly2d.Nth(nEdgeIndex, cv);
				ASSERT(!!cv);
				if (cv.Is(CURVE_LINE))
				{ // Move
					XLine ln = cv.GetLine();
					ln.SetStartPoint(ln.GetStartPoint()+ vtOffset);
					ln.SetEndPoint(ln.GetEndPoint() + vtOffset);
					ln.SetLineFlag(LS_INFINITE);
					XDirectionCurve prevSeg, nextSeg;
					int nPrev = nEdgeIndex-1, nNext = nEdgeIndex+1;
					if (poly2d.IsClosed()) 
					{
						nPrev = XExport::DePeriod(nTotalEdge, nPrev);
						nNext = XExport::DePeriod(nTotalEdge, nNext);
					}
					
					XPoint ptStart, ptEnd;
					BOOL bUpdateIt = TRUE;
					//更新起点
					if (nPrev >= 0 && nPrev < nTotalEdge)
					{ 
						poly2d.Nth(nPrev, prevSeg);
						prevSeg.SetLineFlag(LS_INFINITE);
						XPoint ptInt[2];
						int nIntNum = prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
						if (nIntNum == 1) 
						{
							ptStart = ptInt[0];
						}
						else if (nIntNum == 2) 
						{
							ptStart = XLine(ptInt[0], ptInt[1]).NearPoint(ln.GetStartPoint());
						}
						else
						{
							bUpdateIt = FALSE;
						}
					} 
					else
					{
						ptStart = *poly2d[nEdgeIndex] + vtOffset;
					}
					
					// 更新下一点
					if (nNext >= 0 && nNext < nTotalEdge)
					{ 
						poly2d.Nth(nNext, nextSeg);
						nextSeg.SetLineFlag(LS_INFINITE);
						XPoint ptInt[2];
						int nIntNum = nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
						if (nIntNum == 1)
						{
							ptEnd = ptInt[0];
						}
						else if (nIntNum == 2) 
						{
							ptEnd = XLine(ptInt[0], ptInt[1]).NearPoint(ln.GetEndPoint());
						} 
						else 
						{
							bUpdateIt = FALSE;
						}
					}
					else
					{
						ptEnd = *poly2d[nEdgeIndex+1] + vtOffset;
					}
					
					if (bUpdateIt) 
					{
						double nPrevBulge = 0.0, nNextBulge = 0.0;
						if (fabs(prevSeg.GetBulge())>1.0E-5) 
						{
							XArc prevArc = prevSeg.GetArc();
							double nAngBeg = ads_angle(prevArc.GetCenterPt(), prevSeg.GetStartPoint());
							double nAngEnd = ads_angle(prevArc.GetCenterPt(), ptStart);
							if (prevSeg.IsMinusArc()) 
							{
								nPrevBulge = -XExport::CT_std_angle(nAngBeg-nAngEnd);
							} 
							else
							{
								nPrevBulge = XExport::CT_std_angle(nAngEnd-nAngBeg);
							}
						}
						if (fabs(nextSeg.GetBulge()) > 1.0E-5) 
						{
							XArc nextArc = nextSeg.GetArc();
							double nAngBeg = ads_angle(nextArc.GetCenterPt(), ptEnd);
							double nAngEnd = ads_angle(nextArc.GetCenterPt(), nextSeg.GetEndPoint());
							if (nextSeg.IsMinusArc()) 
							{
								nNextBulge = -XExport::CT_std_angle(nAngBeg-nAngEnd);
							} 
							else 
							{
								nNextBulge = XExport::CT_std_angle(nAngEnd-nAngBeg);
							}
						}
						
						*poly2d[nEdgeIndex] = ptStart;
						if (nNext >= 0 && nNext < poly2d.Length())
						{
							*poly2d[nNext] = ptEnd;
							poly2d.SetBulge(nNext, nNextBulge);
						}
						if (nPrev >= 0 && nPrev < poly2d.Length())
						{
							poly2d.SetBulge(nPrev, nPrevBulge);
						}
						
					}
					
				} 
				else 
				{ // Change Arc Segment--bulge
					XPoint ptMid = cv.MidPoint();
					XPoint ptMidNew =  ptMid + vtOffset;
					XArc arNew(cv.GetStartPoint(), ptMidNew, cv.GetEndPoint());
					if (!!arNew) 
					{ //新的弧有效
						XCurveSegment cvLine(cv.GetStartPoint(), cv.GetEndPoint(), 0.0);
						int nSideOld = cvLine.OnWhichSide(ptMid);
						int nSideNew = cvLine.OnWhichSide(ptMidNew);
						double dSignal = cv.GetBulge()/fabs(cv.GetBulge());
						if (nSideOld == nSideNew) 
						{
							poly2d.SetBulge(nEdgeIndex, dSignal * arNew.Bulge());
						}
						else 
						{
							poly2d.SetBulge(nEdgeIndex, -dSignal * arNew.Bulge());
						}
					}
				}
				
				for (int n = 0; n<poly2d.Length(); n++) 
				{
					poly2d[n]->z = polyPath[n]->z;
				}
				polyPath = poly2d;
			} 
		}
	}
	polyPath.Compress(false);
	return Acad::eOk;
}

 Acad::ErrorStatus XExport2::GetGripText(const XPoly2D&poly,int idx,CString &cs)
{
	Acad::ErrorStatus es = Acad::eNotApplicable;
	
	int nVertexCount = poly.Length();
	if (idx<nVertexCount)
	{ // Move vertex
		cs.Format(_T("移动第%d个顶点"), idx+1);
		es = Acad::eOk;
	}
	else 
	{ // Move Edge or Shape
		int nEdgeIndex = idx-nVertexCount;
		int nTotalEdge = poly.TotalSegments();
		if (nEdgeIndex<nTotalEdge) 
		{ //移动边
			cs.Format(_T("移动第%d条边"), nEdgeIndex+1);
			es = Acad::eOk;
		}
	}
	return es;
}

#if ARX > 17
void XExport2::CreateGrip(AEntityBase* pThis,XPoly2D& poly,int iFirst)
{
	XPoly2D&m_polyBase = poly;
	//节点
	for (long i = 0;i < m_polyBase.Length();i++)
	{
		if (m_polyBase.IsClosed() || i > 0)//有前段
		{
			bool bPreArc = fabs(m_polyBase.GetBulge((i - 1 + m_polyBase.Length()) % m_polyBase.Length())) > 1E-5;//前段是否为弧段
			if (!bPreArc)//直段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripDistDim(AcDbDimData::kDimResultantLength));//长度
			}
			else//弧段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//包络角度[0,360)
			}
		}
		
		if (m_polyBase.IsClosed() || i < m_polyBase.Length() - 1)//有后段
		{
			bool bNextArc = fabs(m_polyBase.GetBulge(i % m_polyBase.Length())) > 1E-5;//后段的是否为弧段
			if (!bNextArc)//直段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripDistDim(AcDbDimData::kDimResultantLength));//长度
			}
			else//弧段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//包络角度[0,360)
			}
		}
		
		if (m_polyBase.IsClosed()||i>0)//有前段
		{
			bool bPreArc = fabs(m_polyBase.GetBulge((i - 1 + m_polyBase.Length()) % m_polyBase.Length())) > 1E-5;//前段是否为弧段
			if (!bPreArc)//直段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//角度[0,180]
			}
			else//弧段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//前弧终止角度[0,180]
			}
		}
		
		if (m_polyBase.IsClosed() || i < m_polyBase.Length() - 1)//有后段
		{
			bool bNextArc = fabs(m_polyBase.GetBulge(i % m_polyBase.Length())) > 1E-5;//后段的是否为弧段
			if (!bNextArc)//直段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//角度[0,180]
			}
			else//弧段
			{
				pThis->GetGrip(i + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//后弧起始角度[0,180]
			}
		}
	}
	
	//边中点
	for (int i = 0;i<m_polyBase.TotalSegments();i++)
	{
		bool bArc = fabs(m_polyBase.GetBulge(i)) > 1E-5;//是否弧边
		long iSeg = i+m_polyBase.Length();
		if (bArc)
		{
			pThis->GetGrip(iSeg + iFirst)->AppendDim(new AecDbGripRadiusDim(AcDbDimData::kDimRadius));//半径
			pThis->GetGrip(iSeg + iFirst)->AppendDim(new AecDbGripAngleDim(AcDbDimData::kDimResultantAngle));//包络角度[0,360)
		}
		else
		{
			pThis->GetGrip(iSeg + iFirst)->AppendDim(new AecDbGripDistDim(AcDbDimData::kDimDeltaLength,false));//偏移
		}
	}
}

Acad::ErrorStatus XExport2::EntityToDim(AEntityBase* pThis,XPoly2D polyPath,long iGrip,long iDim,int iFirst)
{
	AecDbGripDim *pDim = pThis->GetGripDim(iGrip,iDim);
	if (pDim == NULL)
	{
		return Acad::eInvalidInput;
	}
	
	iGrip -= iFirst;
	XPoly2D m_polyBase;
	AcGeVector3d normal;
	pThis->GetPathPoly(m_polyBase,normal);
	XPoint ptLow,ptUp;
	polyPath.GetExtend(ptLow,ptUp);
	//中点
	if (iGrip  >=  polyPath.Length())
	{
		int nPos = iGrip - polyPath.Length();
		XDirectionCurve seg;
		polyPath.Nth(nPos, seg);
		bool bArc = fabs(polyPath.GetBulge(nPos)) > 1E-5;//是否为弧段
		if (!bArc)//直段
		{
			switch(iDim)
			{
			case 0:
				{
					AecDbGripDistDim* pDistDim = (AecDbGripDistDim*)pDim;
					XDirectionCurve seg1;
					m_polyBase.Nth(nPos, seg1);

					XPoint pt;
					seg1.ProjectToMe(seg.MidPoint().AsAcGePoint3d(),pt);
					pDistDim->SetData(pt.AsAcGePoint3d(),seg.MidPoint().AsAcGePoint3d(),0);
				}
				break;
			default:
				return Acad::eNotImplementedYet;
			}
		}
		else//弧段
		{
			switch(iDim)
			{
			case 0:
				{
					AecDbGripRadiusDim* pRadiusDim = (AecDbGripRadiusDim* )pDim;
					pRadiusDim->SetData(seg.GetArc().GetCenterPt().AsAcGePoint3d(),seg.MidPoint().AsAcGePoint3d());
				}
				break;
			case 1:
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					if ( seg.GetBulge() < 0)
					{
						seg.Reverse();
					}
					pAngleDim->SetData(seg);
				}
				break;
			default:
				return Acad::eNotImplementedYet;
			}
		}
		return Acad::eOk;
	}
	
	// 端点
	bool bPre = polyPath.IsClosed() || iGrip > 0;
	int nPre = (iGrip - 1 + polyPath.Length()) % polyPath.Length();
	
	XDirectionCurve segPre;
	polyPath.Nth(nPre, segPre);

	AcGeVector2d vtPre = segPre.Direction3d().AsAcGeVector2d();
	bool bPreArc = fabs(polyPath.GetBulge(nPre)) > 1E-5;//前段是否为弧段
	
	bool bNext = polyPath.IsClosed() || iGrip < polyPath.Length() - 1;
	int nNext = iGrip % polyPath.Length();

	XDirectionCurve segNext;
	polyPath.Nth(nNext, segNext);
	
	AcGeVector2d vtNext = segNext.Direction3d().AsAcGeVector2d();
	bool bNextArc = fabs(polyPath.GetBulge(nNext)) > 1E-5;//后段的是否为弧段
	
	if (bPre && bNext)
	{// 有前段有后段
		switch(iDim)
		{
		case 0:
			{
				if (!bPreArc)//长度
				{
					AecDbGripDistDim* pDistDim = (AecDbGripDistDim* )pDim;
					double dGrip = vtPre.angle() - vtNext.angle();
					if ( dGrip < -1E-6 )
					{
						dGrip += 2 * PI;
					}

					if ( dGrip > 0 && dGrip < PI )
					{
						segPre.Reverse();
					}
					pDistDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d());
				}
				else//包络角度
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					if ( segPre.GetBulge() < 0)
					{
						segPre.Reverse();
					}
					pAngleDim->SetData(segPre);
				}
			}
			break;
		case 1:
			{
				if (!bNextArc)//长度
				{
					AecDbGripDistDim* pDistDim = (AecDbGripDistDim* )pDim;
					double dGrip = vtPre.angle() - vtNext.angle();
					if ( dGrip < -1E-6 )
					{
						dGrip += 2 * PI;
					}

					if ( dGrip > 0 && dGrip < PI )
					{
						segNext.Reverse();
					}
					pDistDim->SetData(segNext.GetStartPoint().AsAcGePoint3d(), segNext.GetEndPoint().AsAcGePoint3d());
				}
				else//包络角度
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					if ( segNext.GetBulge() < 0)
					{
						segNext.Reverse();
					}
					pAngleDim->SetData(segNext);
				}
			}
			break;
		case 2:
			{
				if (!bPreArc)//角度
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XPoint ptEnd = segPre.GetStartPoint() + XPoint(1000,0,0);
					pAngleDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(),segPre.GetEndPoint().AsAcGePoint3d(),ptEnd.AsAcGePoint3d());
				}
				else//前弧终止角度
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XArc arc = segPre.GetArc();
					XPoint ptHorz = arc.GetCenterPt() + XPoint(arc.GetRadius(),0,0);
					pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(),segPre.GetEndPoint().AsAcGePoint3d(),ptHorz.AsAcGePoint3d());
				}
			}
			break;
		case 3:
			{
				if (!bNextArc)//角度
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XPoint ptEnd = segNext.GetEndPoint() + XPoint(1000,0,0);
					pAngleDim->SetData(segNext.GetEndPoint().AsAcGePoint3d(),segNext.GetStartPoint().AsAcGePoint3d(),ptEnd.AsAcGePoint3d());
				}
				else//前弧终止角度
				{
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XArc arc = segNext.GetArc();
					XPoint ptHorz = arc.GetCenterPt() + XPoint(arc.GetRadius(),0,0);
					pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(),segNext.GetStartPoint().AsAcGePoint3d(),ptHorz.AsAcGePoint3d());
				}
			}
			break;
		default:
			return Acad::eNotImplementedYet;
		}
	}
	else if (bPre && !bNext)
	{// 有前段无后段
		switch(iDim)
		{
		case 0:
			{
				if (!bPreArc)
				{//长度
					AecDbGripDistDim* pDistDim = (AecDbGripDistDim* )pDim;
					if ( segPre.Direction3d().y  >=  0 )
					{
						pDistDim->SetData(segPre.GetEndPoint().AsAcGePoint3d(), segPre.GetStartPoint().AsAcGePoint3d());
					}
					else
					{
						pDistDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d());
					}
				}
				else
				{//包络角度
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					if ( segPre.GetBulge() < 0)
					{
						segPre.Reverse();
					}
					pAngleDim->SetData(segPre);
				}
			}
			break;
		case 1:
			{
				if (!bPreArc)
				{//角度
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XPoint ptEnd = segPre.GetStartPoint() + XPoint(1000,0,0);
					pAngleDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(),segPre.GetEndPoint().AsAcGePoint3d(),ptEnd.AsAcGePoint3d());
				}
				else
				{//后弧起始角度
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XArc arc = segPre.GetArc();
					XPoint ptHorz = arc.GetCenterPt() + XPoint(arc.GetRadius(),0,0);
					pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(),segPre.GetEndPoint().AsAcGePoint3d(),ptHorz.AsAcGePoint3d());
				}
			}
			break;
		default:
			return Acad::eNotImplementedYet;
		}
	}
	else if (!bPre && bNext)
	{// 无前段有后段
		switch(iDim)
		{
		case 0:
			{
				if (!bNextArc)
				{//长度
					AecDbGripDistDim* pDistDim = (AecDbGripDistDim* )pDim;
					if ( segNext.Direction3d().y  >=  0 )
					{
						pDistDim->SetData(segNext.GetEndPoint().AsAcGePoint3d(), segNext.GetStartPoint().AsAcGePoint3d());
					}
					else
					{
						pDistDim->SetData(segNext.GetStartPoint().AsAcGePoint3d(), segNext.GetEndPoint().AsAcGePoint3d());
					}
				}
				else
				{//包络角度
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					if ( segNext.GetBulge() < 0)
					{
						segNext.Reverse();
					}
					pAngleDim->SetData(segNext);
				}
			}
			break;
		case 1:
			{
				if (!bNextArc)
				{//角度
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XPoint ptEnd = segNext.GetEndPoint() + XPoint(1000,0,0);
					pAngleDim->SetData(segNext.GetEndPoint().AsAcGePoint3d(),segNext.GetStartPoint().AsAcGePoint3d(),ptEnd.AsAcGePoint3d());
				}
				else
				{//后弧起始角度
					AecDbGripAngleDim* pAngleDim = (AecDbGripAngleDim* )pDim;
					XArc arc = segNext.GetArc();
					XPoint ptHorz = arc.GetCenterPt() + XPoint(arc.GetRadius(),0,0);
					pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(),segNext.GetStartPoint().AsAcGePoint3d(),ptHorz.AsAcGePoint3d());
				}
			}
			break;
		default:
			return Acad::eNotImplementedYet;
		}
	}
	else
	{
		return Acad::eNotImplementedYet;
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus XExport2::DimToEntity(AEntityBase* pThis,XPoly2D &m_polyBase,long iGrip,long iDim,double newValue,const AcGeVector3d& offset,int iFirst)
{
	AcGePoint3d ptNew = pThis->GetGripPoint(iGrip) + offset;
	
	iGrip -= iFirst;
	//中点
	if (iGrip >= m_polyBase.Length())
	{
		int nPos = iGrip - m_polyBase.Length();
		bool bArc = fabs(m_polyBase.GetBulge(nPos)) > 1E-5;//是否为弧段
		if (!bArc)//直段
		{
			switch(iDim)
			{
			case 0://偏移
				{
					XPoly2D poly2d(m_polyBase);
					poly2d.SetElevation(0.0);

					int nTotalEdge = poly2d.TotalSegments();
					XDirectionCurve seg;
					poly2d.Nth(nPos, seg);
					
					AcGeVector3d vtOffset = offset;
					vtOffset.normalize();
					
					double dAngle = vtOffset.angleTo(seg.Direction3d().AsAcGeVector3d());
					vtOffset *= newValue / sin(dAngle);
					
					if (seg.OnWhichSide(ptNew) == 0)
					{//左边
						newValue *= -1;
					}
					
					XLine ln = seg.GetLine();
					ln = ln.Offset(newValue);
					ln.SetLineFlag( LS_INFINITE);

					XDirectionCurve prevSeg, nextSeg;
					int nPrev = nPos - 1;
					int nNext = nPos + 1;

					if (poly2d.IsClosed()) 
					{
						nPrev = XExport::DePeriod(nTotalEdge, nPrev);
						nNext = XExport::DePeriod(nTotalEdge, nNext);
					}
					
					XPoint ptStart, ptEnd;
					BOOL bUpdateIt = TRUE;
					//更新起点
					if (nPrev >= 0 && nPrev < nTotalEdge) 
					{ 
						poly2d.Nth(nPrev, prevSeg);
						prevSeg.SetLineFlag( LS_INFINITE);

						XPoint ptInt[2];
						int nIntNum = prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
						if (nIntNum == 1) 
						{
							ptStart = ptInt[0];
						}
						else if (nIntNum == 2)
						{
							ptStart = XLine(ptInt[0], ptInt[1]).NearPoint(ln.GetStartPoint());
						}
						else 
						{
							bUpdateIt = FALSE;
						}
					} 
					else 
					{
						ptStart = *poly2d[nPos] + vtOffset;
					}
					
					// 更新下一点
					if (nNext >= 0 && nNext < nTotalEdge) 
					{ 
						poly2d.Nth(nNext, nextSeg);
						nextSeg.SetLineFlag(LS_INFINITE);

						XPoint ptInt[2];
						int nIntNum = nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
						if (nIntNum == 1) 
						{
							ptEnd = ptInt[0];
						}
						else if (nIntNum == 2) 
						{
							ptEnd = XLine(ptInt[0], ptInt[1]).NearPoint(ln.GetEndPoint());
						}
						else 
						{
							bUpdateIt = FALSE;
						}
					} 
					else
					{
						ptEnd = *poly2d[nPos + 1] + vtOffset;
					}
					
					if (bUpdateIt) 
					{
						double nPrevBulge = 0.0, nNextBulge = 0.0;
						if (fabs(prevSeg.GetBulge()) > 1.0E-5)
						{
							XArc prevArc = prevSeg.GetArc();
							double nAngBeg = ads_angle(prevArc.GetCenterPt(), prevSeg.GetStartPoint());
							double nAngEnd = ads_angle(prevArc.GetCenterPt(), ptStart);
							if (prevSeg.IsMinusArc())
							{
								nPrevBulge = -XExport::CT_std_angle(nAngBeg - nAngEnd);
							}
							else
							{
								nPrevBulge = XExport::CT_std_angle(nAngEnd - nAngBeg);
							}
						}
						if (fabs(nextSeg.GetBulge()) > 1.0E-5) 
						{
							XArc nextArc = nextSeg.GetArc();
							double nAngBeg = ads_angle(nextArc.GetCenterPt(), ptEnd);
							double nAngEnd = ads_angle(nextArc.GetCenterPt(), nextSeg.GetEndPoint());
							if (nextSeg.IsMinusArc())
							{
								nNextBulge = -XExport::CT_std_angle(nAngBeg - nAngEnd);
							} 
							else
							{
								nNextBulge = XExport::CT_std_angle(nAngEnd - nAngBeg);
							}
						}
						
						*poly2d[nPos] = ptStart;
						if (nNext >= 0 && nNext < poly2d.Length()) 
						{
							*poly2d[nNext] = ptEnd;
							poly2d.SetBulge(nNext, nNextBulge);
						}
						if (nPrev >= 0 && nPrev < poly2d.Length())
						{
							poly2d.SetBulge(nPrev, nPrevBulge);
						}
						
						for (int n = 0; n < poly2d.Length(); n++)
						{
							poly2d[n]->z = m_polyBase[n]->z;
						}
						
						m_polyBase = poly2d;
					}
				}
			break;
			}
		}
		else
		{
			XDirectionCurve seg;
			m_polyBase.Nth(nPos, seg);
			switch(iDim)
			{
			case 0://半径
				{
					XCurveSegment line(seg.GetStartPoint(),seg.GetEndPoint(),0);
					double len = line.GetLength();
					if (newValue < 0.5 * len)
					{
						return Acad::eInvalidInput;
					}

					newValue = 2.0 * asin(len*  0.5 / newValue);
					XPoint ptMid = seg.MidPoint();
					if (ptMid.Distance2d(ptNew) > len / 2)
					{
						newValue = 2.0 * PI - newValue;
					}
				}
			case 1://包络角
				{
					seg.SetBulge(0);
					if (seg.OnWhichSide(ptNew) == 0)
					{//左边
						newValue *= -1;
					}
					
					m_polyBase.SetBulge(nPos, newValue);
				}
				break;
			}
		}
		return Acad::eOk;
	}

	// 端点
	bool bPre = m_polyBase.IsClosed() || iGrip > 0;
	int nPre = (iGrip - 1 + m_polyBase.Length()) % m_polyBase.Length();
	XDirectionCurve segPre;
	m_polyBase.Nth(nPre, segPre);

	bool bPreArc = fabs(m_polyBase.GetBulge(nPre)) > 1E-5;//前段是否为弧段

	bool bNext = m_polyBase.IsClosed() || iGrip < m_polyBase.Length() - 1;
	int nNext = iGrip % m_polyBase.Length();
	XDirectionCurve segNext;
	m_polyBase.Nth(nNext, segNext);

	bool bNextArc = fabs(m_polyBase.GetBulge(nNext)) > 1E-5;//后段的是否为弧段

	if (bPre && bNext)
	{// 有前段有后段
		switch(iDim)
		{
		case 0:
			{
				if (!bPreArc)//长度
				{
					if (newValue>1E-6)
					{
						XPoint vt = segPre.Direction3d();
						AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
						if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
						{
							vt *= newValue;
						}
						else
						{
							vt *= -newValue;
						}
						*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt; 
					}
				}
				else//包络角度
				{
					XArc arc = segPre.GetArc();
					if (segPre.GetBulge() < 0)
					{
						arc.SetStarAngle(arc.GetEndAngle() - newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						
						m_polyBase.SetBulge(nPre, -arc.Bulge());
						*m_polyBase[nPre + 1] = segPre.GetStartPoint();
					}
					else
					{
						arc.SetEndAngle(arc.GetStarAngle() + newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, arc.Bulge());
						*m_polyBase[nPre + 1] = segPre.GetEndPoint();
					}
				}
			}
			break;
		case 1:
			{
				if (!bNextArc)
				{//长度
					if (newValue>1E-6)
					{
						XPoint vt = segNext.Direction3d();
						AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
						if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
						{
							vt *= newValue;
						}
						else
						{
							vt *= -newValue;
						}
						*m_polyBase[nNext] = segNext.GetEndPoint() + vt; 
					}
				}
				else
				{//包络角度
					XArc arc = segNext.GetArc();
					if (segNext.GetBulge()  < 0)
					{
						arc.SetEndAngle(arc.GetStarAngle() + newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, -arc.Bulge());
						*m_polyBase[nNext] = segNext.GetEndPoint();
					}
					else
					{
						arc.SetStarAngle(arc.GetEndAngle() - newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, arc.Bulge());
						*m_polyBase[nNext] = segNext.GetStartPoint();
					}
				}
			}
			break;
		case 2:
			{
				if (!bPreArc)
				{//角度
					AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
					if (vt1.y < 0)
					{
						newValue *= -1;
					}

					XPoint vt2(segPre.GetLength(),0,0);
					vt2.Rotate(newValue);
					*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt2;
				}
				else
				{//前弧终止角度
					XArc arc = segPre.GetArc();
					if (ptNew.y < arc.GetCenterPt().y)
					{
						newValue = 2.0 * PI - newValue;
					}

					if (segPre.GetBulge() < 0)
					{
						arc.SetStarAngle( newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, -arc.Bulge());
					}
					else
					{
						arc.SetEndAngle(newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, arc.Bulge());
					}
					*m_polyBase[nPre + 1] = segPre.GetEndPoint();
				}
			}
			break;
		case 3:
			{
				if (!bNextArc)
				{//角度
					AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
					if (vt1.y < 0)
					{
						newValue *= -1;
					}

					XPoint vt2(segNext.GetLength(),0,0);
					vt2.Rotate(newValue);
					*m_polyBase[nNext] = segNext.GetEndPoint() + vt2;
				}
				else
				{//后弧起始角度
					XArc arc = segNext.GetArc();
					if (ptNew.y < arc.GetCenterPt().y)
					{
						newValue = 2.0 * PI - newValue;
					}

					if (segNext.GetBulge() < 0)
					{
						arc.SetEndAngle(newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, -arc.Bulge());
					}
					else
					{
						arc.SetStarAngle(newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, arc.Bulge());
					}
					*m_polyBase[nNext] = segNext.GetStartPoint();
				}
			}
			break;
		}
	}
	else if (bPre && !bNext)
	{// 有前段无后段
		switch(iDim)
		{
		case 0:
			{
				if (!bPreArc)//长度
				{
					if (newValue > 1E-6)
					{
						XPoint vt = segPre.Direction3d();
						AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
						if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
						{
							vt *= newValue;
						}
						else
						{
							vt *= -newValue;
						}
						*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt; 
					}
				}
				else//包络角度
				{
					XArc arc = segPre.GetArc();
					if (segPre.GetBulge() < 0)
					{
						arc.SetStarAngle(arc.GetEndAngle() - newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, -arc.Bulge());
						*m_polyBase[nPre + 1] = segPre.GetStartPoint();
					}
					else
					{
						arc.SetEndAngle(arc.GetStarAngle() + newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, arc.Bulge());
						*m_polyBase[nPre + 1] = segPre.GetEndPoint();
					}
				}
			}
			break;
		case 1:
			{
				if (!bPreArc)
				{//角度
					AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
					if (vt1.y < 0)
					{
						newValue *= -1;
					}

					XPoint vt2(segPre.GetLength(),0,0);
					vt2.Rotate(newValue);
					*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt2;
				}
				else
				{//前弧终止角度
					XArc arc = segPre.GetArc();
					if (ptNew.y < arc.GetCenterPt().y)
					{
						newValue = 2.0 * PI - newValue;
					}
					if (segPre.GetBulge() < 0)
					{
						arc.SetStarAngle(newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, -arc.Bulge());
					}
					else
					{
						arc.SetEndAngle(newValue);
						arc.GetStartPoint(segPre.StartPoint());
						arc.GetEndPoint(segPre.EndPoint());
						m_polyBase.SetBulge(nPre, arc.Bulge());
					}
					*m_polyBase[nPre + 1] = segPre.GetEndPoint();
				}
			}
			break;
		}
	}
	else if (!bPre && bNext)
	{// 无前段有后段
		switch(iDim)
		{
		case 0:
			{
				if (!bNextArc)
				{//长度
					if (newValue > 1E-6)
					{
						XPoint vt = segNext.Direction3d();
						AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
						if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
						{
							vt *= newValue;
						}
						else
						{
							vt *= -newValue;
						}
						*m_polyBase[nNext] = segNext.GetEndPoint() + vt; 
					}
				}
				else
				{//包络角度
					XArc arc = segNext.GetArc();
					if (segNext.GetBulge() < 0)
					{
						arc.SetEndAngle(arc.GetStarAngle() + newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, -arc.Bulge());
						*m_polyBase[nNext] = segNext.GetEndPoint();
					}
					else
					{
						arc.SetStarAngle(arc.GetEndAngle() - newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, arc.Bulge());
						*m_polyBase[nNext] = segNext.GetStartPoint();
					}
				}
			}
			break;
		case 1:
			{
				if (!bNextArc)
				{//角度
					AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
					if (vt1.y<0)
					{
						newValue *= -1;
					}

					XPoint vt2(segNext.GetLength(),0,0);
					vt2.Rotate(newValue);
					*m_polyBase[nNext] = segNext.GetEndPoint() + vt2;
				}
				else
				{//后弧起始角度
					XArc arc = segNext.GetArc();
					if (ptNew.y < arc.GetCenterPt().y)
					{
						newValue = 2.0 * PI - newValue;
					}
					if (segNext.GetBulge() < 0)
					{
						arc.SetEndAngle(newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, -arc.Bulge());
					}
					else
					{
						arc.SetStarAngle(newValue);
						arc.GetStartPoint(segNext.StartPoint());
						arc.GetEndPoint(segNext.EndPoint());
						m_polyBase.SetBulge(nNext, arc.Bulge());
					}
					*m_polyBase[nNext] = segNext.GetStartPoint();
				}
			}
			break;
		}
	}

	return Acad::eOk;
}
#endif


// 区域的布尔运算
Adesk::Boolean XExport2::PolyBoolOper(const XPoly2D &poly1, const XPoly2D & poly2, DList<XPoly2D> & poly, AcDb::BoolOperType operation)
{
	int nRetCode = RTERROR;

	if ( XPrivate::GetGlobalConfigBase() != NULL)
	{
		nRetCode = XPrivate::GetGlobalConfigBase()->BoolOper(operation,(LPVOID)&poly1,(LPVOID)&poly2,(LPVOID)&poly);
	}

	return (nRetCode == RTNORM ? Adesk::kTrue : Adesk::kFalse);
}

// 区域的并集
void XExport2::Union(const DList<XPoly2D> &lstSourcePolies, const DList<XPoly2D> &lstClipPolies, DList<XPoly2D> &lstResultPolies)
{
	//return;//zjq---

	DList<XPoly2D> lstSource, lstDest, *pSource = NULL, *pDest = NULL;
	pSource = &lstSource;  
	pDest = &lstDest;   
	for (int i = 0; i<lstSourcePolies.Length(); i++) 
	{
		lstSource.Append(new XPoly2D(lstSourcePolies[i]));
	}
	int nPiceNum = lstClipPolies.Length();
	int nStep = nPiceNum / 100;
	if (nStep<1)
	{
		nStep = 1;
	}
	if (g_bEchoSearch && nStep > 1)
	{
		acedSetStatusBarProgressMeter(_T("求并集"), 0, nPiceNum);
	}
	for (int i = 0; i<lstClipPolies.Length(); i++) 
	{
		if (g_bEchoSearch && nStep>1 && !(i%nStep)) 
		{
			acedSetStatusBarProgressMeterPos(i);
		}
		const XPoly2D &polyClip = lstClipPolies[i];
		pDest->Reset();
		for (int j = 0; j<pSource->Length(); j++) 
		{
			XPoly2D &polySrc = *(*pSource)[j];
			if ( XPrivate::GetGlobalConfigBase() != NULL)
			{
				XPrivate::GetGlobalConfigBase()->BoolOper(AcDb::kBoolUnite,(LPVOID)&polySrc,(LPVOID)&polyClip,(LPVOID)pDest);
			}

			//Union(polySrc, polyClip, *pDest);
		}
		Exchange(pSource, pDest);
	}
	if (g_bEchoSearch && nStep > 1) 
	{
		acedRestoreStatusBar();
	}
	for (int i = 0; i<pSource->Length(); i++) 
	{
		XPoly2D *pPoly = new XPoly2D(*(*pSource)[i]);
		pPoly->Compress();
		lstResultPolies.Append(pPoly);
	}
}

// 区域的减法
void XExport2::Subtract(const DList<XPoly2D> &lstSourcePolies, const DList<XPoly2D> &lstClipPolies, DList<XPoly2D> &lstResultPolies)
{
	//return;//zjq---
	DList<XPoly2D> lstSource, lstDest, *pSource = NULL, *pDest = NULL;
	pSource = &lstSource;  
	pDest = &lstDest;   
	for (int i = 0; i<lstSourcePolies.Length(); i++) 
	{
		lstSource.Append(new XPoly2D(lstSourcePolies[i]));
	}
	
	for (int i = 0; i<lstClipPolies.Length(); i++) 
	{
		const XPoly2D &polyClip = lstClipPolies[i];
		pDest->Reset();
		for (int j = 0; j<pSource->Length(); j++) 
		{
			XPoly2D &polySrc = *(*pSource)[j];

			if ( XPrivate::GetGlobalConfigBase() != NULL)
			{
				XPrivate::GetGlobalConfigBase()->BoolOper(AcDb::kBoolSubtract,(LPVOID)&polySrc,(LPVOID)&polyClip,(LPVOID)pDest);
			}

			//Subtract(polySrc, polyClip, *pDest);
		}
		Exchange(pSource, pDest);
	}
	for (int i = 0; i<pSource->Length(); i++) 
	{
		XPoly2D *pPoly = new XPoly2D(*(*pSource)[i]);
		pPoly->Compress();
		lstResultPolies.Append(pPoly);
	}
}

// 区域的减法
void XExport2::Intersect(const DList<XPoly2D> &lstSourcePolies, const DList<XPoly2D> &lstClipPolies, DList<XPoly2D> &lstResultPolies)
{
	//return;//zjq---
	DList<XPoly2D> lstSource, lstDest, *pSource = NULL, *pDest = NULL;
	pSource = &lstSource;  
	pDest = &lstDest;   
	for (int i = 0; i<lstSourcePolies.Length(); i++) 
	{
		lstSource.Append(new XPoly2D(lstSourcePolies[i]));
	}
	
	for (int i = 0; i<lstClipPolies.Length(); i++) 
	{
		const XPoly2D &polyClip = lstClipPolies[i];
		pDest->Reset();
		for (int j = 0; j<pSource->Length(); j++) 
		{
			XPoly2D &polySrc = *(*pSource)[j];
			if ( XPrivate::GetGlobalConfigBase() != NULL)
			{
				XPrivate::GetGlobalConfigBase()->BoolOper(AcDb::kBoolIntersect,(LPVOID)&polySrc,(LPVOID)&polyClip,(LPVOID)pDest);
			}

			//XExport2::Intersect(polySrc, polyClip, *pDest);
		}
		Exchange(pSource, pDest);
	}
	for (int i = 0; i<pSource->Length(); i++) 
	{
		XPoly2D *pPoly = new XPoly2D(*(*pSource)[i]);
		pPoly->Compress();
		lstResultPolies.Append(pPoly);
	}
}

void XExport2::InitModel(const XMasterProperties &prop, const AcDbEntity *pEntity,
						  AcGeMatrix3d *pMatTran, AcDbVoidPtrArray &entSet3dface)
{
	TCHAR szMatch[256] = _T("AEC_*");
	
	XMasterProperties subProp(prop);
	subProp.SetFrom(pEntity);
	if (pEntity->isKindOf(AcDbFace::desc())) 
	{
		AcDbFace *pFace = (AcDbFace *)pEntity->clone();
		ASSERT(pFace);
		if (pMatTran) 
		{
			if (pFace->transformBy(*pMatTran) != Acad::eOk) 
			{
				AcGePoint3d ptArray[4];
				for (int i = 0; i<4; i++)
				{
					pFace->getVertexAt(i, ptArray[i]);
					ptArray[i].transformBy(*pMatTran);
					pFace->setVertexAt(i, ptArray[i]);
				}
			}
		}
		subProp.SetTo(pFace);
		entSet3dface.append(pFace);
	} 
	else if (pEntity->isKindOf(AcDbPolyFaceMesh::desc()) || pEntity->isKindOf(AcDbPolygonMesh::desc())) 
	{
		AcDbVoidPtrArray entSet1;
		VERIFY(pEntity->explode(entSet1) == Acad::eOk);
		InitModel(subProp, entSet1, pMatTran, entSet3dface);
		XExport::ReleaseEntSet(entSet1);
	}
	else if (pEntity->isKindOf(AcDbBlockReference::desc()))
	{
		AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
		ASSERT(pInsert);
		AcGeMatrix3d matNew = BlockTransform(pInsert);
		if (pMatTran)
		{
			matNew.preMultBy(*pMatTran);
		}
		AcDbObjectId idBlock = pInsert->blockTableRecord();
		OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlockTableRecord);
		if (pBlockTableRecord)
		{
			AcDbBlockTableRecordIterator *pBlockIterator = NULL;
			VERIFY(pBlockTableRecord->newIterator(pBlockIterator) == Acad::eOk && pBlockIterator);
			for (pBlockIterator->start(); !pBlockIterator->done();pBlockIterator->step())
			{
				AcDbEntity *pEntNew = NULL;
				if (pBlockIterator->getEntity(pEntNew, AcDb::kForRead) != Acad::eOk || !pEntNew)
				{
					continue;
				}
				if (pEntNew->visibility() == AcDb::kVisible) 
				{
					XExport2::InitModel(subProp, pEntNew, &matNew, entSet3dface);
				}
				pEntNew->close();
			}
			delete pBlockIterator;
		}
		OPENOBJ_END();
	} 
	else if (ads_wcmatch(pEntity->isA()->dxfName(), szMatch) == RTNORM) 
	{ // 在2000i/20002下，$对象的分解由于调用了Region的运算导致出错有问题
		AcDbVoidPtrArray entSet1;
		if (pEntity->explode(entSet1) == Acad::eOk) 
		{
			XExport2::InitModel(subProp, entSet1, pMatTran, entSet3dface);
			XExport::ReleaseEntSet(entSet1);
		}
	} 
	else if (_tcsicmp(pEntity->isA()->dxfName(), _T("3DSOLID")) == 0 || _tcsicmp(pEntity->isA()->dxfName(), _T("REGION")) == 0 ||
		_tcsicmp(pEntity->isA()->dxfName(), _T("3DBODY")) == 0  )
	{
		AcDbVoidPtrArray entSet;
		ExplodeAcis(pEntity, entSet);
		XExport2::InitModel(subProp, entSet, pMatTran, entSet3dface);
		XExport::ReleaseEntSet(entSet);
	}
	else if (_tcsicmp(pEntity->isA()->dxfName(), _T("SOLID")) == 0) 
	{ //二维物体
		AcDbSolid *pClone = (AcDbSolid *)pEntity->clone();
		ASSERT(pClone);
		if (pMatTran) 
		{
			if (pClone->transformBy(*pMatTran) != Acad::eOk) 
			{
				AcGePoint3d ptArray[4];
				for (int i = 0; i<4; i++) 
				{
					pClone->getPointAt(i, ptArray[i]);
					ptArray[i].transformBy(*pMatTran);
					pClone->setPointAt(i, ptArray[i]);
				}
			}
		}
		subProp.SetTo(pClone);
		entSet3dface.append(pClone);
	} 
	else if (pEntity->isA() == AcDbLine::desc()) 
	{
		AcDbLine *pLine = (AcDbLine *)pEntity->clone();
		ASSERT(pLine);
		if (pMatTran) 
		{
			if (pLine->transformBy(*pMatTran) != Acad::eOk) 
			{
				AcGePoint3d pt1 = pLine->startPoint();
				AcGePoint3d pt2 = pLine->endPoint();
				AcGeVector3d vt = pLine->normal();
				AcGeVector3d vtNormal = vt;
				vt *= pLine->thickness();
				pt1.transformBy(*pMatTran);
				pt2.transformBy(*pMatTran);
				vt.transformBy(*pMatTran);
				vtNormal.transformBy(*pMatTran);
				if (vt.length()>_DIST_SNAP) 
				{
					AcDbFace *pFace = new AcDbFace(pt1, pt2, pt2+vt, pt1+vt);
					subProp.SetTo(pFace);
					entSet3dface.append(pFace);
					delete pLine;
				}
				else
				{
					pLine->setStartPoint(pt1);
					pLine->setEndPoint(pt2);
					pLine->setThickness(0.0);
					vtNormal.normalize();
					pLine->setNormal(vtNormal);
					subProp.SetTo(pLine);
					entSet3dface.append(pLine);
				}
			} 
			else
			{
				subProp.SetTo(pLine);
				entSet3dface.append(pLine);
			}
		} 
		else
		{
			AcGeVector3d vt = pLine->normal();
			AcGeVector3d vtNormal = vt;
			vt *= pLine->thickness();
			AcGePoint3d pt1 = pLine->startPoint();
			AcGePoint3d pt2 = pLine->endPoint();
			if (vt.length()>_DIST_SNAP) 
			{
				AcDbFace *pFace = new AcDbFace(pt1, pt2, pt2+vt, pt1+vt);
				subProp.SetTo(pFace);
				entSet3dface.append(pFace);
				delete pLine;
			}
			else 
			{
				pLine->setStartPoint(pt1);
				pLine->setEndPoint(pt2);
				pLine->setThickness(0.0);
				vtNormal.normalize();
				pLine->setNormal(vtNormal);
				subProp.SetTo(pLine);
				entSet3dface.append(pLine);
			}
		}
		
	}
	else
	{ //拉伸的曲线
		AcDbPolyline *pline = AsPolyline(pEntity);
		if (pline) 
		{
			if (pline->thickness()>_DIST_SNAP) 
			{
				// 没有消除圆弧折线化后的不可见边
				double nThick = pline->thickness();
				XPoly2D poly;
				XExport2::PolyConvert(*pline, poly);

				if (poly.IsClosed() && poly.PathArea()>0.0)
				{
					poly.Reverse();  //确保逆时针
				}
				XVector3D vtNormal;
				AcGeVector3d vt = pline->normal();
				(AcGeVector3d &)vtNormal = vt;
				
				double nWidth = 0.0;
				if (pline->getConstantWidth(nWidth) != Acad::eOk)
				{
					nWidth = 0.0;
				}
				if (nWidth>_DIST_SNAP) 
				{
					XPoly2D poly1, poly2;
					poly.Offset(-nWidth/2, poly1);
					poly.Offset(nWidth/2, poly2);
					ThickPoly2Face(subProp, poly1, vtNormal, nThick, entSet3dface, pMatTran);
					ThickPoly2Face(subProp, poly2, vtNormal, nThick, entSet3dface, pMatTran);
					
					if (poly.IsClosed())
					{
						poly1.SetFlag(0);
						poly2.SetFlag(0);
						poly1.AppendNode(*poly1.Head());
						poly2.AppendNode(*poly2.Head());
					}
					XPoly2D poly3(poly1);
					poly2.Reverse();
					for (int n = 0; n<poly2.Length(); n++) 
					{
						poly3.AppendNode(*poly2[n], poly2.GetBulge(n));
					}
					XPoly polygon;
					poly3.AsOpenPoly1(polygon, _AS_SYS_UNIT(g_nCirDeviation));
					
					DList<XTriangle> lstTris[2];
					
					XHoleModel model;
					for (int k = 0; k < polygon.Length(); k++)
					{
						//model.m_outline.AppendNode(*polygon[k], TRUE);
						model.GetOutLine().AppendNode(*poly1[k], TRUE);
					}
					model.Triangulate(FALSE, lstTris[0]);
					
					XPoint vtN = vtNormal;
					vtN *= nThick;
					for (int n = 0; n<lstTris[0].Length(); n++) 
					{
						XTriangle *pTri = lstTris[0][n];
						XTriangle *pTri1 = new XTriangle(*pTri);
						pTri1->vertex1 += vtN;
						pTri1->vertex2 += vtN;
						pTri1->vertex3 += vtN;
						lstTris[1].Append(pTri1);
					}
					for (int ii = 0; ii<2; ii++) 
					{
						for (int jj = 0; jj<lstTris[ii].Length(); jj++)
						{
							XTriangle *triangle = lstTris[ii][jj];
							triangle->vertex1 = Ecs2Wcs(triangle->vertex1, vtNormal);
							triangle->vertex2 = Ecs2Wcs(triangle->vertex2, vtNormal);
							triangle->vertex3 = Ecs2Wcs(triangle->vertex3, vtNormal);
							Adesk::Boolean bSide1 = !(triangle->m_nFlag&SIDE1_INVISIBLE);
							Adesk::Boolean bSide2 = !(triangle->m_nFlag&SIDE2_INVISIBLE);
							Adesk::Boolean bSide3 = !(triangle->m_nFlag&SIDE3_INVISIBLE);
							AcDbFace *pFace = new AcDbFace(triangle->vertex1, triangle->vertex2,
								triangle->vertex3, triangle->vertex1, bSide1, bSide2, bSide3);
							subProp.SetTo(pFace);
							entSet3dface.append(pFace);
						}
					}
					
				}
				else 
				{
					ThickPoly2Face(subProp, poly, vtNormal, nThick, entSet3dface, pMatTran);
				}
				delete pline;
			} 
			else 
			{
				if (!pMatTran) 
				{
					subProp.SetTo(pline);
					entSet3dface.append(pline);
				} 
				else if (pline->transformBy(*pMatTran) == Acad::eOk) 
				{
					subProp.SetTo(pline);
					entSet3dface.append(pline);
				} 
				else
				{
					XPoly2D poly2d, polyDest;
					XExport2::PolyConvert(*pline, poly2d);

					poly2d.Disperse1(polyDest, _AS_SYS_UNIT(g_nCirDeviation));
					AcGeVector3d vtNormal = pline->normal();
					XVector3D vtN(vtNormal[0], vtNormal[1], vtNormal[2]);
					Groups gv(vtN), g0(0);
					polyDest.TransUCS((const resbuf *)&gv, (const resbuf *)&g0);
					
					ads_matrix mat;
					AsAdsMatrix(*pMatTran, mat);
					polyDest.TransUCS(mat);
					
					int nSeg = polyDest.TotalSegments();
					for (int iSeg = 0; iSeg<nSeg; iSeg++)
					{
						XCurveSegment ln;
						polyDest.Nth(iSeg,ln);
						AcDbCurve *pCurve = ln.AsAcDbCurve();
						subProp.SetTo(pCurve);
						entSet3dface.append(pCurve);
					}
					delete pline;
				}
			}
		}
	}
}

void XExport2::InitModel(const XMasterProperties &prop, const AcDbVoidPtrArray &entSet, AcGeMatrix3d *pMatTran, AcDbVoidPtrArray &entSet3dface)
{
    int nCount = entSet.length();
	for (int i = 0; i<nCount; i++)
	{
		AcDbEntity *pEntity = (AcDbEntity *)entSet[i];
        XExport2::InitModel(prop, pEntity, pMatTran, entSet3dface);
	}
}

int XExport2::SearchRegions(const DList<XCurveSegment> &lstSeg1In, DList<XPoly2D> &lstDest)
{
    try 
	{
		XSearchRegionFromCurve aSearch;
		aSearch.InitStart(lstSeg1In);
		if (aSearch.SearchRegions()) 
		{
			aSearch.RemoveDupRegions();
			for (int n = 0; n<aSearch.m_regions.Length(); n++)
			{
				XPoly2D *pNewPoly = new XPoly2D(1);
				if (aSearch.m_regions[n]->CenterPoly2D(*pNewPoly) == RTNORM)
				{
					lstDest.Append(pNewPoly);
				}
				else
				{
					delete pNewPoly;
				}
			}
		}    
	} 
	catch(...) 
	{
		if (g_bEchoSearch)
		{
			XGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
		}
		return RTERROR;
    }
	
    return RTNORM;
}