//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TGRegion2D.cpp
// = Version	:   ver2.0
// = Author		:   xlc
// = CreateDate	:   2002-09-09
// = Description:   类的定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TGRegion2D.h"
#include "TPGeCurve2D.h"
#include "TGRegionEx2D.h"
#include "TGPolygonEx2D.h"
#include "TGPolygon2D.h"
#include "TPGeGraph.h"
#include "TPushMemVar.h"
#include "TProductid.h"

extern int g_nProductId;

IMPLEMENT_RUN_TIME_CLASS1(TGRegion2D,"TGRegion2D",TGObject2D)

TGRegion2D::~TGRegion2D()
{

}

bool TGRegion2D::IsValid() const
{	
	if (GetBoundaryNum()<1)
	{
		return false;
	}

	if (IsOutlineExist())
	{
		TPGeCurve2D&curve0 = Outline();
		if (!curve0.IsValid() || curve0.IsSelfCross() || 
			!(curve0.IsInfinite() || (curve0.IsClosed() && !curve0.IsClockwise())))
		{
			return false;
		}
	}

	if (!IsHoleExist())
	{
		return true;
	}

	TGObjectList holes;
	if (IsOutlineExist())
	{
		TGRegionEx2D face0(Outline(),false);
		for (long i = 0;i<GetHoleNum();i++)
		{
			if (GetBoundary(i+1) == NULL)
			{
				return false;
			}

			TPGeCurve2D& curve1 = Hole(i);
			if (!curve1.IsValid() || curve1.IsSelfCross() || 
				!(curve1.IsInfinite() || (curve1.IsClosed() && curve1.IsClockwise())))
			{
				return false;
			}

			TPGeCurve2D* pNewCurve = (TPGeCurve2D*)curve1.Clone();
			pNewCurve->Reverse();
			TGRegionEx2D *pHole = new TGRegionEx2D(pNewCurve,false);
			if (face0.IsInclude(*pHole))
			{
				holes.AddTail(pHole);
			}
			else
			{
				delete pHole;
				return false;
			}
		}
	}
	else
	{
		for (long i = 0;i<GetHoleNum();i++)
		{
			if (GetBoundary(i+1) == NULL)
			{
				return false;
			}

			TPGeCurve2D& curve1 = Hole(i);
			if (!curve1.IsValid() || curve1.IsSelfCross() || 
				!(curve1.IsInfinite() || (curve1.IsClosed() && curve1.IsClockwise())))
			{
				return false;
			}

			TPGeCurve2D* pNewCurve = (TPGeCurve2D*)curve1.Clone();
			pNewCurve->Reverse();
			holes << new TGRegionEx2D(pNewCurve,false);
		}
	}

	TGObjectList buf;
	while(holes.GetLength()>1)
	{
		TGRegion2D *pFirst = (TGRegion2D*)(holes.Fetch(0));
		buf << pFirst;
		for (holes.MoveToFirst();!holes.IsOut();holes.MoveToNext())
		{
			if (pFirst->Inter(holes.GetCurRegion2D(),buf))
			{
				return false;
			}
		}
	}
	return IsAllowBoundaryInter()?true:!IsBoundaryInter();
}

bool TGRegion2D::IsInclude(const TGObject&obj) const
{
	if (IS_CLASS(&obj,TGRegion2D))
	{
		TGObjectList left;
		((const TGRegion2D&)obj).SubtractBy(*this,left);
		return left.IsEmpty();
	}
	TGObjectList in,out;
	Clip(obj,in,out,in);
	return out.IsEmpty();
}

void TGRegion2D::SetElev(double elev)
{
	long num = GetBoundaryNum();
	for (long i = 0;i<num;i++)
	{
		TPGeCurve2D*pCurve = GetBoundary(i);
		if (pCurve != NULL)
		{
			pCurve->SetElev(elev);	
		}
	}
}

double TGRegion2D::GetElev() const
{
	long num = GetBoundaryNum();
	for (long i = 0;i<num;i++)
	{
		TPGeCurve2D*pCurve = GetBoundary(i);
		if (pCurve != NULL)
		{
			return pCurve->GetElev();
		}
	}
	return 0;
}

