//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TGPLine2D 类
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TGPLine2D 定义
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TGPLine2D.h"
#include "TGPa.h"
#include "TPDList.h"
#include "TGPoint2D.h"
#include "TSPTable.h"

IMPLEMENT_RUN_TIME_CLASS1(TGPLine2D,"TGPLine2D",TGMLine2D)

bool TGPLine2D::IsValid() const
{
	if (!TGMLine2D::IsValid())
	{
		return false;
	}
	for (long i=0;i<bulges.GetLength();i++)
	{
		if (UPEQUAL_ZEROA(bulges.GetAt(i)-PI2) || DOWNEQUAL_ZEROA(bulges.GetAt(i)+PI2))
		{
			return false;
		}
	}
	return true;
}

TGPLine2D::TGPLine2D(long vertexNum,bool bClosed):TGMLine2D(vertexNum,bClosed)
{
	bulges.Realloc(vertexNum);
	bulges.SetAll(0);
}

TGPLine2D::TGPLine2D(const TArray<TGPoint>&vertexs,bool bClosed):TGMLine2D(vertexs,bClosed)
{
	bulges.Realloc(vertexs.GetLength());
	bulges.SetAll(0);
}

TGPLine2D::TGPLine2D(const TTable<TGPoint>&vertexs,bool bClosed):TGMLine2D(vertexs,bClosed)
{
	bulges.Realloc(vertexs.GetLength());
	bulges.SetAll(0);
}

TGPLine2D::TGPLine2D(const TArray<TGPoint>&vertexs,const TArray<double>&angles,bool bClosed):TGMLine2D(vertexs,bClosed),
																						bulges(angles)
{
}

TGPLine2D::TGPLine2D(const TTable<TGPoint>&vertexs,const TTable<double>&angles,bool bClosed):TGMLine2D(vertexs,bClosed),
																						bulges(angles)
{
}

TGPLine2D::TGPLine2D(const TGMLine2D&mLine):TGMLine2D(mLine)
{
	bulges.Realloc(mLine.GetVertexNum());
	bulges.SetAll(0);
}

TGPLine2D::TGPLine2D(const TPGeCircle2D&cir):TGMLine2D(2,true)
{
	bulges.Realloc(2);
	cir.Pa2Pt(0,(*this)[0]);
	cir.Pa2Pt(PI,(*this)[1]);
	if (cir.IsClockwise())
	{
		(*this)(0) = -PI;
		(*this)(1) = -PI;
	}
	else
	{
		(*this)(0) = PI;
		(*this)(1) = PI;
	}
}

TGPLine2D::TGPLine2D(const TPGeArc2D&arc):TGMLine2D(2,false)
{
	bulges.Realloc(2);
	(*this)[0] = arc.GetStartPoint();
	(*this)[1] = arc.GetEndPoint();
	(*this)(0) = arc.IsClockwise()?-arc.centralAngle:arc.centralAngle;
	(*this)(1) = 0;
}

TGPLine2D::~TGPLine2D()
{
	
}

double&  TGPLine2D::operator ()(long i)
{
	return bulges[i];
}

TGMLine2D* TGPLine2D::PLinearize(double paDist) const
{
	return new TGPLine2D(*this);
}

TGObject * TGPLine2D::Clone() const
{
	return new TGPLine2D(*this);
}

double TGPLine2D::GetBulge(long i) const
{
	return bulges.GetAt(i);
}

bool TGPLine2D::IsArc(long i) const
{
	return !EQUAL_ZEROA(bulges.GetAt(i));
}

void TGPLine2D::GetSegment(long i,TPGeLine2D& seg) const
{
	TGMLine2D::GetSegment(i,seg);
}

bool TGPLine2D::IsArcExist() const
{
	long num = GetSegNum();
	for (long i = 0;i<num;i++)
	{
		if (IsArc(i))
		{
			return true;
		}
	}
	return false;
}

void TGPLine2D::SetVertexNum(long num,bool bCopy)
{
	points.Realloc(num,bCopy);
	if (bCopy)
	{
		long oldNum = bulges.GetLength();
		bulges.Realloc(num,true);
		for (long i = oldNum;i<num;i++)
		{
			bulges[i] = 0;
		}
	}
	else
	{
		bulges.Realloc(num,false);
		bulges.SetAll(0);
	}
}

bool TGPLine2D::RemoveDupPoint()
{
	if (points.GetLength() < 2)
	{
		return false;
	}

	TList<TGPoint> ptList;
	TList<double> aList;
	ptList.AddTail(points.GetAt(0));
	for (long i = 1;i<points.GetLength();i++)
	{
		if (ptList.GetCurData() != points.GetAt(i))
		{
			ptList.AddTail(points.GetAt(i));
			aList.AddTail(bulges.GetAt(i-1));
		}
	}

	aList.AddTail(bulges.GetAt(bulges.GetLastIndex()));
	if (Is(CLOSED_CURVE) && ptList.GetLength()>1 && points.GetAt(0) == ptList.GetCurData())
	{
		ptList.DelCur();
		aList.DelCur();
	}
	if (ptList.GetLength() < 2)
	{
		return false;
	}
	if (ptList.GetLength()<points.GetLength())
	{
		points = ptList;
		bulges = aList;
	}
	return true;	
}

bool TGPLine2D::IsSelfCross() const
{
	long num = GetSegNum();
	if (num < 2)
	{
		return false;
	}
	
	bool bClosed = IsClosed();
	long num1 = num-1;;
	for (long i = 0;i<num1;i++)
	{
		TGObjectList buf;
		TPGeCurve2D *pSegi = GetSegment(i);
		buf << pSegi;
		for (long j = i+1;j<num;j++)
		{
			TPGeCurve2D *pSegj = GetSegment(j);
			buf << pSegj;

			TGObjectList oList;
			if (pSegi->Intersect(*pSegj,oList))
			{
				if (oList[0]->GetClassID() != CID_GPoint2D)
				{
					return true;
				}
				else if (oList.GetLength() == 2)
				{
					if (!(num == 2 && bClosed))
					{
						return true;
					}
				}
				else
				{
					if (j != i+1 && (i != 0 || j != num1 || !bClosed))
					{
						return true;
					}
				}
			}
		}
	}
	return false;
}

void TGPLine2D::Pa2Pt(double pa,TGPoint&pt) const
{
	if (EQUAL_ZERO(pa))
	{
		GetStartPoint(pt);
	}
	else if (EQUAL_ZERO(pa-1))
	{
		GetEndPoint(pt);
	}
	else
	{
		long i = Pa2Seg(pa);
		TPGeCurve2D* pSeg = GetSegment(i);
		pSeg->Pa2Pt(pa,pt);
		delete pSeg;
	}
}

