//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   XCurveSegment 类
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   XCurveSegment 类定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "XCurveSegment.h"
#include "XDbObject.h"
#include "XGlobalCurveFunc.h"
#include "XPrivateGlobalFunc.h"
#include "XCurveInline.h"
#include "XGlobalFunc.h"


XCurveSegment::XCurveSegment(int flg)
: XLine(flg),m_dBulge(0.0) 
{
	
}

XCurveSegment::XCurveSegment(const Entity &e, int flg)
: XLine(flg),m_dBulge(0.0)
{
	XDbObject obj(e.name, AcDb::kForRead, Adesk::kTrue);
	if (!obj) 
	{
		return;
	}
	
	if (obj.m_pObject->isKindOf(AcDbLine::desc())) 
	{
		AcDbLine *pLine = (AcDbLine *)obj.m_pObject;
		
		m_startPoint = pLine->startPoint();
		m_endPoint = pLine->endPoint();
	}
	else if (obj.m_pObject->isKindOf(AcDbArc::desc())) 
	{
		AcDbArc *pLine = (AcDbArc *)obj.m_pObject;
		
		XPoint ptCen;
		(AcGePoint3d &)ptCen = pLine->center();
		
		XVector3D vtNormal;
		(AcGeVector3d &)vtNormal = pLine->normal();
		
		ptCen = XPrivate::Wcs2Ecs(ptCen, vtNormal);
		
		XArc arc(ptCen, pLine->radius(), pLine->startAngle(), pLine->endAngle());
		
		m_nFlag = LS_FINITE;
		
		ads_polar(arc.GetCenterPt(), arc.GetStarAngle(), arc.GetRadius(), m_startPoint);
		ads_polar(arc.GetCenterPt(), arc.GetEndAngle(), arc.GetRadius(), m_endPoint);
		
		m_dBulge = arc.Bulge();
	} 
	else if (obj.m_pObject->isKindOf(AcDbCircle::desc())) 
	{
		AcDbCircle *pLine = (AcDbCircle *)obj.m_pObject;
		
		XPoint ptCen;
		(AcGePoint3d &)ptCen = pLine->center();
		
		XVector3D vtNormal;
		(AcGeVector3d &)vtNormal = pLine->normal();
		
		ptCen = XPrivate::Wcs2Ecs(ptCen, vtNormal);
		
		ads_polar(ptCen, 0.0, pLine->radius(), m_startPoint);
		ads_polar(ptCen, PI, pLine->radius(), m_endPoint);
		
		m_dBulge = PI*2.0;      
	}
}

XCurveSegment::XCurveSegment(const XPoint &spt, const XPoint &ept, ads_real ang, int flg)
: XLine(spt,ept,flg)
{
	m_dBulge = ang;
}

XCurveSegment::XCurveSegment(const XCurveSegment &src)
: XLine(LS_FINITE)
{
	m_startPoint = src.m_startPoint;
	m_endPoint = src.m_endPoint;
	m_dBulge = src.m_dBulge;
	m_nFlag = src.m_nFlag;
}

XCurveSegment::~XCurveSegment()
{

}

//zjq 2009-08-31 增加line,arc的set函数
XCurveSegment & XCurveSegment::SetLine(const XPoint& pt1, const XPoint& pt2)
{
	m_nFlag = LS_INFINITE;
	m_startPoint = pt1;
	m_endPoint = pt2;
	m_dBulge = 0.0;
	return *this;
}