void TGRegion2D::TransformBy(const TGMatrix&matrix)
{
	long num = GetBoundaryNum();
	for (long i = 0;i<num;i++)
	{
		TPGeCurve2D* pCurve = GetBoundary(i);
		if (pCurve != NULL)
		{
			pCurve->TransformBy(matrix);
		}
	}
}

bool TGRegion2D::Offset(double offset)
{
	long num = GetBoundaryNum();
	for (long i = 0;i<num;i++)
	{
		TPGeCurve2D* pCurve = GetBoundary(i);
		if (pCurve != NULL && !pCurve->Offset(offset))
		{
			return false;
		}
	}
	return true;
}

bool TGRegion2D::IsBoundaryInter() const
{
	if (!IsHoleExist())
	{
		return false;
	}

	TDualPtrList<TPGeCurve2D*> curves;
	for (long i = 0;i<GetBoundaryNum();i++)
	{
		TPGeCurve2D* pCurve = GetBoundary(i);
		if (pCurve != NULL)
		{
			curves << GetBoundary(i);
		}
	}

	TGObjectList buf;
	while(curves.GetLength()>1)
	{
		curves.MoveToFirst();
		TPGeCurve2D *pCurve0 = curves.GetCurData();
		curves.DelCur();

		for (curves.MoveToFirst();!curves.IsOut();curves.MoveToNext())
		{
			if (pCurve0->Intersect(*curves.GetCurData(),buf))
			{
				return true;
			}
		}
	}
	return false;
}

GRelation TGRegion2D::HitTest(const TGPoint&pt) const
{
	if (IsOutlineExist())
	{
		GRelation r = Outline().HitTest(pt);
		if (r.Is(GR_OUTSIDE))
		{
			return GR_OUT;
		}
		else if (r.Is(GR_IN))
		{
			return GR_IN|GR_EDGE;
		}
	}

	for (long i = 0;i<GetHoleNum();i++)
	{
		GRelation r = Hole(i).HitTest(pt);
		if (r.Is(GR_INSIDE))
		{
			return GR_OUT|GR_HOLE;
		}
		else if (r.Is(GR_IN))
		{
			return GR_IN|GR_EDGE|GR_HOLE;
		}
	}
	return GR_IN;	
}

void TGRegion2D::Clip(const TGObject &obj,TGObjectList&inList,TGObjectList&outList,TGObjectList&midList) const
{
	TGObjectList in;
	if (IsOutlineExist())
	{
		// modify by xlc on 110610 区分日照，影响速度
		if (g_nProductId == kTSUN)
		{
			Outline().Cut(obj,in,outList,midList);
		}
		else
		{
			struct resbuf rb;
			acedGetVar(_T("CMDNAMES"),&rb);
			CString sCmd = rb.resval.rstring;
			acutDelString(rb.resval.rstring);
			sCmd.MakeUpper();
			if (sCmd.Find(_T("TUPDSPACE")) >= 0)	//modify by xlc on 110117 搜索房间时不改变精度(搜索房间时不考虑柱子)
			{
				Outline().Cut(obj,in,outList,midList);
			}
			else
			{
				//add by xlc on 100906 解决部分加粗不显示的问题
				TPushMemVar<double> vPrec(g_distZero,1.0e-6);
				Outline().Cut(obj,in,outList,midList);
			}
		}

		if (in.IsEmpty())
		{
			return;
		}
	}
	else
	{
		in << obj.Clone();
	}

	for (long i = 0;i<GetHoleNum();i++)
	{
		TGObjectList in1;
		in1.Conbine(in);
		in1.CutBy(Hole(i),outList,in,midList);
	}

	inList.Conbine(in);
}

bool TGRegion2D::Intersect(const TGObject&obj,TGObjectList&res) const
{
	if (IS_CLASS(&obj,TGRegion2D))
	{
		return Inter((const TGRegion2D&)obj,res);
	}

	TGObjectList out,in;
	Clip(obj,in,out,in);
	if (in.IsEmpty())
	{
		return false;
	}
	else
	{
		res.Conbine(in);
		return true;
	}
}

