#include "stdafx.h"
#include "UndergroundRampStyle.h"
#include "XDrawUGRampEdJig.h"
#include "UndergroundRampDlg.h"
#include "GlwGlobalVariable.h"
#include "GlwUGRampDataManage.h"
//合成道路边线、箭头、末端折线
extern void GetRampOutPoly(XPoly2D &rampPolyLeftOut, XPoly2D &rampPolyRightOut, XPoly2D &rampPolyLeftIn, XPoly2D &rampPolyRightIn, XPoly2D &rampPolyMid,TGGeCurveSegment &segStartSec, XPoly2D &xRampOutLine, XPoly2D &xRampInLine, XPoly2D &xRampMidLine, XPoly2D &xBrokenLine, XPoly2D &xArrowPoly, bool bShowOutLine);
//给定弧上一点截取弧的前或后半部分
void CutOutArc(TGGeCurveSegment &segSrc, TGGeCurveSegment &segRet, XPoint &ptOnArc, BOOL bIsFromSt);
//弧与直线倒角
BOOL FilletArcAndLine(TGGeCurveSegment &segPre, TGGeCurveSegment &SegSec, double dRad, XPoly2D &xPolyNew);
//弧与弧倒角
BOOL FillletArc(TGGeCurveSegment &segPre, TGGeCurveSegment &segSec, double dRad, XPoly2D &xPolyNew);
//直线与弧倒角
BOOL FilletLineAndArc(TGGeCurveSegment &segPre, TGGeCurveSegment &SegSec, double dRad, XPoly2D &xPolyNew);
//直线与直线倒角
void FilletCrossLine(TGGeCurveSegment &segPre, TGGeCurveSegment &seg, double dRad, XPoly2D &xPolyNew, XPoint &ptCenter);
//截取两线段的相交线（没有相交时，延长取相交线）
BOOL GetInterLine(TGGeCurveSegment &segFirst, TGGeCurveSegment &segSec);
//多线段倒角
void FilletRampPoly(XPoly2D &rampPolyBase, XPoly2D &rampPolyLeftOut, XPoly2D &rampPolyLeftIn, XPoly2D &rampPolyRightOut, XPoly2D &rampPolyRightIn, XPoly2D &rampPolyMid);
//确定两线的位置关系，得到平移方向及转角半径
void GetExcircleForArcAndLine(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &rampPolyMid, BOOL bIsFirst);
void GetExcircleForLineAndArc(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &rampPolyMid, BOOL bIsFirst);
void GetExcircleForDoubleLine(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &rampPolyMid, BOOL bIsFirst);
void GetExcircleForArc(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &rampPolyMid, BOOL bIsFirst);
//去掉polyPre的最后一段与polyAdd合并
void MergerPoly(XPoly2D &polyPre, XPoly2D &polyAdd, XPoly2D &xpolyNew);

