//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   导出全局函数实现文件
// = Version	:   ver2.0
// = Author		:   lfy
// = CreateDate	:   2002-09-09
// = Description:   全局函数的声明
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TchSubGlobalFunc.h"
#include "TGRegionEx2D.h"
#include "TGPolygon2D.h"
#include "TGPoint2D.h"
#include "TPGeCurveMesh.h"
#include "TGMesh.h"
#include "TPushMemVar.h"
#include "TProductid.h"
#include "TGMLine2D.h"
#include "TGPLine2D.h"
#include "TGMCurve2D.h"
#include "TGPolygon2D.h"
#include "TGPolygonEx2D.h"
#include "TGRegionEx2D.h"
#include "TGPoint3D.h"
#include "TPGeGLine3D.h"
#include "TPGeGLineRay3D.h"
#include "TPGeGLineSeg3D.h"
#include "TGPCurve3D.h"
#include "TGMLine3D.h"
#include "TGMCurve3D.h"
#include "TGPlane3D.h"
#include "TPGeGraph.h"
#include "TGGeRegion2D.h"
#include "TchGlobalCurveFunc.h"

extern int g_nProductId;

void TchSubExport::RegisterClassId()
{
	REGISTER_CID(TGPoint2D,CID_GPoint2D);
	REGISTER_CID(TPGeGLine2D,CID_GLine2D);
	REGISTER_CID(TPGeGLineRay2D,CID_GLineRay2D);
	REGISTER_CID(TPGeGLineSeg2D,CID_GLineSeg2D);		
	REGISTER_CID(TPGeCircle2D,CID_GCircle2D);
	REGISTER_CID(TPGeArc2D,CID_GArc2D); 
	REGISTER_CID(TGMLine2D,CID_GMLine2D);
	REGISTER_CID(TGPLine2D,CID_GPLine2D);
	REGISTER_CID(TGMCurve2D,CID_GMCurve2D);
	REGISTER_CID(TGPolygon2D,CID_GPolygon2D);
	REGISTER_CID(TGPolygonEx2D,CID_GPolygonEx2D);
	REGISTER_CID(TGRegionEx2D,CID_GRegionEx2D);
	REGISTER_CID(TGPoint3D,CID_GPoint3D);
	REGISTER_CID(TPGeGLine3D,CID_GLine3D);
	REGISTER_CID(TPGeGLineRay3D,CID_GLineRay3D);
	REGISTER_CID(TPGeGLineSeg3D,CID_GLineSeg3D);
	REGISTER_CID(TGPCurve3D,CID_GPCurve3D);
	REGISTER_CID(TGMLine3D,CID_GMLine3D);
	REGISTER_CID(TGMCurve3D,CID_GMCurve3D);
	REGISTER_CID(TGPlane3D,CID_GPlane3D);
	
	TGObjectList ss;
	{
		TPGeFitGraph a;
		a.MakeEdge();
		a.MakeTriangle();
		a.Fit(0);
		a.CreateCurve(ss);
		a.Reset();
		
		NA(0);
	}
}

void TchSubExport::GOutput(const TGObject*pObj,int color)
{
	AcDbEntity *pEnt = TchSubExport::Obj2Entity((TGObject*)pObj);
	if (pEnt != NULL)
	{
		pEnt->setColorIndex(color);
		TchExport::AddToModelSpace(pEnt,Adesk::kTrue);
	}
}

BOOL TchSubExport::Offset(double dist,TGGePoly2D &poly)//poly是输入也是输出
{
	TGPLine2D polyNew;
	TchSubExport::TGGePoly2DToTGPLine2D(poly,polyNew);
	
	if (!polyNew.Offset(dist))
	{
		return FALSE;
	}
	poly.Reset();
	TchSubExport::TGMLine2DToTGGePoly2D(polyNew,poly);
	
	return TRUE;
}

void TchSubExport::Offset(double dist,TGGePoly2D poly,TDPtrList<TGGePoly2D>&lstRes)
{
	if (poly.Length() < 1 || !poly.IsClosed())
	{
		return;
	}
	
	double elev = poly[0]->z;
	TchSubExport::Offset(dist,poly);
	
	if (poly.IsSelfIntersect())
	{
		TDPtrList<TGGeCurveSegment> lstSeg;
		ExplodePoly2D(poly,lstSeg);
		
		TGObjectList oList,oList1;
		for (long i = 0; i < lstSeg.Length(); i++)
		{
			oList << TchSubExport::TGGeCurveSegmentToTPGeCurve2D(*lstSeg[i]);
		}
		oList.InterBreakCurve2D(oList1);
		
		TPGeCurveMesh mesh(oList1);
		mesh.FindAllMesh();
		for (mesh.m_allMesh.MoveToFirst();!mesh.m_allMesh.IsOut();mesh.m_allMesh.MoveToNext())
		{
			TPGeCurve2D* pCurve = mesh.m_allMesh.GetCurData()->CreateCurve();
			if (pCurve != NULL)
			{
				if (pCurve->IsClockwise())//内环
				{
					TGMLine2D *pPline = pCurve->PLinearize();
					if (pPline != NULL)
					{
						TGGePoly2D polyTemp(1);
						TchSubExport::TGMLine2DToTGGePoly2D(*pPline,polyTemp);
						delete pPline;
						polyTemp.Reverse();
						polyTemp.Compress();
						polyTemp.SetElevation(elev);
						lstRes.Append(new TGGePoly2D(polyTemp));
					}
				}
				delete pCurve;
			}
		}	
	}
	else
	{
		lstRes.Append(new TGGePoly2D(poly));
	}
}