TPGeCurve2D* TGPLine2D::GetSubCurve(double pa0,double pa1) const
{
	TList<TGPoint> ptList;
	TList<double> paList;
	TGPoint pt;
	if (IsClosed())
	{
		if (EQUAL_ZERO(pa0-1))
		{
			pa0 = 0;
		}
		if (EQUAL_ZERO(pa1-1))
		{
			pa1 = 0;
		}
	}
	if (UP_ZERO(pa1-pa0))
	{
		long iSeg0 = Pa2Seg(pa0),iSeg1 = Pa2Seg(pa1);
		TPGeCurve2D *pSeg0 = GetSegment(iSeg0),*pSeg1 = GetSegment(iSeg1);

		if (DOWN_ZERO(pa0-1))
		{
			pSeg0->Pa2Pt(pa0,pt);
			ptList.AddTail(pt);
			if (iSeg0  == iSeg1)
			{
				paList.AddTail(GetBulge(iSeg0)*(pa1-pa0));
			}
			else
			{
				paList.AddTail(GetBulge(iSeg0)*(1-pa0));
			}
		}

		for (long i = iSeg0+1;i<iSeg1;i++)
		{
			ptList.AddTail(GetVertex(i));
			paList.AddTail(GetBulge(i));
		}
		if (iSeg0 != iSeg1)
		{
			ptList.AddTail(GetVertex(iSeg1));
			paList.AddTail(GetBulge(iSeg1)*pa1);
		}

		if (UP_ZERO(pa1))
		{
			pSeg1->Pa2Pt(pa1,pt);
			ptList.AddTail(pt);
			paList.AddTail(0);
		}
		delete pSeg0;
		delete pSeg1;
		return new TGPLine2D(ptList,paList,false);
	}
	else if (DOWN_ZERO(pa1-pa0))
	{
		long iSeg0 = Pa2Seg(pa0),iSeg1 = Pa2Seg(pa1);
		TPGeCurve2D *pSeg0 = GetSegment(iSeg0),*pSeg1 = GetSegment(iSeg1);

		if (DOWN_ZERO(pa0-1))
		{
			
			pSeg0->Pa2Pt(pa0,pt);
			ptList.AddTail(pt);
			paList.AddTail(GetBulge(iSeg0)*(1-pa0));
		}

		for (long i = iSeg0+1;i<GetVertexNum();i++)
		{
			ptList.AddTail(GetVertex(i));
			paList.AddTail(GetBulge(i));
		}

		for (i = 0;i<iSeg1;i++)
		{
			ptList.AddTail(GetVertex(i));
			paList.AddTail(GetBulge(i));
		}
		ptList.AddTail(GetVertex(iSeg1));
		paList.AddTail(GetBulge(iSeg1)*pa1);

		if (UP_ZERO(pa1))
		{
			pSeg1->Pa2Pt(pa1,pt);
			ptList.AddTail(pt);
			paList.AddTail(0);
		}
		delete pSeg0;
		delete pSeg1;
		return new TGPLine2D(ptList,paList,false);
	}
	else
	{
		long iSeg = Pa2Seg(pa0);
		TPGeCurve2D* pSeg = GetSegment(iSeg);
		if (DOWN_ZERO(pa0-1))
		{
			pSeg->Pa2Pt(pa0,pt);
			ptList.AddTail(pt);
			paList.AddTail(GetBulge(iSeg)*(1-pa0));
		}

		for (long i = iSeg+1;i<GetVertexNum();i++)
		{
			ptList.AddTail(GetVertex(i));
			paList.AddTail(GetBulge(i));
		}
		for (i = 0;i<iSeg;i++)
		{
			ptList.AddTail(GetVertex(i));
			paList.AddTail(GetBulge(i));
		}
		if (UP_ZERO(pa0))
		{
			ptList.AddTail(GetVertex(iSeg));
			paList.AddTail(GetBulge(iSeg)*pa0);
		}
		delete pSeg;
		return new TGPLine2D(ptList,paList,true);
	}
}

void TGPLine2D::Pt2Pa(const TGPoint&pt,double&pa) const
{
	pa = -1;
	TGObjectList buf;
	for (long i = 0;i<GetSegNum();i++)
	{
		TPGeCurve2D* pSeg = GetSegment(i);
		buf << pSeg;
		if (pSeg->HitTest(pt).Is(GR_IN))
		{
			pSeg->Pt2Pa(pt,pa);
			pa = (pa+i)/GetSegNum();
			break;
		}
	}
}

void TGPLine2D::GetTangent(double pa,TPGeLine2D&line) const
{
	long i = Pa2Seg(pa);
	if (IsArc(i))
	{
		TPGeArc2D aSeg;
		GetSegment(i,aSeg);
		aSeg.GetTangent(pa,line);
	}
	else
	{
		GetSegment(i,line);
		line.Normalize();
	}
}

void TGPLine2D::Reverse()
{
	if (Is(CLOSED_CURVE))
	{
		points.Reverse(1);
		bulges.Reverse();
	}
	else
	{
		points.Reverse();
		if (bulges.GetLength()>2)
		{
			bulges.Reverse(0,bulges.GetLength()-2);
		}
	}
	for (long i = 0;i<bulges.GetLength();i++)
	{
		bulges[i] = -(bulges[i]);
	}
}

double TGPLine2D::Integration(double pa0,double pa1) const
{
	double d = pa0-pa1;
	if (DOWN_ZERO(d))
	{
		long seg0 = Pa2Seg(pa0),seg1 = Pa2Seg(pa1);
		TPGeCurve2D*pSeg = GetSegment(seg0);
		if (seg0 == seg1)
		{
			double r = pSeg->Integration(pa0,pa1);
			delete pSeg;
			return r;
		}

		double r = pSeg->Integration(pa0,1);
		delete pSeg;
		pSeg = GetSegment(seg1);
		r += pSeg->Integration(0,pa1);
		delete pSeg;
		for (long i = seg0+1;i<seg1;i++)
		{	
			pSeg = GetSegment(i);
			r += pSeg->AllIntegration();
			delete pSeg;
		}
		return r;
	}
	else if (UP_ZERO(d))
	{
		Exchange(pa0,pa1);
		long seg0 = Pa2Seg(pa0),seg1 = Pa2Seg(pa1);
		TPGeCurve2D*pSeg = GetSegment(seg0);
		if (seg0 == seg1)
		{
			double r = pSeg->Integration(pa0,pa1);
			delete pSeg;
			return -r;
		}

		double r = pSeg->Integration(pa0,1);
		delete pSeg;
		pSeg = GetSegment(seg1);
		r += pSeg->Integration(0,pa1);
		delete pSeg;
		for (long i = seg0+1;i<seg1;i++)
		{
			pSeg = GetSegment(i);
			r += pSeg->AllIntegration();
			delete pSeg;
		}
		return -r;
	}
	else
	{
		return 0;
	}
}