BOOL FilletArcAndLine(TGGeCurveSegment &segPre, TGGeCurveSegment &SegSec, double dRad, XPoly2D &xPolyNew)
{
	XPoint ptArcEnd, ptArcSt, ptCenter, ptCenterNew;
	TGGeCurveSegment segPreArc, segArc, segTan, segTemp;
	ptArcEnd = segPre.GetEndPoint();
	ptCenter = segPre.GetArc().GetCenterPt();
	double dRadius = segPre.GetArc().GetRadius();
	double dLength = abs(SegSec.GetDist2Me(ptCenter));
	AcGeVector3d vec = SegSec.GetEndPoint() - SegSec.GetStartPoint();
	AcGeVector3d  vecTan = segPre.GetEndPoint() - segPre.GetArc().GetCenterPt();

	double dAngle; 
	if (segPre.GetBulge() > 0)
	{
		vecTan = vecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
		segTan = XLine(segPre.GetEndPoint(), segPre.GetEndPoint() + segPre.GetLength() * vecTan / vecTan.length());
		if (segTan.OnWhichSide(SegSec.GetEndPoint()))
		{
			if (SegSec.OnWhichSide(ptCenter))
			{
				if ((dRad - dLength) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dRad - dLength)/ (dRadius + dRad));
			}
			else
			{
				if ((dLength + dRad) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dLength + dRad) / (dRadius + dRad));
			}
			vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			vec= vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
			ptCenterNew = ptCenter + (dRadius + dRad) * vec / vec.length();
			ptArcSt = ptCenter + dRadius * vec / vec.length();
			ptArcEnd = ptCenterNew  - dRad * vegRadial / vegRadial.length();
			segArc.SetStartPoint(ptArcSt);
			segArc.SetEndPoint(ptArcEnd);
			segArc.SetBulge(-dAngle);
			if (SegSec.GetLength() < ptArcEnd.Distance(SegSec.GetStartPoint()))
			{
				return FALSE;
			}
			SegSec.SetStartPoint(ptArcEnd);
			dAngle = acos((2 * pow(dRadius, 2) - pow(segPre.GetEndPoint().Distance(ptArcSt), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(segPre.GetBulge()))
			{
				return FALSE;
			}
			segTemp = segPre;
			CutOutArc(segTemp, segPre, ptArcSt, FALSE);
		}
		else
		{
			vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			if (SegSec.OnWhichSide(ptCenter))
			{
				if ((dRad + dLength) > (dRadius - dRad))
				{
					return FALSE;
				}
				dAngle = acos((dRad + dLength) / (dRadius - dRad));
				dAngle = PI - dAngle;	
			}
			else
			{
				if ((dLength - dRad) > (dRadius - dRad))
				{
					return FALSE;
				}
				dAngle = acos((dLength - dRad)/ (dRadius - dRad));
			}
			vec= vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
			ptCenterNew = ptCenter + (dRadius - dRad) * vec / vec.length();
			ptArcSt = ptCenter + dRadius * vec / vec.length();
			ptArcEnd = ptCenterNew + dRad * vegRadial / vegRadial.length();
			segArc.SetStartPoint(ptArcSt);
			segArc.SetEndPoint(ptArcEnd);
			segArc.SetBulge(dAngle);
			if (SegSec.GetLength() < ptArcEnd.Distance(SegSec.GetStartPoint()))
			{
				return FALSE;
			}
			SegSec.SetStartPoint(ptArcEnd);
			dAngle = acos((2 * pow(dRadius, 2) - pow(segPre.GetEndPoint().Distance(ptArcSt), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(segPre.GetBulge()))
			{
				return FALSE;
			}
			segTemp = segPre;
			CutOutArc(segTemp, segPre, ptArcSt, FALSE);
		}
	}
	else
	{
		vecTan = vecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
		segTan = XLine(segPre.GetEndPoint(), segPre.GetEndPoint() + segPre.GetLength() * vecTan / vecTan.length());
		if (segTan.OnWhichSide(SegSec.GetEndPoint()))
		{
			if (SegSec.OnWhichSide(ptCenter))
			{
				if (dLength > dRad)
				{
					if ((dLength - dRad) > (dRadius - dRad))
					{
						return FALSE;
					}
					dAngle = acos((dLength - dRad)/ (dRadius - dRad));
				}
				else
				{
					if ((dRad - dLength) > (dRadius - dRad))
					{
						return FALSE;
					}
					dAngle = acos((dRad - dLength) / (dRadius - dRad));
					dAngle = PI - dAngle;
				}
				vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
				AcGeVector3d vegRadial = vec;
				vec= vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptCenterNew = ptCenter + (dRadius - dRad) * vec / vec.length();
				ptArcSt = ptCenter + dRadius * vec / vec.length();
				ptArcEnd = ptCenterNew  + dRad * vegRadial / vegRadial.length();
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
			}
			else
			{
				if ((dLength + dRad) > (dRadius - dRad) )
				{
					return FALSE;
				}
				dAngle = acos((dLength + dRad) / (dRadius - dRad));
				dAngle = PI - dAngle;		
				vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
				AcGeVector3d vegRadial = vec;
				vec= vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptCenterNew = ptCenter + (dRadius - dRad) * vec / vec.length();
				ptArcSt = ptCenter + dRadius * vec / vec.length();
				ptArcEnd = ptCenterNew  + dRad * vegRadial / vegRadial.length();
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
			}
			
			if (SegSec.GetLength() < ptArcEnd.Distance(SegSec.GetStartPoint()))
			{
				return FALSE;
			}
			SegSec.SetStartPoint(ptArcEnd);
			dAngle = acos((2 * pow(dRadius, 2) - pow(segPre.GetEndPoint().Distance(ptArcSt), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(segPre.GetBulge()))
			{
				return FALSE;
			}
			segTemp = segPre;
			CutOutArc(segTemp, segPre, ptArcSt, FALSE);
		}
		else
		{
			vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			if (SegSec.OnWhichSide(ptCenter))
			{
				if ((dRad + dLength) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dRad + dLength)/ (dRadius + dRad));
				vec= vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				
			}
			else
			{
				if (dLength > dRad)
				{
					if ((dLength - dRad) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = asin((dLength - dRad) / (dRadius + dRad));
					dAngle = 0.5 * PI + dAngle;	
					vec= vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				}
				else
				{
					if((dRad - dLength) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = acos((dRad - dLength) / (dRadius + dRad));
					vec= vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				}
				
			}
			ptCenterNew = ptCenter - (dRadius + dRad) * vec / vec.length();
			ptArcSt = ptCenter - dRadius * vec / vec.length();
			ptArcEnd = ptCenterNew + dRad * vegRadial / vegRadial.length();	
			segArc.SetStartPoint(ptArcSt);
			segArc.SetEndPoint(ptArcEnd);
			segArc.SetBulge(dAngle);
			if (SegSec.GetLength() < ptArcEnd.Distance(SegSec.GetStartPoint()))
			{
				return FALSE;
			}
			SegSec.SetStartPoint(ptArcEnd);
			dAngle = acos((2 * pow(dRadius, 2) - pow(segPre.GetEndPoint().Distance(ptArcSt), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(segPre.GetBulge()))
			{
				return FALSE;
			}
			segTemp = segPre;
			CutOutArc(segTemp, segPre, ptArcSt, FALSE);
		}	
	}
	xPolyNew.AppendSegment(segPre, 0, 0);
	xPolyNew.AppendSegment(segArc, 0, 0);
	xPolyNew.AppendSegment(SegSec, 0, 1);
	return TRUE;
}
BOOL FillletArc(TGGeCurveSegment &segPre, TGGeCurveSegment &segSec, double dRad, XPoly2D &xPolyNew)
{
	XPoint ptPreCenter, ptSecCenter, ptEnd, ptArcSt, ptArcEnd, ptCenterNew;
	double dPreRad, dSecRad;
	double dLength ,dAngle;
	XLine xPreTanLine;
	TGGeCurveSegment segArc, segTemp;
	dSecRad = segSec.GetArc().GetRadius();
	dPreRad = segPre.GetArc().GetRadius();
	ptPreCenter = segPre.GetArc().GetCenterPt();
	ptSecCenter = segSec.GetArc().GetCenterPt();
	AcGeVector3d vecPre = segPre.GetEndPoint() - ptPreCenter;
	AcGeVector3d vecSec = segSec.GetStartPoint() - ptSecCenter;
	AcGeVector3d vec = ptSecCenter - ptPreCenter;
	if (segSec.GetBulge() > 0)
	{
		vecSec = vecSec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);

	}
	else
	{
		vecSec = vecSec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
	}
	if (segPre.GetBulge() > 0)
	{
		vecPre = vecPre.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
	}
	else
	{
		vecPre = vecPre.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
	}
	xPreTanLine.SetStartPoint(segPre.GetEndPoint());
	ptEnd = segPre.GetEndPoint() + segPre.GetLength() * vecPre / vecPre.length();
	xPreTanLine.SetEndPoint(ptEnd);
	ptEnd = segSec.GetStartPoint() + dSecRad * vecSec / vecSec.length();
	dLength = ptPreCenter.Distance(ptSecCenter);
	if (xPreTanLine.OnWhichSide(ptEnd))
	{
		if (segPre.GetBulge() > 0)
		{
			if (segSec.GetBulge() > 0)
			{
				if ((dPreRad + dLength) < dSecRad)
				{
					return FALSE;
				}
				dAngle = acos((pow(dPreRad + dRad, 2) + pow(dLength, 2) - pow(dSecRad + dRad, 2)) / (2 * (dPreRad + dRad) * (dLength)));
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
				ptCenterNew = ptPreCenter + (dPreRad + dRad) * vec / vec.length();
				AcGeVector3d vecT = ptCenterNew - ptSecCenter;
				ptArcEnd = ptSecCenter + dSecRad * vecT / vecT.length();
				dAngle = vecT.angleTo(vec);
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
				
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}
			else
			{
				if ((dSecRad - dRad + dLength) < (dRad + dPreRad))
				{
					return FALSE;
				}
				dAngle = acos((pow(dSecRad - dRad, 2) + pow(dLength, 2) - pow(dRad + dPreRad, 2)) / (2 * (dSecRad - dRad) * (dLength)));
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				ptArcEnd = ptSecCenter - dSecRad * vec / vec.length();
				ptCenterNew = ptSecCenter - (dSecRad - dRad) * vec / vec.length();
				AcGeVector3d vecT = ptCenterNew - ptPreCenter;
				ptArcSt = ptPreCenter + dPreRad * vecT / vecT.length();	
				dAngle = vec.angleTo(vecT);
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
				
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}

		}
		else
		{
			if (segSec.GetBulge() > 0)
			{
				if ((dPreRad- dRad + dLength) < (dRad + dSecRad))
				{
					return FALSE;
				}
				dAngle = acos((pow(dPreRad - dRad, 2) + pow(dLength, 2) - pow(dRad + dSecRad, 2)) / (2 * (dPreRad - dRad) * (dLength)));
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
				ptCenterNew = ptPreCenter + (dPreRad - dRad) * vec / vec.length();
				AcGeVector3d vecT = ptSecCenter - ptCenterNew;
				ptArcEnd = ptCenterNew + dRad * vecT / vecT.length();
				dAngle = vec.angleTo(vecT);	
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
				
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}
			else
			{
				if ((dPreRad - dRad + dLength) < (dSecRad - dRad))
				{
					return FALSE;
				}
				dAngle = acos((pow(dPreRad - dRad, 2) + pow(dLength, 2) - pow(dSecRad - dRad, 2)) / (2 * (dPreRad - dRad) * (dLength)));
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
				ptCenterNew = ptPreCenter + (dPreRad - dRad) * vec / vec.length();
				AcGeVector3d vecT = ptCenterNew - ptSecCenter;
				ptArcEnd = ptSecCenter + dSecRad * vecT / vecT.length();
				dAngle = vecT.angleTo(vec);
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
				
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}

		}
	}
	else
	{
		if (segPre.GetBulge() > 0)
		{
			if (segSec.GetBulge() > 0)
			{	
				if ((dPreRad - dRad + dLength) < (dSecRad - dRad))
				{
					return FALSE;
				}
				dAngle = acos((pow(dPreRad - dRad, 2) + pow(dLength, 2) - pow(dSecRad - dRad, 2)) / (2 * (dPreRad - dRad) * (dLength)));
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
				ptCenterNew = ptPreCenter + (dPreRad - dRad) * vec / vec.length();
				AcGeVector3d vecT = ptCenterNew - ptSecCenter;
				ptArcEnd = ptSecCenter + dSecRad * vecT / vecT.length();
				dAngle = vecT.angleTo(vec);
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(dAngle);
				
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}
			else
			{
				if (dPreRad > dRad)
				{
					if ((dPreRad - dRad + dLength) < (dRad + dSecRad))
					{
						return FALSE;
					}
					dAngle = acos((pow(dPreRad - dRad, 2) + pow(dLength, 2) - pow(dRad + dSecRad, 2)) / (2 * (dPreRad - dRad) * (dLength)));
					vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
					ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
					ptCenterNew = ptPreCenter + (dPreRad - dRad) * vec / vec.length();
				}
				else
				{
					if ((dRad - dPreRad + dLength) < (dRad + dSecRad))
					{
						return FALSE;
					}
					dAngle = acos((pow(dRad - dPreRad, 2) + pow(dLength, 2) - pow(dRad + dSecRad, 2)) / (2 * (dRad - dPreRad) * (dLength)));
					vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
					ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
					ptCenterNew = ptPreCenter - (dRad - dPreRad) * vec / vec.length();	
				}
				AcGeVector3d vecT = ptSecCenter - ptCenterNew;
				ptArcEnd = ptSecCenter - dSecRad * vecT / vecT.length();	
				dAngle = vec.angleTo(vecT);
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(dAngle);
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}
		}
		else
		{
			if (segSec.GetBulge() > 0)
			{
				if ((dRad + dPreRad + dLength) < (dSecRad - dRad))
				{
					return FALSE;
				}
				dAngle = acos((pow(dRad + dPreRad, 2) + pow(dLength, 2) - pow(dSecRad - dRad, 2)) / (2 * (dRad + dPreRad) * (dLength)));
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
				ptCenterNew = ptPreCenter + (dPreRad + dRad) * vec / vec.length();
				AcGeVector3d vecT = ptSecCenter - ptCenterNew;
				ptArcEnd = ptSecCenter - dSecRad * vecT / vecT.length();
				dAngle = vec.angleTo(vecT);	
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(dAngle);
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}
			else
			{
				if ((dPreRad + dRad + dLength) < (dSecRad + dRad))
				{
					return FALSE;
				}
				dAngle = acos((pow(dPreRad + dRad, 2) + pow(dLength, 2) - pow(dSecRad + dRad, 2)) / (2 * (dPreRad + dRad) * (dLength)));
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptArcSt = ptPreCenter + dPreRad * vec / vec.length();
				ptCenterNew = ptPreCenter + (dPreRad + dRad) * vec / vec.length();
				AcGeVector3d vecT = ptCenterNew - ptSecCenter;
				ptArcEnd = ptSecCenter + dSecRad * vecT / vecT.length();
				dAngle = vecT.angleTo(vec);
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(dAngle);
				dAngle = acos((2 * pow(dPreRad, 2) - pow(ptArcSt.Distance(segPre.GetEndPoint()), 2)) / (2 * pow(dPreRad, 2)));
				if (dAngle > abs(segPre.GetBulge()))
				{
					return FALSE;
				}
				dAngle = acos((2 * pow(dSecRad, 2) - pow(ptArcEnd.Distance(segSec.GetStartPoint()), 2)) / (2 * pow(dSecRad, 2)));
				if (dAngle > abs(segSec.GetBulge()))
				{
					return FALSE;
				}
				segTemp = segPre;
				CutOutArc(segTemp, segPre, ptArcSt, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptArcEnd, TRUE);
			}
		}
	}
	xPolyNew.AppendSegment(segPre, 0, 0);
	xPolyNew.AppendSegment(segArc, 0, 0);
	xPolyNew.AppendSegment(segSec, 0, 1);
	return TRUE;
}
BOOL GetInterLine(TGGeCurveSegment &segFirst, TGGeCurveSegment &segSec)
{
	XPoint ptInter[2], ptOnArc;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth = pRampDataManage->GetRampWidth();
	double angle;
	TGGeCurveSegment segTemp;
	int nInterNum;
	if (abs(segFirst.GetBulge()) > 1.0e-6)
	{
		if (abs(segSec.GetBulge()) > 1.0e-6)
		{
			AcGeVector3d vecTan, vecPreTan, vecSecTan;
			XPoint ptTemp,ptst, ptCenter;
			BOOL bCanFillet = TRUE;
			GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
			double dWidth, dTurnningRad;
			dWidth = pRampDataManage->GetRampWidth();
			dTurnningRad = pRampDataManage->GetTurningRad();
			vecPreTan = segFirst.GetEndPoint()  - segFirst.GetArc().GetCenterPt();
			vecSecTan = segSec.GetStartPoint() - segSec.GetArc().GetCenterPt();
			if (segFirst.GetBulge() > 0)
				vecPreTan = vecPreTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			else
				vecPreTan = vecPreTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			if (segSec.GetBulge() > 0)
				vecSecTan = vecSecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			else
				vecSecTan = vecSecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			segTemp = XLine(segFirst.GetEndPoint(), segFirst.GetEndPoint() + segSec.GetLength() * vecPreTan / vecPreTan.length());
			ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vecSecTan / vecSecTan.length();
			nInterNum = segFirst.Intersection(segSec, ptInter[0], ptInter[1]);
			int nFlag = segFirst.HitTest2d(ptInter[0]);
			nFlag = segSec.HitTest2d(ptInter[0]);
			
			if((nInterNum == 1) && ((segSec.HitTest2d(ptInter[0]) == 4) || (segSec.HitTest2d(ptInter[0]) == 7) || (segSec.HitTest2d(ptInter[0]) == 6) || (segSec.HitTest2d(ptInter[0]) == 5)) && (!segTemp.OnWhichSide(ptTemp)))
			{
				segTemp = segFirst;
				CutOutArc(segTemp, segFirst, ptInter[0], FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptInter[0], TRUE);
			}
			else if ((nInterNum == 1) && (segFirst.HitTest2d(ptInter[0]) == 5) && (segSec.HitTest2d(ptInter[0]) == 5) && (segSec.GetBulge() < 0) && (segTemp.OnWhichSide(ptTemp)) && (!segTemp.OnWhichSide(segSec.GetArc().GetCenterPt())))
			{
				segTemp = segFirst;
				CutOutArc(segTemp, segFirst, ptInter[0], FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptInter[0], TRUE);
				return TRUE;
			}
			else if(nInterNum == 2)
			{
				ptCenter = segSec.GetArc().GetCenterPt();
				if (segFirst.GetEndPoint().Distance(ptInter[0]) > segFirst.GetEndPoint().Distance(ptInter[1]))
				{
					ptOnArc = ptInter[1];
					if ((segFirst.GetBulge() < 0) && (segSec.GetBulge() > 0) && (!segTemp.OnWhichSide(ptTemp)) && (segTemp.OnWhichSide(ptCenter)) && (segTemp.OnWhichSide(segSec.GetEndPoint())))
						ptOnArc = ptInter[0];
					if ((segFirst.GetBulge() > 0) && (segSec.GetBulge() > 0) && (!segTemp.OnWhichSide(ptTemp)) && (segTemp.OnWhichSide(ptCenter)) && (segTemp.OnWhichSide(segSec.GetEndPoint())))
						ptOnArc = ptInter[0];
				}
				else
				{
					ptOnArc = ptInter[0];
					if ((segFirst.GetBulge() < 0) && (segSec.GetBulge() > 0) && (!segTemp.OnWhichSide(ptTemp)) && (segTemp.OnWhichSide(ptCenter)) && (segTemp.OnWhichSide(segSec.GetEndPoint())))
						ptOnArc = ptInter[1];
					if ((segFirst.GetBulge() > 0) && (segSec.GetBulge() > 0) && (!segTemp.OnWhichSide(ptTemp)) && (segTemp.OnWhichSide(ptCenter)) && (segTemp.OnWhichSide(segSec.GetEndPoint())))
						ptOnArc = ptInter[0];
				}
				segTemp = segFirst;
				CutOutArc(segTemp, segFirst, ptOnArc, FALSE);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptOnArc, TRUE);
			}
			else
			{
				XCircle circleF(segFirst.GetArc().GetCenterPt(), segFirst.GetArc().GetRadius());
				XCircle circleS(segSec.GetArc().GetCenterPt(), segSec.GetArc().GetRadius());
				if(circleF.Intersection(&circleS, ptInter[0], ptInter[1]) == 0)
					return FALSE;
				if (segFirst.GetEndPoint().Distance(ptInter[0]) > segFirst.GetEndPoint().Distance(ptInter[1]))
				{
					ptOnArc = ptInter[1];
					
				}
				else
				{
					ptOnArc = ptInter[0];		
				}
				if((segFirst.HitTest2d(ptOnArc) == 4) || (segFirst.HitTest2d(ptOnArc) == 7))
				{
					segTemp = segFirst;
					CutOutArc(segTemp, segFirst, ptOnArc, FALSE);
				}
				else
				{
					segTemp = XArc(segFirst.GetStartPoint(), segFirst.GetEndPoint(), ptOnArc);
					if (segFirst.GetBulge() < 0)
					{
						XPoint ptSt = segTemp.GetStartPoint();
						double dAngle = segTemp.GetBulge();
						segTemp.SetStartPoint(segTemp.GetEndPoint());
						segTemp.SetEndPoint(ptSt);
						segTemp.SetBulge(-dAngle);
					}
					segFirst = segTemp;
				}

				if((segSec.HitTest2d(ptOnArc) == 4) || (segSec.HitTest2d(ptOnArc) == 7))
				{
					segTemp = segSec;
					CutOutArc(segTemp, segSec, ptOnArc, TRUE);
				}
				else
				{
					segTemp = XArc(ptOnArc, segSec.GetStartPoint(), segSec.GetEndPoint());
					if (segSec.GetBulge() < 0)
					{
						double dAngle = segTemp.GetBulge();
						if (segFirst.GetEndPoint() != segTemp.GetStartPoint())
						{
							XPoint ptSt = segTemp.GetStartPoint();
							segTemp.SetStartPoint(segTemp.GetEndPoint());
							segTemp.SetEndPoint(ptSt);
						}	
						segTemp.SetBulge(-dAngle);
					}
					segSec = segTemp;
				}
			}
		}
		else
		{
			AcGeVector3d vecPreTan = segFirst.GetEndPoint()  - segFirst.GetArc().GetCenterPt();
			if (segFirst.GetBulge() > 0)
				vecPreTan = vecPreTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			else
				vecPreTan = vecPreTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			XLine tanline(segFirst.GetEndPoint(), segFirst.GetEndPoint() + segFirst.GetLength() * vecPreTan /vecPreTan.length());
			nInterNum = segFirst.Intersection(segSec, ptInter[0], ptInter[1]);
			int nFlag = segFirst.HitTest2d(ptInter[0]);
			nFlag = segSec.HitTest2d(ptInter[0]);
			nFlag = tanline.OnWhichSide(segSec.GetEndPoint());
			if ((nInterNum == 1) && (!((segFirst.GetBulge() > 0) && (tanline.OnWhichSide(segSec.GetEndPoint())))) && (!((segFirst.GetBulge() < 0)/* && (tanline.OnWhichSide(segSec.GetEndPoint()))*/)))
			{
				segSec.SetStartPoint(ptInter[0]);
				segTemp = segFirst;
				CutOutArc(segTemp, segFirst, ptInter[0], FALSE);
			}
			else if(nInterNum == 2)
			{
				if (ptInter[0].Distance(segFirst.GetEndPoint()) > ptInter[1].Distance(segFirst.GetEndPoint()))
				{
					segSec.SetStartPoint(ptInter[1]);
					segTemp = segFirst;
					CutOutArc(segTemp, segFirst, ptInter[1], FALSE);
				}
				else
				{
					segSec.SetStartPoint(ptInter[0]);
					segTemp = segFirst;
					CutOutArc(segTemp, segFirst, ptInter[0], FALSE);
				}	
			}
			else
			{
				segTemp = segSec;
				double dRad = segFirst.GetArc().GetRadius();
				XCircle circleS(segFirst.GetArc().GetCenterPt(), dRad);
				AcGeVector3d vec = segSec.GetStartPoint() - segSec.GetEndPoint();
				segTemp.SetEndPoint(segSec.GetEndPoint() - 2 * segFirst.GetLength() * vec / vec.length());
				segTemp.SetStartPoint(segSec.GetStartPoint() + 2 * segFirst.GetLength() * vec / vec.length());
				if(segTemp.Intersection(&circleS, ptInter[0], ptInter[1]) == 0)
					return FALSE;
				if (ptInter[0].Distance(segFirst.GetEndPoint()) > ptInter[1].Distance(segFirst.GetEndPoint()))
				{
					if (segSec.HitTest2d(ptInter[1]) == 5)
					{
						segTemp = segFirst;
						CutOutArc(segTemp, segFirst, ptInter[1], FALSE);
					}
					else
					{
						segTemp = XArc(segFirst.GetStartPoint(), segFirst.GetEndPoint(), ptInter[1]);
						if (segFirst.GetBulge() < 0)
						{
							double dAngle = segTemp.GetBulge();
							segTemp.SetStartPoint(segFirst.GetStartPoint());
							segTemp.SetEndPoint(ptInter[1]);
							segTemp.SetBulge(-dAngle);
						}
						segFirst = segTemp;
					}
					segSec.SetStartPoint(ptInter[1]);
				}
				else
				{
					
					int n = segSec.HitTest2d(ptInter[0]);
					if (segSec.HitTest2d(ptInter[0]) == 5)
					{
						segTemp = segFirst;
						CutOutArc(segTemp, segFirst, ptInter[0], FALSE);
					}
					else
					{
						segTemp = XArc(segFirst.GetStartPoint(), segFirst.GetEndPoint(), ptInter[0]);
						if (segFirst.GetBulge() < 0)
						{
							XPoint ptSt = segTemp.GetStartPoint();
							double dAngle = segTemp.GetBulge();
							segTemp.SetStartPoint(segTemp.GetEndPoint());
							segTemp.SetEndPoint(ptSt);
							segTemp.SetBulge(-dAngle);
						}
						segFirst = segTemp;
					}
					segSec.SetStartPoint(ptInter[0]);	
				}
			}
		}
	}
	else
	{
		if (abs(segSec.GetBulge()) > 1.0e-6)
		{
			XPoint ptTemp;
			AcGeVector3d vec = segSec.GetStartPoint() - segSec.GetArc().GetCenterPt();
			if (segSec.GetBulge() > 0)
			{
				vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
				ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vec / vec.length();
			}
			else
			{
				vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
				ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vec / vec.length();
			}
			nInterNum = segFirst.Intersection(segSec, ptInter[0], ptInter[1]);
			if((nInterNum == 1 ) && (!segFirst.OnWhichSide(segSec.GetArc().GetCenterPt())) && (segSec.GetBulge() < 0))
			{
				segFirst.SetEndPoint(ptInter[0]);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptInter[0], TRUE);
			}
			else if (nInterNum == 2)
			{
				if (ptInter[0].Distance(segSec.GetStartPoint()) > ptInter[1].Distance(segSec.GetStartPoint()))
				{
					ptOnArc = ptInter[1];
					if (segSec.GetBulge() > 0)
					{
						if((!segFirst.OnWhichSide(ptTemp)) &&(segFirst.OnWhichSide(segSec.GetArc().GetCenterPt())))
							ptOnArc = ptInter[0];
					}
				}
				else
				{
					ptOnArc = ptInter[0];
					
					if (segSec.GetBulge() > 0)
					{
						if((!segFirst.OnWhichSide(ptTemp)) &&(segFirst.OnWhichSide(segSec.GetArc().GetCenterPt())))
							ptOnArc = ptInter[1];
					}
				}	
				segFirst.SetEndPoint(ptOnArc);
				segTemp = segSec;
				CutOutArc(segTemp, segSec, ptOnArc, TRUE);
			}
			else
			{
				segTemp = segFirst;
				double dRad = segSec.GetArc().GetRadius();
				XCircle circleS(segSec.GetArc().GetCenterPt(), dRad);
				AcGeVector3d vec = segFirst.GetEndPoint() - segFirst.GetStartPoint();
				segTemp.SetEndPoint(segFirst.GetEndPoint() + 2 * dRad * PI * vec / vec.length());
				segTemp.SetStartPoint(segFirst.GetStartPoint() - 2 * dRad * PI * vec / vec.length());
				nInterNum = segTemp.Intersection(&circleS, ptInter[0], ptInter[1]);
				if(nInterNum == 0)
					return FALSE;
				if (ptInter[0].Distance(segFirst.GetEndPoint()) > ptInter[1].Distance(segFirst.GetEndPoint()))
				{
					int nFlag = segSec.HitTest2d(ptInter[1]);
					if ((segFirst.HitTest2d(ptInter[1]) == 5) || (segSec.HitTest2d(ptInter[1]) == 6))
					{
						segTemp = segSec;
						CutOutArc(segTemp, segSec, ptInter[1], TRUE);
					}
					else
					{
						segTemp = XArc(ptInter[1], segSec.GetStartPoint(), segSec.GetEndPoint());
						if (segSec.GetBulge() < 0)
						{
							double dAngle = segTemp.GetBulge();
							segTemp.SetStartPoint(ptInter[1]);
							segTemp.SetEndPoint(segSec.GetEndPoint());
							segTemp.SetBulge(-dAngle);
						}
						segSec = segTemp;
					}
					segFirst.SetEndPoint(ptInter[1]);	
				}
				else
				{
					if (segFirst.HitTest2d(ptInter[0]) == 5)
					{
						segFirst.SetEndPoint(ptInter[0]);
						segTemp = segSec;
						CutOutArc(segTemp, segSec, ptInter[0], TRUE);
					}
					else
					{
						segFirst.SetEndPoint(ptInter[0]);
						segTemp = XArc(ptInter[0], segSec.GetStartPoint(), segSec.GetEndPoint());
						if (segSec.GetBulge() < 0)
						{
							XPoint ptSt = segTemp.GetStartPoint();
							double dAngle = segTemp.GetBulge();
							segTemp.SetStartPoint(segTemp.GetEndPoint());
							segTemp.SetEndPoint(ptSt);
							segTemp.SetBulge(-dAngle);
						}
						segSec = segTemp;
					}
				}
			}					
		}
		else
		{
			AcGeVector3d vec = segFirst.GetEndPoint() - segFirst.GetStartPoint();
			AcGeVector3d vecNew = segSec.GetEndPoint() - segSec.GetStartPoint();
			angle = vec.angleTo(vecNew);
			segFirst.SetEndPoint(segFirst.GetEndPoint() + 2 * dWidth * tan(0.5 * angle) * vec / vec.length());
			segSec.SetStartPoint(segSec.GetStartPoint() - 2 * dWidth * tan(0.5 * angle) * vecNew / vecNew.length());
			TGGeLine ll(segSec.GetLine());
			if(segFirst.GetLine().Intersection(&ll, ptInter[0]) == 1)
			{
				segFirst.SetEndPoint(ptInter[0]);
				segSec.SetStartPoint(ptInter[0]);
			}
			else
			{
				return FALSE;
			}
			
		}
	}
	return TRUE;
}
BOOL FilletLineAndArc(TGGeCurveSegment &segPre, TGGeCurveSegment &SegSec, double dRad, XPoly2D &xPolyNew)
{
	XPoint ptArcEnd, ptArcSt, ptCenter, ptProject, ptCenterNew;
	TGGeCurveSegment segPreArc, segArc, segTemp;
	ptArcEnd = SegSec.GetEndPoint();
	ptCenter = SegSec.GetArc().GetCenterPt();
	double dRadius = SegSec.GetArc().GetRadius();
	segPre.ProjectToMe(ptCenter, ptProject);
	double dLength = abs(segPre.GetDist2Me(ptCenter));
	AcGeVector3d vecTan = SegSec.GetStartPoint() - ptCenter;
	AcGeVector3d vec = segPre.GetEndPoint() - segPre.GetStartPoint();
	XPoint pt[2];
	SegSec.Intersection(segPre.GetLine(),pt[0], pt[1]);
	double dAngle; 
	if (SegSec.GetBulge() > 0)
	{
		vecTan = vecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
		XPoint ptTemp = SegSec.GetStartPoint() + SegSec.GetLength() * vecTan / vecTan.length();
		if (segPre.OnWhichSide(ptTemp))
		{
			if (segPre.OnWhichSide(ptCenter))
			{
				if (dLength > dRad)
				{
					if ((dLength - dRad) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = acos((dLength - dRad) / (dRadius + dRad));
					dAngle = PI - dAngle;
				}
				else
				{
					if ((dRad - dLength) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = acos((dRad - dLength) / (dRadius + dRad));
				}				
			}
			else
			{
				if ((dLength + dRad) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dLength + dRad) / (dRadius + dRad));
			}

			vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
			ptCenterNew = ptCenter - (dRadius + dRad) * vec / vec.length();
			ptArcEnd = ptCenter - dRadius * vec / vec.length();
			ptArcSt = ptCenterNew + dRad * vegRadial / vegRadial.length();
			segArc.SetStartPoint(ptArcSt);
			segArc.SetEndPoint(ptArcEnd);
			segArc.SetBulge(-dAngle);
			if (segPre.GetLength() < ptArcSt.Distance(segPre.GetEndPoint()))
			{
				return FALSE;
			}
			segPre.SetEndPoint(ptArcSt);
			segTemp = SegSec;
			dAngle = acos((2 * pow(dRadius, 2) - pow(SegSec.GetStartPoint().Distance(ptArcEnd), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(SegSec.GetBulge()))
			{
				return FALSE;
			}
			CutOutArc(segTemp, SegSec, ptArcEnd, TRUE);
		}
		else
		{
			vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			if (dLength > dRad)
			{
				if((dLength - dRad) > (dRadius - dRad))
				{
					return FALSE;
				}
				dAngle = acos((dLength - dRad) / (dRadius - dRad));	
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptCenterNew = ptCenter - (dRadius - dRad) * vec / vec.length();
				ptArcEnd = ptCenter - dRadius * vec / vec.length();
				ptArcSt = ptCenterNew - dRad * vegRadial / vegRadial.length();
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(dAngle);
			}
			else
			{
				if((dRad - dLength) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dRad - dLength) / (dRadius + dRad));
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
				ptCenterNew = ptCenter - (dRadius + dRad) * vec / vec.length();
				ptArcEnd = ptCenter - dRadius * vec / vec.length();
				ptArcSt = ptCenterNew + dRad * vegRadial / vegRadial.length();
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
			}
			if (segPre.GetLength() < ptArcSt.Distance(segPre.GetEndPoint()))
			{
				return FALSE;
			}
			segPre.SetEndPoint(ptArcSt);
			segTemp = SegSec;
			dAngle = acos((2 * pow(dRadius, 2) - pow(SegSec.GetStartPoint().Distance(ptArcEnd), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(SegSec.GetBulge()))
			{
				return FALSE;
			}
			CutOutArc(segTemp, SegSec, ptArcEnd, TRUE);
		}
	}
	else
	{
		vecTan = vecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
		XPoint ptTemp = SegSec.GetStartPoint() + SegSec.GetLength() * vecTan / vecTan.length();
		if (segPre.OnWhichSide(ptTemp))
		{
			vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			if (segPre.OnWhichSide(ptCenter))
			{
				if (dLength > dRad)
				{
					if ((dLength - dRad) > (dRadius - dRad))
					{
						return FALSE;
					}
					dAngle = acos((dLength - dRad) / (dRadius - dRad));
					vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
					ptCenterNew = ptCenter - (dRadius - dRad) * vec / vec.length();
					ptArcEnd = ptCenter - dRadius * vec / vec.length();
					ptArcSt = ptCenterNew  - dRad * vegRadial / vegRadial.length();
				}
				else
				{
					if ((dRad - dLength) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = acos((dRad - dLength) / (dRadius + dRad));
					vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
					ptCenterNew = ptCenter + (dRadius + dRad) * vec / vec.length();
					ptArcEnd = ptCenter + dRadius * vec / vec.length();
					ptArcSt = ptCenterNew  - dRad * vegRadial / vegRadial.length();
				}
				
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(-dAngle);
			}
			else
			{
				if ((dLength + dRad) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dLength + dRad) / (dRadius + dRad));
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
				ptCenterNew = ptCenter - (dRadius + dRad) * vec / vec.length();
				ptArcEnd = ptCenter - dRadius * vec / vec.length();
				ptArcSt = ptCenterNew  + dRad * vegRadial / vegRadial.length();
				segArc.SetStartPoint(ptArcSt);
				segArc.SetEndPoint(ptArcEnd);
				segArc.SetBulge(dAngle);
			}
			if (segPre.GetLength() < ptArcSt.Distance(segPre.GetEndPoint()))
			{
				return FALSE;
			}
			dAngle = acos((2 * pow(dRadius, 2) - pow(SegSec.GetStartPoint().Distance(ptArcEnd), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(SegSec.GetBulge()))
			{
				return FALSE;
			}
			segPre.SetEndPoint(ptArcSt);
			segTemp = SegSec;
			CutOutArc(segTemp, SegSec, ptArcEnd, TRUE);
		}
		else
		{
			vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			AcGeVector3d vegRadial = vec;
			if (segPre.OnWhichSide(ptCenter))
			{
				if ((dRad + dLength) > (dRadius + dRad))
				{
					return FALSE;
				}
				dAngle = acos((dRad + dLength) / (dRadius + dRad));
			}
			else
			{
				if (dLength > dRad)
				{
					if((dLength - dRad) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = asin((dLength - dRad) / (dRadius + dRad)) + 0.5 * PI;
				}
				else
				{
					if((dRad - dLength) > (dRadius + dRad))
					{
						return FALSE;
					}
					dAngle = acos((dRad - dLength) / (dRadius + dRad));

				}
			}
			vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
			ptCenterNew = ptCenter + (dRadius + dRad) * vec / vec.length();
			ptArcEnd = ptCenter + dRadius * vec / vec.length();
			ptArcSt = ptCenterNew  - dRad * vegRadial / vegRadial.length();
			segArc.SetStartPoint(ptArcSt);
			segArc.SetEndPoint(ptArcEnd);
			segArc.SetBulge(dAngle);
			if (segPre.GetLength() < ptArcSt.Distance(segPre.GetEndPoint()))
			{
				return FALSE;
			}
			dAngle = acos((2 * pow(dRadius, 2) - pow(SegSec.GetStartPoint().Distance(ptArcEnd), 2)) / (2 * pow(dRadius, 2)));
			if (dAngle > abs(SegSec.GetBulge()))
			{
				return FALSE;
			}
			segPre.SetEndPoint(ptArcSt);
			segTemp = SegSec;
			CutOutArc(segTemp, SegSec, ptArcEnd, TRUE);
		}
	}
	xPolyNew.AppendSegment(segPre, 0, 0);
	xPolyNew.AppendSegment(segArc, 0, 0);
	xPolyNew.AppendSegment(SegSec, 0, 1);
	return TRUE;
}
void FilletRampPoly(XPoly2D &rampPolyBase, XPoly2D &rampPolyLeftOut, XPoly2D &rampPolyLeftIn, XPoly2D &rampPolyRightOut, XPoly2D &rampPolyRightIn, XPoly2D &rampPolyMid)
{
	XPoly2D polyLeftOut, polyRightOut, polyLeftIn, polyRightIn, polyTemp, polyMid;
	TGGeCurveSegment segPre, segSec, segLeftPre, segMidPre, segRightPreIn, segRightPreOut;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth, dAngle;
	XPoint ptSt;
	BOOL bIsFirst;
	dWidth = pRampDataManage->GetRampWidth();
	if (rampPolyBase.TotalSegments() == 1)
	{
		rampPolyLeftIn = rampPolyBase;
		rampPolyBase.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), rampPolyLeftOut);
		rampPolyBase.Offset(0.5 * dWidth, rampPolyMid);
		rampPolyBase.Offset(dWidth, rampPolyRightIn);
		rampPolyBase.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), rampPolyRightOut);
		return;
	}
	rampPolyBase.Nth(0, segPre);
	if (rampPolyBase.GetBulge(0) < 0)
	{
		ptSt = segPre.GetStartPoint();
		dAngle = segPre.GetBulge();
		segPre.SetStartPoint(segPre.GetEndPoint());
		segPre.SetEndPoint(ptSt);
		segPre.SetBulge(-dAngle);
	}
	for (int i = 1; i < rampPolyBase.TotalSegments(); ++i)
	{
		if (i == 1)
		{
			bIsFirst = TRUE;
		}
		else
		{
			bIsFirst = FALSE;
		}
		rampPolyBase.Nth(i, segSec);
		if (rampPolyBase.GetBulge(i) < 0)
		{
			ptSt = segSec.GetStartPoint();
			dAngle = segSec.GetBulge();
			segSec.SetStartPoint(segSec.GetEndPoint());
			segSec.SetEndPoint(ptSt);
			segSec.SetBulge(-dAngle);
		}
		if (abs(segPre.GetBulge()) > 1.0E-6)
		{
			if (abs(segSec.GetBulge()) > 1.0E-6)
			{
				GetExcircleForArc(segPre, segLeftPre, segMidPre, segRightPreIn, segRightPreOut, segSec, polyLeftOut, polyLeftIn, polyRightOut, polyRightIn, polyMid, bIsFirst);
			}
			else
			{
				GetExcircleForArcAndLine(segPre, segLeftPre, segMidPre, segRightPreIn, segRightPreOut, segSec, polyLeftOut, polyLeftIn, polyRightOut, polyRightIn, polyMid, bIsFirst);
			}
		}
		else
		{
			if (abs(segSec.GetBulge()) > 1.0E-6)
			{
				GetExcircleForLineAndArc(segPre, segLeftPre, segMidPre, segRightPreIn, segRightPreOut, segSec, polyLeftOut, polyLeftIn, polyRightOut, polyRightIn, polyMid, bIsFirst);
			}
			else
			{
				GetExcircleForDoubleLine(segPre, segLeftPre, segMidPre, segRightPreIn, segRightPreOut, segSec, polyLeftOut, polyLeftIn, polyRightOut, polyRightIn, polyMid, bIsFirst);
			}
		}
		polyTemp = rampPolyLeftOut;
		rampPolyLeftOut.Reset();
		MergerPoly(polyTemp, polyLeftOut, rampPolyLeftOut);
		polyTemp = rampPolyLeftIn;
		rampPolyLeftIn.Reset();
		MergerPoly(polyTemp, polyLeftIn, rampPolyLeftIn);
		polyTemp = rampPolyRightOut;
		rampPolyRightOut.Reset();
		MergerPoly(polyTemp, polyRightOut, rampPolyRightOut);
		polyTemp = rampPolyRightIn;
		rampPolyRightIn.Reset();
		MergerPoly(polyTemp, polyRightIn, rampPolyRightIn);	
		polyTemp = rampPolyMid;
		rampPolyMid.Reset();
		MergerPoly(polyTemp, polyMid, rampPolyMid);	
		polyLeftOut.Reset();
		polyLeftIn.Reset();
		polyRightOut.Reset();
		polyRightIn.Reset();
		polyMid.Reset();
		rampPolyLeftOut.Nth(rampPolyLeftOut.TotalSegments() - 1, segLeftPre);
		rampPolyLeftIn.Nth(rampPolyLeftIn.TotalSegments() - 1, segPre);
		rampPolyMid.Nth(rampPolyMid.TotalSegments() - 1, segMidPre);
		rampPolyRightIn.Nth(rampPolyRightIn.TotalSegments() - 1, segRightPreIn);
		rampPolyRightOut.Nth(rampPolyRightOut.TotalSegments() - 1, segRightPreOut);
		if (rampPolyLeftOut.TotalSegments() < 1)
			return;
		if (rampPolyLeftOut.GetBulge(rampPolyLeftOut.TotalSegments() - 1) < 0)
		{
			ptSt = segLeftPre.GetStartPoint();
			dAngle = segLeftPre.GetBulge();
			segLeftPre.SetStartPoint(segLeftPre.GetEndPoint());
			segLeftPre.SetEndPoint(ptSt);
			segLeftPre.SetBulge(-dAngle);
		}

		if (rampPolyLeftIn.GetBulge(rampPolyLeftIn.TotalSegments() - 1) < 0)
		{
			ptSt = segPre.GetStartPoint();
			dAngle = segPre.GetBulge();
			segPre.SetStartPoint(segPre.GetEndPoint());
			segPre.SetEndPoint(ptSt);
			segPre.SetBulge(-dAngle);
		}
		if (rampPolyMid.GetBulge(rampPolyMid.TotalSegments() - 1) < 0)
		{
			ptSt = segMidPre.GetStartPoint();
			dAngle = segMidPre.GetBulge();
			segMidPre.SetStartPoint(segMidPre.GetEndPoint());
			segMidPre.SetEndPoint(ptSt);
			segMidPre.SetBulge(-dAngle);
		}
		if (rampPolyRightIn.GetBulge(rampPolyRightIn.TotalSegments() - 1) < 0)
		{
			ptSt = segRightPreIn.GetStartPoint();
			dAngle = segRightPreIn.GetBulge();
			segRightPreIn.SetStartPoint(segRightPreIn.GetEndPoint());
			segRightPreIn.SetEndPoint(ptSt);
			segRightPreIn.SetBulge(-dAngle);
		}
		if (rampPolyRightOut.GetBulge(rampPolyRightOut.TotalSegments() - 1) < 0)
		{
			ptSt = segRightPreOut.GetStartPoint();
			dAngle = segRightPreOut.GetBulge();
			segRightPreOut.SetStartPoint(segRightPreOut.GetEndPoint());
			segRightPreOut.SetEndPoint(ptSt);
			segRightPreOut.SetBulge(-dAngle);
		}
	}
}

void FilletCrossLine(TGGeCurveSegment &segPre, TGGeCurveSegment &seg, double dRad, XPoly2D &xPolyNew, XPoint &ptCenter)
{
	XPoint ptArcSt, ptArcEnd, ptArcMid;
	AcGeVector3d vecPre = segPre.GetEndPoint().AsAcGePoint3d() - segPre.GetStartPoint().AsAcGePoint3d();
	AcGeVector3d vecSeg = seg.GetEndPoint().AsAcGePoint3d() - seg.GetStartPoint().AsAcGePoint3d();
	double dAngle =  vecPre.angleTo(vecSeg);
	double dLength;	
	dLength = dRad * tan(0.5 * dAngle);
	ptArcEnd = segPre.GetEndPoint() + dLength * vecSeg / vecSeg.length();
	ptArcSt = segPre.GetEndPoint() - dLength * vecPre / vecPre.length();
	if (segPre.OnWhichSide(seg.GetEndPoint()))
		vecSeg = vecSeg.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
	else
		vecSeg = vecSeg.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
	ptCenter = ptArcEnd + dRad * vecSeg / vecSeg.length();
	vecSeg = segPre.GetEndPoint().AsAcGePoint3d() - ptCenter.AsAcGePoint3d();
	ptArcMid = ptCenter + dRad * vecSeg / vecSeg.length();
	TGGeCurveSegment segArc,segTemp;

	XArc xArc(ptArcSt, ptArcMid, ptArcEnd);

	segPre.SetEndPoint(ptArcSt);
	seg.SetStartPoint(ptArcEnd);

	segArc = xArc;
	segTemp = xArc;
	xPolyNew.AppendSegment(segPre, 0, 0);
	if (segPre.OnWhichSide(seg.GetEndPoint()))
	{
		segArc.SetStartPoint(ptArcSt);
		segArc.SetEndPoint(ptArcEnd);
		segArc.SetBulge(-segTemp.GetBulge());
	}

	xPolyNew.AppendSegment(segArc, 0, 0);
	xPolyNew.AppendSegment(seg, 0, 1);	

}

void GetExcircleForArcAndLine(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &polyMid, BOOL bIsFirst)
{
	TGGeCurveSegment segLeftPreOut, segLeftSecondOut, segRightPreOut, segRightSecondOut, segRightPreIn, segRightSecondIn, segMidPre, segMidSecond, segTan, segPreTan, segSecTan;
	AcGeVector3d vecTan, vecPreTan, vecSecTan;
	XPoint ptTemp;
	BOOL bIsCanFillet = TRUE;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth, dTurnningRad;
	dWidth = pRampDataManage->GetRampWidth();
	dTurnningRad = pRampDataManage->GetTurningRad();
	vecTan = segPre.GetEndPoint() - segPre.GetArc().GetCenterPt();
	vecSecTan = segSec.GetEndPoint() - segSec.GetStartPoint();
	segLeftSecondOut = segSec.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);		
	segMidSecond = segSec.Offset(0.5 * dWidth, LS_INFINITE);	
	segRightSecondIn = segSec.Offset(dWidth, LS_INFINITE);	
	segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
	if (segPre.GetBulge() > 0)
	{
		segLeftPreOut = segPre.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		segMidPre = segPre.Offset(0.5 * dWidth, LS_INFINITE);
		segRightPreIn = segPre.Offset((dWidth), LS_INFINITE);
		segRightPreOut = segPre.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		if (!bIsFirst)
		{
			segLeftPreOut = segLeft;
			segMidPre = segMid;
			segRightPreIn = segRightIn;
			segRightPreOut = segRightOut;
		}
		GetInterLine(segLeftPreOut, segLeftSecondOut);
		GetInterLine(segMidPre, segMidSecond);
		GetInterLine(segRightPreIn, segRightSecondIn);
		GetInterLine(segRightPreOut, segRightSecondOut);
		vecTan = vecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
		segTan = XLine(segPre.GetEndPoint(), segPre.GetEndPoint() + segPre.GetLength() * vecTan / vecTan.length());
		if (vecTan.isParallelTo(vecSecTan))
		{
			polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
			polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);
			polyMid.AppendSegment(segMidPre, 0, 0);
			polyMid.AppendSegment(segMidSecond, 0, 1);
			polyLeftIn.AppendSegment(segPre, 0, 0);
			polyLeftIn.AppendSegment(segSec, 0, 1);
			polyRightIn.AppendSegment(segRightPreIn, 0, 0);
			polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
			polyRightOut.AppendSegment(segRightPreOut, 0, 0);
			polyRightOut.AppendSegment(segRightSecondOut, 0, 1);
			return;
		}
		else if (segTan.OnWhichSide(segSec.GetEndPoint()))
		{
			if (!FilletArcAndLine(segPre, segSec,dWidth + dTurnningRad, polyLeftIn))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segRightPreIn, segRightSecondIn,dTurnningRad, polyRightIn))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
				bIsCanFillet = FALSE;
		}
		else
		{
			
			if (!FilletArcAndLine(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segPre, segSec,dTurnningRad, polyLeftIn))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segRightPreIn, segRightSecondIn,dWidth + dTurnningRad, polyRightIn))
				bIsCanFillet = FALSE;
		}
	}
	else
	{
		XPoint ptst, ptEnd, ptCenter;
		double dAngle = segPre.GetBulge();	
		vecTan = vecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
		segTan = XLine(segPre.GetEndPoint(), segPre.GetEndPoint() + segPre.GetLength() * vecTan / vecTan.length());
		segLeftPreOut = segPre.Offset(_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		segMidPre = segPre.Offset(-0.5 * dWidth, LS_INFINITE);		
		segRightPreIn = segPre.Offset(-dWidth, LS_INFINITE);		
		segRightPreOut = segPre.Offset(-(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);
		
		ptTemp = segLeftPreOut.GetStartPoint();
		segLeftPreOut.SetStartPoint(segLeftPreOut.GetEndPoint());
		segLeftPreOut.SetEndPoint(ptTemp);
		segLeftPreOut.SetBulge(dAngle);		

		ptTemp = segMidPre.GetStartPoint();
		segMidPre.SetStartPoint(segMidPre.GetEndPoint());
		segMidPre.SetEndPoint(ptTemp);
		segMidPre.SetBulge(dAngle);		

		ptTemp = segRightPreIn.GetStartPoint();
		segRightPreIn.SetStartPoint(segRightPreIn.GetEndPoint());
		segRightPreIn.SetEndPoint(ptTemp);
		segRightPreIn.SetBulge(dAngle);			

		ptTemp = segRightPreOut.GetStartPoint();
		segRightPreOut.SetStartPoint(segRightPreOut.GetEndPoint());
		segRightPreOut.SetEndPoint(ptTemp);
		segRightPreOut.SetBulge(dAngle);

		if (!bIsFirst)
		{
			segLeftPreOut = segLeft;
			segMidPre = segMid;
			segRightPreIn = segRightIn;
			segRightPreOut = segRightOut;
		}
		GetInterLine(segLeftPreOut, segLeftSecondOut);
		GetInterLine(segMidPre, segMidSecond);
		GetInterLine(segRightPreIn, segRightSecondIn);
		GetInterLine(segRightPreOut, segRightSecondOut);
		if (vecTan.isParallelTo(vecSecTan))
		{
			polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
			polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);
			polyMid.AppendSegment(segMidPre, 0, 0);
			polyMid.AppendSegment(segMidSecond, 0, 1);
			polyLeftIn.AppendSegment(segPre, 0, 0);
			polyLeftIn.AppendSegment(segSec, 0, 1);
			polyRightIn.AppendSegment(segRightPreIn, 0, 0);
			polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
			polyRightOut.AppendSegment(segRightPreOut, 0, 0);
			polyRightOut.AppendSegment(segRightSecondOut, 0, 1);
			return;
		}
		else if (segTan.OnWhichSide(segSec.GetEndPoint()))
		{
			if (!FilletArcAndLine(segPre, segSec,dWidth + dTurnningRad, polyLeftIn))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segRightPreIn, segRightSecondIn,dTurnningRad, polyRightIn))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
				bIsCanFillet = FALSE;
			
		}
		else
		{
			if(!FilletArcAndLine(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segPre, segSec,dTurnningRad, polyLeftIn))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
				bIsCanFillet = FALSE;
			if(!FilletArcAndLine(segRightPreIn, segRightSecondIn,dWidth + dTurnningRad, polyRightIn))
				bIsCanFillet = FALSE;
		}
	}
	if (!bIsCanFillet)
	{
		polyLeftIn.Reset();
		polyLeftOut.Reset();
		polyRightIn.Reset();
		polyRightOut.Reset();
		polyMid.Reset();
		polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
		polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);
		polyMid.AppendSegment(segMidPre, 0, 0);
		polyMid.AppendSegment(segMidSecond, 0, 1);
		polyLeftIn.AppendSegment(segPre, 0, 0);
		polyLeftIn.AppendSegment(segSec, 0, 1);
		polyRightIn.AppendSegment(segRightPreIn, 0, 0);
		polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
		polyRightOut.AppendSegment(segRightPreOut, 0, 0);
		polyRightOut.AppendSegment(segRightSecondOut, 0, 1);
	}
}