XCurveSegment & XCurveSegment:: SetArc(const XPoint &spt, const XPoint &ept, ads_real dang)
{
	ads_real ddis = ads_distance(spt, ept) / 2.0;
	ads_real dangTmp = fabs(dang / 2.0);
	ads_real dRadius = ddis / sin(dangTmp);
	ads_real dcosr = fabs( dRadius * cos(dangTmp));
	ads_real dstartAngle = 0.0,dendAngle = 0.0;

	XPoint ptc1, ptc2, mpt,ptCenter;
	mpt = spt + ept;
	mpt.Scale(0.5);

	ads_polar(mpt, ads_angle(spt, ept) - PI / 2.0, dcosr, ptc1);
	ads_polar(mpt, ads_angle(spt, ept) + PI / 2.0, dcosr, ptc2);

	if (dang > 0)
	{
		if (fabs(dang) > PI)
		{
			ptCenter = ptc1;
		}
		else
		{
			ptCenter = ptc2;
		}

		dstartAngle = ads_angle(ptCenter, spt);
		dendAngle = ads_angle(ptCenter, ept);
	}
	else
	{
		if (fabs(dang) > PI)
		{
			ptCenter = ptc2;
		}
		else
		{
			ptCenter = ptc1;
		}

		dstartAngle = ads_angle(ptCenter, ept);
		dendAngle = ads_angle(ptCenter, spt);
	}

	m_nFlag = LS_INFINITE;

	ads_polar(ptCenter,dstartAngle, dRadius, m_startPoint);
	ads_polar(ptCenter,dendAngle, dRadius, m_endPoint);

	m_dBulge = dendAngle - dstartAngle;
	if (m_dBulge < -1E-6)
	{
		m_dBulge = 2.0 * PI + m_dBulge;
	}
	return *this;
}

XCurveSegment & XCurveSegment::SetCircle(const XPoint& ptCen,double dRadius)
{
	ads_polar(ptCen, 0.0, dRadius, m_startPoint);
	ads_polar(ptCen, PI, dRadius, m_endPoint);
	m_dBulge = 2.0 * PI;
	return *this;
}

AcDbCurve * XCurveSegment::AsAcDbCurve() const
{
    AcDbCurve *pCurve = NULL;
    if (Is(CURVE_LINE)) 
	{
        pCurve = new AcDbLine(m_startPoint, m_endPoint);
    }
	else if (Is(CURVE_ARC)) 
	{
        XArc ar = GetArc();
        pCurve = new AcDbArc(ar.GetCenterPt(), ar.GetRadius(), ar.GetStarAngle(), ar.GetEndAngle());
    }
    return pCurve;
}

resbuf *XCurveSegment::Mask(LPCTSTR pszLay) 
{
	XString sLayer =  pszLay? pszLay : _T("*");
	return ads_buildlist( -4, _T("<or"),
		RTDXF0,_T("LINE"),   RTDXF0, _T("ARC"),  RTDXF0,_T("CIRCLE"),
		-4, _T("or>"),   8, (LPCTSTR)sLayer, NULL);
}

int XCurveSegment::MakeArrow(Entity &res) const
{
	ads_point cpt, pt1, pt2, pt3;
	ads_real arrowWidth = 200,
		arrowWidthFactor = 5.0;
	XPoint mpt = MidPoint();
	ads_real drt = Direction(mpt);
	
	ads_polar(mpt, drt - PI, arrowWidth * arrowWidthFactor / 2.0, cpt);
	ads_polar(cpt, drt + PI / 2.0, arrowWidth / 2.0, pt1);
	ads_polar(cpt, drt - PI / 2.0, arrowWidth / 2.0, pt2);
	ads_polar(mpt, drt, arrowWidth * arrowWidthFactor / 2.0, pt3);
	
	return res.Make(RTDXF0, _T("SOLID"), 10, pt1, 11, pt2, 12, pt3, 13, pt3, NULL);
}

// 积分面积
ads_real XCurveSegment::PathArea(XPoint &spt) const
{
	spt.z = GetStartPoint().z;
	XPoint ept = (spt.Distance(m_startPoint) < 
						 spt.Distance(m_endPoint))  ?
						 m_endPoint : 
						 m_startPoint;
	
	ads_real result;
	if (Is(CURVE_LINE))
	{
		result = (ept.x - spt.x) * (spt.y + ept.y) / 2.0;
	}
	else if (Is(CURVE_ARC))
	{
		result = GetArc().PathArea();
		// 顺时针的弧
		if (spt.Distance2d(m_startPoint) > spt.Distance2d(m_endPoint))
		{
			result = 0.0 - result;
		}
	}
	else
	{
		result = GetCircle().Area();
	}
	
	spt = ept;
	return result;
}

