733 lines
14 KiB
C++
733 lines
14 KiB
C++
#include "StdAfx.h"
|
|
#include "GeLine.h"
|
|
#include "globalfunc.h"
|
|
#include "GePoly.h"
|
|
#include "AcDbObjectPtr.h"
|
|
#include "ADSGePoint3d.h"
|
|
#include "PointList.h"
|
|
#include "GeCurveInline.h"
|
|
|
|
enum HitTestPos
|
|
{
|
|
POS_Error = 0, //错误
|
|
POS_Left = 1, //左边
|
|
POS_Rigth = 2, //右边
|
|
POS_Start = 3, //起始点
|
|
POS_End = 4, //终止点
|
|
POS_InLine = 5, //线内
|
|
POS_StartLineEx = 6, //起始侧延长线
|
|
POS_EndLineEx = 7 //终止侧延长线
|
|
};
|
|
|
|
// 仅处理z坐标相同的线
|
|
static int Inters(const ADSGePoint3d &pt1, const ADSGePoint3d &pt2,
|
|
const ADSGePoint3d &qt1, const ADSGePoint3d &qt2, ADSGePoint3d &ptInter)
|
|
{
|
|
if (fabs(pt1.z - pt2.z) > g_Option::instance()._DIST_SNAP)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
// Ax+ By+ C = 0;
|
|
ads_real A1 = pt2.y - pt1.y,
|
|
B1 = pt1.x - pt2.x,
|
|
C1 = pt1.y * pt2.x - pt1.x * pt2.y;
|
|
ads_real A2 = qt2.y - qt1.y,
|
|
B2 = qt1.x - qt2.x,
|
|
C2 = qt1.y * qt2.x - qt1.x * qt2.y;
|
|
|
|
ads_real E = A1 * B2 - A2 * B1;
|
|
if (fabs(E) < g_Option::instance()._DIST_SNAP * g_Option::instance()._DIST_SNAP) //重合或平行
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
ptInter.x = (B1 * C2 - B2 * C1) / E;
|
|
ptInter.y = (C1 * A2 - C2 * A1) / E;
|
|
ptInter.z = pt1.z;
|
|
return RTNORM;
|
|
}
|
|
|
|
GeLine::GeLine(const ads_point p1, const ads_point p2, int nflag)
|
|
{
|
|
m_startPoint = p1;
|
|
m_endPoint = p2;
|
|
m_nFlag = nflag;
|
|
}
|
|
|
|
GeLine::GeLine(const EntitySet& entLine, int nflag , ads_matrix tranMat)
|
|
{
|
|
AcDbObjectPtr obj(entLine.name, AcDb::kForRead, Adesk::kTrue);
|
|
if (!obj)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (obj.m_pObject->isKindOf(AcDbLine::desc()))
|
|
{
|
|
AcDbLine *pLine = (AcDbLine *)obj.m_pObject;
|
|
(AcGePoint3d &)m_startPoint = pLine->startPoint();
|
|
(AcGePoint3d &)m_endPoint = pLine->endPoint();
|
|
|
|
if (tranMat)
|
|
{
|
|
m_startPoint.TransformBy(tranMat);
|
|
m_endPoint.TransformBy(tranMat);
|
|
}
|
|
}
|
|
}
|
|
|
|
GeLine::GeLine(const GeLine & src)
|
|
: m_startPoint(src.m_startPoint), m_endPoint(src.m_endPoint), m_nFlag(src.m_nFlag)
|
|
{
|
|
|
|
}
|
|
|
|
GeLine::GeLine(int nflag)
|
|
{
|
|
m_nFlag = nflag;
|
|
}
|
|
|
|
GeLine::GeLine(const ADSGePoint3d &ptThrough, ads_real dDrt)
|
|
: m_startPoint(ptThrough), m_nFlag(LS_INFINITE)
|
|
{
|
|
ads_polar(m_startPoint, dDrt, 100.0, m_endPoint);
|
|
}
|
|
|
|
GeLine::~GeLine()
|
|
{
|
|
|
|
}
|
|
|
|
int GeLine::OnWhichSide(const ADSGePoint3d &ptsrc) const
|
|
{
|
|
GeCurveSegment seg;
|
|
seg = *this;
|
|
return seg.OnWhichSide(ptsrc);
|
|
}
|
|
|
|
// 同两条线的特征有关
|
|
int GeLine::Intersection(const GeLine* pLine, ads_point ptrp) const
|
|
{
|
|
if (pLine != NULL)
|
|
{
|
|
// modify by xlc 100613 取消AcGe算法，速度慢
|
|
// modify by xlc on 110503 大坐标采用AcGe算法，保证精度
|
|
ADSGePoint3d ptGe;
|
|
if (fabs(m_startPoint.x) > 1.e8 || fabs(m_startPoint.y) > 1.e8
|
|
||fabs(m_endPoint.x) > 1.e8 || fabs(m_endPoint.y) > 1.e8)//大坐标
|
|
{
|
|
AcGeLine3d lineT,lineO;
|
|
lineT.set(m_startPoint.AsAcGePoint3d(),
|
|
m_endPoint.AsAcGePoint3d());
|
|
lineO.set(pLine->m_startPoint.AsAcGePoint3d(),
|
|
pLine->m_endPoint.AsAcGePoint3d());
|
|
|
|
AcGePoint3d ptGeP;
|
|
Adesk::Boolean bInt = lineT.intersectWith(lineO,ptGeP);
|
|
if (!bInt)
|
|
{
|
|
return 0;
|
|
}
|
|
ptGe = ptGeP;
|
|
}
|
|
else
|
|
{
|
|
if (Inters(m_startPoint, m_endPoint, pLine->m_startPoint, pLine->m_endPoint, ptGe) != RTNORM)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (m_nFlag == LS_INFINITE
|
|
&& pLine->m_nFlag == LS_INFINITE)
|
|
{
|
|
ptrp[X] = ptGe.x;
|
|
ptrp[Y] = ptGe.y;
|
|
ptrp[Z] = ptGe.z;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int tag1 = ptGe & (*this);
|
|
int tag2 = ptGe & (*pLine);
|
|
if (tag1 == PR_OUTSIDE || tag2 == PR_OUTSIDE)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ((m_nFlag & LS_FINITE) && (tag1 == PR_EXTEND))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ((pLine->m_nFlag & LS_FINITE) && (tag2 == PR_EXTEND))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ptrp[X] = ptGe.x;
|
|
ptrp[Y] = ptGe.y;
|
|
ptrp[Z] = ptGe.z;
|
|
return 1;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int GeLine::Intersection(const GeArc* pArc, ads_point ptrp1, ads_point ptrp2) const
|
|
{
|
|
if ( pArc != NULL)
|
|
{
|
|
//lfy 2010-08-31 采用AcGe算法
|
|
if (!GlobalFunc::IsEqual(1.0E-5, 3, pArc->GetCenterPt().z, m_startPoint.z, m_endPoint.z))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//lfy 2010-08-31 修改存取方式
|
|
AcGeLine3d lineT(m_startPoint.AsAcGePoint3d(),m_endPoint.AsAcGePoint3d());
|
|
AcGeCircArc3d cirO(pArc->m_ptCenter.AsAcGePoint3d(),AcGeVector3d::kZAxis,pArc->m_dRadius);
|
|
|
|
int nInt = 0;
|
|
ADSGePoint3d pt1, pt2;
|
|
cirO.intersectWith(lineT,nInt,pt1,pt2);
|
|
|
|
//无交点
|
|
if (nInt == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int nt1 = ((pt1 & (*pArc)) != PR_OUTSIDE);
|
|
int nt2 = ((pt2 & (*pArc)) != PR_OUTSIDE);
|
|
|
|
if (m_nFlag == LS_FINITE)
|
|
{
|
|
if (nt1)
|
|
{
|
|
int npr1 = pt1 & (*this);
|
|
nt1 = (npr1 == PR_ONPT1) || (npr1 == PR_ONPT2) || (npr1 == PR_INSIDE);
|
|
}
|
|
|
|
if (nt2)
|
|
{
|
|
int npr2 = pt2 & (*this);
|
|
nt2 = (npr2 == PR_ONPT1) || (npr2 == PR_ONPT2) || (npr2 == PR_INSIDE);
|
|
}
|
|
}
|
|
|
|
//保存点
|
|
if (ptrp1)
|
|
{
|
|
if (nt1)
|
|
{
|
|
pt1 > ptrp1;
|
|
}
|
|
|
|
if (!nt1 && nt2)
|
|
{
|
|
pt2 > ptrp1;
|
|
}
|
|
}
|
|
|
|
if (ptrp2)
|
|
{
|
|
if (nt2 && nt1)
|
|
{
|
|
pt2 > ptrp2;
|
|
}
|
|
}
|
|
|
|
if (nt2 + nt1 == 2)
|
|
{
|
|
if (pt1.AsAcGePoint3d().distanceTo(pt2.AsAcGePoint3d()) < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
nt2 = 0;
|
|
}
|
|
}
|
|
|
|
return nt1 + nt2;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int GeLine::Intersection(const GeCircle* pCircle, ads_point ptrp1, ads_point ptrp2) const
|
|
{
|
|
if (pCircle != NULL)
|
|
{
|
|
if (!GlobalFunc::IsEqual(1.0E-5, 3, pCircle->m_ptCenter.z, m_startPoint.z, m_endPoint.z))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AcGeLine3d lineT(m_startPoint.AsAcGePoint3d(), m_endPoint.AsAcGePoint3d());
|
|
AcGeCircArc3d cirO(pCircle->m_ptCenter.AsAcGePoint3d(),AcGeVector3d::kZAxis,pCircle->m_dRadius);
|
|
|
|
int nInt = 0;
|
|
ADSGePoint3d pt1, pt2;
|
|
cirO.intersectWith(lineT,nInt,pt1,pt2);
|
|
|
|
//无交点
|
|
if (nInt == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int nt1 = 1, nt2 = 1;
|
|
|
|
if (m_nFlag == LS_FINITE)
|
|
{
|
|
int npr1 = pt1 & (*this);
|
|
nt1 = (npr1 == PR_ONPT1) || (npr1 == PR_ONPT2) || (npr1 == PR_INSIDE);
|
|
int npr2 = pt2 & (*this);
|
|
nt2 = (npr2 == PR_ONPT1) || (npr2 == PR_ONPT2) || (npr2 == PR_INSIDE);
|
|
}
|
|
|
|
if (ptrp1)
|
|
{
|
|
if (nt1)
|
|
{
|
|
pt1 > ptrp1;
|
|
}
|
|
|
|
if (!nt1 && nt2)
|
|
{
|
|
pt2 > ptrp1;
|
|
}
|
|
|
|
if (ptrp2)
|
|
{
|
|
if (nt2 && nt1)
|
|
{
|
|
pt2 > ptrp2;
|
|
}
|
|
}
|
|
|
|
if (nt1 + nt2 == 2)
|
|
{
|
|
if (asPnt3d(ptrp1).distanceTo(asPnt3d(ptrp2)) < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
nt2 = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nt1 + nt2;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int GeLine::HitTest2d(const ADSGePoint3d &ptTest) const
|
|
{
|
|
double dLineLen = m_startPoint.Distance2d(m_endPoint);
|
|
if (dLineLen < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
return POS_Error;
|
|
}
|
|
|
|
double dDist2Start = m_startPoint.Distance2d(ptTest);
|
|
if (dDist2Start < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
return POS_Start;
|
|
}
|
|
|
|
double dDist2End = m_endPoint.Distance2d(ptTest);
|
|
if (dDist2End < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
return POS_End;
|
|
}
|
|
|
|
TVector3D vtTest = ptTest - m_startPoint;
|
|
TVector3D vtThis = m_endPoint - m_startPoint;
|
|
vtThis /= dLineLen;
|
|
|
|
using namespace GlobalFunc;
|
|
double dDot = (vtTest & vtThis);
|
|
if (fabs(fabs(dDot) - dDist2Start) < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
if (dDot < 0.0)
|
|
{
|
|
return POS_StartLineEx;
|
|
}
|
|
|
|
if (dDot < dLineLen)
|
|
{
|
|
return POS_InLine;
|
|
}
|
|
|
|
return POS_EndLineEx;
|
|
}
|
|
else
|
|
{
|
|
TVector3D vtCross = (vtTest*vtThis);
|
|
if (vtCross.z > 0)
|
|
{
|
|
return POS_Rigth;
|
|
}
|
|
|
|
if (vtCross.z < 0)
|
|
{
|
|
return POS_Left;
|
|
}
|
|
}
|
|
|
|
return POS_Error;
|
|
}
|
|
|
|
int GeLine::Intersection(GePoly* pPoly, PointList &pts) const
|
|
{
|
|
ASSERT(pPoly != NULL);
|
|
|
|
GeLine aLine(LS_FINITE);
|
|
int nlen = pPoly->Length();
|
|
ADSGePoint3d pt;
|
|
for (int i = 0; i < nlen; i++)
|
|
{
|
|
pPoly->NthLine(i, aLine);
|
|
if (Intersection(&aLine, pt))
|
|
{
|
|
if ((pt & (*this)) == PR_INSIDE)
|
|
{
|
|
pts.Insert(pt);
|
|
}
|
|
}
|
|
}
|
|
|
|
return pts.Length() - 2;
|
|
}
|
|
|
|
int GeLine::Modify(const EntitySet* pEntity) const
|
|
{
|
|
ASSERT(pEntity != NULL);
|
|
EntitySet entLine = *pEntity;
|
|
if (!entLine.Is(_T("LINE")))
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
entLine.SetData(10, &m_startPoint);
|
|
entLine.SetData(11, &m_endPoint);
|
|
|
|
return entLine.Modify();
|
|
}
|
|
|
|
int GeLine::MakeEntity(const EntitySet* pEntity) const
|
|
{
|
|
ASSERT(pEntity != NULL);
|
|
EntitySet ent = *pEntity;
|
|
RBGroups g(_T("*"));
|
|
RBList ebuf = ads_entgetx(ent, (resbuf *)&g);
|
|
ebuf.SetData(10, &m_startPoint);
|
|
ebuf.SetData(11, &m_endPoint);
|
|
|
|
return ads_entmake(ebuf);
|
|
}
|
|
|
|
int GeLine::Make(const TCHAR *szlay) const
|
|
{
|
|
TCHAR szlayer[80] = _T("");
|
|
if (szlay)
|
|
{
|
|
_tcscpy(szlayer, szlay);
|
|
}
|
|
else
|
|
{
|
|
GlobalFunc::TGGetVar(_T("clayer"), szlayer);
|
|
}
|
|
|
|
return GlobalFunc::MakeEntity(RTDXF0, _T("LINE"), 10,
|
|
&m_startPoint.x,11,
|
|
&m_endPoint.x, 8, szlayer, NULL);
|
|
}
|
|
|
|
int GeLine::OSnap(int nMode, ADSGePoint3d &ptPick) const
|
|
{
|
|
GeLine &ln = *(GeLine *)this;
|
|
switch(nMode)
|
|
{
|
|
case OS_END:
|
|
ptPick = ln.NearPoint(ptPick);
|
|
return nMode;
|
|
case OS_MID:
|
|
ptPick = MidPoint();
|
|
return nMode;
|
|
case OS_NEA:
|
|
{
|
|
ADSGePoint3d ptSrc = ptPick;
|
|
AcGeLine3d lineT(m_startPoint.AsAcGePoint3d(),
|
|
m_endPoint.AsAcGePoint3d());
|
|
|
|
AcGePointOnCurve3d ptOnCrv;
|
|
lineT.getClosestPointTo(ptPick.AsAcGePoint3d(),ptOnCrv);
|
|
ptPick = ptOnCrv.point3d();
|
|
return nMode;
|
|
}
|
|
break;
|
|
}
|
|
return OS_NON;
|
|
}
|
|
|
|
GeLine GeLine::Offset(ads_real ddist) const
|
|
{
|
|
ADSGePoint3d spt, ept;
|
|
ads_real dang = GlobalFunc::AngleRangeTo2PI(Direction() - PI / 2.0);
|
|
|
|
ads_polar(m_startPoint, dang, ddist, spt);
|
|
ads_polar(m_endPoint, dang, ddist, ept);
|
|
|
|
return GeLine(spt, ept);
|
|
}
|
|
|
|
int GeLine::GetSubLine(const ADSGePoint3d &ptLoc, ads_real ddist, GeLine& res) const
|
|
{
|
|
ads_polar(ptLoc, Direction() - PI, ddist / 2.0, res.m_startPoint);
|
|
ads_polar(ptLoc, Direction(), ddist / 2.0,res.m_endPoint);
|
|
|
|
int nflg1 = res.m_startPoint & (*this);
|
|
int nflg2 = res.m_endPoint & (*this);
|
|
|
|
if ((nflg1 == PR_ONPT1 || nflg1 == PR_ONPT2 || nflg1 == PR_INSIDE) &&
|
|
(nflg2 == PR_ONPT1 || nflg2 == PR_ONPT2 || nflg2 == PR_INSIDE))
|
|
{
|
|
return RTNORM;
|
|
}
|
|
else if (m_nFlag == LS_INFINITE && nflg1 == PR_EXTEND && nflg2 == PR_EXTEND)
|
|
{
|
|
return RTNORM;
|
|
}
|
|
|
|
return RTERROR;
|
|
}
|
|
|
|
int GeLine::operator != (const GeLine& aLine) const
|
|
{
|
|
return !((*this) == aLine);
|
|
}
|
|
|
|
void GeLine::SetStartPoint(ADSGePoint3d ptStart)
|
|
{
|
|
m_startPoint = ptStart;
|
|
}
|
|
|
|
void GeLine::GetStartPoint(ADSGePoint3d& ptStart)
|
|
{
|
|
ptStart = m_startPoint;
|
|
}
|
|
|
|
ADSGePoint3d GeLine::GetStartPoint() const
|
|
{
|
|
return m_startPoint;
|
|
}
|
|
|
|
void GeLine::SetEndPoint(ADSGePoint3d ptEnd)
|
|
{
|
|
m_endPoint = ptEnd;
|
|
}
|
|
|
|
void GeLine::GetEndPoint(ADSGePoint3d& ptEnd)
|
|
{
|
|
ptEnd = m_endPoint;
|
|
}
|
|
|
|
ADSGePoint3d GeLine::GetEndPoint() const
|
|
{
|
|
return m_endPoint;
|
|
}
|
|
|
|
ADSGePoint3d& GeLine::StartPoint()
|
|
{
|
|
return m_startPoint;
|
|
}
|
|
|
|
ADSGePoint3d& GeLine::EndPoint()
|
|
{
|
|
return m_endPoint;
|
|
}
|
|
|
|
ADSGePoint3d& GeLine::StartPoint() const
|
|
{
|
|
return (ADSGePoint3d&)m_startPoint;
|
|
}
|
|
|
|
ADSGePoint3d& GeLine::EndPoint() const
|
|
{
|
|
return (ADSGePoint3d&)m_endPoint;
|
|
}
|
|
|
|
void GeLine::SetLineFlag(int nFlag)
|
|
{
|
|
m_nFlag = nFlag;
|
|
}
|
|
|
|
int GeLine::GetLineFlag() const
|
|
{
|
|
return m_nFlag;
|
|
}
|
|
|
|
void GeLine::SetPoints(const ADSGePoint3d& pt1, const ADSGePoint3d& pt2)
|
|
{
|
|
m_startPoint = pt1;
|
|
m_endPoint = pt2;
|
|
}
|
|
|
|
void GeLine::SetElevation(ads_real delev)
|
|
{
|
|
m_startPoint.z = delev;
|
|
m_endPoint.z = delev;
|
|
}
|
|
|
|
void GeLine::Reverse()
|
|
{
|
|
ADSGePoint3d pttmp = m_startPoint;
|
|
m_startPoint = m_endPoint;
|
|
m_endPoint = pttmp;
|
|
}
|
|
|
|
ads_real* GeLine::NearPoint(const ads_point pt0)
|
|
{
|
|
if (ads_distance((ads_real *)pt0, (ads_real *)m_startPoint)
|
|
< ads_distance((ads_real *)pt0, (ads_real *)m_endPoint))
|
|
{
|
|
return &m_startPoint.x;
|
|
}
|
|
|
|
return &m_endPoint.x;
|
|
}
|
|
|
|
ads_real* GeLine::FarPoint(const ads_point pt0)
|
|
{
|
|
if (ads_distance((ads_real *)pt0, m_startPoint)
|
|
> ads_distance((ads_real *)pt0,m_endPoint))
|
|
{
|
|
return &m_startPoint.x;
|
|
}
|
|
|
|
return &m_endPoint.x;
|
|
}
|
|
|
|
ADSGePoint3d GeLine::MidPoint() const
|
|
{
|
|
ADSGePoint3d ptMid;
|
|
ptMid.x = (m_startPoint.x + m_endPoint.x) / 2.0;
|
|
ptMid.y = (m_startPoint.y + m_endPoint.y) / 2.0;
|
|
ptMid.z = (m_startPoint.z + m_endPoint.z) / 2.0;
|
|
|
|
return ptMid;
|
|
}
|
|
|
|
void GeLine::MidPoint(ADSGePoint3d& ptres) const
|
|
{
|
|
ptres.x = (m_startPoint.x + m_endPoint.x) / 2.0;
|
|
ptres.y = (m_startPoint.y + m_endPoint.y) / 2.0;
|
|
ptres.z = (m_startPoint.z + m_endPoint.z) / 2.0;
|
|
}
|
|
|
|
void GeLine::TransUCS(const resbuf *pfrom, const resbuf *pto)
|
|
{
|
|
ADSGePoint3d spt = m_startPoint, ept = m_endPoint;
|
|
ads_trans(spt, pfrom, pto, 0, m_startPoint);
|
|
ads_trans(ept, pfrom, pto, 0, m_endPoint);
|
|
}
|
|
|
|
void GeLine::TransformBy(ads_matrix mat)
|
|
{
|
|
m_startPoint.TransformBy(mat);
|
|
m_endPoint.TransformBy(mat);
|
|
}
|
|
|
|
bool GeLine::IsKindOf(GeEntity::TEntityId entType) const
|
|
{
|
|
switch(entType)
|
|
{
|
|
case GeEntity::eEntity:
|
|
case GeEntity::eCurve:
|
|
case GeEntity::eLinearEnt:
|
|
case GeEntity::eLine:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
GeEntity::TEntityId GeLine::Type() const
|
|
{
|
|
return GeEntity::eLine;
|
|
}
|
|
|
|
int GeLine::GetExtend(ADSGePoint3d &ptlow, ADSGePoint3d &ptup) const
|
|
{
|
|
ADSGePoint3d ptStart = m_startPoint;
|
|
ADSGePoint3d ptEnd = m_endPoint;
|
|
|
|
ptlow = Min(ptStart, ptEnd);
|
|
ptup = Max(ptStart, ptEnd);
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
ads_real GeLine::GetLength() const
|
|
{
|
|
//return m_startPoint.AsAcGePoint3d().distanceTo(m_endPoint);
|
|
//return ads_distance(m_startPoint,m_endPoint);
|
|
|
|
double t1 = m_startPoint.x - m_endPoint.x;
|
|
double t2 = m_startPoint.y - m_endPoint.y;
|
|
double t3 = m_startPoint.z - m_endPoint.z;
|
|
return sqrt(t1 * t1 + t2 * t2 + t3 * t3);
|
|
}
|
|
|
|
ads_real GeLine::Direction() const
|
|
{
|
|
return ads_angle(m_startPoint,
|
|
m_endPoint);
|
|
}
|
|
|
|
TVector3D GeLine::Direction3d() const
|
|
{
|
|
ASSERT(GetLength() > g_Option::instance()._DIST_SNAP);
|
|
|
|
TVector3D vt = m_endPoint - m_startPoint;
|
|
vt.Normalize();
|
|
|
|
return vt;
|
|
}
|
|
|
|
ads_real GeLine::PathArea() const
|
|
{
|
|
ADSGePoint3d ptStart = m_startPoint;
|
|
ADSGePoint3d ptEnd = m_endPoint;
|
|
|
|
return (ptEnd.x - ptStart.x) * (ptStart.y + ptEnd.y) / 2.0;
|
|
}
|
|
|
|
int GeLine::operator !() const
|
|
{
|
|
return m_endPoint == m_startPoint;
|
|
}
|
|
|
|
bool GeLine::operator == (const GeLine& aLine) const
|
|
{
|
|
ADSGePoint3d ptStart = m_startPoint;
|
|
ADSGePoint3d ptEnd = m_endPoint;
|
|
int nFlag = m_nFlag;
|
|
|
|
ADSGePoint3d ptStartSrc = aLine.GetStartPoint();
|
|
ADSGePoint3d ptEndSrc = aLine.GetEndPoint();
|
|
int nFlagSrc = aLine.GetLineFlag();
|
|
|
|
return (nFlag == nFlagSrc
|
|
&& (ptStart == ptStartSrc && ptEnd == ptEndSrc)
|
|
|| (ptStart == ptEndSrc && ptEnd == ptStartSrc));
|
|
}
|
|
|
|
GeLine& GeLine::operator = (const GeLine& aLine)
|
|
{
|
|
if (this != &aLine)
|
|
{
|
|
m_startPoint = aLine.m_startPoint;
|
|
m_endPoint = aLine.m_endPoint;
|
|
m_nFlag = aLine.m_nFlag;
|
|
}
|
|
return *this;
|
|
}
|
|
|