void GetExcircleForLineAndArc(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &polyMid, BOOL bIsFirst)
{
	TGGeCurveSegment segLeftPreOut, segLeftSecondOut, segRightPreOut, segRightSecondOut, segRightPreIn, segRightSecondIn, segMidPre, segMidSecond, segTan, segPreTan, segSecTan;
	AcGeVector3d vecTan, vecPreTan, vecSecTan;
	XPoint ptTemp;
	BOOL bIsCanFillet = TRUE;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth, dTurnningRad, dAngle;
	dWidth = pRampDataManage->GetRampWidth();
	dTurnningRad = pRampDataManage->GetTurningRad();
	dAngle = segSec.GetBulge();
	
	vecSecTan = segPre.GetEndPoint() - segPre.GetStartPoint();
	vecTan = segSec.GetStartPoint() - segSec.GetArc().GetCenterPt();
	
	if (dAngle < 0)
	{
		segLeftPreOut = segPre.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);	
		segMidPre = segPre.Offset(1, 0.5 * dWidth, LS_INFINITE);
		segRightPreIn = segPre.Offset(1, dWidth, LS_INFINITE);
		segRightPreOut = segPre.Offset(1, dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		if (!bIsFirst)
		{
			segLeftPreOut = segLeft;
			segMidPre = segMid;
			segRightPreIn = segRightIn;
			segRightPreOut = segRightOut;
		}			
		segLeftSecondOut = segSec.Offset(_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);	
		segMidSecond = segSec.Offset(-0.5 * dWidth, LS_INFINITE);	
		segRightSecondIn = segSec.Offset(-dWidth, LS_INFINITE);
		segRightSecondOut = segSec.Offset(-(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);
		ptTemp = segLeftSecondOut.GetStartPoint();
		segLeftSecondOut.SetStartPoint(segLeftSecondOut.GetEndPoint());
		segLeftSecondOut.SetEndPoint(ptTemp);
		segLeftSecondOut.SetBulge(dAngle);	
		ptTemp = segMidSecond.GetStartPoint();
		segMidSecond.SetStartPoint(segMidSecond.GetEndPoint());
		segMidSecond.SetEndPoint(ptTemp);
		segMidSecond.SetBulge(dAngle);	
		ptTemp = segRightSecondIn.GetStartPoint();
		segRightSecondIn.SetStartPoint(segRightSecondIn.GetEndPoint());
		segRightSecondIn.SetEndPoint(ptTemp);
		segRightSecondIn.SetBulge(dAngle);		
		ptTemp = segRightSecondOut.GetStartPoint();
		segRightSecondOut.SetStartPoint(segRightSecondOut.GetEndPoint());
		segRightSecondOut.SetEndPoint(ptTemp);
		segRightSecondOut.SetBulge(dAngle);	
		vecTan = vecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
	}
	else
	{
		segLeftPreOut = segPre.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);	
		segMidPre = segPre.Offset(0.5 * dWidth, LS_INFINITE);		
		segRightPreIn = segPre.Offset(dWidth, LS_INFINITE);		
		segRightPreOut = segPre.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		if (!bIsFirst)
		{
			segLeftPreOut = segLeft;
			segMidPre = segMid;
			segRightPreIn = segRightIn;
			segRightPreOut = segRightOut;
		}		
		segLeftSecondOut = segSec.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);		
		segMidSecond = segSec.Offset(0.5 * dWidth, LS_INFINITE);		
		segRightSecondIn = segSec.Offset(dWidth, LS_INFINITE);		
		segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);		
		vecTan = vecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
	}
	GetInterLine(segLeftPreOut, segLeftSecondOut);
	GetInterLine(segMidPre, segMidSecond);
	GetInterLine(segRightPreIn, segRightSecondIn);
	GetInterLine(segRightPreOut, segRightSecondOut);
	ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vecTan / vecTan.length();
	if (vecSecTan.isParallelTo(vecTan))
	{
		polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
		polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);
		polyMid.AppendSegment(segMidPre, 0, 0);
		polyMid.AppendSegment(segMidSecond, 0, 1);
		polyLeftIn.AppendSegment(segPre, 0, 0);
		polyLeftIn.AppendSegment(segSec, 0, 1);
		polyRightOut.AppendSegment(segRightPreOut, 0, 0);
		polyRightOut.AppendSegment(segRightSecondOut, 0, 1);
		polyRightIn.AppendSegment(segRightPreIn, 0, 0);
		polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
		return;
	}
	if (segPre.OnWhichSide(ptTemp))
	{
		if(!FilletLineAndArc(segPre, segSec,dWidth + dTurnningRad, polyLeftIn))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segRightPreIn, segRightSecondIn,dTurnningRad, polyRightIn))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
			bIsCanFillet = FALSE;
	}
	else
	{
		if(!FilletLineAndArc(segPre, segSec,dTurnningRad, polyLeftIn))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segRightPreIn, segRightSecondIn,dWidth + dTurnningRad, polyRightIn))
			bIsCanFillet = FALSE;
		if(!FilletLineAndArc(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
			bIsCanFillet = FALSE;
	}
	if (!bIsCanFillet)
	{
		polyLeftIn.Reset();
		polyLeftOut.Reset();
		polyRightIn.Reset();
		polyRightOut.Reset();
		polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
		polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);
		polyMid.AppendSegment(segMidPre, 0, 0);
		polyMid.AppendSegment(segMidSecond, 0, 1);
		polyLeftIn.AppendSegment(segPre, 0, 0);
		polyLeftIn.AppendSegment(segSec, 0, 1);
		polyRightOut.AppendSegment(segRightPreOut, 0, 0);
		polyRightOut.AppendSegment(segRightSecondOut, 0, 1);
		polyRightIn.AppendSegment(segRightPreIn, 0, 0);
		polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
		return;
	}
}