TPGeCurve2D* TchSubExport::TGGeCurveSegmentToTPGeCurve2D(TGGeCurveSegment cv)
{
	if (cv.Is(CURVE_LINE))
	{
		return new TPGeGLineSeg2D(TGPoint((double*)cv.GetStartPoint()),(TGPoint((double*)cv.GetEndPoint())));
	}
	else
	{
		return new TPGeArc2D((double*)cv.GetStartPoint(),(double*)cv.GetEndPoint(),cv.GetBulge());
	}
}

void TchSubExport::SearchOutline(const TDPtrList<TGGeCurveSegment>&lstSeg,TDPtrList<TGGePoly2D>&lstPoly)
{
	TGObjectList oList,oList1;
	for (long i = 0; i < lstSeg.Length(); i++)
	{
		oList << TchSubExport::TGGeCurveSegmentToTPGeCurve2D(lstSeg[i]);
	}
	oList.InterBreakCurve2D(oList1);
	oList.Clear();
	
	TPGeCurveMesh mesh(oList1);
	mesh.FindAllMesh();
	for (mesh.m_allMesh.MoveToFirst();!mesh.m_allMesh.IsOut();mesh.m_allMesh.MoveToNext())
	{
		TPGeCurve2D* pCurve = mesh.m_allMesh.GetCurData()->CreateCurve();
		if (!pCurve->IsClockwise())
		{
			TGMLine2D *pPline = pCurve->PLinearize();
			if (pPline != NULL)
			{
				TGGePoly2D poly(1);
				TchSubExport::TGMLine2DToTGGePoly2D(*pPline,poly);
				delete pPline;
				poly.Compress();
				lstPoly.Append(new TGGePoly2D(poly));
			}
		}
		delete pCurve;
	}
}



void TchSubExport::TGGePoly2DToTGPLine2D(const TGGePoly2D&poly0,TGPLine2D&poly)
{
	poly.SetVertexNum(poly0.Length());
	poly.SetClosed(poly0.IsClosed() == TRUE);
	for (long i = 0;i<poly0.Length();i++)
	{
		poly[i] = (double*)(poly0[i]);
		poly(i) = poly0.GetBulge(i);
	}
}

TGGeRegion2D* TchSubExport::TGRegion2DToTGGeRegion2D(const TGRegion2D&r1)
{
	if (r1.GetBoundaryNum() < 1)
	{
		return NULL;
	}
	
	TPGeCurve2D &curve = r1.Outline();
	TGMLine2D* pMLine = curve.PLinearize();
	if (pMLine == NULL)
	{
		return NULL;
	}
	TGGeRegion2D *pNewRegion = new TGGeRegion2D;
	TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewRegion);
	delete pMLine;
	
	for (long i = 0;i<r1.GetHoleNum();i++)
	{
		pMLine = r1.Hole(i).PLinearize();
		if (pMLine == NULL)
		{
			continue;
		}
		TGGePoly2D *pHole = new TGGePoly2D(1);
		TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pHole);
		delete pMLine;
		
		pNewRegion->AppendHole(pHole);
	}
	
	if (pNewRegion->IsValid())
	{
		return pNewRegion;
	}
	else
	{
		delete pNewRegion;
		return NULL;
	}
}

void TchSubExport::TGMLine2DToTGGePoly2D(const TGMLine2D&poly0,TGGePoly2D&poly)
{
	poly.Reset();
	if (IS_TYPE(&poly0,TGMLine2D))
	{
		for (long i = 0;i<poly0.GetVertexNum();i++)
		{
			const TGPoint&pt = poly0.GetVertex(i);
			poly.AppendNode(TADSGePoint3d(pt.x,pt.y,pt.z));
		}
	}
	else
	{
		const TGPLine2D&poly1 = (const TGPLine2D&)poly0;
		for (long i = 0;i<poly1.GetVertexNum();i++)
		{
			const TGPoint&pt = poly1.GetVertex(i);
			poly.AppendNode(TADSGePoint3d(pt.x,pt.y,pt.z),poly1.GetBulge(i));
		}
	}
	
	poly.SetFlag(poly0.IsClosed() ? 1 : 0);
}