bool TGPLine2D::GetExtend2D(TPGeExtend2D&ext) const
{
	return TGObject2D::GetExtend2D(ext);
}

GRelation TGPLine2D::HitTest(const TGPoint&pt) const
{
	if (IsClosed())
	{
		//modify by xlc on 101123 解决搜索房间求布尔运算错误的问题
		//TPGeGLineRay2D ray(TGVector2D(1,0),pt);
		TPGeGLineRay2D ray(TGVector2D(cos(0.005*PI),sin(0.005*PI)),pt);

		bool bOutside = true;
		long segNum = GetSegNum();
		TPGeGLineSeg2D lSeg;
		TPGeArc2D aSeg;
		for (long i = 0;i<segNum;i++)
		{
			if (IsArc(i))
			{
				GetSegment(i,aSeg);

				if (aSeg.HitTest(pt).Is(GR_IN))
				{
					return GR_IN;
				}

				TGObjectList oList;
				if (aSeg.Intersect(ray,oList))
				{
					for (oList.MoveToFirst();!oList.IsOut();oList.MoveToNext())
					{
						const TGPoint2D &pt1 = (const TGPoint2D&)(oList.GetCurPData());
						if (pt1 != pt)
						{
							if (pt1 != GetVertex(i))
							{
								if (pt1 != GetVertex((i+1)%segNum))
								{
									TGVector2D vt0(aSeg.circle.center,pt1),vt;
									vt0.GetLVertVector(vt);
									if (!vt.IsParallel(ray))
									{
										bOutside=!bOutside;
									}
								}
								else
								{
									TPGeGLine2D tan;
									aSeg.GetTangent(1,tan);
									bool bLeft1,bLeft2;
									if (UP_ZERO(tan.y))
									{
										bLeft1 = false;
									}
								
									else if (DOWN_ZERO(tan.y))
									{
										bLeft1 = true;
									}
									else
									{
										bLeft1 = aSeg.circle.center.y>pt.y;
									}

									int j = (i+1)%segNum;
									while(true)
									{
										if (IsArc(j))
										{
											GetSegment(j,aSeg);
											aSeg.GetTangent(0,tan);
											if (UP_ZERO(tan.y))
											{
												bLeft2 = true;
											}
											else if (DOWN_ZERO(tan.y))
											{
												bLeft2 = false;
											}
											else
											{
												bLeft2 = aSeg.circle.center.y>pt.y;
											}
											break;
										}
										else
										{
											GetSegment(j,tan);		
											tan.Normalize();
											if (EQUAL_ZERO(tan.y))
											{
												j = (j+1)%segNum;
											}
											else
											{
												bLeft2 = UP_ZERO(tan.y);
												break;	
											}
										}
									}
									if ((bLeft1 && !bLeft2) || (!bLeft1 && bLeft2))
									{
										bOutside = !bOutside;
									}
								}
							}
						}
						else
						{
							return GR_IN;
						}
					}
				}
			}
			else
			{
				GetSegment(i,lSeg);

				if (lSeg.HitTest(pt).Is(GR_IN))
					return GR_IN;

				double pa1,pa2;
				int iRet = ray.GetGeLine().Intersect(lSeg,pa1,pa2);
				double dpa2 = pa2-1;
				if (iRet == INT_1PT && UPEQUAL_ZERO(pa1) && 
				UPEQUAL_ZERO(pa2) && DOWNEQUAL_ZERO(dpa2))
				{
					if (UP_ZERO(pa1))
					{
						if (UP_ZERO(pa2) && DOWN_ZERO(dpa2))
						{
							bOutside=!bOutside;
						}
						else if (EQUAL_ZERO(dpa2)) // 1E-9
						// sg add 091109，替换为下面这句话，则可以解决某张图的搜索房间问题
//						else if ((dpa2)>=-1E-10 && (dpa2)<=1E-10)
						{
							TPGeGLine2D tan;
							bool bLeft1 = lSeg.GetStartPoint().y>pt.y,bLeft2;

							
							int j = (i+1)%segNum;
							while(true)
							{
								if (IsArc(j))
								{
									GetSegment(j,aSeg);
									aSeg.GetTangent(0,tan);
									if (UP_ZERO(tan.y))
									{
										bLeft2 = true;
									}
									else if (DOWN_ZERO(tan.y))
									{
										bLeft2 = false;
									}
									else
									{
										bLeft2 = aSeg.circle.center.y>pt.y;
									}
									break;
								}
								else
								{
									GetSegment(j,tan);	
									tan.Normalize();
									if (EQUAL_ZERO(tan.y))
									{
										j = (j+1)%segNum;
									}
									else
									{
										bLeft2 = UP_ZERO(tan.y);
										break;	
									}
								}
							}
							if ((bLeft1 && !bLeft2) || (!bLeft1 && bLeft2))
							{
								bOutside = !bOutside;
							}
						}
					}
					else
					{
						return GR_IN;
					}
				}
				else if (iRet == INT_LINE)
				{
					lSeg.Pt2Pa(pt,pa1);
					if (UPEQUAL_ZERO(pa1) && DOWNEQUAL_ZERO(pa1-1))
					{
						return GR_IN;
					}
				}	
			}
		}
		return bOutside?GR_OUTSIDE:GR_INSIDE;
	}
	else
	{
		return TGObject::HitTest(pt);
	}
}