bool TGRegion2D::GetExtend2D(TPGeExtend2D&ext) const
{
	if (IsOutlineExist())
	{
		return Outline().GetExtend2D(ext);
	}
	else
	{
		return false;
	}
}

void TGRegion2D::SubtractBy(const TGObjectList&faces,TGObjectList&res) const
{
	TGObject*const*pCur = faces.GetFirst();
	if (pCur == NULL)
	{
		res << Clone();
		return;
	}

	const TGRegion2D& face = (const TGRegion2D&)(**pCur);
	TGObjectList buf;
	SubtractBy(face,buf);
	if (buf.IsEmpty())
	{
		return;
	}

	for (pCur = faces.GetNext(pCur);pCur != NULL;pCur = faces.GetNext(pCur))
	{
		TGObjectList buf1;
		const TGRegion2D&face = (const TGRegion2D&)(**pCur);
		for (buf.MoveToFirst();!buf.IsOut();buf.MoveToNext())
		{
			buf.GetCurRegion2D().SubtractBy(face,buf1);
		}

		if (buf1.IsEmpty())
		{
			return;
		}
		buf.Clear();
		buf.Conbine(buf1);
	}
	res.Conbine(buf);
}

void TGRegion2D::Normalize()
{
	if (IsClosed() && Outline().IsClockwise())
	{
		Outline().Reverse();
	}

	for (long i = 1;i<GetBoundaryNum();i++)
	{
		TPGeCurve2D* pCurve = GetBoundary(i);
		if (pCurve != NULL && pCurve->IsClosed() && !pCurve->IsClockwise())
		{
			pCurve->Reverse();
		}
	}
}

double TGRegion2D::Area() const
{
	if (!IsClosed())
	{
		return 0;
	}

	double A = Outline().Area();

	for (long i = 0;i<GetHoleNum();i++)
	{
		A -= Hole(i).Area();
	}
	return A;
}

TGPolygon2D* TGRegion2D::MLinearize(double paDist) const
{
	if (!IsClosed())
	{
		return NULL;
	}

	if (IsHoleExist())
	{
		TGMLine2D* pMLine = Outline().MLinearize(paDist);	
		TGPolygonEx2D *pFace = new TGPolygonEx2D(*pMLine,false);
		delete pMLine;

		for (long i = 0;i<GetHoleNum();i++)
		{
			pFace->AppendHole(Hole(i).MLinearize(paDist),false);
		}
		return pFace;
	}
	else
	{
		TGMLine2D* pMLine = Outline().MLinearize(paDist);	
		TGPolygon2D *pFace = new TGPolygon2D(*pMLine,false);
		delete pMLine;
		return pFace;
	}
}

bool TGRegion2D::Explode(TGObjectList&res) const
{
	TGPolygon2D* pPoly = MLinearize();
	if (pPoly == NULL)
	{
		return false;
	}
	res << pPoly;
	return true;
}