void MergerPoly(XPoly2D &polyPre, XPoly2D &polyAdd, XPoly2D &xpolyNew)
{
	for (int i = 0; i < polyPre.TotalSegments() - 1; ++i)
	{
		TGGeCurveSegment segTemp;
		polyPre.Nth(i, segTemp);
		if (polyPre.GetBulge(i) < 0)
		{
			XPoint ptSt = segTemp.GetStartPoint();
			double dAngle = segTemp.GetBulge();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptSt);
			segTemp.SetBulge(-dAngle);
		}
		xpolyNew.AppendSegment(segTemp, 0, 0);
	}
	for (int i = 0; i < polyAdd.TotalSegments(); ++i)
	{
		TGGeCurveSegment segTemp;
		polyAdd.Nth(i, segTemp);
		if (polyAdd.GetBulge(i) < 0)
		{
			XPoint ptSt = segTemp.GetStartPoint();
			double dAngle = segTemp.GetBulge();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptSt);
			segTemp.SetBulge(-dAngle);
		}
		if (i == polyAdd.TotalSegments() - 1)
			xpolyNew.AppendSegment(segTemp, 0, 1);
		else
			xpolyNew.AppendSegment(segTemp, 0, 0);
	}
}
void GetExcircleForDoubleLine(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &polyMid, BOOL bIsFirst)
{
	TGGeCurveSegment segLeftPreOut, segLeftSecondOut, segRightPreOut, segRightSecondOut, segRightPreIn, segRightSecondIn, segMidPre, segMidSecond, seg;
	AcGeVector3d vecPre, vecSeg;
	XPoint ptCenter;
	BOOL bCanFillet = TRUE;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth, dTurnningRad, dAngle, dLength;
	dWidth = pRampDataManage->GetRampWidth();
	dTurnningRad = pRampDataManage->GetTurningRad();
	segLeftPreOut = segPre.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
	segLeftSecondOut = segSec.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
	segMidPre = segPre.Offset(0.5 * dWidth, LS_INFINITE);
	segMidSecond = segSec.Offset(0.5 * dWidth, LS_INFINITE);
	segRightPreIn = segPre.Offset(dWidth, LS_INFINITE);
	segRightSecondIn = segSec.Offset(dWidth, LS_INFINITE);
	segRightPreOut = segPre.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
	segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
	if(!bIsFirst)
	{
		segLeftPreOut = segLeft;
		segMidPre = segMid;
		segRightPreIn = segRightIn;
		segRightPreOut = segRightOut;
	}
	if (!GetInterLine(segLeftPreOut, segLeftSecondOut))
		bCanFillet = FALSE;
	if(!GetInterLine(segMidPre, segMidSecond))
		bCanFillet = FALSE;
	if(!GetInterLine(segRightPreIn, segRightSecondIn))
		bCanFillet = FALSE;
	if(!GetInterLine(segRightPreOut, segRightSecondOut))
		bCanFillet = FALSE;
	
	vecPre = segPre.GetEndPoint().AsAcGePoint3d() - segPre.GetStartPoint().AsAcGePoint3d();
	vecSeg = segSec.GetEndPoint().AsAcGePoint3d() - segSec.GetStartPoint().AsAcGePoint3d();
	dAngle = vecPre.angleTo(vecSeg);
	//当两相交线不够长时，直接返回，不处理拐角
	dLength = (0.5 * dWidth + dTurnningRad) / tan(0.5 * (PI - dAngle));
	if (((segMidPre.GetLength() < dLength) || (segMidSecond.GetLength() < dLength)) || (abs(dAngle) < 1.0e-6) || (!bCanFillet))
	{
		polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
		polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);

		polyMid.AppendSegment(segMidPre, 0, 0);
		polyMid.AppendSegment(segMidSecond, 0, 1);

		polyLeftIn.AppendSegment(segPre, 0, 0);
		polyLeftIn.AppendSegment(segSec, 0, 1);

		polyRightOut.AppendSegment(segRightPreOut, 0, 0);
		polyRightOut.AppendSegment(segRightSecondOut, 0, 1);

		polyRightIn.AppendSegment(segRightPreIn, 0, 0);
		polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
		return;
	}
	////两线方向相同时不处理拐角
	//if(vecPre.isParallelTo(vecSeg))
	//{
	//	polyLeftOut.AppendSegment(segPre, 0, 0);
	//	polyLeftOut.AppendSegment(segSec, 0, 1);

	//	polyMid.AppendSegment(segMidPre, 0, 0);
	//	polyMid.AppendSegment(segMidSecond, 0, 1);

	//	polyLeftIn.AppendSegment(segLeftPreIn, 0, 0);
	//	polyLeftIn.AppendSegment(segLeftSecondIn, 0, 1);

	//	polyRightOut.AppendSegment(segRightPreOut, 0, 0);
	//	polyRightOut.AppendSegment(segRightSecondOut, 0, 1);

	//	polyRightIn.AppendSegment(segRightPreIn, 0, 0);
	//	polyRightIn.AppendSegment(segRightSecondIn, 0, 1);
	//	return;
	//}
	if (segPre.OnWhichSide(segSec.GetEndPoint()) == 1)
	{
		FilletCrossLine(segPre, segSec, dWidth +dTurnningRad, polyLeftIn, ptCenter);
		FilletCrossLine(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid, ptCenter);
		FilletCrossLine(segLeftPreOut, segLeftSecondOut, dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut, ptCenter);
		FilletCrossLine(segRightPreIn, segRightSecondIn, dTurnningRad, polyRightIn, ptCenter);
		FilletCrossLine(segRightPreOut, segRightSecondOut, dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut, ptCenter);	
	}
	else
	{
		FilletCrossLine(segPre, segSec, dTurnningRad, polyLeftIn, ptCenter);
		FilletCrossLine(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid, ptCenter);
		FilletCrossLine(segLeftPreOut, segLeftSecondOut, dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut, ptCenter);
		FilletCrossLine(segRightPreIn, segRightSecondIn, dWidth + dTurnningRad, polyRightIn, ptCenter);
		FilletCrossLine(segRightPreOut, segRightSecondOut, dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut, ptCenter);	
	}
	
}