// 点到自身的距离, 负数为内/左侧
double XCurveSegment::GetDist2Me(XPoint ptMid) const
{
	XPoint ptPrj;
	ProjectToMe(ptMid, ptPrj);
	
	int nSide = OnWhichSide(ptMid);
	double nDist = ptMid.Distance2d(ptPrj);
	return (nSide == OFFSET_LEFT ? -nDist : nDist);
}

// 取得一段子曲线
//  loc -- center of the subCurve
//  chordLen -- 子曲线弦长
//  res -- 结果子曲线
//  return:  RTNORM--OK; RTERROR--fail
int XCurveSegment::GetSubSegment(const XPoint &ptloc, ads_real dchordLen, XCurveSegment &res) const
{
	//zjq 2009-08-31 修改了部分值调用
	res.SetBulge(GetBulge());
	res.SetLineFlag(LS_FINITE);
	
	int rc = RTERROR;
	if (Is(CURVE_LINE))
	{
		rc = GetLine().GetSubLine(ptloc, dchordLen, res);
	}
	else if (Is(CURVE_ARC)) 
	{
		XArc arc1 = GetArc(), arc;
		if (m_nFlag == LS_INFINITE)
		{
			rc = XCircle(arc1.m_ptCenter, arc1.m_dRadius).GetSubArc(ptloc, dchordLen, arc);
		}
		else 
		{
			rc = arc1.GetSubArc(ptloc, dchordLen, arc);
		}
		
		if (rc == RTNORM) 
		{
			XPoint ptStart = res.StartPoint();
			XPoint ptEnd = res.EndPoint();
			
			ads_polar(arc.m_ptCenter, arc.m_dstartAngle,arc.m_dRadius, ptStart);
			ads_polar(arc.m_ptCenter, arc.m_dendAngle, arc.m_dRadius, ptEnd);
			
			res.SetStartPoint(ptStart);
			res.SetEndPoint(ptEnd);
			
			res.SetBulge(arc.Bulge());
		}
	} 
	else if (Is(CURVE_CIRCLE)) 
	{
		XArc arc;
		rc = GetCircle().GetSubArc(ptloc, dchordLen, arc);
		if (rc == RTNORM) 
		{
			XPoint ptStart = res.StartPoint(),
						  ptEnd = res.EndPoint();
			
			ads_polar(arc.m_ptCenter, arc.m_dstartAngle, arc.m_dRadius, ptStart);
			ads_polar(arc.m_ptCenter, arc.m_dendAngle, arc.m_dRadius, ptEnd);
			
			res.SetStartPoint(ptStart);
			res.SetEndPoint(ptEnd);
			
			res.SetBulge(arc.Bulge());
		}
	}
   return rc;
}

XPoint XCurveSegment::MidPoint() const
{
	XPoint mpt;
	if (Is(CURVE_LINE))
	{
		mpt = XLine::MidPoint();
	}
	else if (Is(CURVE_ARC))
	{
		GetArc().MidPoint(mpt);
	}
	else
	{
		return GetStartPoint();
	}
	
   return mpt;
}

ads_real XCurveSegment::GetLength() const
{
    if (Is(CURVE_LINE)) 
	{
		return XLine::GetLength();
	}
    else if (Is(CURVE_ARC))
	{
		return GetArc().GetLength();
	}
    else
	{
		return GetCircle().GetLength();
	}
}

void XCurveSegment::SetPoints(const XPoint &ptStart, const XPoint &ptEnd) 
{
	assert(!Is(CURVE_CIRCLE));
	if (Is(CURVE_ARC)) 
	{
		XArc ar = GetArc();
		ar.SetAngleByPoints(ptStart, ptEnd);
		
		*this = ar;
	} 
	else 
	{
		//XLine::SetPoints(ptStart, ptEnd);
		m_startPoint = ptStart;
		m_endPoint = ptEnd;
	}
}