bool TchSubExport::IsInter(const TGGePoly2D& poly1,const TGGePoly2D& poly2)
{
	TGPLine2D pline1,pline2;
	TchSubExport::TGGePoly2DToTGPLine2D(poly1,pline1);
	TchSubExport::TGGePoly2DToTGPLine2D(poly2,pline2);
	
	TGObjectList buf;
	return pline1.Intersect(pline2,buf);
}

bool TchSubExport::IsInclude(const TGGePoly2D& poly1,const TGGePoly2D& poly2)
{
	TGPLine2D pline1,pline2;
	TchSubExport::TGGePoly2DToTGPLine2D(poly1,pline1);
	TchSubExport::TGGePoly2DToTGPLine2D(poly2,pline2);
	
	TGRegionEx2D region1(pline1);
	if (region1.IsValid() && region1.IsInclude(pline2))
	{
		return true;
	}
	
	return false;
}

void TchSubExport::CutPoly2D(const TGGePoly2D&poly2d,double dist,TGObjectList &res)
{
	//准备切割
	TGPLine2D poly;
	TchSubExport::TGGePoly2DToTGPLine2D(poly2d,poly);
	
	TPGeExtend2D ext;
	poly.GetExtend2D(ext);
	
	TGObjectList buf,right,left;
	buf.AddTail(new TGRegionEx2D(poly));
	
	//横向切割
	TPGeGLine2D lineX(TGVector2D(1,0),TGPoint(0,ext.m_yExt.m_fMin));
	double& Y = lineX.basePoint.y, maxY = ext.m_yExt.m_fMax-0.001;
	for (Y += dist; Y < maxY; Y += dist)//从下往上切
	{
		buf.CutBy(lineX,left,right,left);
		buf.Clear();
		buf.Conbine(left);
	}
	buf.Conbine(right);
	
	TPGeGLine2D lineY(TGVector2D(0,1),TGPoint(ext.m_xExt.m_fMin,0));
	double& X = lineY.basePoint.x, maxX = ext.m_xExt.m_fMax-0.001;
	for (X += dist; X < maxX; X += dist)//从左向右切
	{
		buf.CutBy(lineY,left,right,right);
		buf.Clear();
		buf.Conbine(right);
	}
	buf.Conbine(left);
	res.Conbine(buf);
}

bool TchSubExport::GetSubPoly(const TGGePoly2D&poly,TADSGePoint3d pt1,TADSGePoint3d pt2,TGGePoly2D&subPoly)
{
	TGPLine2D pline;
	TchSubExport::TGGePoly2DToTGPLine2D(poly,pline);
	
	double pa1,pa2;
	pline.Pt2Pa(TGPoint(pt1.x,pt1.y),pa1);
	pline.Pt2Pa(TGPoint(pt2.x,pt2.y),pa2);
	
	if (UPEQUAL_ZERO(pa1) && UPEQUAL_ZERO(pa2))
	{
		TPGeCurve2D *pCurve = pline.GetSubCurve(pa1,pa2);
		if (pCurve != NULL)
		{
			TGMLine2D *pMLine = pCurve->PLinearize();
			delete pCurve;
			
			if (pMLine != NULL)
			{
				TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,subPoly);
				delete pMLine;
				return true;
			}
		}
	}
	return false;
}