void TGPLine2D::QuickCut(const TPGeGLine2D&line,TGObjectList&left,TGObjectList&right,TGObjectList&mid) const
{
	long segNum = GetSegNum();
	const TPGeLine2D &line0 = line;
	TPGeGLine2D line1(line);
	TPDList<TGPa> cutList;
	double pa0,pa1;
	TPGeGLineSeg2D lSeg;
	TPGeArc2D aSeg;
	GRelation r;

	for (long i = 0;i<segNum;i++)
	{
		if (IsArc(i))
		{
			GetSegment(i,aSeg);
			TGObjectList oList;
			if (aSeg.Intersect(line1,oList))
			{
				for (oList.MoveToFirst();!oList.IsOut();oList.MoveToNext())
				{
					const TGPoint2D&pt = (const TGPoint2D&)(oList.GetCurPData());
					if (pt == GetVertex(i))
					{
						long j = (i-1+segNum)%segNum;
						bool bLeft0,bLeft1;
						TPGeGLine2D tan;
						if (IsArc(j))
						{
							TPGeArc2D aSeg0;
							GetSegment(j,aSeg0);
							aSeg0.GetTangent(1,tan);
							double s = line0*tan;
							if (UP_ZERO(s))
							{
								bLeft0 = false;
							}
							else if (DOWN_ZERO(s))
							{
								bLeft0 = true;
							}
							else
							{
								bLeft0 = line0.HitTest(aSeg0.circle.center).Is(GR_LEFT);
							}

							aSeg.GetTangent(0,tan);
							s = line0*tan;
							if (UP_ZERO(s))
							{
								bLeft1 = true;
							}
							else if (DOWN_ZERO(s))
							{
								bLeft1 = false;
							}
							else
							{
								bLeft1 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
							}

							if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
							{
								line0.Pt2Pa(pt,pa0);
								cutList << new TGPa(pa0);
							}
						}
						else
						{
							r = line0.HitTest(GetVertex(j));
							if (r.IsNot(GR_IN))
							{
								bLeft0 = r.Is(GR_LEFT);

								aSeg.GetTangent(0,tan);
								double s = line0*tan;
								if (UP_ZERO(s))
								{
									bLeft1 = true;
								}
								else if (DOWN_ZERO(s))
								{
									bLeft1 = false;
								}
								else
								{
									bLeft1 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
								}

								if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
								{
									line0.Pt2Pa(pt,pa0);
									cutList << new TGPa(pa0);
								}
							}
						}
					}
					else if (pt != GetVertex((i+1)%segNum))
					{
						TGVector2D tan;
						TGVector2D(aSeg.circle.center,pt).GetLVertVector(tan);
						if (!tan.IsParallel(line0))
						{
							line0.Pt2Pa(pt,pa0);
							cutList << new TGPa(pa0);
						}
					}
				}
			}
		}
		else
		{
			GetSegment(i,lSeg);
			int iRet = line0.Intersect(lSeg,pa0,pa1);
			if (iRet == INT_1PT)
			{
				if (UP_ZERO(pa1) && DOWN_ZERO(pa1-1))
				{
					cutList << new TGPa(pa0);
				}
				else if (EQUAL_ZERO(pa1))
				{
					long j = (i-1+segNum)%segNum;
					if (IsArc(j))
					{
						bool bLeft0,bLeft1 = line0.HitTest(lSeg.GetEndPoint()).Is(GR_LEFT);

						GetSegment(j,aSeg);
						TPGeGLine2D tan;
						aSeg.GetTangent(1,tan);
						double s = line0*tan;
						if (UP_ZERO(s))
						{
							bLeft0 = false;
						}
						else if (DOWN_ZERO(s))
						{
							bLeft0 = true;
						}
						else
						{
							bLeft0 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
						}

						if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
						{
							cutList << new TGPa(pa0);
						}
					}
					else
					{
						r = line0.HitTest(GetVertex(j));
						if (r.IsNot(GR_IN))
						{
							bool bLeft0 = r.Is(GR_LEFT),bLeft1 = line0.HitTest(lSeg.GetEndPoint()).Is(GR_LEFT);
							if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
							{
								cutList << new TGPa(pa0);
							}
						}
					}
				}
			}
			else if (iRet  == INT_LINE)
			{
				long j = (i-1+segNum)%segNum;
				bool bLeft0,bLeft1;
				if (IsArc(j))
				{
					GetSegment(j,aSeg);
					TPGeGLine2D tan;
					aSeg.GetTangent(1,tan);
					double s = line0*tan;
					if (UP_ZERO(s))
					{
						bLeft0 = false;
					}
					else if (DOWN_ZERO(s))
					{
						bLeft0 = true;
					}
					else
					{
						bLeft0 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
					}

					r.AddFlag(GR_IN);
					for (j = (i+2)%segNum;r.Is(GR_IN);j = (j+1)%segNum)
					{
						r = line0.HitTest(GetVertex(j));
					}
					bLeft1 = r.Is(GR_LEFT);

					line0.Pt2Pa(lSeg.GetStartPoint(),pa0);
					line0.Pt2Pa(GetVertex((j-2+segNum)%segNum),pa1);
					if (pa0>pa1)
					{
						Exchange(pa0,pa1);
					}
					if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
					{
						cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1);
					}
					else
					{
						cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1,MID_PT);
					}
				}
				else
				{
					r = line0.HitTest(GetVertex(j));
					if (r.IsNot(GR_IN))
					{
						bLeft0 = r.Is(GR_LEFT),bLeft1;

						r.AddFlag(GR_IN);
						for (j = (i+2)%segNum;r.Is(GR_IN);j = (j+1)%segNum)
						{
							r = line0.HitTest(GetVertex(j));
						}
						bLeft1 = r.Is(GR_LEFT);

						line0.Pt2Pa(lSeg.GetStartPoint(),pa0);
						line0.Pt2Pa(GetVertex((j-2+segNum)%segNum),pa1);
						if (pa0>pa1)
						{
							Exchange(pa0,pa1);
						}
						if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
						{
							cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1);
						}
						else
						{
							cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1,MID_PT);
						}
					}
				}
			}
		}
	}
	if (cutList.IsEmpty())
	{
		right << new TPGeGLine2D(line);
		return;
	}
	cutList.Arrange();

	bool bOut = true;
	bool bMid = false;
	TGPoint pt0,pt1;
	cutList.MoveToFirst();
	line0.Pa2Pt(cutList.GetCurPData().pa,pt0);
	right << new TPGeGLineRay2D(TGVector2D(-line0),pt0);
	if (cutList.GetCurPData().Is(MID_PT))
	{
		bMid = true;
	}
	else
	{
		bOut = false;
	}
	for (cutList.MoveToNext();!cutList.IsOut();cutList.MoveToNext())
	{
		const TGPa&pa = cutList.GetCurPData();
		line0.Pa2Pt(pa.pa,pt1);
		TPGeGLineSeg2D *pNewSeg = new TPGeGLineSeg2D(pt0,pt1);
		if (bMid)
		{
			mid << pNewSeg;
		}
		else if (bOut)
		{
			right << pNewSeg;
		}
		else 
		{
			left << pNewSeg;
		}

		pt0 = pt1;
		if (pa.Is(MID_PT))
		{
			bMid = !bMid;
		}
		else
		{
			bOut = !bOut;
			bMid = false;
		}
	}
	right << new TPGeGLineRay2D(TGVector2D(line0),pt0);
}