XCircle XCurveSegment::GetCircle() const
{
	return XCircle(m_startPoint, m_endPoint); 
}

XArc XCurveSegment::GetArc() const
{ 
	return XArc(m_startPoint, m_endPoint, m_dBulge); 
}

int XCurveSegment::Intersection(const XCurveSegment& curve, ads_point pt1, ads_point pt2) const
{
	if (curve.Is(CURVE_LINE))
	{
		return Intersection(curve.GetLine(), pt1, pt2);
	}
    else if (curve.Is(CURVE_ARC)) 
	{
		XArc aArc = curve.GetArc();
		if (curve.GetLineFlag() == LS_INFINITE) 
		{
			XCircle aCir = aArc;
			int rc = Intersection(&aCir, pt1, pt2);
			return rc;
		} 
		else
		{
			return Intersection(&aArc, pt1, pt2);
		}
    } 
	else
	{
		XCircle xc(curve.GetCircle());
		return Intersection(&xc, pt1, pt2);
	}
}

int XCurveSegment::Intersection(const XLine& line, ads_point pt1, ads_point pt2) const
{
	if(Is(CURVE_LINE)) 
	{
		return GetLine().Intersection(&line, pt1);
	}
    else if(Is(CURVE_ARC)) 
	{
		XArc aArc = GetArc();
		if(m_nFlag == LS_FINITE)
		{
			return aArc.Intersection(&line, pt1, pt2);
		}
		
		XCircle aCir = aArc;
		int rc = aCir.Intersection(&line, pt1, pt2);
		return rc;
    }
	else
	{
		return GetCircle().Intersection(&line, pt1, pt2);
	}
}

int XCurveSegment::Intersection(const XArc* pArc, ads_point pt1, ads_point pt2) const
{
	if (Is(CURVE_LINE)) 
	{
		return GetLine().Intersection(pArc, pt1,pt2);
	}
    else if (Is(CURVE_ARC)) 
	{
		XArc aArc = GetArc();
		if (m_nFlag == LS_FINITE)
		{
			return aArc.Intersection(pArc, pt1, pt2);
		}
		
		XCircle aCir = aArc;
		int rc = aCir.Intersection(pArc, pt1, pt2);
		return rc;
    }
	else
	{
		return GetCircle().Intersection(pArc, pt1, pt2);
	}
}

int XCurveSegment::Intersection(const XCircle* pCir, ads_point pt1, ads_point pt2) const
{
	if (Is(CURVE_LINE)) 
	{
		return GetLine().Intersection(pCir, pt1,pt2);
	}
    else if (Is(CURVE_ARC)) 
	{
		XArc aArc = GetArc();
		if (m_nFlag == LS_FINITE)
		{
			return aArc.Intersection(pCir, pt1, pt2);
		}
		
		XCircle aCir = aArc;
		int rc = aCir.Intersection(pCir, pt1, pt2);
		return rc;
    }
	else
	{
		return GetCircle().Intersection(pCir, pt1, pt2);
	}
}

int XCurveSegment::ProjectToMe(const XPoint &src, XPoint &res) const
{
	//zjq 2009-08-31 下面两句似乎无用
	/*XPoint src1 = src;
	src1.z = GetStartPoint().z;*/
	
	if (Is(CURVE_LINE))
	{
		return AT_pt_ProjectLine(src, m_startPoint, m_endPoint, res);
	}
	else if (Is(CURVE_ARC)) 
	{
		XArc xa(GetArc());
		return src.Project(&xa, res);
	}
	else
	{
		XCircle xc(GetCircle());
		return src.Project(&xc, res);
	}
	return -1;
}