// 区域的减法
// what? poly1-poly2 = ?
int TchSubExport::Subtract(const TGGePoly2D &poly1, const TGGePoly2D &poly2, TDPtrList<TGGePoly2D> &lstResult)
{
	if (g_nProductId != kTSUN)
	{
		//注意：日照计算时不需要启动这两行
		TPushMemVar<double> vPrec(g_distZero,_DIST_SNAP);
		TPushMemVar<double> vPrec1(g_fZero,1E-6);
		
		TGPLine2D newPoly1,newPoly2;
		// modify by xlc on 101105 在当前精度下压缩区域，解决在此精度下区域边界有重合点不合法的问题
		//TchSubExport::TGGePoly2DToTGPLine2D(poly1,newPoly1);
		//TchSubExport::TGGePoly2DToTGPLine2D(poly2,newPoly2);
		TGGePoly2D polyOld1(poly1),polyOld2(poly2);
		polyOld1.Compress();
		polyOld2.Compress();
		TGGePoly2DToTGPLine2D(polyOld1,newPoly1);
		TGGePoly2DToTGPLine2D(polyOld2,newPoly2);

		TGRegionEx2D region1(newPoly1),region2(newPoly2);
		if (!region1.IsValid() || !region2.IsValid())
		{
			return RTERROR;
		}
		TGObjectList res;
		region1.SubtractBy(region2,res);
		for (res.MoveToFirst();!res.IsOut();res.MoveToNext())
		{
			TGObject *pObj = res.GetCurData();
			if (IS_CLASS(pObj,TGRegion2D))
			{
				TGRegion2D *pRegion = (TGRegion2D*)pObj;
				TGMLine2D* pMLine = pRegion->Outline().PLinearize();
				TGGePoly2D *pNewPoly = new TGGePoly2D(1);
				TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
				delete pMLine;
				
				//add by xlc on 100813  消除重合点，解决墙体造型和弧墙加粗不显示的问题
				pNewPoly->Compress(false);

				lstResult.Append(pNewPoly);
			}
		}
	}
	else
	{
		TGPLine2D newPoly1,newPoly2;
		TchSubExport::TGGePoly2DToTGPLine2D(poly1,newPoly1);
		TchSubExport::TGGePoly2DToTGPLine2D(poly2,newPoly2);
		TGRegionEx2D region1(newPoly1),region2(newPoly2);
		if (!region1.IsValid() || !region2.IsValid())
		{
			return RTERROR;
		}
		TGObjectList res;
		region1.SubtractBy(region2,res);
		for (res.MoveToFirst();!res.IsOut();res.MoveToNext())
		{
			TGObject *pObj = res.GetCurData();
			if (IS_CLASS(pObj,TGRegion2D))
			{
				TGRegion2D *pRegion = (TGRegion2D*)pObj;
				TGMLine2D* pMLine = pRegion->Outline().PLinearize();
				TGGePoly2D *pNewPoly = new TGGePoly2D(1);
				TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
				delete pMLine;
				lstResult.Append(pNewPoly);
			}
		}
	}
	return RTNORM;	
}

void TchSubExport::Subtract(TDPtrList<TGGeRegion2D> &lst1,const TDPtrList<TGGeRegion2D> &lst2)
{
	TGObjectList oList1,oList2,oList3;
	for (long i = 0;i<lst1.Length();i++)
	{
		TGRegion2D *pRegion = TchSubExport::TGGeRegion2DToTGRegion2D(*lst1[i]);
		if (pRegion != NULL)
		{
			oList1<<pRegion;
		}
	}
	
	for (i = 0;i<lst2.Length();i++)
	{
		TGRegion2D *pRegion = TchSubExport::TGGeRegion2DToTGRegion2D(lst2[i]);
		if (pRegion != NULL)
		{
			oList2<<pRegion;
		}
	}
	oList1.SubtractBy(oList2,oList3);
	
	lst1.Reset();
	for (i = 0;i<oList3.GetLength();i++)
	{
		TGGeRegion2D *pRegion = TchSubExport::TGRegion2DToTGGeRegion2D((const TGRegion2D&)(*oList3[i]));
		if (pRegion != NULL)
		{
			lst1.Append(pRegion);
		}
	}
}


void TchSubExport::Union(TDPtrList<TGGeRegion2D> &lst1)
{
	TGObjectList oList;
	for (long i = 0; i < lst1.Length(); i++)
	{
		TGRegion2D *pRegion = TchSubExport::TGGeRegion2DToTGRegion2D(*lst1[i]);
		if (pRegion != NULL)
		{
			oList << pRegion;
		}
	}
	lst1.Reset();
	
	oList.Union();
	
	for (i = 0; i < oList.GetLength(); i++)
	{
		TGGeRegion2D *pRegion = TchSubExport::TGRegion2DToTGGeRegion2D((const TGRegion2D&)(*oList[i]));
		if (pRegion != NULL)
		{
			lst1.Append(pRegion);
		}
	}
}