bool TGRegion2D::Inter(const TGRegion2D&face,TGObjectList&res) const
{
	if (!IsMayBoundaryInter() && !face.IsMayBoundaryInter())
	{
		if (!IsOutlineExist())
		{
			res << face.Clone();
			return true;
		}
		else if (!face.IsOutlineExist())
		{
			res << Clone();
			return true;
		}
		else
		{
			TGObjectList aInB,aOutB,aOnB,bInA,bOutA,bOnA;
			for (long i = 0;i<GetBoundaryNum();i++)
			{
				face.Clip(*GetBoundary(i),aInB,aOutB,aOnB);
			}
			for (i = 0;i<face.GetBoundaryNum();i++)
			{
				Clip(*face.GetBoundary(i),bInA,bOutA,bOnA);
			}

			if (bOutA.IsEmpty() && aInB.IsEmpty())
			{
				res << face.Clone();
				return true;
			}
			else if (aOutB.IsEmpty() && bInA.IsEmpty())
			{
				res << Clone();
				return true;
			}
			else if (aInB.IsEmpty() || bInA.IsEmpty())
			{
				return false;
			}
			else
			{
				TGObjectList list,buf;
				list.Conbine(aInB);
				list.Conbine(bInA);
				list.Conbine(aOnB);

				if (Outline().IsClosed() && face.Outline().IsClosed())
				{
					CreateRegion2D(list,res,IsHoleExist() || face.IsHoleExist());
				}
				else
				{
					CreateRegion2DEx(list,res,IsHoleExist() || face.IsHoleExist());
				}
				return true;
			}
		}
	}
	else if (IsHoleExist())
	{
		TGObjectList buf;
		if (IsOutlineExist())
		{
			if (!TGRegionEx2D(Outline(),false).Inter(face,buf))
			{
				return false;
			}
		}
		else
		{
			buf.AddTail(face.Clone());
		}

		TGObjectList holes;
		for (long i = 0;i<GetHoleNum();i++)
		{
			holes << new TGRegionEx2D(Hole(i),false);
			holes.GetCurRegion2D().Outline().Reverse();
		}

		TGObjectList buf1;
		for (buf.MoveToFirst();!buf.IsOut();buf.MoveToNext())
		{
			buf.GetCurRegion2D().SubtractBy(holes,buf1);
		}

		if (buf1.IsEmpty())
		{
			return false;
		}
		else
		{
			res.Conbine(buf1);
			return true;
		}
	}
	else
	{
		return face.Inter(*this,res);
	}
}

void TGRegion2D::SubtractBy(const TGRegion2D&face,TGObjectList&res) const
{
	if (!IsMayBoundaryInter() && !face.IsMayBoundaryInter())
	{
		if (!IsOutlineExist())
		{
			if (face.IsOutlineExist())
			{
				TGRegionEx2D *pFace = new TGRegionEx2D;
				TPGeCurve2D *pCurve = (TPGeCurve2D*)(face.Outline().Clone());
				pCurve->Reverse();
				pFace->AppendHole(pCurve,false);
				res << pFace;
			}
			for (long i = 0;i<face.GetHoleNum();i++)
			{
				TPGeCurve2D *pCurve = (TPGeCurve2D*)(face.Hole(i).Clone());
				pCurve->Reverse();
				res << new TGRegionEx2D(pCurve,false);
			}
		}
		else if (!face.IsOutlineExist())
		{
			return;
		}
		else
		{
			TGObjectList aInB,aOutB,aOnB,bInA,bOutA,bOnA;
			for (long i = 0;i<GetBoundaryNum();i++)
			{
				face.Clip(*GetBoundary(i),aInB,aOutB,aOnB);
			}
			for (i = 0;i<face.GetBoundaryNum();i++)
			{
				Clip(*face.GetBoundary(i),bInA,bOutA,bOnA);
			}

			if (aOutB.IsEmpty() && bInA.IsEmpty())
			{
				return;
			}
			else if (bOutA.IsEmpty() && aInB.IsEmpty())
			{
				TGObjectList list;
				bInA.ReverseCurve2D();
				list.Conbine(bInA);
				list.Conbine(aOutB);
				list.Conbine(aOnB);
				if (Outline().IsClosed() && face.Outline().IsClosed())
				{
					CreateRegion2D(list,res,true);
				}
				else
				{
					CreateRegion2DEx(list,res,true);
				}
			}
			else if (aInB.IsEmpty() || bInA.IsEmpty())
			{
				res << Clone();
			}
			else
			{
				TGObjectList list;
				bInA.ReverseCurve2D();
				list.Conbine(bInA);
				list.Conbine(aOutB);
				list.Conbine(aOnB);
				if (Outline().IsClosed() && face.Outline().IsClosed())
				{
					CreateRegion2D(list,res,IsHoleExist() || face.IsHoleExist());
				}
				else
				{
					CreateRegion2DEx(list,res,IsHoleExist() || face.IsHoleExist());
				}
			}
		}
	}
	else if (face.IsHoleExist())
	{
		if (face.IsOutlineExist())
		{
			SubtractBy(TGRegionEx2D(face.Outline(),false),res);
		}

		for (long i = 0;i<face.GetHoleNum();i++)
		{
			TGRegionEx2D hFace(face.Hole(i),false);
			hFace.Outline().Reverse();
			Inter(hFace,res);
		}
	}
	else
	{
		TGObjectList buf;
		TGRegionEx2D region0;
		if (IsOutlineExist())
		{
			region0.SetOutline((TPGeCurve2D*)Outline().Clone(),false);
		}
		region0.SubtractBy(face,buf);
		if (buf.IsEmpty())
		{
			return;
		}

		TGObjectList holes;
		for (long i = 0;i<GetHoleNum();i++)
		{
			holes << new TGRegionEx2D(Hole(i),false);
			holes.GetCurRegion2D().Outline().Reverse();
		}

		buf.MoveToFirst();
		if (buf.GetCurRegion2D().IsHoleExist())
		{
			holes.Union(face);

			TGRegionEx2D *pRes = new TGRegionEx2D(Outline(),false);
			for (holes.MoveToFirst();!holes.IsOut();holes.MoveToNext())
			{
				TPGeCurve2D* pCurve = (TPGeCurve2D*)(holes.GetCurRegion2D().Outline().Clone());
				pCurve->Reverse();
				pRes->AppendHole(pCurve,false);
			}
			res << pRes;
		}
		else
		{
			for (buf.MoveToFirst();!buf.IsOut();buf.MoveToNext())
			{
				buf.GetCurRegion2D().SubtractBy(holes,res);
			}
		}
	}
}

