//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TGGeCurveSegment 类
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TGGeCurveSegment 类定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TGGeCurveSegment.h"
#include "TAcDbObjectPtr.h"
#include "TchGlobalCurveFunc.h"
#include "TchPrivateGlobalFunc.h"
#include "TGGeCurveInline.h"
#include "TchGlobalFunc.h"


TGGeCurveSegment::TGGeCurveSegment(int flg)
: TGGeLine(flg),m_dBulge(0.0) 
{
	
}

TGGeCurveSegment::TGGeCurveSegment(const TEntitySet &e, int flg)
: TGGeLine(flg),m_dBulge(0.0)
{
	TAcDbObjectPtr 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;
		
		TADSGePoint3d ptCen;
		(AcGePoint3d &)ptCen = pLine->center();
		
		TVector3D vtNormal;
		(AcGeVector3d &)vtNormal = pLine->normal();
		
		ptCen = TchPrivate::Wcs2Ecs(ptCen, vtNormal);
		
		TGGeArc 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;
		
		TADSGePoint3d ptCen;
		(AcGePoint3d &)ptCen = pLine->center();
		
		TVector3D vtNormal;
		(AcGeVector3d &)vtNormal = pLine->normal();
		
		ptCen = TchPrivate::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;      
	}
}

TGGeCurveSegment::TGGeCurveSegment(const TADSGePoint3d &spt, const TADSGePoint3d &ept, ads_real ang, int flg)
: TGGeLine(spt,ept,flg)
{
	m_dBulge = ang;
}

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

TGGeCurveSegment::~TGGeCurveSegment()
{

}

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

TGGeCurveSegment & TGGeCurveSegment:: SetArc(const TADSGePoint3d &spt, const TADSGePoint3d &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;

	TADSGePoint3d 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;
}