// 区域的并
// what? poly1+poly2 = ?
// Modify on 2002/11/15解决2个完全一样的poly的并集问题
int TchSubExport::Union(const TGGePoly2D &poly1, const TGGePoly2D &poly2, TDPtrList<TGGePoly2D> &lstResult)
{
	if (g_nProductId != kTSUN)
	{
		//注意：日照计算时不需要启动这两行
		TPushMemVar<double> vPrec(g_distZero,_DIST_SNAP);
		TPushMemVar<double> vPrec1(g_fZero,1E-6);
		
		TGPLine2D newPoly1,newPoly2;
		// modify by xlc on 101105 在当前精度下压缩区域，解决在此精度下区域边界有重合点不合法的问题
		//TchSubExport::TGGePoly2DToTGPLine2D(poly1,newPoly1);
		//TchSubExport::TGGePoly2DToTGPLine2D(poly2,newPoly2);
		TGGePoly2D polyOld1(poly1),polyOld2(poly2);
		polyOld1.Compress();
		polyOld2.Compress();
		TGGePoly2DToTGPLine2D(polyOld1,newPoly1);
		TGGePoly2DToTGPLine2D(polyOld2,newPoly2);

		TGRegionEx2D region1(newPoly1),region2(newPoly2);		
		if (!region1.IsValid() || !region2.IsValid())
		{
			return RTERROR;
		}
		
		TGRegion2D *pRegion = region1.Union(region2);
		if (pRegion != NULL)
		{
			TGMLine2D* pMLine = pRegion->Outline().PLinearize();
			TGGePoly2D *pNewPoly = new TGGePoly2D(1);
			TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
			delete pMLine;
			delete pRegion;
			lstResult.Append(pNewPoly);
		}
	}
	else
	{
		TGPLine2D newPoly1,newPoly2;
		TchSubExport::TGGePoly2DToTGPLine2D(poly1,newPoly1);
		TchSubExport::TGGePoly2DToTGPLine2D(poly2,newPoly2);
		TGRegionEx2D region1(newPoly1),region2(newPoly2);
		
		if (!region1.IsValid() || !region2.IsValid())
		{
			return RTERROR;
		}
		
		TGRegion2D *pRegion = region1.Union(region2);
		if (pRegion != NULL)
		{
			TGMLine2D* pMLine = pRegion->Outline().PLinearize();
			TGGePoly2D *pNewPoly = new TGGePoly2D(1);
			TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
			delete pMLine;
			delete pRegion;
			lstResult.Append(pNewPoly);
		}
	}

	return RTNORM;
}

// Pline表示的区域的交集
int TchSubExport::Intersect(const TGGePoly2D &poly1, const TGGePoly2D &poly2, TDPtrList<TGGePoly2D> &lstDest)
{
	//注意：日照计算时不需要启动这两行
	// sg modify 091202，建议恢复下面这两行，7.5时，以下两行是打开的，布尔运算相对稳定
	if (g_nProductId != kTSUN)
	{
		TPushMemVar<double> vPrec(g_distZero,_DIST_SNAP);
		TPushMemVar<double> vPrec1(g_fZero,1E-6);

		TGPLine2D newPoly1,newPoly2;

		// modify by xlc on 101105 在当前精度下压缩区域，解决在此精度下区域边界有重合点不合法的问题
		//TGGePoly2DToTGPLine2D(poly1,newPoly1);
		//TGGePoly2DToTGPLine2D(poly2,newPoly2);
		TGGePoly2D polyOld1(poly1),polyOld2(poly2);
		polyOld1.Compress();
		polyOld2.Compress();
		TGGePoly2DToTGPLine2D(polyOld1,newPoly1);
		TGGePoly2DToTGPLine2D(polyOld2,newPoly2);
		
		TGRegionEx2D region1(newPoly1),region2(newPoly2);
		if (!region1.IsValid()||!region2.IsValid())
		{
			return RTERROR;
		}
		
		TGObjectList res;
		region1.Inter(region2,res);
		for (res.MoveToFirst();!res.IsOut();res.MoveToNext())
		{
			TGObject *pObj = res.GetCurData();
			if (IS_CLASS(pObj,TGRegion2D))
			{
				TGRegion2D *pRegion = (TGRegion2D*)pObj;
				TGMLine2D* pMLine = pRegion->Outline().PLinearize();
				
				TGGePoly2D *pNewPoly = new TGGePoly2D(1);
				TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
				
				delete pMLine;
				lstDest.Append(pNewPoly);
			}
		}
	}
	else
	{
		TGPLine2D newPoly1,newPoly2;
		TGGePoly2DToTGPLine2D(poly1,newPoly1);
		TGGePoly2DToTGPLine2D(poly2,newPoly2);
		
		TGRegionEx2D region1(newPoly1),region2(newPoly2);
		if (!region1.IsValid()||!region2.IsValid())
		{
			return RTERROR;
		}
		
		TGObjectList res;
		region1.Inter(region2,res);
		for (res.MoveToFirst();!res.IsOut();res.MoveToNext())
		{
			TGObject *pObj = res.GetCurData();
			if (IS_CLASS(pObj,TGRegion2D))
			{
				TGRegion2D *pRegion = (TGRegion2D*)pObj;
				TGMLine2D* pMLine = pRegion->Outline().PLinearize();
				
				TGGePoly2D *pNewPoly = new TGGePoly2D(1);
				TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
				
				delete pMLine;
				lstDest.Append(pNewPoly);
			}
		}
	}
	return RTNORM;
}