TGRegion2D* TGRegion2D::Union(const TGRegion2D&face) const
{
	if (!IsMayBoundaryInter() && !face.IsMayBoundaryInter())
	{
		if (!IsOutlineExist())
		{
			return (TGRegion2D*)Clone();
		}
		else if (!face.IsOutlineExist())
		{
			return (TGRegion2D*)face.Clone();
		}
		else
		{
			TGObjectList aInB,aOutB,aOnB,bInA,bOutA,bOnA;
			for (long i = 0;i<GetBoundaryNum();i++)
			{
				face.Clip(*GetBoundary(i),aInB,aOutB,aOnB);
			}
			for (i = 0;i<face.GetBoundaryNum();i++)
			{
				Clip(*face.GetBoundary(i),bInA,bOutA,bOnA);
			}

			if (bOutA.IsEmpty() && aInB.IsEmpty())
			{
				return (TGRegion2D*)Clone();
			}
			else if (aOutB.IsEmpty() && bInA.IsEmpty())
			{
				return (TGRegion2D*)face.Clone();
			}
			else if (aInB.IsEmpty() || bInA.IsEmpty())
			{
				if (aOnB.IsEmpty())
				{
					return NULL;
				}
				else
				{
					TGObjectList list,res;
					list.Conbine(aOutB);
					list.Conbine(bOutA);
					if (Outline().IsClosed() && face.Outline().IsClosed())
					{
						CreateRegion2D(list,res,true);
					}
					else
					{
						CreateRegion2DEx(list,res,true);
					}
					return (TGRegion2D*)res.Fetch(0);
				}
			}
			else
			{
				TGObjectList list,res;
				list.Conbine(aOutB);
				list.Conbine(bOutA);
				list.Conbine(aOnB);
				if (Outline().IsClosed() && face.Outline().IsClosed())
				{
					CreateRegion2D(list,res,true);
				}
				else
				{
					CreateRegion2DEx(list,res,true);
				}
				return (TGRegion2D*)res.Fetch(0);
			}
		}
	}
	else if (IsHoleExist())
	{
		TGRegion2D *pU0;
		if (IsOutlineExist())
		{
			pU0 = TGRegionEx2D(Outline(),false).Union(face);
			if (pU0 == NULL)
			{
				return NULL;
			}
		}
		else
		{
			pU0 = new TGRegionEx2D;
		}

		TGObjectList holes;
		for (long i = 0;i<GetHoleNum();i++)
		{	
			TGRegionEx2D hFace(Hole(i),false);
			hFace.Outline().Reverse();
			hFace.SubtractBy(face,holes);
		}

		if (holes.IsEmpty())
		{
			return pU0;
		}
		else
		{
			TGRegionEx2D*pU1;
			if (IS_TYPE(pU0,TGRegionEx2D))
			{
				pU1 = (TGRegionEx2D*)pU0;
			}
			else
			{
				pU1 = new TGRegionEx2D(*pU0);
				delete pU0;
			}

			for (holes.MoveToFirst();!holes.IsOut();holes.MoveToNext())
			{
				TGRegion2D&hHole = holes.GetCurRegion2D();
				if (hHole.IsHoleExist())
				{
					delete pU1;
					return NULL;
				}

				TPGeCurve2D*pCurve = (TPGeCurve2D*)hHole.Outline().Clone();
				pCurve->Reverse();
				pU1->AppendHole(pCurve,false);
			}
			return pU1;
		}
	}
	else
	{
		return face.Union(*this);
	}
}

