1422 lines
29 KiB
C++
1422 lines
29 KiB
C++
#include "StdAfx.h"
|
|
#include "GeCurveSegment.h"
|
|
#include "ADSGePointDir2d.h"
|
|
#include "AcDbObjectPtr.h"
|
|
#include "GeCurveInline.h"
|
|
#include "GlobalFunc.h"
|
|
|
|
|
|
GeCurveSegment::GeCurveSegment(int flg)
|
|
: GeLine(flg),m_dBulge(0.0)
|
|
{
|
|
|
|
}
|
|
|
|
GeCurveSegment::GeCurveSegment(const EntitySet &e, int flg)
|
|
: GeLine(flg),m_dBulge(0.0)
|
|
{
|
|
AcDbObjectPtr 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;
|
|
|
|
ADSGePoint3d ptCen;
|
|
(AcGePoint3d &)ptCen = pLine->center();
|
|
|
|
TVector3D vtNormal;
|
|
(AcGeVector3d &)vtNormal = pLine->normal();
|
|
|
|
ptCen = GlobalFunc::Wcs2Ecs(ptCen, vtNormal);
|
|
|
|
GeArc 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;
|
|
|
|
ADSGePoint3d ptCen;
|
|
(AcGePoint3d &)ptCen = pLine->center();
|
|
|
|
TVector3D vtNormal;
|
|
(AcGeVector3d &)vtNormal = pLine->normal();
|
|
|
|
ptCen = GlobalFunc::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;
|
|
}
|
|
}
|
|
|
|
GeCurveSegment::GeCurveSegment(const ADSGePoint3d &spt, const ADSGePoint3d &ept, ads_real ang, int flg)
|
|
: GeLine(spt,ept,flg)
|
|
{
|
|
m_dBulge = ang;
|
|
}
|
|
|
|
GeCurveSegment::GeCurveSegment(const GeCurveSegment &src)
|
|
: GeLine(LS_FINITE)
|
|
{
|
|
m_startPoint = src.m_startPoint;
|
|
m_endPoint = src.m_endPoint;
|
|
m_dBulge = src.m_dBulge;
|
|
m_nFlag = src.m_nFlag;
|
|
}
|
|
|
|
GeCurveSegment::~GeCurveSegment()
|
|
{
|
|
|
|
}
|
|
|
|
//lfy 2010-08-31 增加line,arc的set函数
|
|
GeCurveSegment & GeCurveSegment::SetLine(const ADSGePoint3d& pt1, const ADSGePoint3d& pt2)
|
|
{
|
|
m_nFlag = LS_INFINITE;
|
|
m_startPoint = pt1;
|
|
m_endPoint = pt2;
|
|
m_dBulge = 0.0;
|
|
return *this;
|
|
}
|
|
|
|
GeCurveSegment & GeCurveSegment:: SetArc(const ADSGePoint3d &spt, const ADSGePoint3d &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;
|
|
|
|
ADSGePoint3d 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;
|
|
}
|
|
|
|
GeCurveSegment & GeCurveSegment::SetCircle(const ADSGePoint3d& 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 * GeCurveSegment::AsAcDbCurve() const
|
|
{
|
|
AcDbCurve *pCurve = NULL;
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
pCurve = new AcDbLine(m_startPoint, m_endPoint);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GeArc ar = GetArc();
|
|
pCurve = new AcDbArc(ar.GetCenterPt(), ar.GetRadius(), ar.GetStarAngle(), ar.GetEndAngle());
|
|
}
|
|
return pCurve;
|
|
}
|
|
|
|
resbuf *GeCurveSegment::Mask(LPCTSTR pszLay)
|
|
{
|
|
CString 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 GeCurveSegment::MakeArrow(EntitySet &res) const
|
|
{
|
|
ads_point cpt, pt1, pt2, pt3;
|
|
ads_real arrowWidth = 200,
|
|
arrowWidthFactor = 5.0;
|
|
ADSGePoint3d 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 GeCurveSegment::PathArea(ADSGePoint3d &spt) const
|
|
{
|
|
spt.z = GetStartPoint().z;
|
|
ADSGePoint3d 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 GeCurveSegment::GetDist2Me(ADSGePoint3d ptMid) const
|
|
{
|
|
ADSGePoint3d 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 GeCurveSegment::GetSubSegment(const ADSGePoint3d &ptloc, ads_real dchordLen, GeCurveSegment &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))
|
|
{
|
|
GeArc arc1 = GetArc(), arc;
|
|
if (m_nFlag == LS_INFINITE)
|
|
{
|
|
rc = GeCircle(arc1.m_ptCenter, arc1.m_dRadius).GetSubArc(ptloc, dchordLen, arc);
|
|
}
|
|
else
|
|
{
|
|
rc = arc1.GetSubArc(ptloc, dchordLen, arc);
|
|
}
|
|
|
|
if (rc == RTNORM)
|
|
{
|
|
ADSGePoint3d ptStart = res.StartPoint();
|
|
ADSGePoint3d 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))
|
|
{
|
|
GeArc arc;
|
|
rc = GetCircle().GetSubArc(ptloc, dchordLen, arc);
|
|
if (rc == RTNORM)
|
|
{
|
|
ADSGePoint3d 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;
|
|
}
|
|
|
|
ADSGePoint3d GeCurveSegment::MidPoint() const
|
|
{
|
|
ADSGePoint3d mpt;
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
mpt = GeLine::MidPoint();
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GetArc().MidPoint(mpt);
|
|
}
|
|
else
|
|
{
|
|
return GetStartPoint();
|
|
}
|
|
|
|
return mpt;
|
|
}
|
|
|
|
ads_real GeCurveSegment::GetLength() const
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GeLine::GetLength();
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
return GetArc().GetLength();
|
|
}
|
|
else
|
|
{
|
|
return GetCircle().GetLength();
|
|
}
|
|
}
|
|
|
|
void GeCurveSegment::SetPoints(const ADSGePoint3d &ptStart, const ADSGePoint3d &ptEnd)
|
|
{
|
|
assert(!Is(CURVE_CIRCLE));
|
|
if (Is(CURVE_ARC))
|
|
{
|
|
GeArc ar = GetArc();
|
|
ar.SetAngleByPoints(ptStart, ptEnd);
|
|
|
|
*this = ar;
|
|
}
|
|
else
|
|
{
|
|
//GeLine::SetPoints(ptStart, ptEnd);
|
|
m_startPoint = ptStart;
|
|
m_endPoint = ptEnd;
|
|
}
|
|
}
|
|
|
|
|
|
GeCircle GeCurveSegment::GetCircle() const
|
|
{
|
|
return GeCircle(m_startPoint, m_endPoint);
|
|
}
|
|
|
|
GeArc GeCurveSegment::GetArc() const
|
|
{
|
|
return GeArc(m_startPoint, m_endPoint, m_dBulge);
|
|
}
|
|
|
|
int GeCurveSegment::Intersection(const GeCurveSegment& 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))
|
|
{
|
|
GeArc aArc = curve.GetArc();
|
|
if (curve.GetLineFlag() == LS_INFINITE)
|
|
{
|
|
GeCircle aCir = aArc;
|
|
int rc = Intersection(&aCir, pt1, pt2);
|
|
return rc;
|
|
}
|
|
else
|
|
{
|
|
return Intersection(&aArc, pt1, pt2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GeCircle cir(curve.GetCircle());
|
|
return Intersection(&cir, pt1, pt2);
|
|
}
|
|
}
|
|
|
|
int GeCurveSegment::Intersection(const GeLine& line, ads_point pt1, ads_point pt2) const
|
|
{
|
|
if(Is(CURVE_LINE))
|
|
{
|
|
return GetLine().Intersection(&line, pt1);
|
|
}
|
|
else if(Is(CURVE_ARC))
|
|
{
|
|
GeArc aArc = GetArc();
|
|
if(m_nFlag == LS_FINITE)
|
|
{
|
|
return aArc.Intersection(&line, pt1, pt2);
|
|
}
|
|
|
|
GeCircle aCir = aArc;
|
|
int rc = aCir.Intersection(&line, pt1, pt2);
|
|
return rc;
|
|
}
|
|
else
|
|
{
|
|
return GetCircle().Intersection(&line, pt1, pt2);
|
|
}
|
|
}
|
|
|
|
int GeCurveSegment::Intersection(const GeArc* pArc, ads_point pt1, ads_point pt2) const
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GetLine().Intersection(pArc, pt1,pt2);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GeArc aArc = GetArc();
|
|
if (m_nFlag == LS_FINITE)
|
|
{
|
|
return aArc.Intersection(pArc, pt1, pt2);
|
|
}
|
|
|
|
GeCircle aCir = aArc;
|
|
int rc = aCir.Intersection(pArc, pt1, pt2);
|
|
return rc;
|
|
}
|
|
else
|
|
{
|
|
return GetCircle().Intersection(pArc, pt1, pt2);
|
|
}
|
|
}
|
|
|
|
int GeCurveSegment::Intersection(const GeCircle* pCir, ads_point pt1, ads_point pt2) const
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GetLine().Intersection(pCir, pt1,pt2);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GeArc aArc = GetArc();
|
|
if (m_nFlag == LS_FINITE)
|
|
{
|
|
return aArc.Intersection(pCir, pt1, pt2);
|
|
}
|
|
|
|
GeCircle aCir = aArc;
|
|
int rc = aCir.Intersection(pCir, pt1, pt2);
|
|
return rc;
|
|
}
|
|
else
|
|
{
|
|
return GetCircle().Intersection(pCir, pt1, pt2);
|
|
}
|
|
}
|
|
|
|
int GeCurveSegment::ProjectToMe(const ADSGePoint3d &src, ADSGePoint3d &res) const
|
|
{
|
|
//lfy 2010-08-31 下面两句似乎无用
|
|
/*ADSGePoint3d src1 = src;
|
|
src1.z = GetStartPoint().z;*/
|
|
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GlobalFunc::PointProjectToLine(src, m_startPoint, m_endPoint, res);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GeArc arc(GetArc());
|
|
return src.Project(&arc, res);
|
|
}
|
|
else
|
|
{
|
|
GeCircle cir(GetCircle());
|
|
return src.Project(&cir, res);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int GeCurveSegment::Make(const TCHAR *pszLay) const
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
GeLine::Make(pszLay);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GetArc().Make(pszLay);
|
|
}
|
|
else
|
|
{
|
|
GetCircle().Make(pszLay);
|
|
}
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
int GeCurveSegment::OSnap(int nMode, ADSGePoint3d &ptPick) const
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GeLine::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 GeCurveSegment::AsPoly2D(GePoly2D &poly) const
|
|
{
|
|
//用两个弧来近似
|
|
if (Is(CURVE_CIRCLE))
|
|
{
|
|
poly.AppendPointListAt(new ADSGePoint3d(m_startPoint));
|
|
poly.AppendBugle(PI);
|
|
poly.AppendPointListAt(new ADSGePoint3d(m_endPoint));
|
|
poly.AppendBugle(PI);
|
|
poly.SetFlag(1);
|
|
|
|
}
|
|
else
|
|
{
|
|
poly.AppendPointListAt(new ADSGePoint3d(m_startPoint));
|
|
poly.AppendBugle(m_dBulge);
|
|
poly.AppendPointListAt(new ADSGePoint3d(m_endPoint));
|
|
poly.AppendBugle(0.0);
|
|
poly.SetFlag(0);
|
|
}
|
|
}
|
|
|
|
// 把曲线化作篱笆
|
|
resbuf * GeCurveSegment::AsFence(int nCirDiv) const
|
|
{
|
|
GePoly2D poly(0);
|
|
AsPoly2D(poly);
|
|
|
|
return poly.Fence();
|
|
}
|
|
|
|
ads_real GeCurveSegment::IDirection(int npt) const
|
|
{
|
|
using namespace GlobalFunc;
|
|
ads_real result;
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
result = npt ? RevDrtAngle(GeLine::Direction()) : GeLine::Direction();
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
GeArc aArc(m_startPoint, m_endPoint, m_dBulge);
|
|
result = aArc.IDirection(npt);
|
|
}
|
|
else
|
|
{
|
|
g_Option::instance().adsout << _T("\nInvalid Call to IDirection() for Circle!");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
ads_real GeCurveSegment::Direction(const ADSGePoint3d &pt) const
|
|
{
|
|
//lfy 2010-08-31 修改值传递
|
|
ADSGePoint3d cpt;
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GeLine::Direction();
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
cpt = GetArc().m_ptCenter;
|
|
}
|
|
else
|
|
{
|
|
cpt = GetCircle().m_ptCenter;
|
|
}
|
|
|
|
return GlobalFunc::AngleRangeTo2PI(ads_angle(cpt, pt) + PI / 2.0);
|
|
}
|
|
|
|
// 求通过pt点的法向
|
|
ads_real GeCurveSegment::OrthoDirection(const ADSGePoint3d &pt) const
|
|
{
|
|
return GlobalFunc::AngleRangeTo2PI(GeCurveSegment::Direction(pt) - PI / 2.0);
|
|
}
|
|
|
|
// Following should move to GeCurveSegment
|
|
// 从端点开始沿曲线走过给定距离的点向量
|
|
int GeCurveSegment::Polar(ads_real dDist, ADSGePointDir2d &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 ? GeLine::Direction() : GlobalFunc::AngleRangeTo2PI(GeLine::Direction() + PI);
|
|
ads_polar(bFromStart ? m_startPoint : m_endPoint, nDrt, dDist, ptres);
|
|
ptres.nDirection = dDist > -1.0E-9 ? nDrt : GlobalFunc::AngleRangeTo2PI(nDrt + PI);
|
|
}
|
|
else
|
|
{
|
|
GeArc arc = GetArc();
|
|
ads_real nAcrossAngle = dDist / arc.m_dRadius;
|
|
if (!bFromStart)
|
|
{
|
|
nAcrossAngle = -nAcrossAngle;
|
|
}
|
|
|
|
ads_real nPositionAngle = GlobalFunc::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 = GlobalFunc::AngleRangeTo2PI(nPositionAngle + PI / 2.0 + nFactor * PI);
|
|
}
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
|
|
// pt如果不在线上的话则先投影
|
|
// Note: 不能用于CIRCLE
|
|
ads_real GeCurveSegment::PathDistance(const ADSGePoint3d &pt, int bFromStart) const
|
|
{
|
|
assert(!Is(CURVE_CIRCLE));
|
|
|
|
ADSGePoint3d ptOnBase;
|
|
ProjectToMe(pt, ptOnBase);
|
|
|
|
const GeCurveSegment &thisCurve = *this;
|
|
int nPrFlag = ptOnBase & thisCurve;
|
|
const ADSGePoint3d &ptEnd = bFromStart ? m_startPoint : m_endPoint;
|
|
const ADSGePoint3d &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
|
|
{
|
|
GeArc 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
|
|
{
|
|
GeArc ar = GetArc();
|
|
//GeArc 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 GeCurveSegment::IsDirectionCurve()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
GeCurveSegment GeCurveSegment::Offset(double dDist, int nflg) const
|
|
{
|
|
return Offset(OFFSET_RIGHT, dDist, nflg);
|
|
}
|
|
|
|
// lr-- 0:逆时针，左侧; 1:顺时针，右侧
|
|
GeCurveSegment GeCurveSegment::Offset(int nlr, ads_real dDist, int nflg) const
|
|
{
|
|
//lfy 2008-08-31 修改值传递
|
|
ads_real ang = nlr ? -PI / 2.0 : PI / 2.0; //右:顺时针;左:逆时针
|
|
ADSGePoint3d spt, ept;
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
ang = GlobalFunc::AngleRangeTo2PI(GeLine::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;
|
|
}
|
|
|
|
GeArc aArc(m_startPoint, m_endPoint, ang);
|
|
ads_real r = nlr ? (aArc.m_dRadius + dDist) : (aArc.m_dRadius - dDist);
|
|
if (r < g_Option::instance()._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 GeCurveSegment(spt, ept, m_dBulge, nflg);
|
|
}
|
|
|
|
void GeCurveSegment::TransformBy(ads_matrix mat)
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
m_startPoint.TransformBy(mat);
|
|
m_endPoint.TransformBy(mat);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
ADSGePoint3d ptMid = MidPoint();
|
|
|
|
m_startPoint.TransformBy(mat);
|
|
m_endPoint.TransformBy(mat);
|
|
ptMid.TransformBy(mat);
|
|
|
|
(GeCurveSegment &)(*this) = GeArc(m_startPoint, ptMid, m_endPoint);
|
|
|
|
}
|
|
}
|
|
|
|
int GeCurveSegment::OnWhichSide1(const ADSGePoint3d &src) const
|
|
{
|
|
using namespace GlobalFunc;
|
|
int nSideFlag = 2;
|
|
|
|
ADSGePoint3d ptOnMe;
|
|
if (ProjectToMe(src, ptOnMe) != RTNORM)
|
|
{
|
|
nSideFlag = 2;
|
|
}
|
|
else
|
|
{
|
|
ADSGePoint3d src1 = src;
|
|
src1.z = m_startPoint.z;
|
|
if (src1 == ptOnMe)
|
|
{
|
|
nSideFlag = 2;
|
|
}
|
|
else
|
|
{
|
|
double nDir1 = Direction(ptOnMe);
|
|
double nDir2 = GlobalFunc::AngleRangeTo2PI(ads_angle(src1, ptOnMe) + PI / 2.0);
|
|
|
|
if (IsExactSameDrt(nDir1, nDir2, g_DimOption::instance()._angSnap))
|
|
{
|
|
nSideFlag = OFFSET_LEFT;
|
|
}
|
|
else
|
|
{
|
|
nSideFlag = OFFSET_RIGHT;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Is(CURVE_ARC))
|
|
{
|
|
int nSideFlag0 = GeLine::OnWhichSide(src);
|
|
if (nSideFlag0 == OFFSET_LEFT)
|
|
{
|
|
nSideFlag = nSideFlag0;
|
|
}
|
|
}
|
|
|
|
return nSideFlag;
|
|
}
|
|
|
|
// 0--Left, 1--Right, 2--Other
|
|
int GeCurveSegment::OnWhichSide(const ADSGePoint3d &src) const
|
|
{
|
|
using namespace GlobalFunc;
|
|
int nSideFlag = 2;
|
|
|
|
ADSGePoint3d ptOnMe;
|
|
if (ProjectToMe(src, ptOnMe) != RTNORM)
|
|
{
|
|
nSideFlag = 2;
|
|
}
|
|
else
|
|
{
|
|
ADSGePoint3d src1 = src;
|
|
src1.z = m_startPoint.z;
|
|
if (src1 == ptOnMe)
|
|
{
|
|
nSideFlag = 2;
|
|
}
|
|
else
|
|
{
|
|
double nDir1 = Direction(ptOnMe);
|
|
double nDir2 = GlobalFunc::AngleRangeTo2PI(ads_angle(src1, ptOnMe) + PI / 2.0);
|
|
|
|
if (IsExactSameDrt(nDir1, nDir2, g_DimOption::instance()._angSnap))
|
|
{
|
|
nSideFlag = OFFSET_LEFT;
|
|
}
|
|
else
|
|
{
|
|
nSideFlag = OFFSET_RIGHT;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nSideFlag;
|
|
}
|
|
|
|
//Wcs到展开坐标系
|
|
ADSGePoint3d GeCurveSegment::Wcs2Ecs(ADSGePoint3d pt) const
|
|
{
|
|
ADSGePoint3d ptPrj;
|
|
ProjectToMe(pt, ptPrj);
|
|
|
|
ADSGePoint3d 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
|
|
ADSGePoint3d GeCurveSegment::Ecs2Wcs(ADSGePoint3d pt) const
|
|
{
|
|
ADSGePointDir2d ptDir;
|
|
Polar(pt.x, ptDir);
|
|
|
|
ADSGePoint3d ptWcs;
|
|
ptWcs = ptDir;
|
|
ptWcs.z = pt.y - m_startPoint.z;
|
|
|
|
if (fabs(pt.z) > g_Option::instance()._DIST_SNAP)
|
|
{
|
|
ads_polar(ADSGePoint3d(ptWcs), ptDir.nDirection - PI / 2.0, pt.z, ptWcs);
|
|
}
|
|
return ptWcs;
|
|
}
|
|
|
|
void GeCurveSegment::Wcs2Ecs(const GePoly2D &polyWcs, GePoly2D &polyEcs) const
|
|
{
|
|
polyEcs.Reset();
|
|
polyEcs.SetFlag(polyWcs.GetFlag());
|
|
for (int i = 0; i < polyWcs.Length(); i++)
|
|
{
|
|
ADSGePoint3d ptEcs = Wcs2Ecs(polyWcs.GetPointListAt(i));
|
|
polyEcs.AppendNode(ptEcs, polyWcs.GetBulge(i));
|
|
}
|
|
}
|
|
|
|
void GeCurveSegment::Ecs2Wcs(const GePoly2D &polyEcs, GePoly2D &polyWcs) const
|
|
{
|
|
polyWcs.Reset();
|
|
polyWcs.SetFlag(polyEcs.GetFlag());
|
|
for (int i = 0; i < polyEcs.Length(); i++)
|
|
{
|
|
ADSGePoint3d ptWcs = Ecs2Wcs(polyEcs.GetPointListAt(i));
|
|
polyWcs.AppendNode(ptWcs, polyEcs.GetBulge(i));
|
|
}
|
|
|
|
}
|
|
|
|
double GeCurveSegment::GetBulge() const
|
|
{
|
|
return m_dBulge;
|
|
}
|
|
|
|
void GeCurveSegment::SetBulge(const double dBulge)
|
|
{
|
|
m_dBulge = dBulge;
|
|
}
|
|
|
|
bool GeCurveSegment::IsKindOf(GeEntity::TEntityId entType) const
|
|
{
|
|
switch(entType)
|
|
{
|
|
case GeEntity::eEntity:
|
|
case GeEntity::eCurve:
|
|
case GeEntity::eLinearEnt:
|
|
case GeEntity::eLine:
|
|
case GeEntity::eCurveSegment:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
GeEntity::TEntityId GeCurveSegment::Type() const
|
|
{
|
|
return GeEntity::eCurveSegment;
|
|
}
|
|
|
|
void GeCurveSegment::CopyFrom(const GeEntity* pSrc)
|
|
{
|
|
if (this != pSrc && pSrc->IsKindOf(GeEntity::eCurveSegment))
|
|
{
|
|
GeCurveSegment* pEntSeg = (GeCurveSegment* )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(GeEntity::eLine))
|
|
{
|
|
GeCurveSegment* pEntLine = (GeCurveSegment* )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)
|
|
{
|
|
ADSGePoint3d 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 = GlobalFunc::AngleRangeTo2PI(ads_angle(ptOrg1, ptY1) - ads_angle(ptOrg1, ptX1));
|
|
|
|
return (fabs(nAng - PI * 1.5) < g_DimOption::instance()._angSnap);
|
|
}
|
|
|
|
GeDirectionCurve::GeDirectionCurve(const ADSGePoint3d &spt, const ADSGePoint3d &ept, ads_real dAng, int flg)
|
|
: GeCurveSegment(spt,ept,dAng, flg)
|
|
{
|
|
|
|
}
|
|
|
|
GeDirectionCurve::GeDirectionCurve(int flg)
|
|
: GeCurveSegment(flg)
|
|
{
|
|
|
|
}
|
|
|
|
GeDirectionCurve::GeDirectionCurve(const GeDirectionCurve &src)
|
|
: GeCurveSegment(src)
|
|
{
|
|
|
|
}
|
|
|
|
GeDirectionCurve::GeDirectionCurve(const GeArc &ar, int bMinus)
|
|
{
|
|
GeCurveSegment &seg = *this;
|
|
seg = ar;
|
|
|
|
if (bMinus)
|
|
{
|
|
m_dBulge = -fabs(m_dBulge);
|
|
GlobalFunc::Exchange(m_startPoint, m_endPoint);
|
|
}
|
|
}
|
|
|
|
GeDirectionCurve::~GeDirectionCurve()
|
|
{
|
|
|
|
}
|
|
|
|
GeArc GeDirectionCurve::GetArc() const
|
|
{
|
|
if (IsMinusArc())
|
|
{
|
|
return GeArc(m_endPoint, m_startPoint, fabs(m_dBulge));
|
|
}
|
|
|
|
return GeArc(m_startPoint, m_endPoint, m_dBulge);
|
|
}
|
|
|
|
int GeDirectionCurve::IsMinusArc() const
|
|
{
|
|
return m_dBulge < -1.0E-8;
|
|
}
|
|
|
|
GeCurveSegment GeDirectionCurve::GetCurve() const
|
|
{
|
|
GeCurveSegment seg;
|
|
if (IsMinusArc())
|
|
{
|
|
seg = GetArc();
|
|
}
|
|
else
|
|
{
|
|
seg = *this;
|
|
}
|
|
|
|
return seg;
|
|
}
|
|
|
|
void GeDirectionCurve::TransUCS(const resbuf *rb1, const resbuf *rb2)
|
|
{
|
|
GeLine::TransUCS(rb2, rb2);
|
|
if (IsMirrorTransform(rb1, rb2))
|
|
{
|
|
m_dBulge = -m_dBulge;
|
|
}
|
|
}
|
|
|
|
void GeDirectionCurve::TransUCS(ads_matrix mat)
|
|
{
|
|
GeLine::TransformBy(mat);
|
|
if (GlobalFunc::IsMirrorMatrix(mat))
|
|
{
|
|
m_dBulge = -m_dBulge;
|
|
}
|
|
}
|
|
|
|
void GeDirectionCurve::Reverse()
|
|
{
|
|
GlobalFunc::Exchange(m_startPoint, m_endPoint);
|
|
m_dBulge = -m_dBulge;
|
|
}
|
|
|
|
// dist: <0 left side; >0 right siede
|
|
GeDirectionCurve GeDirectionCurve::Offset(ads_real dist, int flg) const
|
|
{
|
|
assert(!Is(CURVE_CIRCLE));
|
|
|
|
ADSGePoint3d spt, ept;
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
ads_real ang = GeLine::Direction()-PI/2.0;
|
|
ads_polar(m_startPoint, ang, dist, spt);
|
|
ads_polar(m_endPoint, ang, dist, ept);
|
|
|
|
return GeDirectionCurve(spt, ept, 0.0, flg);
|
|
}
|
|
|
|
GeArc aArc = GetArc();
|
|
ads_real r = (!IsMinusArc()) ? (aArc.GetRadius() + dist) : (aArc.GetRadius() - dist);
|
|
|
|
if (r < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
return GeDirectionCurve();
|
|
}
|
|
|
|
aArc.SetRadius(r);
|
|
|
|
GeDirectionCurve curve(aArc, IsMinusArc());
|
|
curve.m_nFlag = flg;
|
|
return curve;
|
|
}
|
|
|
|
ads_real GeDirectionCurve::IDirection(int npt) const
|
|
{
|
|
if (IsMinusArc())
|
|
{
|
|
return GetCurve().IDirection(1 - npt);
|
|
}
|
|
|
|
return GeCurveSegment::IDirection(npt);
|
|
}
|
|
|
|
int GeDirectionCurve::OnWhichSide(const ADSGePoint3d &src) const
|
|
{
|
|
int nSide = GetCurve().OnWhichSide(src);
|
|
if (IsMinusArc())
|
|
{
|
|
nSide = 1 - nSide;
|
|
}
|
|
|
|
return nSide;
|
|
}
|
|
|
|
int GeDirectionCurve::OnWhichSide1(const ADSGePoint3d &src) const
|
|
{
|
|
int nSide = GetCurve().OnWhichSide1(src);
|
|
if (IsMinusArc())
|
|
{
|
|
nSide = 1 - nSide;
|
|
}
|
|
|
|
return nSide;
|
|
}
|
|
|
|
ads_real GeDirectionCurve::PathArea(ADSGePoint3d &tmpt) const
|
|
{
|
|
double nRet = GetCurve().PathArea(tmpt);
|
|
if (IsMinusArc())
|
|
{
|
|
nRet = -nRet;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
ads_real GeDirectionCurve::Direction(const ADSGePoint3d &pt) const
|
|
{
|
|
double nRet = GetCurve().Direction(pt);
|
|
if (IsMinusArc())
|
|
{
|
|
nRet = -nRet;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
void GeDirectionCurve::AsPoly2D(GePoly2D &poly) const
|
|
{
|
|
GetCurve().AsPoly2D(poly);
|
|
if (IsMinusArc())
|
|
{
|
|
poly.Reverse();
|
|
}
|
|
}
|
|
|
|
// 从端点开始沿曲线走过给定距离的点向量
|
|
int GeDirectionCurve::Polar(ads_real dDist, ADSGePointDir2d &res, BOOL bFromStart) const
|
|
{
|
|
return GetCurve().Polar(dDist, res, IsMinusArc() ? (!bFromStart) : bFromStart);
|
|
}
|
|
|
|
// 求到端点的沿曲线线位移, 在线内距离为正,否则为负, 和Polar配合使用
|
|
// pt如果不在线上的话则先投影
|
|
ads_real GeDirectionCurve::PathDistance(const ADSGePoint3d &pt, BOOL bFromStart) const
|
|
{
|
|
return GetCurve().PathDistance(pt, IsMinusArc() ? (!bFromStart) : bFromStart);
|
|
}
|
|
|
|
// 求通过pt点的法向
|
|
ads_real GeDirectionCurve::OrthoDirection(const ADSGePoint3d &pt) const
|
|
{
|
|
double nRet = GetCurve().OrthoDirection(pt);
|
|
if (IsMinusArc())
|
|
{
|
|
nRet = GlobalFunc::AngleRangeTo2PI(nRet + PI);
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
void GeDirectionCurve::SetPoints(const ADSGePoint3d &ptStart, const ADSGePoint3d &ptEnd)
|
|
{
|
|
if (IsMinusArc())
|
|
{
|
|
GeCurveSegment seg = GetCurve();
|
|
seg.SetPoints(ptEnd, ptStart);
|
|
m_startPoint = seg.GetEndPoint();
|
|
m_endPoint = seg.GetStartPoint();
|
|
m_dBulge = -seg.GetBulge();
|
|
}
|
|
else
|
|
{
|
|
GeCurveSegment::SetPoints(ptStart, ptEnd);
|
|
}
|
|
}
|
|
|
|
bool GeDirectionCurve::IsDirectionCurve()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool GeCurveSegment::operator == (const GeCurveSegment &src) const
|
|
{
|
|
bool bRet = false;
|
|
if (src.GetCurveType() != GetCurveType())
|
|
{
|
|
bRet = false;
|
|
}
|
|
else if (Is(CURVE_LINE))
|
|
{
|
|
bRet = (GetLine() == src.GetLine());
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
bRet = (GetArc() == src.GetArc());
|
|
}
|
|
else
|
|
{
|
|
bRet = (GetCircle() == src.GetCircle());
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
int GeCurveSegment::Is(CurveType t) const
|
|
{
|
|
double dBulge = fabs(GetBulge());
|
|
return ((dBulge < 1E-6 && t == CURVE_LINE)
|
|
|| (fabs(2.0 * PI - dBulge) < 1E-5 && t == CURVE_CIRCLE)
|
|
|| (dBulge > 1E-6 && dBulge < 2.0 * PI - 1E-6 && t == CURVE_ARC));
|
|
}
|
|
|
|
CurveType GeCurveSegment::GetCurveType() const
|
|
{
|
|
CurveType t;
|
|
double dBulge = fabs(GetBulge());
|
|
if (dBulge < 1E-6)
|
|
{
|
|
t = CURVE_LINE;
|
|
}
|
|
else if (fabs(2.0 * PI - dBulge) < 1E-5)
|
|
{
|
|
t = CURVE_CIRCLE;
|
|
}
|
|
else
|
|
{
|
|
t = CURVE_ARC;
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
GeLine GeCurveSegment::GetLine() const
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
double GeCurveSegment::GetChordLength(double nArcLen) const
|
|
{
|
|
double nRes = nArcLen;
|
|
if (Is(CURVE_ARC))
|
|
{
|
|
GeArc ar = GetArc();
|
|
double dRadius = ar.GetRadius();
|
|
nRes = 2.0 * dRadius * sin(nArcLen / 2.0 / dRadius);
|
|
}
|
|
|
|
return fabs(nRes);
|
|
}
|
|
|
|
int GeCurveSegment::HitTest2d(const ADSGePoint3d &ptTest) const
|
|
{
|
|
CurveType t = GetCurveType();
|
|
int nHitFlag = 0;
|
|
if (t == CURVE_LINE)
|
|
{
|
|
nHitFlag = GetLine().HitTest2d(ptTest);
|
|
}
|
|
else if (t == CURVE_ARC)
|
|
{
|
|
nHitFlag = GetArc().HitTest2d(ptTest);
|
|
}
|
|
else if (t == CURVE_CIRCLE)
|
|
{
|
|
nHitFlag = GetCircle().HitTest2d(ptTest);
|
|
}
|
|
return nHitFlag;
|
|
}
|
|
|
|
int GeCurveSegment::MakeEntity(const EntitySet &e)
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GetLine().MakeEntity(&e);
|
|
}
|
|
|
|
if (Is(CURVE_ARC))
|
|
{
|
|
return GetArc().MakeEntity(&e);
|
|
}
|
|
|
|
if (Is(CURVE_CIRCLE))
|
|
{
|
|
return GetCircle().MakeEntity(&e);
|
|
}
|
|
return RTERROR;
|
|
}
|
|
|
|
int GeCurveSegment::GetExtend(ADSGePoint3d &lowPt, ADSGePoint3d &upPt) const
|
|
{
|
|
if (Is(CURVE_LINE))
|
|
{
|
|
return GeLine::GetExtend(lowPt, upPt);
|
|
}
|
|
else if (Is(CURVE_ARC))
|
|
{
|
|
return GetArc().GetExtend(lowPt, upPt);
|
|
}
|
|
else
|
|
{
|
|
return GetCircle().GetExtend(lowPt, upPt);
|
|
}
|
|
}
|
|
|
|
GeCurveSegment & GeCurveSegment::operator = (const GeCurveSegment &src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
m_nFlag = src.m_nFlag;
|
|
m_startPoint = src.m_startPoint;
|
|
m_endPoint = src.m_endPoint;
|
|
m_dBulge = src.m_dBulge;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
GeCurveSegment & GeCurveSegment::operator = (const GeLine &ln)
|
|
{
|
|
m_nFlag = ln.m_nFlag;
|
|
m_startPoint = ln.m_startPoint;
|
|
m_endPoint = ln.m_endPoint;
|
|
m_dBulge = 0.0;
|
|
return *this;
|
|
}
|
|
|
|
GeCurveSegment & GeCurveSegment::operator = (const GeArc &arc)
|
|
{
|
|
//SetLineFlag(LS_FINITE);
|
|
m_nFlag = LS_FINITE;
|
|
|
|
ADSGePoint3d ptStart, ptEnd;
|
|
ADSGePoint3d ptCen = arc.GetCenterPt();
|
|
double dRadius = arc.GetRadius();
|
|
|
|
ads_polar(ptCen, arc.GetStarAngle(), dRadius, ptStart);
|
|
ads_polar(ptCen, arc.GetEndAngle(), dRadius, ptEnd);
|
|
|
|
m_startPoint = ptStart;
|
|
m_endPoint = ptEnd;
|
|
m_dBulge = arc.Bulge();
|
|
|
|
return *this;
|
|
}
|
|
|
|
GeCurveSegment & GeCurveSegment::operator = (const GeCircle &cir)
|
|
{
|
|
ADSGePoint3d ptStart, ptEnd;
|
|
ADSGePoint3d ptCen = cir.GetCenterPt();
|
|
double dRadius = cir.GetRadius();
|
|
|
|
ads_polar(ptCen, 0.0, dRadius, ptStart);
|
|
ads_polar(ptCen, PI, dRadius, ptEnd);
|
|
|
|
m_startPoint = ptStart;
|
|
m_endPoint = ptEnd;
|
|
m_dBulge = 2.0 * PI;
|
|
|
|
return *this;
|
|
}
|
|
|