void TchSubExport::Intersect(const TGGeRegion2D &r1,const TGGeRegion2D &r2,TDPtrList<TGGeRegion2D> &res)
{
	TGRegion2D *pRegion1 = TchSubExport::TGGeRegion2DToTGRegion2D(r1);
	if (pRegion1 != NULL)
	{
		TGRegion2D *pRegion2 = TchSubExport::TGGeRegion2DToTGRegion2D(r2);
		if (pRegion2 != NULL)
		{
			TGObjectList oList;
			pRegion1->Inter(*pRegion2,oList);
			for (long i = 0;i<oList.GetLength();i++)
			{
				TGGeRegion2D *pRegion = TchSubExport::TGRegion2DToTGGeRegion2D((const TGRegion2D&)*oList[i]);
				if (pRegion != NULL)
				{
					res.Append(pRegion);
				}
			}
			
			delete pRegion2;
		}
		delete pRegion1;
	}
}

TGRegion2D* TchSubExport::TGGeRegion2DToTGRegion2D(const TGGeRegion2D&r1)
{
	TGObjectList oList;
	TGPLine2D*pNewPoly = new TGPLine2D;
	
	TchSubExport::TGGePoly2DToTGPLine2D(r1,*pNewPoly);
	oList << (TGObject*)pNewPoly;
	
	for (long i = 0;i<r1.GetHoleNum();i++)
	{
		pNewPoly = new TGPLine2D;
		TchSubExport::TGGePoly2DToTGPLine2D(r1.GetHole(i),*pNewPoly);
		oList<<pNewPoly;
	}
	
	TGRegion2D* pNewRegion = new TGRegionEx2D(oList,true);//自动纠正方向
	
	bool bHasArc = r1.HasArcSegment() == TRUE;
	if (!bHasArc)
	{
		for (long i = 0;i<r1.GetHoleNum();i++)
		{
			if (r1.GetHole(i).HasArcSegment())
			{
				bHasArc = true;
			}
		}
	}
	if (!bHasArc)
	{
		TGRegion2D *pPolygon = pNewRegion->MLinearize();
		if (pPolygon != NULL)
		{
			delete pNewRegion;
			pNewRegion = pPolygon;
		}
	}
	
	if (pNewRegion->IsValid())
	{
		return pNewRegion;
	}
	else
	{
		delete pNewRegion;
		return NULL;
	}
}

//GObject转换为对应AcDbEntity
AcDbEntity * TchSubExport::Obj2Entity(TGObject *pObj)
{
	if (pObj == NULL)
	{
		return NULL;
	}
	long i = 0;
	switch(pObj->GetClassID())
	{
	case CID_GPoint2D:
		{
			TGPoint2D* pPt = (TGPoint2D*)pObj;
			return new AcDbPoint(TchSubPrivate::GP3AP(*pPt));
		}
	case CID_GLineSeg2D:
		{
			TPGeGLineSeg2D *pSeg = (TPGeGLineSeg2D*)pObj;
			return new AcDbLine(GP3AP(pSeg->GetStartPoint()),GP3AP(pSeg->GetEndPoint()));
		}
	case CID_GCircle2D:
		{
			TPGeCircle2D *pCircle = (TPGeCircle2D*)pObj;
			return new AcDbCircle(GP3AP(pCircle->center), pCircle->IsClockwise() ? AcGeVector3d(0,0,-1) : AcGeVector3d(0,0,1),pCircle->r);
		}
	case CID_GArc2D:
		{
			TPGeArc2D *pArc = (TPGeArc2D*)pObj;
			if (pArc->IsClockwise())
			{
				return new AcDbArc(GP3AP(pArc->circle.center),pArc->circle.r,-pArc->GetEndAngle(),-pArc->startAngle);
			}
			else
			{
				return new AcDbArc(GP3AP(pArc->circle.center),pArc->circle.r,pArc->startAngle,pArc->GetEndAngle());
			}
		}
	case CID_GMLine2D:
		{
			TGMLine2D*pMLine = (TGMLine2D*)pObj;
			AcDbPolyline*pLine = new AcDbPolyline(pMLine->GetVertexNum());
			for (i = 0;i<pMLine->GetVertexNum();i++)
			{
				pLine->addVertexAt(i,TchSubPrivate::GP2AP((*pMLine)[i]));
			}
			pLine->setClosed(pMLine->IsClosed()?Adesk::kTrue:Adesk::kFalse);
			return pLine;
		}
	case CID_GPLine2D:
		{
			TGPLine2D*pPLine = (TGPLine2D*)pObj;
			AcDbPolyline*pLine = new AcDbPolyline(pPLine->GetVertexNum());
			for (i = 0;i<pPLine->GetVertexNum();i++)
			{
				pLine->addVertexAt(i,GP2AP((*pPLine)[i]),tan(((*pPLine)(i)/4)));
			}
			pLine->setClosed(pPLine->IsClosed()?Adesk::kTrue:Adesk::kFalse);
			return pLine;
		}
		break;
	case CID_GPolygon2D:
		{
			TGPolygon2D*pPoly = (TGPolygon2D*)pObj;
			TGMLine2D *pMLine = &(pPoly->Outline());
			AcDbPolyline*pLine = new AcDbPolyline(pMLine->GetVertexNum());
			
			for (i = 0;i<pMLine->GetVertexNum();i++)
			{
				pLine->addVertexAt(i,GP2AP((*pMLine)[i]));
			}
			
			pLine->setClosed(pMLine->IsClosed()?Adesk::kTrue:Adesk::kFalse);
			return pLine;
		}
		break;
	}
	return NULL;
}