void TGRegion2D::CutBy(const TPGeCurve2D&curve,TGObjectList&left,TGObjectList&right) const
{
	if (IsMayBoundaryInter())
	{
		TGObjectList lBuf,rBuf;
		TGRegionEx2D region0;
		if (IsOutlineExist())
		{
			region0.SetOutline((TPGeCurve2D*)Outline().Clone(),false);
		}
		region0.CutBy(curve,lBuf,rBuf);
		if (lBuf.IsEmpty())
		{
			right << Clone();
		}
		else if (rBuf.IsEmpty())
		{
			left << Clone();
		}
		else
		{
			TGObjectList lHole,rHole;
			for (long i = 0;i<GetHoleNum();i++)
			{
				TGRegionEx2D hFace(Hole(i),false);
				hFace.Outline().Reverse();
				hFace.CutBy(curve,lHole,rHole);
			}

			for (lBuf.MoveToFirst();!lBuf.IsOut();lBuf.MoveToNext())
			{
				lBuf.GetCurRegion2D().SubtractBy(lHole,left);
			}
			for (rBuf.MoveToFirst();!rBuf.IsOut();rBuf.MoveToNext())
			{
				rBuf.GetCurRegion2D().SubtractBy(rHole,right);
			}
		}			
	}
	else if (!IsOutlineExist())
	{
		TGRegionEx2D *pLeft = new TGRegionEx2D(curve,false);
		left << pLeft;
		TPGeCurve2D *pCurve = (TPGeCurve2D*)curve.Clone();
		pCurve->Reverse();
		TGRegionEx2D *pRight = new TGRegionEx2D(pCurve,false);
		right << pRight;
	}
	else
	{
		TGObjectList aInB,aOutB,aOnB,bInA,bOutA,bOnA;
		for (long i = 0;i<GetBoundaryNum();i++)
		{
			curve.Cut(*GetBoundary(i),bInA,bOutA,bOnA);
		}
		Clip(curve,aInB,aOutB,aOnB);

		if (bOutA.IsEmpty() && aInB.IsEmpty())
		{
			left << Clone();
		}
		else if (curve.IsClosed() && aOutB.IsEmpty() && bInA.IsEmpty())
		{
			bool bClockwise = curve.IsClockwise();
			TPGeCurve2D*pNewCurve = (TPGeCurve2D*)curve.Clone();
			if (bClockwise)
			{
				pNewCurve->Reverse();
			}
			left << new TGRegionEx2D(pNewCurve,false);
			TGObjectList rList;
			if (!bClockwise)
			{
				aInB.ReverseCurve2D();
			}

			rList.Conbine(aInB);
			rList.Conbine(bOutA);
			rList.Conbine(bOnA);
			if (Outline().IsClosed())
			{
				CreateRegion2D(rList,right,true);
			}
			else
			{
				CreateRegion2DEx(rList,right,true);
			}
		}
		else if (aInB.IsEmpty() || bInA.IsEmpty())
		{
			right << Clone();
		}
		else
		{
			bool bFinite = Outline().IsClosed();

			TGObjectList lList,temp(aInB);
			bool bClockwise = curve.IsClosed() && curve.IsClockwise();
			if (bClockwise)
			{
				temp.ReverseCurve2D();
				aOnB.ReverseCurve2D();
			}
			lList.Conbine(temp);
			lList.Conbine(bInA);
			lList.Conbine(aOnB);
			if (bFinite)
			{
				CreateRegion2D(lList,left,IsHoleExist());
			}
			else
			{
				CreateRegion2DEx(lList,left,IsHoleExist());
			}
			TGObjectList rList;
			if (!bClockwise)
			{
				aInB.ReverseCurve2D();
			}
			rList.Conbine(aInB);
			rList.Conbine(bOutA);
			rList.Conbine(bOnA);
			if (bFinite)
			{
				CreateRegion2D(rList,right,IsHoleExist());
			}
			else
			{
				CreateRegion2DEx(rList,right,IsHoleExist());
			}
		}
	}
}