int XCurveSegment::Make(const TCHAR *pszLay) const
{
	if (Is(CURVE_LINE)) 
	{
		XLine::Make(pszLay);
	}
	else if (Is(CURVE_ARC))
	{
		GetArc().Make(pszLay);
	}
	else 
	{
		GetCircle().Make(pszLay);
	}
	
   return RTNORM;
}

int XCurveSegment::OSnap(int nMode, XPoint &ptPick) const
{
	if (Is(CURVE_LINE))
	{
		return XLine::OSnap(nMode, ptPick);
	}
	else if (Is(CURVE_ARC))
	{
		return GetArc().OSnap(nMode, ptPick);
	}
	else if (Is(CURVE_CIRCLE))
	{
		return GetCircle().OSnap(nMode, ptPick);
	}
	
   return OS_NON;
}

// 把曲线化作Poly2D
void XCurveSegment::AsPoly2D(XPoly2D &poly) const
{
	//用两个弧来近似
	if (Is(CURVE_CIRCLE))
	{ 
		poly.AppendPointListAt(new XPoint(m_startPoint));
		poly.AppendBugle(PI);
		poly.AppendPointListAt(new XPoint(m_endPoint));
		poly.AppendBugle(PI);
		poly.SetFlag(1);
		
	}
	else 
	{
		poly.AppendPointListAt(new XPoint(m_startPoint));
		poly.AppendBugle(m_dBulge);
		poly.AppendPointListAt(new XPoint(m_endPoint));
		poly.AppendBugle(0.0);
		poly.SetFlag(0);
   }
}

// 把曲线化作篱笆
resbuf * XCurveSegment::AsFence(int nCirDiv) const
{
	XPoly2D poly(0);
	AsPoly2D(poly);
	
	return poly.Fence();
}

ads_real XCurveSegment::IDirection(int npt) const
{
	ads_real result;
	if (Is(CURVE_LINE))
	{
		result = npt ? CT_RevDrt(XLine::Direction()) : XLine::Direction();
	}
	else if (Is(CURVE_ARC)) 
	{
		XArc aArc(m_startPoint, m_endPoint, m_dBulge);
		result = aArc.IDirection(npt);
	}
	else
	{
		XGeLib::adsout << _T("\nInvalid Call to IDirection() for Circle!");
	}
	
	return result;
}

ads_real XCurveSegment::Direction(const XPoint &pt) const
{
	//zjq 2009-08-31 修改值传递
	XPoint cpt;
	if (Is(CURVE_LINE))
	{
		return XLine::Direction();
	}
	else if (Is(CURVE_ARC))
	{
		cpt = GetArc().m_ptCenter;
	}
	else 
	{
		cpt = GetCircle().m_ptCenter;
	}
	
	return CT_std_angle(ads_angle(cpt, pt) + PI / 2.0);
}

// 求通过pt点的法向
ads_real XCurveSegment::OrthoDirection(const XPoint &pt) const
{
	return CT_std_angle(XCurveSegment::Direction(pt) - PI / 2.0);
}

// Following should move to XCurveSegment
// 从端点开始沿曲线走过给定距离的点向量
int XCurveSegment::Polar(ads_real dDist, XPointDir2d  &ptres, int bFromStart) const
{
	//zjq 2009-08-31 修改值传递
	if (Is(CURVE_CIRCLE))
	{
		return RTERROR;
	}
	
	int bIsLine = Is(CURVE_LINE);
	if (bIsLine) 
	{
		ads_real nDrt = bFromStart ? XLine::Direction() : CT_std_angle(XLine::Direction() + PI);
		ads_polar(bFromStart ? m_startPoint : m_endPoint, nDrt, dDist, ptres);
		ptres.nDirection = dDist > -1.0E-9 ? nDrt : CT_std_angle(nDrt + PI);
	}
	else 
	{
		XArc arc = GetArc();
		ads_real nAcrossAngle = dDist / arc.m_dRadius;
		if (!bFromStart) 
		{
			nAcrossAngle = -nAcrossAngle;
		}
		
		ads_real nPositionAngle = CT_std_angle((bFromStart ? arc.m_dstartAngle : arc.m_dendAngle) + nAcrossAngle);
		ads_polar(arc.m_ptCenter, nPositionAngle, arc.m_dRadius, ptres);
		
		int nFactor = (dDist > -1.0E-9 ? 1 : -1) * (bFromStart ? 1 : -1);
		if (nFactor < 0)
		{
			nFactor = 1;
		}
		else 
		{
			nFactor = 0;
		}
		
		ptres.nDirection = CT_std_angle(nPositionAngle + PI / 2.0 + nFactor * PI);
	}
	
   return RTNORM;
}

// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
// pt如果不在线上的话则先投影
// Note: 不能用于CIRCLE
ads_real XCurveSegment::PathDistance(const XPoint &pt, int bFromStart) const
{
	assert(!Is(CURVE_CIRCLE));
	
	XPoint ptOnBase;
	ProjectToMe(pt, ptOnBase);
	
	const XCurveSegment &thisCurve = *this;
	int nPrFlag = ptOnBase & thisCurve;
	const XPoint &ptEnd = bFromStart ? m_startPoint : m_endPoint;
	const XPoint &ptOther = bFromStart ? m_endPoint : m_startPoint;
	
	switch(nPrFlag) 
	{
	case PR_ONPT1:
		return bFromStart ? 0.0 : thisCurve.GetLength();
	case PR_ONPT2: 
		return bFromStart ? thisCurve.GetLength() : 0.0;
	case PR_INSIDE: 
		if (Is(CURVE_LINE)) 
		{
			return ads_distance(ptEnd, ptOnBase);
		}
		else 
		{
            XArc ar = GetArc();
			
			if (bFromStart) 
			{
				ar.SetEndAngle(ads_angle(ar.m_ptCenter, ptOnBase));
			}
            else 
			{
				ar.SetStarAngle(ads_angle(ar.m_ptCenter, ptOnBase));
			}
			
            return ar.GetLength();
		}
	case PR_EXTEND:
	case PR_OUTSIDE:  // 原先不正确, 在线段之外, 并不一定为负
		if (Is(CURVE_LINE)) 
		{
            ads_real nDist = ads_distance(ptEnd, ptOnBase);
            ads_real nDist1 = ads_distance(ptOther, ptOnBase);
            if (nDist < nDist1)  // 在靠近ptEnd的延长线上,
			{
				return -nDist;
			}
            else
			{
				return nDist;
			}
		}  
		else
		{ 
            XArc ar = GetArc();
            //XArc ar = arc;
			
			if (bFromStart)
			{
				ar.SetEndAngle(ads_angle(ar.m_ptCenter, ptOnBase));
			}
            else
			{
				ar.SetStarAngle(ads_angle(ar.m_ptCenter, ptOnBase));
			}
			
			double dAngleS = ar.m_dstartAngle;
			double dAngleE = ar.m_dendAngle;
			
            //XPrivate::Exchange(ar.GetStarAngle(), ar.GetEndAngle()); wulw
			ar.SetStarAngle(dAngleE);
			ar.SetEndAngle(dAngleS);
            return -ar.GetLength();
		}
	}
	return 0.0; 
}

bool XCurveSegment::IsDirectionCurve()
{
	return false;
}

XCurveSegment XCurveSegment::Offset(double dDist, int nflg) const
{
    return Offset(OFFSET_RIGHT, dDist, nflg);
}