void TchSubExport::PolyClip(const TDPtrList<TGGePoly2D> &ss,const TGGePoly2D& poly,TDPtrList<TGGePoly2D> &ssIn,TDPtrList<TGGePoly2D> &ssOut,TDPtrList<TGGePoly2D> &ssEdge)
{
	TGPLine2D polyClip;
	TchSubExport::TGGePoly2DToTGPLine2D(poly,polyClip);
	
	TGObjectList lstCurve,lstIn,lstEdge,lstOut;
	for (long i = 0;i<ss.Length();i++)
	{
		const TGGePoly2D& poly = ss[i];
		TGPLine2D *pNewPoly = new TGPLine2D;
		TchSubExport::TGGePoly2DToTGPLine2D(poly,*pNewPoly);
		lstCurve<<pNewPoly;
	}
	lstCurve.CutBy(polyClip,lstIn,lstOut,lstEdge);
	
	for (lstIn.MoveToFirst();!lstIn.IsOut();lstIn.MoveToNext())
	{
		TGMLine2D *pMLine = lstIn.GetCurCurve2D().PLinearize();
		TGGePoly2D *pNewPoly = new TGGePoly2D;
		ssIn.Append(pNewPoly);
		TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
		delete pMLine;
	}
	
	for (lstOut.MoveToFirst();!lstOut.IsOut();lstOut.MoveToNext())
	{
		TGMLine2D *pMLine = lstOut.GetCurCurve2D().PLinearize();
		TGGePoly2D *pNewPoly = new TGGePoly2D;
		ssOut.Append(pNewPoly);
		TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
		delete pMLine;
	}
	
	for (lstEdge.MoveToFirst();!lstEdge.IsOut();lstEdge.MoveToNext())
	{
		TGMLine2D *pMLine = lstEdge.GetCurCurve2D().PLinearize();
		TGGePoly2D *pNewPoly = new TGGePoly2D;
		ssEdge.Append(pNewPoly);
		TchSubExport::TGMLine2DToTGGePoly2D(*pMLine,*pNewPoly);
		delete pMLine;
	}
}

bool TchSubExport::PrepareFit(TSqTable2<TADSGePoint3d> &ptArray0,TPGeFitGraph&graphFit)
{
	long rowNum = ptArray0.GetLength(),colNum = ptArray0[0].GetLength();
	acedSetStatusBarProgressMeter(_T("曲线拟合"), 0, rowNum*2-1);
	
	//构造节点
	TSqTable2<TPGeDscPoint*> ptArray;
	ptArray.Realloc(rowNum,colNum,false);
	for (long i = 0;i<rowNum;i++)
	{
		for (long j = 0;j<colNum;j++)
		{
			TADSGePoint3d& pt = ptArray0[i][j];
			ptArray[i][j] = new TPGeDscPoint(pt.x,pt.y,pt.z);
			graphFit.AppendPoint(ptArray[i][j]);
		}
	}
	
	//构造边
	TSqTable2<TPGeDscEdge*> eArrayX(rowNum,colNum-1),eArrayY(rowNum-1,colNum),eArrayXY(rowNum-1,colNum-1);
	for (i = 0;i<rowNum;i++)
	{
		if (acedUsrBrk()) 
		{
			acedRestoreStatusBar();
			return false;
		}
		acedSetStatusBarProgressMeterPos(i);
		
		for (long j = 0;j<colNum;j++)
		{
			TPGeDscPoint*pPt = ptArray[i][j];
			
			if (j+1<colNum)
			{
				TPGeDscEdge*pEdge = new TPGeDscEdge(pPt,ptArray[i][j+1]);
				graphFit.AppendEdge(pEdge);
				eArrayX[i][j] = pEdge;
			}
			if (i+1<rowNum)
			{
				TPGeDscEdge*pEdge = new TPGeDscEdge(pPt,ptArray[i+1][j]);
				graphFit.AppendEdge(pEdge);
				eArrayY[i][j] = pEdge;
			}
			if (i+1<rowNum&&j+1<colNum)
			{
				TPGeDscEdge*pEdge = new TPGeDscEdge(pPt,ptArray[i+1][j+1]);
				graphFit.AppendEdge(pEdge);
				eArrayXY[i][j] = pEdge;
			}
		}
	}
	
	//构造三角形
	rowNum--;
	colNum--;
	for (i = 0;i<rowNum;i++)
	{
		if (acedUsrBrk()) 
		{
			acedRestoreStatusBar();
			return false;
		}
		acedSetStatusBarProgressMeterPos(i+rowNum);
		
		for (long j = 0;j<colNum;j++)
		{
			graphFit.AppendTriangle(eArrayX[i][j],eArrayY[i][j+1],eArrayXY[i][j]);
			graphFit.AppendTriangle(eArrayX[i+1][j],eArrayY[i][j],eArrayXY[i][j]);
		}
		eArrayX[i].Clear();
		eArrayY[i].Clear();
		eArrayXY[i].Clear();
	}
	acedRestoreStatusBar();
	return true;
}