TPGeCurve2D* TGRegion2D::GetBoundary(long i) const
{
	return NULL;
}

long TGRegion2D::GetBoundaryNum() const
{
	return 1;
}

bool TGRegion2D::IsOutlineExist() const
{
	return GetBoundary(0) != NULL;
}

TPGeCurve2D& TGRegion2D::Outline() const
{
	return *GetBoundary(0);
}

long TGRegion2D::GetHoleNum() const
{
	return GetBoundaryNum()-1;
}

bool TGRegion2D::IsHoleExist() const
{
	return GetBoundaryNum()>1;
}

TPGeCurve2D& TGRegion2D::Hole(long i) const
{
	return *GetBoundary(i+1);
}

bool TGRegion2D::IsClosed() const
{
	return IsOutlineExist() && Outline().IsClosed();
}

bool TGRegion2D::IsAllowBoundaryInter() const
{
	return IsNot(NO_BOUNDARY_INTER);
}

bool TGRegion2D::IsMayBoundaryInter() const
{
	return IsHoleExist() && (IsAllowBoundaryInter() || !IsClosed());
}

bool TGRegion2D::IsEntirePlane() const
{
	return !IsHoleExist() && !IsOutlineExist();
}


void TGRegion2D::CreateRegion2D(TGObjectList &curves,TGObjectList &res,bool bCheckHole)const
{
	TGObjectList closeCurves;
	for (curves.MoveToFirst(); !curves.IsOut(); curves.MoveToNext())
	{
		TPGeCurve2D* pCurve = (TPGeCurve2D*)curves.GetCurData();
		if (pCurve->IsClosed())
		{
			closeCurves << curves.FetchCur();
		}
		else if (!pCurve->IsCurveSeg())
		{
			curves.DelCur();
		}
	}

	TPGeGraph g;
	g.AppendEdge(curves);
	g.FindCurve(closeCurves,closeCurves);

	if (closeCurves.GetLength() == 1 || !bCheckHole)
	{
		for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
		{
			res << new TGRegionEx2D((TPGeCurve2D*)closeCurves.FetchCur(),false);
		}
	}
	else 
	{
		TList<TGRegionEx2D*> face;
		for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
		{
			TPGeCurve2D* pCurve = (TPGeCurve2D*)closeCurves.GetCurData();
			if (!pCurve->IsClockwise())
			{
				closeCurves.FetchCur();
		
				TGRegionEx2D* pFace = new TGRegionEx2D(pCurve,false);
				face << pFace;
				res << pFace;
			}
		}

		if (face.GetLength() == 1)
		{
			TGRegionEx2D *pFace = face.GetAt(0);
			for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
			{
				pFace->AppendHole((TPGeCurve2D*)closeCurves.FetchCur(),false);
			}
		}
		else
		{
			for (face.MoveToFirst(); !face.IsOut(); face.MoveToNext())
			{
				TGRegionEx2D *pFace = face.GetCurData();
				TPGeCurve2D&outline = pFace->Outline();
				
				for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
				{
					GRelation r = outline.HitTest(closeCurves.GetCurPData().GetSamplePoint());
					if (r.Is(GR_INSIDE))
					{
						pFace->AppendHole((TPGeCurve2D*)closeCurves.FetchCur(),false);
					}
				}
			}
		}
	}
}