void TGPLine2D::QuickCut(const TPGeGLineRay2D&line,TGObjectList&left,TGObjectList&right,TGObjectList&mid) const
{
	long segNum = GetSegNum();
	const TPGeLine2D &line0 = line;
	TPGeGLine2D line1(line);
	TPDList<TGPa> cutList;
	double pa0,pa1;
	TPGeGLineSeg2D lSeg;
	TPGeArc2D aSeg;
	GRelation r;
	for (long i = 0;i<segNum;i++)
	{
		if (IsArc(i))
		{
			GetSegment(i,aSeg);
			TGObjectList oList;
			if (aSeg.Intersect(line1,oList))
			{
				for (oList.MoveToFirst();!oList.IsOut();oList.MoveToNext())
				{
					const TGPoint2D&pt = (const TGPoint2D&)(oList.GetCurPData());
					if (pt == GetVertex(i))
					{
						long j = (i-1+segNum)%segNum;
						bool bLeft0,bLeft1;
						TPGeGLine2D tan;
						if (IsArc(j))
						{
							TPGeArc2D aSeg0;
							GetSegment(j,aSeg0);
							aSeg0.GetTangent(1,tan);
							double s = line0*tan;
							if (UP_ZERO(s))
							{
								bLeft0 = false;
							}
							else if (DOWN_ZERO(s))
							{
								bLeft0 = true;
							}
							else
							{
								bLeft0 = line0.HitTest(aSeg0.circle.center).Is(GR_LEFT);
							}

							aSeg.GetTangent(0,tan);
							s = line0*tan;
							if (UP_ZERO(s))
							{
								bLeft1 = true;
							}
							else if (DOWN_ZERO(s))
							{
								bLeft1 = false;
							}
							else
							{
								bLeft1 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
							}

							if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
							{
								line0.Pt2Pa(pt,pa0);
								cutList << new TGPa(pa0);
							}
						}
						else
						{
							r = line0.HitTest(GetVertex(j));
							if (r.IsNot(GR_IN))
							{
								bLeft0 = r.Is(GR_LEFT);

								aSeg.GetTangent(0,tan);
								double s = line0*tan;
								if (UP_ZERO(s))
								{
									bLeft1 = true;
								}
								else if (DOWN_ZERO(s))
								{
									bLeft1 = false;
								}
								else
								{
									bLeft1 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
								}

								if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
								{
									line0.Pt2Pa(pt,pa0);
									cutList << new TGPa(pa0);
								}
							}
						}
					}
					else if (pt != GetVertex((i+1)%segNum))
					{
						TGVector2D tan;
						TGVector2D(aSeg.circle.center,pt).GetLVertVector(tan);
						if (!tan.IsParallel(line0))
						{
							line0.Pt2Pa(pt,pa0);
							cutList << new TGPa(pa0);
						}
					}
				}
			}
		}
		else
		{
			GetSegment(i,lSeg);
			int iRet = line0.Intersect(lSeg,pa0,pa1);
			if (iRet == INT_1PT)
			{
				if (UP_ZERO(pa1) && DOWN_ZERO(pa1-1))
				{
					cutList << new TGPa(pa0);
				}
				else if (EQUAL_ZERO(pa1))
				{
					long j = (i-1+segNum)%segNum;
					if (IsArc(j))
					{
						bool bLeft0,bLeft1 = line0.HitTest(lSeg.GetEndPoint()).Is(GR_LEFT);

						GetSegment(j,aSeg);
						TPGeGLine2D tan;
						aSeg.GetTangent(1,tan);
						double s = line0*tan;
						if (UP_ZERO(s))
						{
							bLeft0 = false;
						}
						else if (DOWN_ZERO(s))
						{
							bLeft0 = true;
						}
						else
						{
							bLeft0 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
						}

						if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
						{
							cutList << new TGPa(pa0);
						}
					}
					else
					{
						r = line0.HitTest(GetVertex(j));
						if (r.IsNot(GR_IN))
						{
							bool bLeft0 = r.Is(GR_LEFT),bLeft1 = line0.HitTest(lSeg.GetEndPoint()).Is(GR_LEFT);
							if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
							{
								cutList << new TGPa(pa0);
							}
						}
					}
				}
			}
			else if (iRet == INT_LINE)
			{
				long j = (i-1+segNum)%segNum;
				bool bLeft0,bLeft1;
				if (IsArc(j))
				{
					GetSegment(j,aSeg);
					TPGeGLine2D tan;
					aSeg.GetTangent(1,tan);
					double s = line0*tan;
					if (UP_ZERO(s))
					{
						bLeft0 = false;
					}
					else if (DOWN_ZERO(s))
					{
						bLeft0 = true;
					}
					else
					{
						bLeft0 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
					}

					r.AddFlag(GR_IN);
					for (j = (i+2)%segNum;r.Is(GR_IN);j = (j+1)%segNum)
					{
						r = line0.HitTest(GetVertex(j));
					}
					bLeft1 = r.Is(GR_LEFT);

					line0.Pt2Pa(lSeg.GetStartPoint(),pa0);
					line0.Pt2Pa(GetVertex((j-2+segNum)%segNum),pa1);
					if (pa0>pa1)
					{
						Exchange(pa0,pa1);
					}
					if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
					{
						cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1);
					}
					else
					{
						cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1,MID_PT);
					}
				}
				else
				{
					r = line0.HitTest(GetVertex(j));
					if (r.IsNot(GR_IN))
					{
						bLeft0 = r.Is(GR_LEFT),bLeft1;

						r.AddFlag(GR_IN);
						for (j = (i+2)%segNum;r.Is(GR_IN);j = (j+1)%segNum)
						{
							r = line0.HitTest(GetVertex(j));
						}
						bLeft1 = r.Is(GR_LEFT);

						line0.Pt2Pa(lSeg.GetStartPoint(),pa0);
						line0.Pt2Pa(GetVertex((j-2+segNum)%segNum),pa1);
						if (pa0>pa1)
						{
							Exchange(pa0,pa1);
						}
						if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
						{
							cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1);
						}
						else
						{
							cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1,MID_PT);
						}
					}
				}
			}
		}
	}
	if (cutList.IsEmpty())
	{
		right << new TPGeGLineRay2D(line);
		return;
	}

	cutList.Arrange();
	bool bOut = true;
	bool bMid = false;
	for (cutList.MoveToFirst();!cutList.IsOut();cutList.MoveToNext())
	{
		const TGPa& pa = cutList.GetCurPData();
		if (UP_ZERO(pa.pa))
		{
			break;
		}
		if (pa.Is(MID_PT))
		{
			bMid = !bMid;
		}
		else
		{
			bOut = !bOut;
			bMid = false;
		}
	}
	if (cutList.IsOut())
	{
		right << new TPGeGLineRay2D(line);
		return;
	}

	TGPoint pt0(line0.basePoint),pt1;
	for (;!cutList.IsOut();cutList.MoveToNext())
	{
		const TGPa&pa = cutList.GetCurPData();
		line0.Pa2Pt(pa.pa,pt1);
		TPGeGLineSeg2D *pNewSeg = new TPGeGLineSeg2D(pt0,pt1);
		if (bMid)
		{
			mid << pNewSeg;
		}
		else if (bOut)
		{
			right << pNewSeg;
		}
		else 
		{
			left << pNewSeg;
		}

		pt0 = pt1;
		if (pa.Is(MID_PT))
		{
			bMid = !bMid;
		}
		else
		{
			bOut = !bOut;
			bMid = false;
		}
	}
	right << new TPGeGLineRay2D(TGVector2D(line0),pt0);
}