//准备拟合
bool TchSubExport::PrepareFit(TADSGePoint3d ptMin,double nDist,int rowNum,int colNum,TSqTable2<float>& array,TPGeFitGraph&graphFit)

{
	//构造节点
	TSqTable2<TPGeDscPoint*> ptArray(rowNum,colNum);
	for (long i = 0;i<rowNum;i++)
	{
		for (long j = 0;j<colNum;j++)
		{
			TPGeDscPoint* pPt = new TPGeDscPoint(ptMin.x+j*nDist,ptMin.y+i*nDist,array[i][j]);
			graphFit.AppendPoint(pPt);
			ptArray[i][j] = pPt;
		}
		array[i].Clear();
	}
	array.Clear();
	
	acedSetStatusBarProgressMeter(_T("曲线拟合"), 0, rowNum*2-1);
	//构造边
	TSqTable2<TPGeDscEdge*> eArrayX(rowNum,colNum-1),eArrayY(rowNum-1,colNum),eArrayXY(rowNum-1,colNum-1);
	for (i = 0;i<rowNum;i++)
	{
		if (acedUsrBrk()) 
		{
			acedRestoreStatusBar();
			return false;
		}
		acedSetStatusBarProgressMeterPos(i);
		
		for (long j = 0;j<colNum;j++)
		{
			TPGeDscPoint*pPt = ptArray[i][j];
			
			if (j+1<colNum)
			{
				TPGeDscEdge*pEdge = new TPGeDscEdge(pPt,ptArray[i][j+1]);
				graphFit.AppendEdge(pEdge);
				eArrayX[i][j] = pEdge;
			}
			if (i+1<rowNum)
			{
				TPGeDscEdge*pEdge = new TPGeDscEdge(pPt,ptArray[i+1][j]);
				graphFit.AppendEdge(pEdge);
				eArrayY[i][j] = pEdge;
			}
			if (i+1<rowNum&&j+1<colNum)
			{
				TPGeDscEdge*pEdge = new TPGeDscEdge(pPt,ptArray[i+1][j+1]);
				graphFit.AppendEdge(pEdge);
				eArrayXY[i][j] = pEdge;
			}
		}
		ptArray[i].Clear();
	}
	ptArray.Clear();
	
	//构造三角形
	rowNum--;
	colNum--;
	for (i = 0;i<rowNum;i++)
	{
		if (acedUsrBrk()) 
		{
			acedRestoreStatusBar();
			return false;
		}
		acedSetStatusBarProgressMeterPos(i+rowNum);
		
		for (long j = 0;j<colNum;j++)
		{
			graphFit.AppendTriangle(eArrayX[i][j],eArrayY[i][j+1],eArrayXY[i][j]);
			graphFit.AppendTriangle(eArrayX[i+1][j],eArrayY[i][j],eArrayXY[i][j]);
		}
		eArrayX[i].Clear();
		eArrayY[i].Clear();
		eArrayXY[i].Clear();
	}
	acedRestoreStatusBar();
	return true;
}

bool TchSubExport::LB_Clip(const double &left,const double &top,const double &right,const double& bot,
						   const double &x1,const double &y1,const double &dx,const double &dy,
						   double &tMin,double &tMax)
{
	double tl = 0.0,tu = 1.0;
	if (TchSubPrivate::LB_IsOk(dx,left - x1,tl,tu))
	{
		if (TchSubPrivate::LB_IsOk(-dx,x1 - right,tl,tu))
		{
			if (TchSubPrivate::LB_IsOk(dy,bot - y1,tl,tu))
			{
				if (TchSubPrivate::LB_IsOk(-dy,y1 - top,tl,tu))
				{
					tMin = tl;
					tMax = tu;
					return true;
				}
			}
		}
	}
	
	return false;
}