void TGRegion2D::CreateRegion2DEx(TGObjectList &curves,TGObjectList &res,bool bCheckHole)const
{
	TGObjectList closeCurves,infiniteCurves;
	for (curves.MoveToFirst(); !curves.IsOut(); curves.MoveToNext())
	{
		TPGeCurve2D* pCurve = (TPGeCurve2D*)curves.GetCurData();
		if (pCurve->IsClosed())
		{
			closeCurves << curves.FetchCur();
		}
		else if (!pCurve->IsFinite(true) && !pCurve->IsFinite(false))
		{
			infiniteCurves << curves.FetchCur();
		}
	}

	TPGeGraph g;
	g.AppendEdge(curves);
	g.FindCurve(closeCurves,infiniteCurves);

	TList<TGRegionEx2D*> face;
	if (infiniteCurves.GetLength() == 2)
	{
		TPGeCurve2D *pCurve0 = (TPGeCurve2D*)infiniteCurves.Fetch(0);
		TPGeCurve2D *pCurve1 = (TPGeCurve2D*)infiniteCurves.Fetch(0);
		
		if (pCurve0->HitTest(pCurve1->GetSamplePoint()).Is(GR_RIGHT)
			&& pCurve1->HitTest(pCurve0->GetSamplePoint()).Is(GR_RIGHT))
		{
			TGRegionEx2D* pRegion0 = new TGRegionEx2D(pCurve0,false);
			TGRegionEx2D* pRegion1 = new TGRegionEx2D(pCurve1,false);
			
			res << pRegion0 << pRegion1;
			face << pRegion0 << pRegion1;
		}
		else
		{
			TGRegionEx2D *pRegion = new TGRegionEx2D(pCurve0,false);
			pRegion->AppendHole(pCurve1,false);
			res << pRegion;
			face << pRegion;
		}
	}
	else if (infiniteCurves.GetLength() == 1)
	{
		TGRegionEx2D *pRegion = new TGRegionEx2D((TPGeCurve2D*)infiniteCurves.Fetch(0),false);
		res << pRegion;
		face << pRegion;
	}

	if (!bCheckHole)
	{
		for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
		{
			res << new TGRegionEx2D((TPGeCurve2D*)closeCurves.FetchCur(),false);
		}
	}
	else 
	{
		for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
		{
			TPGeCurve2D* pCurve = (TPGeCurve2D*)closeCurves.GetCurData();
			if (!pCurve->IsClockwise())
			{
				closeCurves.FetchCur();

				TGRegionEx2D* pRegion = new TGRegionEx2D(pCurve,false);
				face << pRegion;
				res << pRegion;
			}
		}

		if (face.IsEmpty() && !closeCurves.IsEmpty())
		{
			TGRegionEx2D *pRegion = new TGRegionEx2D;
			face << pRegion;
			res << pRegion;
		}

		if (face.GetLength() == 1)
		{
			TGRegionEx2D *pFace = face.GetAt(0);
			for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
			{
				pFace->AppendHole((TPGeCurve2D*)closeCurves.FetchCur(),false);
			}
		}
		else
		{
			for (face.MoveToFirst(); !face.IsOut(); face.MoveToNext())
			{
				TGRegionEx2D *pFace = face.GetCurData();
				TPGeCurve2D&outline = pFace->Outline();
			
				for (closeCurves.MoveToFirst(); !closeCurves.IsOut(); closeCurves.MoveToNext())
				{
					GRelation r = outline.HitTest(closeCurves.GetCurPData().GetSamplePoint());
					if (r.Is(GR_INSIDE))
					{
						pFace->AppendHole((TPGeCurve2D*)closeCurves.FetchCur(),false);
					}
				}
			}
		}
	}
}