void TGPLine2D::QuickCut(const TPGeGLineSeg2D&line,TGObjectList&left,TGObjectList&right,TGObjectList&mid) const
{
	long segNum = GetSegNum();
	const TPGeLine2D &line0 = line;
	TPGeGLine2D line1(line);
	TPDList<TGPa> cutList;
	double pa0,pa1;
	TPGeGLineSeg2D lSeg;
	TPGeArc2D aSeg;
	GRelation r;
	for (long i = 0;i<segNum;i++)
	{
		if (IsArc(i))
		{
			GetSegment(i,aSeg);
			TGObjectList oList;
			if (aSeg.Intersect(line1,oList))
				for (oList.MoveToFirst();!oList.IsOut();oList.MoveToNext())
				{
					const TGPoint2D&pt = (const TGPoint2D&)(oList.GetCurPData());
					if (pt == GetVertex(i))
					{
						long j = (i-1+segNum)%segNum;
						bool bLeft0,bLeft1;
						TPGeGLine2D tan;
						if (IsArc(j))
						{
							TPGeArc2D aSeg0;
							GetSegment(j,aSeg0);
							aSeg0.GetTangent(1,tan);
							double s = line0*tan;
							if (UP_ZERO(s))
							{
								bLeft0 = false;
							}
							else if (DOWN_ZERO(s))
							{
								bLeft0 = true;
							}
							else
							{
								bLeft0 = line0.HitTest(aSeg0.circle.center).Is(GR_LEFT);
							}

							aSeg.GetTangent(0,tan);
							s = line0*tan;
							if (UP_ZERO(s))
							{
								bLeft1 = true;
							}
							else if (DOWN_ZERO(s))
							{
								bLeft1 = false;
							}
							else
							{
								bLeft1 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
							}

							if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
							{
								line0.Pt2Pa(pt,pa0);
								cutList << new TGPa(pa0);
							}
						}
						else
						{
							r = line0.HitTest(GetVertex(j));
							if (r.IsNot(GR_IN))
							{
								bLeft0 = r.Is(GR_LEFT);

								aSeg.GetTangent(0,tan);
								double s = line0*tan;
								if (UP_ZERO(s))
								{
									bLeft1 = true;
								}
								else if (DOWN_ZERO(s))
								{
									bLeft1 = false;
								}
								else
								{
									bLeft1 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
								}

								if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
								{
									line0.Pt2Pa(pt,pa0);
									cutList << new TGPa(pa0);
								}
							}
						}
					}
					else if (pt !=  GetVertex((i+1)%segNum))
					{
						TGVector2D tan;
						TGVector2D(aSeg.circle.center,pt).GetLVertVector(tan);
						if (!tan.IsParallel(line0))
						{
							line0.Pt2Pa(pt,pa0);
							cutList << new TGPa(pa0);
						}
					}
				}
		}
		else
		{
			GetSegment(i,lSeg);
			int iRet = line0.Intersect(lSeg,pa0,pa1);
			if (iRet == INT_1PT)
			{
				if (UP_ZERO(pa1) && DOWN_ZERO(pa1-1))
				{
					cutList << new TGPa(pa0);
				}
				else if (EQUAL_ZERO(pa1))
				{
					long j = (i-1+segNum)%segNum;
					if (IsArc(j))
					{
						bool bLeft0,bLeft1 = line0.HitTest(lSeg.GetEndPoint()).Is(GR_LEFT);

						GetSegment(j,aSeg);
						TPGeGLine2D tan;
						aSeg.GetTangent(1,tan);
						double s = line0*tan;
						if (UP_ZERO(s))
						{
							bLeft0 = false;
						}
						else if (DOWN_ZERO(s))
						{
							bLeft0 = true;
						}
						else
						{
							bLeft0 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
						}

						if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
						{
							cutList << new TGPa(pa0);
						}
					}
					else
					{
						r = line0.HitTest(GetVertex(j));
						if (r.IsNot(GR_IN))
						{
							bool bLeft0 = r.Is(GR_LEFT),bLeft1 = line0.HitTest(lSeg.GetEndPoint()).Is(GR_LEFT);
							if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
							{
								cutList << new TGPa(pa0);
							}
						}
					}
				}
			}
			else if (iRet == INT_LINE)
			{
				long j = (i-1+segNum)%segNum;
				bool bLeft0,bLeft1;
				if (IsArc(j))
				{
					GetSegment(j,aSeg);
					TPGeGLine2D tan;
					aSeg.GetTangent(1,tan);
					double s = line0*tan;
					if (UP_ZERO(s))
					{
						bLeft0 = false;
					}
					else if (DOWN_ZERO(s))
					{
						bLeft0 = true;
					}
					else
					{
						bLeft0 = line0.HitTest(aSeg.circle.center).Is(GR_LEFT);
					}

					r.AddFlag(GR_IN);
					for (j = (i+2)%segNum;r.Is(GR_IN);j = (j+1)%segNum)
					{
						r = line0.HitTest(GetVertex(j));
					}
					bLeft1 = r.Is(GR_LEFT);

					line0.Pt2Pa(lSeg.GetStartPoint(),pa0);
					line0.Pt2Pa(GetVertex((j-2+segNum)%segNum),pa1);
					if (pa0>pa1)
					{
						Exchange(pa0,pa1);
					}
					if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
					{
						cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1);
					}
					else
					{
						cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1,MID_PT);
					}
				}
				else
				{
					r = line0.HitTest(GetVertex(j));
					if (r.IsNot(GR_IN))
					{
						bLeft0 = r.Is(GR_LEFT),bLeft1;

						r.AddFlag(GR_IN);
						for (j = (i+2)%segNum;r.Is(GR_IN);j = (j+1)%segNum)
						{
							r = line0.HitTest(GetVertex(j));
						}
						bLeft1 = r.Is(GR_LEFT);

						line0.Pt2Pa(lSeg.GetStartPoint(),pa0);
						line0.Pt2Pa(GetVertex((j-2+segNum)%segNum),pa1);
						if (pa0>pa1)
						{
							Exchange(pa0,pa1);
						}
						if ((bLeft0 && !bLeft1) || (!bLeft0 && bLeft1))
						{
							cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1);
						}
						else
						{
							cutList << new TGPa(pa0,MID_PT) << new TGPa(pa1,MID_PT);
						}
					}
				}
			}
		}
	}
	if (cutList.IsEmpty())
	{
		right << new TPGeGLineSeg2D(line);
		return;
	}

	cutList.Arrange();
	bool bOut = true;
	bool bMid = false;
	for (cutList.MoveToFirst();!cutList.IsOut();cutList.MoveToNext())
	{
		const TGPa& pa = cutList.GetCurPData();
		if (UP_ZERO(pa.pa))
		{
			break;
		}
		if (pa.Is(MID_PT))
		{
			bMid = !bMid;
		}
		else
		{
			bOut = !bOut;
			bMid = false;
		}
	}
	if (cutList.IsOut())
	{
		right << new TPGeGLineSeg2D(line);
		return;
	}

	TGPoint pt0(line.GetStartPoint()),pt1;
	TPGeGLineSeg2D *pNewSeg = NULL;
	for (bool bContinue = true;bContinue && !cutList.IsOut();cutList.MoveToNext())
	{
		const TGPa&pa = cutList.GetCurPData();
		if (UPEQUAL_ZERO(pa.pa-1))
		{
			pNewSeg = new TPGeGLineSeg2D(pt0,line.GetEndPoint());
			bContinue = false;
		}
		else
		{
			line0.Pa2Pt(pa.pa,pt1);
			pNewSeg = new TPGeGLineSeg2D(pt0,pt1);
		}
		if (bMid)
		{
			mid << pNewSeg;
		}
		else if (bOut)
		{
			right << pNewSeg;
		}
		else 
		{
			left << pNewSeg;
		}

		pt0 = pt1;
		if (pa.Is(MID_PT))
		{
			bMid = !bMid;
		}
		else
		{
			bOut = !bOut;
			bMid = false;
		}
	}

	if (bContinue)
	{
		right << new TPGeGLineSeg2D(pt0,line.GetEndPoint());
	}
}