// lr-- 0:逆时针，左侧;  1:顺时针，右侧
XCurveSegment XCurveSegment::Offset(int nlr, ads_real dDist, int nflg) const
{
	//zjq 2008-08-31 修改值传递
	ads_real ang = nlr ? -PI / 2.0 : PI / 2.0;  //右:顺时针;左:逆时针
	XPoint spt, ept;
	if (Is(CURVE_LINE)) 
	{
		ang = CT_std_angle(XLine::Direction() + ang);
		ads_polar(m_startPoint, ang, dDist, spt);
		ads_polar(m_endPoint, ang, dDist, ept);
	}
	else 
	{
		ads_real ang = m_dBulge;
		if (Is(CURVE_CIRCLE)) 
		{
			ang = PI;
		}
		
		XArc aArc(m_startPoint, m_endPoint, ang);
		ads_real r = nlr ? (aArc.m_dRadius + dDist) : (aArc.m_dRadius - dDist);
		if (r < _DIST_SNAP) 
		{
			spt = aArc.m_ptCenter;
			ept = aArc.m_ptCenter;
		}
		else 
		{
			ads_polar(aArc.m_ptCenter, aArc.m_dstartAngle, r, spt);
			ads_polar(aArc.m_ptCenter, aArc.m_dendAngle, r, ept);
		}
	}
	
   return XCurveSegment(spt, ept, m_dBulge, nflg);
}

void XCurveSegment::TransformBy(ads_matrix mat)
{
    if (Is(CURVE_LINE)) 
	{
		m_startPoint.TransformBy(mat);
        m_endPoint.TransformBy(mat);
    }
	else if (Is(CURVE_ARC)) 
	{
        XPoint ptMid = MidPoint();
		
        m_startPoint.TransformBy(mat);
        m_endPoint.TransformBy(mat);
        ptMid.TransformBy(mat);
        
		(XCurveSegment &)(*this) = XArc(m_startPoint, ptMid, m_endPoint);
		
    }
}

int XCurveSegment::OnWhichSide1(const XPoint &src) const
{
	int nSideFlag = 2;
	
    XPoint ptOnMe;
    if (ProjectToMe(src, ptOnMe) != RTNORM) 
	{
		nSideFlag = 2;
	}
	else 
	{
		XPoint src1 = src;
		src1.z = m_startPoint.z;
		if (src1 == ptOnMe) 
		{
			nSideFlag =  2;
		}
		else 
		{
			double nDir1 = Direction(ptOnMe);
			double nDir2 = CT_std_angle(ads_angle(src1, ptOnMe) + PI / 2.0);
			
			if (CT_IsExactSameDrt(nDir1, nDir2, _angSnap))
			{
				nSideFlag = OFFSET_LEFT;
			}
			else 
			{
				nSideFlag =  OFFSET_RIGHT;
			}
		}
	}
	
	if (Is(CURVE_ARC)) 
	{
		int nSideFlag0 = XLine::OnWhichSide(src);
		if (nSideFlag0 == OFFSET_LEFT)
		{
			nSideFlag = nSideFlag0;
		}
	}
	
	return nSideFlag;  
}

// 0--Left,  1--Right, 2--Other
int XCurveSegment::OnWhichSide(const XPoint &src) const
{
	int nSideFlag = 2;
	
    XPoint ptOnMe;
    if (ProjectToMe(src, ptOnMe) != RTNORM) 
	{
		nSideFlag = 2;
	}
	else 
	{
		XPoint src1 = src;
		src1.z = m_startPoint.z;
		if (src1 == ptOnMe) 
		{
			nSideFlag =  2;
		}
		else 
		{
			double nDir1 = Direction(ptOnMe);
			double nDir2 = CT_std_angle(ads_angle(src1, ptOnMe) + PI / 2.0);
			
			if (CT_IsExactSameDrt(nDir1, nDir2, _angSnap))
			{
				nSideFlag = OFFSET_LEFT;
			}
			else 
			{
				nSideFlag =  OFFSET_RIGHT;
			}
		}
	}
	
	return nSideFlag; 
}

//Wcs到展开坐标系
XPoint XCurveSegment::Wcs2Ecs(XPoint pt) const
{ 
	XPoint ptPrj;
	ProjectToMe(pt, ptPrj);
     
	XPoint ptExpand;
	ptExpand.x = PathDistance(ptPrj);
	ptExpand.y = (pt.z - m_startPoint.z);
     
	double nDist = pt.Distance2d(ptPrj);
	int nSide = OnWhichSide(pt);
	if (nSide == OFFSET_LEFT)
	{
		nDist = -nDist;
	}
	ptExpand.z = nDist;
    
	return ptExpand;
}