TGGeCurveSegment & TGGeCurveSegment::SetCircle(const TADSGePoint3d& 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 * TGGeCurveSegment::AsAcDbCurve() const
{
    AcDbCurve *pCurve = NULL;
    if (Is(CURVE_LINE)) 
	{
        pCurve = new AcDbLine(m_startPoint, m_endPoint);
    }
	else if (Is(CURVE_ARC)) 
	{
        TGGeArc ar = GetArc();
        pCurve = new AcDbArc(ar.GetCenterPt(), ar.GetRadius(), ar.GetStarAngle(), ar.GetEndAngle());
    }
    return pCurve;
}

resbuf *TGGeCurveSegment::Mask(LPCTSTR pszLay) 
{
	TCString 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 TGGeCurveSegment::MakeArrow(TEntitySet &res) const
{
	ads_point cpt, pt1, pt2, pt3;
	ads_real arrowWidth = 200,
		arrowWidthFactor = 5.0;
	TADSGePoint3d 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 TGGeCurveSegment::PathArea(TADSGePoint3d &spt) const
{
	spt.z = GetStartPoint().z;
	TADSGePoint3d 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 TGGeCurveSegment::GetDist2Me(TADSGePoint3d ptMid) const
{
	TADSGePoint3d 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 TGGeCurveSegment::GetSubSegment(const TADSGePoint3d &ptloc, ads_real dchordLen, TGGeCurveSegment &res) const
{
	//lfy 2010-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)) 
	{
		TGGeArc arc1 = GetArc(), arc;
		if (m_nFlag == LS_INFINITE)
		{
			rc = TGGeCircle(arc1.m_ptCenter, arc1.m_dRadius).GetSubArc(ptloc, dchordLen, arc);
		}
		else 
		{
			rc = arc1.GetSubArc(ptloc, dchordLen, arc);
		}
		
		if (rc == RTNORM) 
		{
			TADSGePoint3d ptStart = res.StartPoint();
			TADSGePoint3d 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)) 
	{
		TGGeArc arc;
		rc = GetCircle().GetSubArc(ptloc, dchordLen, arc);
		if (rc == RTNORM) 
		{
			TADSGePoint3d 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;
}

TADSGePoint3d TGGeCurveSegment::MidPoint() const
{
	TADSGePoint3d mpt;
	if (Is(CURVE_LINE))
	{
		mpt = TGGeLine::MidPoint();
	}
	else if (Is(CURVE_ARC))
	{
		GetArc().MidPoint(mpt);
	}
	else
	{
		return GetStartPoint();
	}
	
   return mpt;
}

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

void TGGeCurveSegment::SetPoints(const TADSGePoint3d &ptStart, const TADSGePoint3d &ptEnd) 
{
	assert(!Is(CURVE_CIRCLE));
	if (Is(CURVE_ARC)) 
	{
		TGGeArc ar = GetArc();
		ar.SetAngleByPoints(ptStart, ptEnd);
		
		*this = ar;
	} 
	else 
	{
		//TGGeLine::SetPoints(ptStart, ptEnd);
		m_startPoint = ptStart;
		m_endPoint = ptEnd;
	}
}


TGGeCircle TGGeCurveSegment::GetCircle() const
{
	return TGGeCircle(m_startPoint, m_endPoint); 
}

TGGeArc TGGeCurveSegment::GetArc() const
{ 
	return TGGeArc(m_startPoint, m_endPoint, m_dBulge); 
}

int TGGeCurveSegment::Intersection(const TGGeCurveSegment& 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)) 
	{
		TGGeArc aArc = curve.GetArc();
		if (curve.GetLineFlag() == LS_INFINITE) 
		{
			TGGeCircle aCir = aArc;
			int rc = Intersection(&aCir, pt1, pt2);
			return rc;
		} 
		else
		{
			return Intersection(&aArc, pt1, pt2);
		}
    } 
	else
	{
		TGGeCircle cir(curve.GetCircle());
		return Intersection(&cir, pt1, pt2);
	}
}

int TGGeCurveSegment::Intersection(const TGGeLine& line, ads_point pt1, ads_point pt2) const
{
	if(Is(CURVE_LINE)) 
	{
		return GetLine().Intersection(&line, pt1);
	}
    else if(Is(CURVE_ARC)) 
	{
		TGGeArc aArc = GetArc();
		if(m_nFlag == LS_FINITE)
		{
			return aArc.Intersection(&line, pt1, pt2);
		}
		
		TGGeCircle aCir = aArc;
		int rc = aCir.Intersection(&line, pt1, pt2);
		return rc;
    }
	else
	{
		return GetCircle().Intersection(&line, pt1, pt2);
	}
}

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

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

int TGGeCurveSegment::ProjectToMe(const TADSGePoint3d &src, TADSGePoint3d &res) const
{
	//lfy 2010-08-31 下面两句似乎无用
	/*TADSGePoint3d src1 = src;
	src1.z = GetStartPoint().z;*/
	
	if (Is(CURVE_LINE))
	{
		return PointProjectToLine(src, m_startPoint, m_endPoint, res);
	}
	else if (Is(CURVE_ARC)) 
	{
		TGGeArc arc(GetArc());
		return src.Project(&arc, res);
	}
	else
	{
		
		TGGeCircle cir(GetCircle());
		return src.Project(&cir, res);
	}
	return -1;
}

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

int TGGeCurveSegment::OSnap(int nMode, TADSGePoint3d &ptPick) const
{
	if (Is(CURVE_LINE))
	{
		return TGGeLine::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 TGGeCurveSegment::AsPoly2D(TGGePoly2D &poly) const
{
	//用两个弧来近似
	if (Is(CURVE_CIRCLE))
	{ 
		poly.AppendPointListAt(new TADSGePoint3d(m_startPoint));
		poly.AppendBugle(PI);
		poly.AppendPointListAt(new TADSGePoint3d(m_endPoint));
		poly.AppendBugle(PI);
		poly.SetFlag(1);
		
	}
	else 
	{
		poly.AppendPointListAt(new TADSGePoint3d(m_startPoint));
		poly.AppendBugle(m_dBulge);
		poly.AppendPointListAt(new TADSGePoint3d(m_endPoint));
		poly.AppendBugle(0.0);
		poly.SetFlag(0);
   }
}

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

ads_real TGGeCurveSegment::IDirection(int npt) const
{
	ads_real result;
	if (Is(CURVE_LINE))
	{
		result = npt ? RevDrtAngle(TGGeLine::Direction()) : TGGeLine::Direction();
	}
	else if (Is(CURVE_ARC)) 
	{
		TGGeArc aArc(m_startPoint, m_endPoint, m_dBulge);
		result = aArc.IDirection(npt);
	}
	else
	{
		TchGeLib::adsout << _T("\nInvalid Call to IDirection() for Circle!");
	}
	
	return result;
}

ads_real TGGeCurveSegment::Direction(const TADSGePoint3d &pt) const
{
	//lfy 2010-08-31 修改值传递
	TADSGePoint3d cpt;
	if (Is(CURVE_LINE))
	{
		return TGGeLine::Direction();
	}
	else if (Is(CURVE_ARC))
	{
		cpt = GetArc().m_ptCenter;
	}
	else 
	{
		cpt = GetCircle().m_ptCenter;
	}
	
	return AngleRangeTo2PI(ads_angle(cpt, pt) + PI / 2.0);
}

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

// Following should move to TGGeCurveSegment
// 从端点开始沿曲线走过给定距离的点向量
int TGGeCurveSegment::Polar(ads_real dDist, TADSGePointDir2d  &ptres, int bFromStart) const
{
	//lfy 2010-08-31 修改值传递
	if (Is(CURVE_CIRCLE))
	{
		return RTERROR;
	}
	
	int bIsLine = Is(CURVE_LINE);
	if (bIsLine) 
	{
		ads_real nDrt = bFromStart ? TGGeLine::Direction() : AngleRangeTo2PI(TGGeLine::Direction() + PI);
		ads_polar(bFromStart ? m_startPoint : m_endPoint, nDrt, dDist, ptres);
		ptres.nDirection = dDist > -1.0E-9 ? nDrt : AngleRangeTo2PI(nDrt + PI);
	}
	else 
	{
		TGGeArc arc = GetArc();
		ads_real nAcrossAngle = dDist / arc.m_dRadius;
		if (!bFromStart) 
		{
			nAcrossAngle = -nAcrossAngle;
		}
		
		ads_real nPositionAngle = AngleRangeTo2PI((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 = AngleRangeTo2PI(nPositionAngle + PI / 2.0 + nFactor * PI);
	}
	
   return RTNORM;
}

// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
// pt如果不在线上的话则先投影
// Note: 不能用于CIRCLE
ads_real TGGeCurveSegment::PathDistance(const TADSGePoint3d &pt, int bFromStart) const
{
	assert(!Is(CURVE_CIRCLE));
	
	TADSGePoint3d ptOnBase;
	ProjectToMe(pt, ptOnBase);
	
	const TGGeCurveSegment &thisCurve = *this;
	int nPrFlag = ptOnBase & thisCurve;
	const TADSGePoint3d &ptEnd = bFromStart ? m_startPoint : m_endPoint;
	const TADSGePoint3d &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 
		{
            TGGeArc 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
		{ 
            TGGeArc ar = GetArc();
            //TGGeArc 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;
			
            //TchPrivate::Exchange(ar.GetStarAngle(), ar.GetEndAngle()); wulw
			ar.SetStarAngle(dAngleE);
			ar.SetEndAngle(dAngleS);
            return -ar.GetLength();
		}
	}
	return 0.0; 
}

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

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

// lr-- 0:逆时针，左侧;  1:顺时针，右侧
TGGeCurveSegment TGGeCurveSegment::Offset(int nlr, ads_real dDist, int nflg) const
{
	//lfy 2008-08-31 修改值传递
	ads_real ang = nlr ? -PI / 2.0 : PI / 2.0;  //右:顺时针;左:逆时针
	TADSGePoint3d spt, ept;
	if (Is(CURVE_LINE)) 
	{
		ang = AngleRangeTo2PI(TGGeLine::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;
		}
		
		TGGeArc 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 TGGeCurveSegment(spt, ept, m_dBulge, nflg);
}

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

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

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

//Wcs到展开坐标系
TADSGePoint3d TGGeCurveSegment::Wcs2Ecs(TADSGePoint3d pt) const
{ 
	TADSGePoint3d ptPrj;
	ProjectToMe(pt, ptPrj);
     
	TADSGePoint3d 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
TADSGePoint3d TGGeCurveSegment::Ecs2Wcs(TADSGePoint3d pt) const 
{ 
	TADSGePointDir2d ptDir;
	Polar(pt.x, ptDir);
    
	TADSGePoint3d ptWcs;
	ptWcs = ptDir;
	ptWcs.z = pt.y - m_startPoint.z;
	
	if (fabs(pt.z) > _DIST_SNAP)
	{
		ads_polar(TADSGePoint3d(ptWcs), ptDir.nDirection - PI / 2.0, pt.z, ptWcs);
	}
    return ptWcs;
}

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

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

}

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

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

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

TGGeEntity::TEntityId TGGeCurveSegment::Type() const
{
	return TGGeEntity::eCurveSegment;
}

void TGGeCurveSegment::CopyFrom(const TGGeEntity* pSrc)
{
	if (this != pSrc && pSrc->IsKindOf(TGGeEntity::eCurveSegment))
	{
		TGGeCurveSegment* pEntSeg = (TGGeCurveSegment* )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(TGGeEntity::eLine))
	{
		TGGeCurveSegment* pEntLine = (TGGeCurveSegment* )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)
{
	TADSGePoint3d 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 = AngleRangeTo2PI(ads_angle(ptOrg1, ptY1) - ads_angle(ptOrg1, ptX1));

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

TGGeDirectionCurve::TGGeDirectionCurve(const TADSGePoint3d &spt, const TADSGePoint3d &ept, ads_real dAng, int flg)
: TGGeCurveSegment(spt,ept,dAng, flg) 
{

}

TGGeDirectionCurve::TGGeDirectionCurve(int flg)
: TGGeCurveSegment(flg)
{

}

TGGeDirectionCurve::TGGeDirectionCurve(const TGGeDirectionCurve &src)
: TGGeCurveSegment(src) 
{

}

TGGeDirectionCurve::TGGeDirectionCurve(const TGGeArc &ar, int bMinus) 
{
	TGGeCurveSegment &seg = *this;
	seg = ar;

	if (bMinus) 
	{
		m_dBulge = -fabs(m_dBulge);
		TchPrivate::Exchange(m_startPoint, m_endPoint);
	}
}

TGGeDirectionCurve::~TGGeDirectionCurve()
{

}

TGGeArc TGGeDirectionCurve::GetArc() const
{
	if (IsMinusArc()) 
	{
		return TGGeArc(m_endPoint, m_startPoint, fabs(m_dBulge));
	}

	return TGGeArc(m_startPoint, m_endPoint, m_dBulge);
}

int TGGeDirectionCurve::IsMinusArc() const 
{
	return m_dBulge < -1.0E-8; 
}

TGGeCurveSegment TGGeDirectionCurve::GetCurve() const
{
	TGGeCurveSegment seg;
	if (IsMinusArc())
	{
		seg = GetArc();
	}
	else
	{
		seg = *this;
	}

	return seg;
}

void TGGeDirectionCurve::TransUCS(const resbuf *rb1, const resbuf *rb2)
{
	TGGeLine::TransUCS(rb2, rb2);
	if (IsMirrorTransform(rb1, rb2))
	{
		m_dBulge = -m_dBulge;
	}
}

void TGGeDirectionCurve::TransUCS(ads_matrix mat)
{
	TGGeLine::TransformBy(mat);
	if (IsMirrorMatrix(mat))
	{
		m_dBulge = -m_dBulge;
	}
}

void TGGeDirectionCurve::Reverse()
{
	TchPrivate::Exchange(m_startPoint, m_endPoint);
	m_dBulge = -m_dBulge;
}

// dist:  <0 left side;  >0 right siede
TGGeDirectionCurve TGGeDirectionCurve::Offset(ads_real dist, int flg) const
{	
	assert(!Is(CURVE_CIRCLE));

	TADSGePoint3d spt, ept;
	if (Is(CURVE_LINE)) 
	{
		ads_real ang = TGGeLine::Direction()-PI/2.0;
		ads_polar(m_startPoint, ang, dist, spt);
		ads_polar(m_endPoint, ang, dist, ept);

		return TGGeDirectionCurve(spt, ept, 0.0, flg);
	} 

	TGGeArc aArc = GetArc();
	ads_real r = (!IsMinusArc()) ? (aArc.GetRadius() + dist) : (aArc.GetRadius() - dist);

	if (r < _DIST_SNAP) 
	{
		return TGGeDirectionCurve();
	}

	aArc.SetRadius(r);

	TGGeDirectionCurve curve(aArc, IsMinusArc());
	curve.m_nFlag = flg;	
	return curve;	
}

ads_real TGGeDirectionCurve::IDirection(int npt) const 
{
	if (IsMinusArc()) 
	{
		return GetCurve().IDirection(1 - npt);
	}

	return TGGeCurveSegment::IDirection(npt);
}

int TGGeDirectionCurve::OnWhichSide(const TADSGePoint3d &src) const 
{
	int nSide = GetCurve().OnWhichSide(src);
	if (IsMinusArc())
	{
		nSide = 1 - nSide;
	}

	return nSide;
}

int TGGeDirectionCurve::OnWhichSide1(const TADSGePoint3d &src) const 
{
	int nSide = GetCurve().OnWhichSide1(src);
	if (IsMinusArc())
	{
		nSide = 1 - nSide;
	}

	return nSide;
}

ads_real TGGeDirectionCurve::PathArea(TADSGePoint3d &tmpt) const 
{
	double nRet = GetCurve().PathArea(tmpt);
	if (IsMinusArc())
	{
		nRet = -nRet;
	}

	return nRet;
}

ads_real TGGeDirectionCurve::Direction(const TADSGePoint3d &pt) const 
{
	double nRet = GetCurve().Direction(pt);
	if (IsMinusArc())
	{
		nRet = -nRet;
	}

	return nRet;
}

void TGGeDirectionCurve::AsPoly2D(TGGePoly2D &poly) const 
{
	GetCurve().AsPoly2D(poly);
	if (IsMinusArc())
	{
		poly.Reverse();
	}
}

// 从端点开始沿曲线走过给定距离的点向量
int TGGeDirectionCurve::Polar(ads_real dDist, TADSGePointDir2d  &res, BOOL bFromStart) const 
{
	return GetCurve().Polar(dDist, res, IsMinusArc() ? (!bFromStart) : bFromStart);
}

// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
// pt如果不在线上的话则先投影
ads_real TGGeDirectionCurve::PathDistance(const TADSGePoint3d &pt, BOOL bFromStart) const 
{
	return GetCurve().PathDistance(pt, IsMinusArc() ? (!bFromStart) : bFromStart);
}

// 求通过pt点的法向
ads_real TGGeDirectionCurve::OrthoDirection(const TADSGePoint3d &pt) const 
{
	double nRet = GetCurve().OrthoDirection(pt);
	if (IsMinusArc())
	{
		nRet = AngleRangeTo2PI(nRet + PI);
	}

	return nRet;
}

void TGGeDirectionCurve::SetPoints(const TADSGePoint3d &ptStart, const TADSGePoint3d &ptEnd) 
{	
	if (IsMinusArc()) 
	{
		TGGeCurveSegment seg = GetCurve();
		seg.SetPoints(ptEnd, ptStart);
		m_startPoint = seg.GetEndPoint();
		m_endPoint = seg.GetStartPoint();
		m_dBulge = -seg.GetBulge();
	}
	else 
	{
		TGGeCurveSegment::SetPoints(ptStart, ptEnd);
	}
}

bool TGGeDirectionCurve::IsDirectionCurve()
{
	return true;
}