bool TGPLine2D::IsInclude(const TGObject&obj) const
{
	switch(obj.GetClassID())
	{
		case CID_GArc2D:
		case CID_GCircle2D:
			return false;
		default:
			return TGMLine2D::IsInclude(obj);
	}
}

bool TGPLine2D::Explode(TGObjectList&res) const
{
	long num = GetSegNum();
	for (long i = 0;i<num;i++)
	{
		res << GetSegment(i);
	}
	return true;
}

TGMLine2D* TGPLine2D::MLinearize(double paDist) const
{
	bool bUseDefault = paDist<1E-9;
	long num = GetSegNum();
	TList<TGPoint> ptList;
	long count = 0;
	TPGeArc2D arc;
	for (long i = 0;i<num;i++)
	{
		ptList[count++] = points.GetAt(i);
		if (IsArc(i))
		{
			GetSegment(i,arc);
			long num1;
			if (bUseDefault)
			{
				num1 = (long)(1/arc.GetMLinePrec()+0.999999);
			}
			else
			{
				num1 = (long)(arc.centralAngle/paDist+0.999999);
			}
			if (num1<1)
			{
				continue;
			}
			double paDist1 = 1.0 / num1;
			double pa = paDist1;
			
			for (long j = 1; j < num1; j++,pa += paDist1)
			{
				arc.Pa2Pt(pa,ptList[count++]);
			}
		}
	}
	if (!IsClosed())
	{
		ptList[count] = points.GetAt(i);
	}
	return new TGMLine2D(ptList,IsClosed());
}