void GetExcircleForArc(TGGeCurveSegment &segPre, TGGeCurveSegment &segLeft, TGGeCurveSegment &segMid, TGGeCurveSegment &segRightIn, TGGeCurveSegment &segRightOut, TGGeCurveSegment &segSec, XPoly2D &polyLeftOut, XPoly2D &polyLeftIn, XPoly2D &polyRightOut, XPoly2D &polyRightIn, XPoly2D &polyMid, BOOL bIsFirst)
{
	TGGeCurveSegment segLeftPreOut, segLeftSecondOut, segRightPreOut, segRightSecondOut, segRightPreIn, segRightSecondIn, segMidPre, segMidSecond, segTan, segPreTan, segSecTan;
	AcGeVector3d vecTan, vecPreTan, vecSecTan;
	XPoint ptTemp,ptst;
	BOOL bCanFillet = TRUE;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth, dTurnningRad, dAngle;
	dWidth = pRampDataManage->GetRampWidth();
	dTurnningRad = pRampDataManage->GetTurningRad();
	vecPreTan = segPre.GetEndPoint() - segPre.GetArc().GetCenterPt();
	vecSecTan = segSec.GetStartPoint() - segSec.GetArc().GetCenterPt();
	if (segPre.GetBulge() > 0)
	{
		segLeftPreOut = segPre.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		segMidPre = segPre.Offset(0.5 * dWidth, LS_INFINITE);
		segRightPreIn = segPre.Offset(dWidth, LS_INFINITE);
		segRightPreOut = segPre.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		/*if (!bIsFirst)
		{
			segLeftPreIn = segLeft;
			segMidPre = segMid;
			segRightPreIn = segRightIn;
			segRightPreOut = segRightOut;
		}*/
		vecPreTan = vecPreTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
		segPreTan = XLine(segPre.GetEndPoint(), segPre.GetEndPoint() + segPre.GetLength() * vecPreTan / vecPreTan.length());
		if (segSec.GetBulge() > 0)
		{

			vecSecTan = vecSecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vecSecTan / vecSecTan.length();
			if (segPreTan.OnWhichSide(ptTemp))
			{
				segLeftSecondOut = segSec.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
				segMidSecond = segSec.Offset(0.5 * dWidth, LS_INFINITE);				
				segRightSecondIn = segSec.Offset(dWidth, LS_INFINITE);				
				segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
				GetInterLine(segLeftPreOut, segLeftSecondOut);
				GetInterLine(segMidPre, segMidSecond);
				GetInterLine(segRightPreIn, segRightSecondIn);
				GetInterLine(segRightPreOut, segRightSecondOut);
				if(!FillletArc(segPre, segSec,dWidth + dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dTurnningRad, polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;
			}
			else
			{				
				segLeftSecondOut = segSec.Offset(0, _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);				
				segMidSecond = segSec.Offset(0, -0.5 * dWidth, LS_INFINITE);				
				segRightSecondIn = segSec.Offset(0, -dWidth, LS_INFINITE);				
				segRightSecondOut = segSec.Offset(0, -(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);

				GetInterLine(segLeftPreOut, segLeftSecondOut);
				GetInterLine(segMidPre, segMidSecond);
				GetInterLine(segRightPreIn, segRightSecondIn);
				GetInterLine(segRightPreOut, segRightSecondOut);
				if(!FillletArc(segPre, segSec,dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dWidth + dTurnningRad, polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;
			}
		}
		else
		{
			vecSecTan = vecSecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vecSecTan / vecSecTan.length();
			
			if (segPreTan.OnWhichSide(ptTemp))
			{			
				segLeftSecondOut = segSec.Offset(0, -_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);				
				segMidSecond = segSec.Offset(0, 0.5 * dWidth, LS_INFINITE);				
				segRightSecondIn = segSec.Offset(0, dWidth, LS_INFINITE);				
				segRightSecondOut = segSec.Offset(0, dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
				
				dAngle = segSec.GetBulge();
				ptst = segLeftSecondOut.GetEndPoint();
				segLeftSecondOut.SetEndPoint(segLeftSecondOut.GetStartPoint());
				segLeftSecondOut.SetStartPoint(ptst);
				segLeftSecondOut.SetBulge(dAngle);

				ptst = segMidSecond.GetEndPoint();
				segMidSecond.SetEndPoint(segMidSecond.GetStartPoint());
				segMidSecond.SetStartPoint(ptst);
				segMidSecond.SetBulge(dAngle);

				ptst = segRightSecondIn.GetEndPoint();
				segRightSecondIn.SetEndPoint(segRightSecondIn.GetStartPoint());
				segRightSecondIn.SetStartPoint(ptst);
				segRightSecondIn.SetBulge(dAngle);

				ptst = segRightSecondOut.GetEndPoint();
				segRightSecondOut.SetEndPoint(segRightSecondOut.GetStartPoint());
				segRightSecondOut.SetStartPoint(ptst);
				segRightSecondOut.SetBulge(dAngle);

				GetInterLine(segLeftPreOut, segLeftSecondOut);
				GetInterLine(segMidPre, segMidSecond);
				GetInterLine(segRightPreIn, segRightSecondIn);
				GetInterLine(segRightPreOut, segRightSecondOut);
				if(!FillletArc(segPre, segSec,dWidth + dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))	
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dTurnningRad, polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;
			}
			else
			{
				segLeftSecondOut = segSec.Offset(_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);				
				segMidSecond = segSec.Offset(-0.5 * dWidth, LS_INFINITE);				
				segRightSecondIn = segSec.Offset(-dWidth, LS_INFINITE);				
				segRightSecondOut = segSec.Offset(-(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);
				
				dAngle = segSec.GetBulge();
				ptst = segLeftSecondOut.GetEndPoint();
				segLeftSecondOut.SetEndPoint(segLeftSecondOut.GetStartPoint());
				segLeftSecondOut.SetStartPoint(ptst);
				segLeftSecondOut.SetBulge(dAngle);

				ptst = segMidSecond.GetEndPoint();
				segMidSecond.SetEndPoint(segMidSecond.GetStartPoint());
				segMidSecond.SetStartPoint(ptst);
				segMidSecond.SetBulge(dAngle);

				ptst = segRightSecondIn.GetEndPoint();
				segRightSecondIn.SetEndPoint(segRightSecondIn.GetStartPoint());
				segRightSecondIn.SetStartPoint(ptst);
				segRightSecondIn.SetBulge(dAngle);

				ptst = segRightSecondOut.GetEndPoint();
				segRightSecondOut.SetEndPoint(segRightSecondOut.GetStartPoint());
				segRightSecondOut.SetStartPoint(ptst);
				segRightSecondOut.SetBulge(dAngle);

				GetInterLine(segLeftPreOut, segLeftSecondOut);
				GetInterLine(segMidPre, segMidSecond);
				GetInterLine(segRightPreIn, segRightSecondIn);
				GetInterLine(segRightPreOut, segRightSecondOut);
				if(!FillletArc(segPre, segSec,dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))		
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dWidth + dTurnningRad, polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;
			}
		}
	}
	else
	{
		
		segLeftPreOut = segPre.Offset(_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
		segMidPre = segPre.Offset(-0.5 * dWidth, LS_INFINITE);
		segRightPreIn = segPre.Offset(-dWidth , LS_INFINITE);
		segRightPreOut = segPre.Offset(-(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);
		
		dAngle = segPre.GetBulge();
		ptst = segLeftPreOut.GetEndPoint();
		segLeftPreOut.SetEndPoint(segLeftPreOut.GetStartPoint());
		segLeftPreOut.SetStartPoint(ptst);
		segLeftPreOut.SetBulge(dAngle);

		ptst = segMidPre.GetEndPoint();
		segMidPre.SetEndPoint(segMidPre.GetStartPoint());
		segMidPre.SetStartPoint(ptst);
		segMidPre.SetBulge(dAngle);

		ptst = segRightPreIn.GetEndPoint();
		segRightPreIn.SetEndPoint(segRightPreIn.GetStartPoint());
		segRightPreIn.SetStartPoint(ptst);
		segRightPreIn.SetBulge(dAngle);

		ptst = segRightPreOut.GetEndPoint();
		segRightPreOut.SetEndPoint(segRightPreOut.GetStartPoint());
		segRightPreOut.SetStartPoint(ptst);
		segRightPreOut.SetBulge(dAngle);

		/*if (!bIsFirst)
		{
			segLeftPreIn = segLeft;
			segMidPre = segMid;
			segRightPreIn = segRightIn;
			segRightPreOut = segRightOut;
		}*/
		vecPreTan = vecPreTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
		segPreTan = XLine(segPre.GetEndPoint(), segPre.GetEndPoint() + segPre.GetLength() * vecPreTan / vecPreTan.length());
		if (segSec.GetBulge() > 0)
		{	
			segLeftSecondOut = segSec.Offset(-_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);	
			segMidSecond = segSec.Offset(0.5 * dWidth, LS_INFINITE);
			segRightSecondIn = segSec.Offset(dWidth, LS_INFINITE);
			segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);

			GetInterLine(segLeftPreOut, segLeftSecondOut);
			GetInterLine(segMidPre, segMidSecond);
			GetInterLine(segRightPreIn, segRightSecondIn);
			GetInterLine(segRightPreOut, segRightSecondOut);
			vecSecTan = vecSecTan.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vecSecTan / vecSecTan.length();
			if (segPreTan.OnWhichSide(ptTemp))
			{
				if(!FillletArc(segPre, segSec,dWidth + dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dTurnningRad , polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;
			}
			else
			{
				if(!FillletArc(segPre, segSec,dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dWidth + dTurnningRad, polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;

			}
		}
		else
		{		
			segLeftSecondOut = segSec.Offset(_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);			
			segMidSecond = segSec.Offset(-0.5 * dWidth, LS_INFINITE);			
			segRightSecondIn = segSec.Offset(-dWidth, LS_INFINITE);			
			segRightSecondOut = segSec.Offset(-(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);

			dAngle = segSec.GetBulge();
			ptst = segMidSecond.GetEndPoint();
			segMidSecond.SetEndPoint(segMidSecond.GetStartPoint());
			segMidSecond.SetStartPoint(ptst);
			segMidSecond.SetBulge(dAngle);
			
			ptst = segLeftSecondOut.GetEndPoint();
			segLeftSecondOut.SetEndPoint(segLeftSecondOut.GetStartPoint());
			segLeftSecondOut.SetStartPoint(ptst);
			segLeftSecondOut.SetBulge(dAngle);

			ptst = segRightSecondIn.GetEndPoint();
			segRightSecondIn.SetEndPoint(segRightSecondIn.GetStartPoint());
			segRightSecondIn.SetStartPoint(ptst);
			segRightSecondIn.SetBulge(dAngle);

			ptst = segRightSecondOut.GetEndPoint();
			segRightSecondOut.SetEndPoint(segRightSecondOut.GetStartPoint());
			segRightSecondOut.SetStartPoint(ptst);
			segRightSecondOut.SetBulge(dAngle);
			GetInterLine(segLeftPreOut, segLeftSecondOut);
			GetInterLine(segMidPre, segMidSecond);
			GetInterLine(segRightPreIn, segRightSecondIn);
			GetInterLine(segRightPreOut, segRightSecondOut);
			vecSecTan = vecSecTan.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			ptTemp = segSec.GetStartPoint() + segSec.GetLength() * vecSecTan / vecSecTan.length();
			if (segPreTan.OnWhichSide(ptTemp))
			{
				if(!FillletArc(segPre, segSec,dWidth +dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn,dTurnningRad, polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;
			}
			else
			{
				if(!FillletArc(segPre, segSec,dTurnningRad, polyLeftIn))
					bCanFillet = FALSE;
				if(!FillletArc(segMidPre, segMidSecond, 0.5 * dWidth + dTurnningRad, polyMid))
					bCanFillet = FALSE;
				if(!FillletArc(segLeftPreOut, segLeftSecondOut,dTurnningRad - _AS_SYS_UNIT(DOUBLET_SPACING), polyLeftOut))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreIn, segRightSecondIn, dWidth + dTurnningRad , polyRightIn))
					bCanFillet = FALSE;
				if(!FillletArc(segRightPreOut, segRightSecondOut,dWidth + dTurnningRad + _AS_SYS_UNIT(DOUBLET_SPACING), polyRightOut))
					bCanFillet = FALSE;

			}
		}
	}
	if (!bCanFillet)
	{
		polyLeftIn.Reset();
		polyLeftOut.Reset();
		polyRightIn.Reset();
		polyRightOut.Reset();
		polyMid.Reset();
		polyLeftOut.AppendSegment(segLeftPreOut, 0, 0);
		polyLeftOut.AppendSegment(segLeftSecondOut, 0, 1);
		polyMid.AppendSegment(segMidPre, 0, 0);
		polyMid.AppendSegment(segMidSecond, 0, 1);
		polyLeftIn.AppendSegment(segPre, 0, 0);
		polyLeftIn.AppendSegment(segSec, 0, 1);
		polyRightOut.AppendSegment(segRightPreIn, 0, 0);
		polyRightOut.AppendSegment(segRightSecondIn, 0, 1);
		polyRightIn.AppendSegment(segRightPreOut, 0, 0);
		polyRightIn.AppendSegment(segRightSecondOut, 0, 1);
		return;
	}
}

void CutOutArc(TGGeCurveSegment &segSrc, TGGeCurveSegment &segRet, XPoint &ptOnArc, BOOL bIsFromSt)
{
	double dRadius , dAngle;
	XPoint ptTemp, ptMid;
	dRadius = segSrc.GetArc().GetRadius();
	if (bIsFromSt)
	{
		ptTemp = segSrc.GetStartPoint();
	}
	else
	{
		ptTemp = segSrc.GetEndPoint();
	}
	dAngle = acos((2 * pow(dRadius, 2) - pow(ptOnArc.Distance(ptTemp), 2)) / (2 * pow(dRadius, 2)));
	AcDbArc arc(segSrc.GetArc().GetCenterPt().AsAcGePoint3d(), dRadius, segSrc.GetArc().GetStarAngle(), segSrc.GetArc().GetEndAngle());
	if (segSrc.GetBulge() < 0)
	{
		if (bIsFromSt)
		{
			arc.getPointAtDist(0.5 * (segSrc.GetLength() - dAngle * dRadius), ptMid);
		}
		else
		{
			arc.getPointAtDist(0.5 * (segSrc.GetLength() - dAngle * dRadius) + dAngle * dRadius, ptMid);
		}
	}else
	{
		if (bIsFromSt)
		{
			arc.getPointAtDist(0.5 * (segSrc.GetLength() - dAngle * dRadius) + dAngle * dRadius, ptMid);
		}
		else
		{
			arc.getPointAtDist(0.5 * (segSrc.GetLength() - dAngle * dRadius), ptMid);
		}	
	}
	if (bIsFromSt)
	{
		segRet = XArc(ptOnArc, ptMid, segSrc.GetEndPoint());
	}
	else
	{
		segRet = XArc(segSrc.GetStartPoint(), ptMid, ptOnArc);
	}	
	if (segSrc.GetBulge() < 0)
	{
		ptTemp = segRet.GetStartPoint();
		dAngle = segRet.GetBulge();
		segRet.SetStartPoint(segRet.GetEndPoint());
		segRet.SetEndPoint(ptTemp);
		segRet.SetBulge(-dAngle);
	}
}
void UndergroundRamp()
{
	CUndergroundRampStyle drawRampStyle;
	drawRampStyle.DrawUnderGroundRamp();
}

CUndergroundRampStyle::CUndergroundRampStyle(void)
{
}


CUndergroundRampStyle::~CUndergroundRampStyle(void)
{
}

int CUndergroundRampStyle::DragDrawLine( XDrawUGRampEdJig &jig, XPoint &ptStart, const TCHAR *prompt, XPoint &ptEnd, const TCHAR *kword, int *kwordId, BOOL *bDiscontinue, XPoly2D &rampPolyBase)
{
	
	jig.SetRampPoly(rampPolyBase);
	jig.m_pszKeyword = kword;
	jig.m_pszPrompt = prompt;
	jig.m_ptStart = ptStart;
	jig.m_nFlag=0;
	jig.doIt();

	int nRetCode=jig.GetRetCode(kwordId);
	if (nRetCode==RTNORM) {
		ptEnd = jig.m_ptEnd;
	}
	return nRetCode;
}

// 给定起点, 终点进行弧上一点拖动绘制弧
int CUndergroundRampStyle::DragDrawArc_SEP(XDrawUGRampEdJig &jig, const XPoint &ptStart, const XPoint &ptEnd, 
										   const TCHAR *prompt, XPoint &ptAny, XPoly2D &rampPolyBase, 
										   const TCHAR *kword, int *kwordId)
{
	jig.SetRampPoly(rampPolyBase);
	jig.m_pszKeyword = kword;
	jig.m_pszPrompt = prompt;
	jig.m_ptStart = ptStart;
	jig.m_ptEnd = ptEnd;
	jig.m_nFlag=1;
	jig.doIt();
	int nRetCode=jig.GetRetCode(kwordId);
	if (nRetCode==RTNORM)
	{
		ptAny = jig.m_ptAny;
	}
	return nRetCode;
}

// 给定起点, 终点进行拖动半径绘制弧
int CUndergroundRampStyle::DragDrawArc_SER(XDrawUGRampEdJig &jig, const XPoint &ptStart, const XPoint &ptEnd,
										   XPoint &ptAny, const TCHAR *prompt, double *nRadius, XPoly2D &rampPolyBase, 
										   const TCHAR *kword, int *kwordId)
{
	jig.SetRampPoly(rampPolyBase);
	jig.m_pszKeyword = kword;
	jig.m_pszPrompt = prompt;
	jig.m_ptStart = ptStart;
	jig.m_ptEnd = ptEnd;
	jig.m_nFlag=2;
	jig.doIt();

	int nRetCode=jig.GetRetCode(kwordId);
	if (nRetCode==RTNORM)
	{
		*nRadius = jig.m_nRadius;
		/*if (DocGetMeterUnitDraw())
			*nRadius = jig.m_nRadius * 1000;*/
		ptAny = jig.m_ptAny;
	}
	return nRetCode;
}
void CUndergroundRampStyle::DrawUnderGroundRamp()
{
	int iRet;
	CUndergroundRampDlg dlgRamp(acedGetAcadFrame());
	{
		CAcModuleResourceOverride vTemp;
		dlgRamp.Create(dlgRamp.IDD, acedGetAcadFrame());
	}
	dlgRamp.ShowWindow(SW_SHOW);
		acedGetAcadDwgView()->SetFocus();
	int nPreDatum = dlgRamp.GetLocationLine();
	if(!GET_GLOBAL_VARIABLE(GlwUGRampDataManage))
		SET_GLOBAL_VARIABLE(GlwUGRampDataManage, new GlwUGRampDataManage);
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	pRampDataManage->UpdateDataManage(dlgRamp.GetWidth(), dlgRamp.GetRadius(), dlgRamp.GetLocationLine(), dlgRamp.GetMidline(), dlgRamp.GetLableArrow(), dlgRamp.GetArrowLoc(), dlgRamp.GetViewStyle());
	ERampShape eRampShape = eLineRamp;
	while(1)
	{
		XPoly2D rampPolyBase, polyTemp;
		XPoint ptStart;
		XPoint ptInter[2];
		TGGeCurveSegment segTemp(LS_INFINITE), segLast(LS_INFINITE);
		while(1)
		{
			iRet = ads_getpoint(NULL, _T("\n请点取坡道起点<退出> "), ptStart);
			if (iRet == RTNORM)
			{
				break;
			}
			else 
			{
				dlgRamp.DestroyWindow();
				return;
			}
		}
		BOOL bDiscontinue=FALSE;
		XPointList aStack;
		ptStart = Ucs2Wcs(ptStart);
		aStack.Append(new XPoint(ptStart));
		XDrawUGRampEdJig jig;
		while(1)
		{
			XPoly2D polyBase, xPolyTemp;
			GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
			double dWidth, dOffset(0.0);
			dWidth = pRampDataManage->GetRampWidth();
			int nLOPLoc = pRampDataManage->GetLOPLoc();
			if (nLOPLoc == CUndergroundRampDlg::MIDLINE)
			{
				dOffset = 0.5 * dWidth;
			}
			else if(nLOPLoc == CUndergroundRampDlg::RIGHTLINE)
			{
				dOffset = dWidth;
			}
			if (eRampShape == eLineRamp)
			{
				XPoint pt2;
				const TCHAR *szKeywords=_T("A Q");
				const TCHAR *szPrompt = _T("\n请点取坡道的下一点或[弧段(A)/定位线切换(Q)]<退出>:");
				if (rampPolyBase.TotalSegments() >= 1)
				{
					szKeywords=_T("A Q U");
					szPrompt = _T("\n 请点取坡道的下一点或[弧段(A) /定位线切换(Q)/回退(U)]<退出>:");
				}
				XPoint &ptFrom=*aStack.Tail();
				int nKwordIndex=0;
				int rc=0;
				rc=DragDrawLine(jig, ptFrom, szPrompt, pt2, szKeywords, &nKwordIndex, &bDiscontinue, rampPolyBase);
				if (rc==RTNORM) 
				{
					aStack.Append(new XPoint(pt2));
					TGGeCurveSegment segLine(ptFrom, pt2, LS_INFINITE);
					XPoint ptStart, ptEnd;		
					if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
					{
						segLine = segLine.Offset(-dOffset, LS_INFINITE);
					}
					if (rampPolyBase.TotalSegments() < 1)
					{
						rampPolyBase.AppendSegment(segLine, 0, 1);
					}
					else if (rampPolyBase.TotalSegments() >= 1)
					{
						rampPolyBase.Nth(rampPolyBase.TotalSegments() - 1,segLast);
						if (rampPolyBase.GetBulge(rampPolyBase.TotalSegments() - 1) < 0)
						{
							XPoint ptSt = segLast.GetStartPoint();
							double dAngle = segLast.GetBulge();
							segLast.SetStartPoint(segLast.GetEndPoint());
							segLast.SetEndPoint(ptSt);
							segLast.SetBulge(-dAngle);
						}
						polyTemp = rampPolyBase;
						rampPolyBase.Reset();
						for (int i = 0; i < polyTemp.TotalSegments()-1; ++i)
						{
							polyTemp.Nth(i, segTemp);
							if (polyTemp.GetBulge(i) < 0)
							{
								XPoint ptSt = segTemp.GetStartPoint();
								double dAngle = segTemp.GetBulge();
								segTemp.SetStartPoint(segTemp.GetEndPoint());
								segTemp.SetEndPoint(ptSt);
								segTemp.SetBulge(-dAngle);
							}
							rampPolyBase.AppendSegment(segTemp, 0, 0);
						}
						GetInterLine(segLast, segLine);
						rampPolyBase.AppendSegment(segLast, 0, 0);
						rampPolyBase.AppendSegment(segLine, 0, 1);
					}					
				}
				else if(rc == RTKWORD)
				{
					if (nKwordIndex == 1) 
					{
						eRampShape = eArcRamp;
						continue;
					} 
					else if (nKwordIndex == 2)
					{
						int nLocation = dlgRamp.GetLocationLine();
						switch (nLocation)
						{
						case CUndergroundRampDlg::MIDLINE:
							{
								dlgRamp.UpdataLoctionLine(CUndergroundRampDlg::LEFTLINE);
								pRampDataManage->SetLOPLoc(CUndergroundRampDlg::LEFTLINE);
								break;
							}
						case CUndergroundRampDlg::LEFTLINE:
							{
								dlgRamp.UpdataLoctionLine(CUndergroundRampDlg::RIGHTLINE);
								pRampDataManage->SetLOPLoc(CUndergroundRampDlg::RIGHTLINE);
								break;
							}
						case CUndergroundRampDlg::RIGHTLINE:
							{
								dlgRamp.UpdataLoctionLine(CUndergroundRampDlg::MIDLINE);
								pRampDataManage->SetLOPLoc(CUndergroundRampDlg::MIDLINE);
								break;
							}
						}
						continue;
					} 
					else if (nKwordIndex == 3)
					{
						if (rampPolyBase.TotalSegments() >= 1)
						{
							polyTemp = rampPolyBase;
							rampPolyBase.Reset();
							for (int i = 0; i < polyTemp.TotalSegments()-1; ++i)
							{
								polyTemp.Nth(i, segTemp);
								if (polyTemp.GetBulge(i) < 0)
								{
									XPoint ptSt = segTemp.GetStartPoint();
									double dAngle = segTemp.GetBulge();
									segTemp.SetStartPoint(segTemp.GetEndPoint());
									segTemp.SetEndPoint(ptSt);
									segTemp.SetBulge(-dAngle);
								}
								if (i == (polyTemp.TotalSegments() - 2))
									rampPolyBase.AppendSegment(segTemp, 0, 1);
								else
									rampPolyBase.AppendSegment(segTemp, 0, 0);
							}
						}
						if (aStack.Length() >= 2)
						{
							aStack.Remove(aStack.Length() - 1);
						}
					}
					continue;
				}
				else if(rc == RTNONE)
				{
					if(rampPolyBase.TotalSegments() < 1)
					{
						dlgRamp.DestroyWindow();
						return;
					}
					GenerateEntity(rampPolyBase);
					dlgRamp.DestroyWindow();
					return;
				}
				else 
				{
					dlgRamp.DestroyWindow();
					return;
				}
			}
			else if (eRampShape == eArcRamp) 
			{ 
				XPoint ptEnd, ptAny;
				const TCHAR *szKeywords=_T("L Q");
				const TCHAR *szPrompt = _T("\n请点取弧段的终点或[直段(L)/定位线切换(Q)]<退出>:");
				if (rampPolyBase.Length() >= 1)
				{
					szKeywords=_T("L Q U");
					szPrompt = _T("\n 请点取弧段的终点或[直段(L)/定位线切换(Q)/回退(U)]<退出>:");
				}
				int nIdxKeyword, nRetCode;
				XPoint &ptFrom=*aStack.Tail();
				nRetCode=DragDrawLine(jig, ptFrom, szPrompt, ptEnd, szKeywords, &nIdxKeyword, &bDiscontinue, rampPolyBase);
				if (nRetCode==RTNORM) 
				{

				}
				else if(nRetCode == RTKWORD)
				{
					if (nIdxKeyword == 1) 
					{
						eRampShape = eLineRamp;
						continue;
					} 
					else if(nIdxKeyword == 2)
					{
						int nLocation = dlgRamp.GetLocationLine();
						switch (nLocation)
						{
						case CUndergroundRampDlg::MIDLINE:
							{
								dlgRamp.UpdataLoctionLine(CUndergroundRampDlg::LEFTLINE);
								pRampDataManage->SetLOPLoc(CUndergroundRampDlg::LEFTLINE);
								break;
							}
						case CUndergroundRampDlg::LEFTLINE:
							{
								dlgRamp.UpdataLoctionLine(CUndergroundRampDlg::RIGHTLINE);
								pRampDataManage->SetLOPLoc(CUndergroundRampDlg::RIGHTLINE);
								break;
							}
						case CUndergroundRampDlg::RIGHTLINE:
							{
								dlgRamp.UpdataLoctionLine(CUndergroundRampDlg::MIDLINE);
								pRampDataManage->SetLOPLoc(CUndergroundRampDlg::MIDLINE);
								break;
							}
						}
						continue;
					}
					else if (nIdxKeyword ==3 )
					{
						if (rampPolyBase.TotalSegments() >= 1)
						{
							polyTemp = rampPolyBase;
							rampPolyBase.Reset();
							for (int i = 0; i < polyTemp.TotalSegments()-1; ++i)
							{
								polyTemp.Nth(i, segTemp);
								if (polyTemp.GetBulge(i) < 0)
								{
									XPoint ptSt = segTemp.GetStartPoint();
									double dAngle = segTemp.GetBulge();
									segTemp.SetStartPoint(segTemp.GetEndPoint());
									segTemp.SetEndPoint(ptSt);
									segTemp.SetBulge(-dAngle);
								}
								if (i == (polyTemp.TotalSegments() - 2))
									rampPolyBase.AppendSegment(segTemp, 0, 1);
								else
									rampPolyBase.AppendSegment(segTemp, 0, 0);
							}
						}
						if (aStack.Length() >= 2)
						{
							aStack.Remove(aStack.Length() - 1);
						}
						continue;
					}
				}
				else if(nRetCode == RTNONE)
				{
					if(rampPolyBase.TotalSegments() < 1)
					{
						dlgRamp.DestroyWindow();
						return;
					}
					GenerateEntity(rampPolyBase);
					dlgRamp.DestroyWindow();
					return;
				}
				else
				{
					dlgRamp.DestroyWindow();
					return;
				}
				//const TCHAR *szPromptAny=_T("\n点取弧上任意点或 [半径(R)]<取消>:");
				//nRetCode=DragDrawArc_SEP(jig, *aStack.Tail(), ptEnd, szPromptAny, ptAny, rampPolyBase, _T("R"), &nIdxKeyword);
				const TCHAR *szPromptAny=_T("\n点取弧上任意点<取消>:");
				nRetCode=DragDrawArc_SEP(jig, *aStack.Tail(), ptEnd, szPromptAny, ptAny, rampPolyBase, _T(""), &nIdxKeyword);
				XCurveSegment cv(LS_INFINITE);
				if (nRetCode==RTKWORD)
				{
				/*	static double nRadius=5000.0;
					nRetCode=DragDrawArc_SER(jig, *aStack.Tail(), ptEnd, ptAny, XString(_T("\n输入半径<%.f>:"), _AS_SYS_UNIT(nRadius)), &nRadius, rampPolyBase, NULL, NULL);
					if (nRetCode == RTCAN)
					{
						if(rampPolyBase.TotalSegments() < 1)
						{
							dlgRamp.DestroyWindow();
							return;
						}
						GenerateEntity(rampPolyBase);
						dlgRamp.DestroyWindow();
						return;
					}
					else if (nRetCode!=RTCAN) 
					{
						double nChordLen=ads_distance(*aStack.Tail(), ptEnd);
						if (nChordLen<2.0*nRadius+1.0E-6)
						{
							double bulge=2.0*asin(nChordLen/2.0/nRadius);
							XLine lineChord(ptStart, ptEnd);
							if (lineChord.OnWhichSide(ptAny))
							{
								cv=XCurveSegment(*aStack.Tail(), ptEnd, bulge, LS_FINITE);
							}
							else
							{
								cv=XCurveSegment(*aStack.Tail(), ptEnd, -bulge, LS_FINITE);
							}
							nRetCode=RTNORM;
							aStack.Append(new XPoint(ptEnd));	
							if ((nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
							{
								if (cv.GetBulge() > 0)
								{
									cv = cv.Offset(-dOffset, LS_INFINITE);		
								}
								else
								{
									cv = cv.Offset(dOffset, LS_INFINITE);
									double dAngle = cv.GetBulge();
									ptStart = cv.GetEndPoint();
									cv.SetEndPoint(cv.GetStartPoint());
									cv.SetStartPoint(ptStart);
									cv.SetBulge(dAngle);
								}
							}
							if (rampPolyBase.TotalSegments() < 1)
							{	
								rampPolyBase.AppendSegment(cv, 0, 1);
							}
							else if (rampPolyBase.TotalSegments() >= 1)
							{
								rampPolyBase.Nth(rampPolyBase.TotalSegments() - 1,segLast);
								if (rampPolyBase.GetBulge(rampPolyBase.TotalSegments() - 1) < 0)
								{
									XPoint ptSt = segLast.GetStartPoint();
									double dAngle = segLast.GetBulge();
									segLast.SetStartPoint(segLast.GetEndPoint());
									segLast.SetEndPoint(ptSt);
									segLast.SetBulge(-dAngle);
								}
								polyBase = rampPolyBase;			
								rampPolyBase.Reset();
								for (int i = 0; i < polyBase.TotalSegments() - 1; ++i)
								{
									polyBase.Nth(i, segTemp);
									if (polyBase.GetBulge(i) < 0)
									{
										XPoint ptSt = segTemp.GetStartPoint();
										double dAngle = segTemp.GetBulge();
										segTemp.SetStartPoint(segTemp.GetEndPoint());
										segTemp.SetEndPoint(ptSt);
										segTemp.SetBulge(-dAngle);
									}
									rampPolyBase.AppendSegment(segTemp, 0, 0);
								}
								GetInterLine(segLast, cv);
								rampPolyBase.AppendSegment(segLast, 0, 0);
								rampPolyBase.AppendSegment(cv, 0, 1);
							}
						} 
						else 
						{
							adsout << _T("半径值太小!");
							nRetCode=RTERROR;
						}
						continue;
					}*/
				}
				else if(nRetCode==RTNORM )		//第三点
				{ 
					cv=XArc(*aStack.Tail(), ptAny, ptEnd);
					XLine linePath(*aStack.Tail(), ptEnd);
					if(!linePath.OnWhichSide(ptAny))
					{
						double dAngle = cv.GetBulge();
						cv.SetStartPoint(*aStack.Tail());
						cv.SetEndPoint(ptEnd);
						cv.SetBulge(-dAngle);
					}
					aStack.Append(new XPoint(ptEnd));
					if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
					{
						if (cv.GetBulge() > 0)
						{
							cv = cv.Offset(-dOffset, LS_INFINITE);		
						}
						else
						{
							cv = cv.Offset(dOffset, LS_INFINITE);
							double dAngle = cv.GetBulge();
							ptStart = cv.GetEndPoint();
							cv.SetEndPoint(cv.GetStartPoint());
							cv.SetStartPoint(ptStart);
							cv.SetBulge(dAngle);
						}
					}
					if (rampPolyBase.TotalSegments() < 1)
					{	
						rampPolyBase.AppendSegment(cv, 0, 1);
					}
					else if (rampPolyBase.TotalSegments() >= 1)
					{
						rampPolyBase.Nth(rampPolyBase.TotalSegments() - 1,segLast);
						if (rampPolyBase.GetBulge(rampPolyBase.TotalSegments() - 1) < 0)
						{
							XPoint ptSt = segLast.GetStartPoint();
							double dAngle = segLast.GetBulge();
							segLast.SetStartPoint(segLast.GetEndPoint());
							segLast.SetEndPoint(ptSt);
							segLast.SetBulge(-dAngle);
						}
						polyBase = rampPolyBase;			
						rampPolyBase.Reset();
						for (int i = 0; i < polyBase.TotalSegments() - 1; ++i)
						{
							polyBase.Nth(i, segTemp);
							if (polyBase.GetBulge(i) < 0)
							{
								XPoint ptSt = segTemp.GetStartPoint();
								double dAngle = segTemp.GetBulge();
								segTemp.SetStartPoint(segTemp.GetEndPoint());
								segTemp.SetEndPoint(ptSt);
								segTemp.SetBulge(-dAngle);
							}
							rampPolyBase.AppendSegment(segTemp, 0, 0);
						}
						GetInterLine(segLast, cv);
						rampPolyBase.AppendSegment(segLast, 0, 0);
						rampPolyBase.AppendSegment(cv, 0, 1);
					}
				}
				else if(nRetCode == RTNONE)								//取消
				{
					if(rampPolyBase.TotalSegments() < 1)
					{
						dlgRamp.DestroyWindow();
						return;
					}
					GenerateEntity(rampPolyBase);
					dlgRamp.DestroyWindow();
					return;
				}
				else
				{
					dlgRamp.DestroyWindow();
					return;
				}
			}
		}
	}
	acedPostCommandPrompt();
	return;
}

void CUndergroundRampStyle::GenerateEntity(XPoly2D &rampPolyBase)
{
	int nLen = rampPolyBase.Length();
	for (int i = 0 ; i < nLen; ++i)
	{
		TADSGePoint3d ptTest = *rampPolyBase.GetAt(i);
	}
	XPoly2D rampPolyLeftOut, rampPolyLeftIn, rampPolyRightOut, rampPolyRightIn, rampPolyMid;
	XPoly2D xRampOutLine, xRampInLine, xRampPolyMid, xBrokenLine, xArrowPoly;
	TGGeCurveSegment segSatrtSec;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	BOOL bIsMeter = DocGetMeterUnitDraw();
	FilletRampPoly(rampPolyBase, rampPolyLeftOut, rampPolyLeftIn, rampPolyRightOut, rampPolyRightIn, rampPolyMid);
	
	//在绘制地下坡道的时候，根据需求，单线和双线的rampPolyLeftIn长度不一致，增加下面代码进行判断。
	bool bShowOutLine = false;
	int nDrawStyle = pRampDataManage->GetDrawStyle();
	if (nDrawStyle == CUndergroundRampDlg::VIEW2 || nDrawStyle == CUndergroundRampDlg::VIEW5 || nDrawStyle == CUndergroundRampDlg::VIEW8)
		bShowOutLine = true;
	GetRampOutPoly(rampPolyLeftOut, rampPolyRightOut, rampPolyLeftIn, rampPolyRightIn, rampPolyMid, segSatrtSec, xRampOutLine, xRampInLine, xRampPolyMid, xBrokenLine, xArrowPoly, bShowOutLine);
	PickSet ssAll(SS_FREE);
	ssAll.IncludeBegin();	
	
	AcDbPolyline* pPolyOut = new AcDbPolyline;
	PolyConvert(xRampOutLine, *pPolyOut);
	pPolyOut->setLayer(InitLayer(LAY_ROAD));
	AcDbPolyline* pPolyIn = new AcDbPolyline;
	PolyConvert(xRampInLine, *pPolyIn);
	pPolyIn->setLayer(InitLayer(LAY_ROAD));
	AcDbPolyline* pPloyBroken = new AcDbPolyline;
	PolyConvert(xBrokenLine, *pPloyBroken);
	pPloyBroken->setLayer(InitLayer(LAY_ROAD));
	if (nDrawStyle != CUndergroundRampDlg::VIEW1 && nDrawStyle != CUndergroundRampDlg::VIEW2 && nDrawStyle != CUndergroundRampDlg::VIEW3)
		AddToCurrentSpace(pPloyBroken, Adesk::kTrue);
	AcDbPolyline* pPolyMid = new AcDbPolyline;
	PolyConvert(xRampPolyMid, *pPolyMid);
	pPolyMid->setLayer(InitLayer(LAY_ROADDOTE));

	if (pRampDataManage->GetIsDrawMidLine())
	{
		if (bIsMeter)
		{
			pPolyMid->setLinetypeScale(0.001);
		}
		AddToCurrentSpace(pPolyMid, Adesk::kTrue);
	}

	AcDbLine* pline = new AcDbLine(segSatrtSec.GetStartPoint(), segSatrtSec.GetEndPoint());
	pline->setLayer(InitLayer(LAY_ROAD));
	AddToCurrentSpace(pline, Adesk::kTrue);
	if (nDrawStyle == CUndergroundRampDlg::VIEW3 || nDrawStyle == CUndergroundRampDlg::VIEW6 || nDrawStyle == CUndergroundRampDlg::VIEW9)
	{
		pPolyIn->setConstantWidth(_AS_SYS_UNIT(DOUBLET_SPACING));
	}	

	AddToCurrentSpace(pPolyIn, Adesk::kTrue);
	if (nDrawStyle == CUndergroundRampDlg::VIEW2 || nDrawStyle == CUndergroundRampDlg::VIEW5 || nDrawStyle == CUndergroundRampDlg::VIEW8)
		AddToCurrentSpace(pPolyOut, Adesk::kTrue);
	if (nDrawStyle == CUndergroundRampDlg::VIEW4 || nDrawStyle == CUndergroundRampDlg::VIEW5 || nDrawStyle == CUndergroundRampDlg::VIEW6 || nDrawStyle == CUndergroundRampDlg::VIEW7 || nDrawStyle == CUndergroundRampDlg::VIEW8 || nDrawStyle == CUndergroundRampDlg::VIEW9)
		AddToCurrentSpace(pPloyBroken, Adesk::kTrue);	
	if (pRampDataManage->GetIsDimArrow())
	{
		TDbSymbArrow* pArrow = new TDbSymbArrow;
		pArrow->SetPoly2D(xArrowPoly);
		if (bIsMeter)
			pArrow->SetArrowSize(1.2);
		else
			pArrow->SetArrowSize(12);
		pArrow->setLayer(InitLayer(LAY_OTHER_DIM));
		pArrow->SetTextStyleId(InitTextStyle(TS_DIM));
		AddToCurrentSpace(pArrow, Adesk::kTrue);
	}
	ssAll.IncludeEnd();
	ssAll.MakeUnnamedGroup();
}