//展开坐标系到Wcs
XPoint XCurveSegment::Ecs2Wcs(XPoint pt) const 
{ 
	XPointDir2d ptDir;
	Polar(pt.x, ptDir);
    
	XPoint ptWcs;
	ptWcs = ptDir;
	ptWcs.z = pt.y - m_startPoint.z;
	
	if (fabs(pt.z) > _DIST_SNAP)
	{
		ads_polar(XPoint(ptWcs), ptDir.nDirection - PI / 2.0, pt.z, ptWcs);
	}
    return ptWcs;
}

void XCurveSegment::Wcs2Ecs(const XPoly2D &polyWcs, XPoly2D &polyEcs) const
{
    polyEcs.Reset();
    polyEcs.SetFlag(polyWcs.GetFlag());
    for (int i = 0; i < polyWcs.Length(); i++) 
	{
        XPoint ptEcs = Wcs2Ecs(polyWcs.GetPointListAt(i));
        polyEcs.AppendNode(ptEcs, polyWcs.GetBulge(i));
    }
}

void XCurveSegment::Ecs2Wcs(const XPoly2D &polyEcs, XPoly2D &polyWcs) const
{
    polyWcs.Reset();
    polyWcs.SetFlag(polyEcs.GetFlag());
    for (int i = 0; i < polyEcs.Length(); i++) 
	{
        XPoint ptWcs = Ecs2Wcs(polyEcs.GetPointListAt(i));
        polyWcs.AppendNode(ptWcs, polyEcs.GetBulge(i));
    }

}

double XCurveSegment::GetBulge() const
{
	return m_dBulge;
}

void XCurveSegment::SetBulge(const double dBulge)
{
	m_dBulge = dBulge;
}

bool XCurveSegment::IsKindOf(XEntity::TEntityId entType) const
{
	switch(entType)
	{
	case XEntity::eEntity:
	case XEntity::eCurve:
	case XEntity::eLinearEnt:
	case XEntity::eLine:
	case XEntity::eCurveSegment:
		return true;
	}
	return false;
}

XEntity::TEntityId XCurveSegment::Type() const
{
	return XEntity::eCurveSegment;
}

void XCurveSegment::CopyFrom(const XEntity* pSrc)
{
	if (this != pSrc && pSrc->IsKindOf(XEntity::eCurveSegment))
	{
		XCurveSegment* pEntSeg = (XCurveSegment* )pSrc;
		m_startPoint = pEntSeg->m_startPoint;
		m_endPoint = pEntSeg->m_endPoint;
		m_dBulge = pEntSeg->m_dBulge;
		m_nFlag = pEntSeg->m_nFlag;

	}
	else if(this != pSrc && pSrc->IsKindOf(XEntity::eLine))
	{
		XCurveSegment* pEntLine = (XCurveSegment* )pSrc;
		m_startPoint = pEntLine->m_startPoint;
		m_endPoint = pEntLine->m_endPoint;
		m_dBulge = 0.0;
		m_nFlag = pEntLine->m_nFlag;
	}
}


static BOOL IsMirrorTransform(const resbuf *rb1, const resbuf *rb2)
{
	XPoint ptOrg, ptX(1000, 0), ptY(0, 1000), ptOrg1, ptX1, ptY1;

	ads_trans(ptOrg, rb1, rb2, FALSE, ptOrg1);
	ads_trans(ptX, rb1, rb2, FALSE, ptX1);
	ads_trans(ptY, rb1, rb2, FALSE, ptY1);

	double nAng = CT_std_angle(ads_angle(ptOrg1, ptY1) - ads_angle(ptOrg1, ptX1));

	return (fabs(nAng - PI * 1.5) < _angSnap);
}