bool TGPLine2D::Offset(double offset)
{
	TSPTable<TPGeCurve2D> curves(GetSegNum());
	for (long i = 0;i<GetSegNum();i++)
	{
		if (IsArc(i))
		{
			TPGeArc2D arc;
			GetSegment(i,arc);
			if (!arc.Offset(offset))
				return false;
			curves.AddTail(arc.GetExtendCurve());
		}
		else 
		{
			TPGeGLine2D *pLine = new TPGeGLine2D;
			GetSegment(i,*pLine);
			pLine->Offset(offset);
			curves.AddTail(pLine);
		}
	}
		
	TArray<TGPoint> newPt(GetVertexNum());
	for (i = 1;i<curves.GetLength();i++)
	{
		TPGeCurve2D*pCurve0 = curves[i-1],*pCurve1 = curves[i];
		TGObjectList buf;
		if (pCurve0->Intersect(*pCurve1,buf))
		{
			TPGeCurve2D*pSeg = GetSegment(i);
			pSeg->Offset(offset);
			if (IS_CLASS(buf[0],TPGeCurve2D))
			{
				pSeg->GetStartPoint(newPt[i]);
			}
			else
			{
				TGPoint2D &pt0 = (TGPoint2D&)(*buf[0]);
				if (buf.GetLength()  == 1)
				{
					newPt[i] = pt0;
				}
				else
				{
					TGPoint2D &pt1 = (TGPoint2D&)(*buf[1]),pt2;
					pSeg->GetStartPoint(pt2);
					double nDist0 = pt2.Distance(pt0),nDist1 = pt2.Distance(pt1);
					newPt[i] = nDist0<nDist1?pt0:pt1;
				}
			}
			delete pSeg;
		}
		else
		{
			return false;
		}
	}

	if (IsClosed())
	{
		TPGeCurve2D*pCurve0 = curves[i-1],*pCurve1 = curves[0];
		TGObjectList buf;
		if (pCurve0->Intersect(*pCurve1,buf))
		{
			TPGeCurve2D*pSeg = GetSegment(0);
			pSeg->Offset(offset);
			if (IS_CLASS(buf[0],TPGeCurve2D))
			{
				pSeg->GetStartPoint(newPt[0]);
			}
			else
			{
				TGPoint2D &pt0 = (TGPoint2D&)(*buf[0]);
				if (buf.GetLength()  == 1)
				{
					newPt[0] = pt0;
				}
				else
				{
					TGPoint2D &pt1 = (TGPoint2D&)(*buf[1]),pt2;
					pSeg->GetStartPoint(pt2);
					double nDist0 = pt2.Distance(pt0),nDist1 = pt2.Distance(pt1);
					newPt[0] = nDist0<nDist1?pt0:pt1;
				}
			}
			delete pSeg;
		}
		else
		{
			return false;
		}
	}
	else 
	{
		TPGeCurve2D *pSegFirst = GetSegment(0),*pSegLast = GetSegment(i-1);
		pSegFirst->Offset(offset);
		pSegLast->Offset(offset);
		pSegFirst->GetStartPoint(newPt[0]);
		pSegLast->GetEndPoint(newPt[newPt.GetLastIndex()]);
		delete pSegFirst;
		delete pSegLast;
	}
	
	points = newPt;
	for (i = 0;i<GetSegNum();i++)
	{
		if (IsArc(i))
		{
			double pa0,pa1;
			curves[i]->Pt2Pa(newPt[i],pa0);
			curves[i]->Pt2Pa(newPt[(i+1)%GetVertexNum()],pa1);
			bulges[i] = curves[i]->IsClockwise()?-ALEN(pa0,pa1):ALEN(pa0,pa1);
		}
	}
	return true;
}

bool TGPLine2D::OffsetSeg(long iSeg,double offset)
{
	TSPTable<TPGeCurve2D> curves(GetSegNum());
	for (long i = 0;i<GetSegNum();i++)
	{
		if (IsArc(i))
		{
			TPGeArc2D arc;
			GetSegment(i,arc);
			if (i  == iSeg && !arc.Offset(offset))
			{
				return false;
			}
			curves.AddTail(arc.GetExtendCurve());
		}
		else 
		{
			TPGeGLine2D *pLine = new TPGeGLine2D;
			GetSegment(i,*pLine);
			if (i  == iSeg)
			{
				pLine->Offset(offset);
			}
			curves.AddTail(pLine);
		}
	}
		
	TArray<TGPoint> newPt(points);
	for (i = 1;i<curves.GetLength();i++)
	{
		if (i !=  iSeg && i != iSeg+1)
		{
			continue;
		}

		TPGeCurve2D*pCurve0 = curves[i-1],*pCurve1 = curves[i];
		TGObjectList buf;
		if (pCurve0->Intersect(*pCurve1,buf))
		{
			TPGeCurve2D*pSeg = GetSegment(i);
			if (IS_CLASS(buf[0],TPGeCurve2D))
			{
				pSeg->GetStartPoint(newPt[i]);
			}
			else
			{
				TGPoint2D &pt0 = (TGPoint2D&)(*buf[0]);
				if (buf.GetLength() == 1)
				{
					newPt[i] = pt0;
				}
				else
				{
					TGPoint2D &pt1 = (TGPoint2D&)(*buf[1]),pt2;
					pSeg->GetStartPoint(pt2);
					double nDist0 = pt2.Distance(pt0),nDist1 = pt2.Distance(pt1);
					newPt[i] = nDist0<nDist1?pt0:pt1;
				}
			}
			delete pSeg;
		}
		else
		{
			return false;
		}
	}

	if (IsClosed())
	{
		if (iSeg == 0 || iSeg == i-1)
		{
			TPGeCurve2D*pCurve0 = curves[i-1],*pCurve1 = curves[0];
			TGObjectList buf;
			if (pCurve0->Intersect(*pCurve1,buf))
			{
				TPGeCurve2D*pSeg = GetSegment(0);
				if (IS_CLASS(buf[0],TPGeCurve2D))
				{
					pSeg->GetStartPoint(newPt[0]);
				}
				else
				{
					TGPoint2D &pt0 = (TGPoint2D&)(*buf[0]);
					if (buf.GetLength()  == 1)
					{
						newPt[0] = pt0;
					}
					else
					{
						TGPoint2D &pt1 = (TGPoint2D&)(*buf[1]),pt2;
						pSeg->GetStartPoint(pt2);
						double nDist0 = pt2.Distance(pt0),nDist1 = pt2.Distance(pt1);
						newPt[0] = nDist0<nDist1?pt0:pt1;
					}
				}
				delete pSeg;
			}
			else
			{
				return false;
			}
		}
	}
	else if (iSeg == 0)
	{
		TPGeCurve2D *pSegFirst = GetSegment(0);
		pSegFirst->Offset(offset);
		pSegFirst->GetStartPoint(newPt[0]);
		delete pSegFirst;
	}
	else if (iSeg  == i-1)
	{
		TPGeCurve2D *pSegLast=GetSegment(i-1);
		pSegLast->Offset(offset);
		pSegLast->GetEndPoint(newPt[newPt.GetLastIndex()]);
		delete pSegLast;
	}
	
	points = newPt;
	for (i = 0;i<GetSegNum();i++)
	{
		if (IsArc(i))
		{
			double pa0,pa1;
			curves[i]->Pt2Pa(newPt[i],pa0);
			curves[i]->Pt2Pa(newPt[(i+1)%GetVertexNum()],pa1);
			bulges[i] = curves[i]->IsClockwise()?-ALEN(pa0,pa1):ALEN(pa0,pa1);
		}
	}
	return true;
}

void TGPLine2D::SetClosed(bool bClosed,double angle)
{
	if (bulges.GetLength() < 1 || bulges.GetLastIndex() < 0 || bulges.GetLastIndex() >= bulges.GetLength())
	{
		return;
	}

	if(bClosed)
	{
		AddFlag(CLOSED_CURVE);
		bulges[bulges.GetLastIndex()]=angle;
	}
	else
	{
		RemoveFlag(CLOSED_CURVE);
		bulges[bulges.GetLastIndex()]=0;
	}
}