3106 lines
64 KiB
C++
3106 lines
64 KiB
C++
//-----------------------------------------------------------------------------+
|
|
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
|
|
// = FileName : TBPloyLine.cpp
|
|
// = Version : ver2.0
|
|
// = Author : xlc
|
|
// = CreateDate : 2002-09-09
|
|
// = Description: 类的定义
|
|
// = Maintainers:
|
|
//
|
|
//-----------------------------------------------------------------------------+
|
|
#include "StdAfx.h"
|
|
#include "TBPloyLine.h"
|
|
#include <geray3d.h>
|
|
#include "TchGlobalFunc.h"
|
|
#include "TchPrivateGlobalFunc.h"
|
|
|
|
TBPloyLine::TBPloyLine()
|
|
{
|
|
m_bClosed = 0;
|
|
}
|
|
|
|
TBPloyLine::TBPloyLine(const TBPloyLine& bline)
|
|
{
|
|
ReleaseBasLst();
|
|
POSITION pos = bline.m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = bline.m_BNodeList.GetNext(pos);
|
|
TBNode* pNodeNew = new TBNode;
|
|
*pNodeNew = *pNode;
|
|
m_BNodeList.AddTail(pNodeNew);
|
|
}
|
|
m_bClosed = bline.m_bClosed;
|
|
}
|
|
|
|
TBPloyLine::~TBPloyLine()
|
|
{
|
|
POSITION pos = m_BNodeList.GetTailPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetPrev(pos);
|
|
if (pNode != NULL)
|
|
{
|
|
delete pNode;
|
|
}
|
|
}
|
|
m_BNodeList.RemoveAll();
|
|
|
|
pos = m_DNodeList.GetTailPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TDNode* pNode = m_DNodeList.GetPrev(pos);
|
|
if (pNode != NULL)
|
|
{
|
|
delete pNode;
|
|
}
|
|
}
|
|
m_DNodeList.RemoveAll();
|
|
}
|
|
|
|
BOOL TBPloyLine::IsClosed() const
|
|
{
|
|
return m_bClosed;
|
|
}
|
|
|
|
void TBPloyLine::ReleaseAll()
|
|
{
|
|
ReleaseBasLst();
|
|
ReleaseDivLst();
|
|
m_bClosed = 0;
|
|
}
|
|
|
|
void TBPloyLine::ReleaseBasLst()
|
|
{
|
|
POSITION pos = m_BNodeList.GetTailPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetPrev(pos);
|
|
if (pNode != NULL)
|
|
{
|
|
delete pNode;
|
|
}
|
|
}
|
|
m_BNodeList.RemoveAll();
|
|
}
|
|
|
|
void TBPloyLine::ReleaseDivLst()
|
|
{
|
|
POSITION pos = m_DNodeList.GetTailPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TDNode* pNode = m_DNodeList.GetPrev(pos);
|
|
if (pNode != NULL)
|
|
{
|
|
delete pNode;
|
|
}
|
|
}
|
|
m_DNodeList.RemoveAll();
|
|
}
|
|
|
|
TBPloyLine& TBPloyLine::operator = (const TBPloyLine& basLine)
|
|
{
|
|
ReleaseBasLst();
|
|
m_bClosed = basLine.m_bClosed;
|
|
POSITION pos = basLine.m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = basLine.m_BNodeList.GetNext(pos);
|
|
if (pNode != NULL)
|
|
{
|
|
TBNode* pNodeNew = new TBNode;
|
|
*pNodeNew = *pNode;
|
|
m_BNodeList.AddTail(pNodeNew);
|
|
}
|
|
}
|
|
ReCalcSValue();
|
|
return *this;
|
|
}
|
|
|
|
void TBPloyLine::RmvOverlapPt(double tol)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (GetLength(1) < TOL)
|
|
{
|
|
TBNode* pHead = Head();
|
|
TBNode* pTail = Tail();
|
|
pHead->m_eType = BLINESEG;
|
|
|
|
if (pHead->m_pArc != NULL)
|
|
{
|
|
delete pHead->m_pArc;
|
|
pHead->m_pArc = NULL;
|
|
}
|
|
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posTemp = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode != pHead && pNode != pTail)
|
|
{
|
|
delete pNode;
|
|
m_BNodeList.RemoveAt(posTemp);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posThis = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
TBNode* pNodeNext = NULL;
|
|
if (pos != NULL)
|
|
{
|
|
pNodeNext = m_BNodeList.GetAt(pos);
|
|
}
|
|
|
|
if (pNodeNext != NULL && IsEqual(pNode->m_pt,pNodeNext->m_pt,tol))
|
|
{
|
|
if (m_BNodeList.GetCount() > 2)
|
|
{
|
|
m_BNodeList.RemoveAt(posThis);
|
|
delete pNode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
BOOL TBPloyLine::InsertBLineInto(TBNode* pNode,TBPloyLine* pBLine,BOOL LinkEdgeUnvisible)
|
|
{
|
|
if (pBLine == NULL)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (IsEmpty())
|
|
{
|
|
POSITION pos1 = pBLine->m_BNodeList.GetHeadPosition();
|
|
while (pos1 != NULL)
|
|
{
|
|
TBNode* pNode1 = pBLine->m_BNodeList.GetNext(pos1);
|
|
TBNode* pNodeNew = new TBNode(pNode1);
|
|
m_BNodeList.AddTail(pNodeNew);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
if (pNode == NULL)
|
|
{
|
|
pNode = Tail();
|
|
}
|
|
|
|
TBNodeList tempList;
|
|
|
|
BOOL bNextVisible = pNode->m_bVisible;
|
|
pNode->m_bVisible = 0;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNodeHere = m_BNodeList.GetNext(pos);
|
|
tempList.AddTail(pNodeHere);
|
|
if (pNodeHere == pNode)
|
|
{
|
|
POSITION pos1 = pBLine->m_BNodeList.GetHeadPosition();
|
|
while (pos1 != NULL)
|
|
{
|
|
TBNode* pNode1 = pBLine->m_BNodeList.GetNext(pos1);
|
|
TBNode* pNodeNew = new TBNode(pNode1);
|
|
if (pos1 == NULL && LinkEdgeUnvisible)
|
|
{
|
|
pNodeNew->m_bVisible = 0;
|
|
}
|
|
tempList.AddTail(pNodeNew);
|
|
}
|
|
TBNode* pNodeHereNew = new TBNode(pNodeHere);
|
|
pNodeHereNew->m_bVisible = bNextVisible;
|
|
tempList.AddTail(pNodeHereNew);//多增加一个结点
|
|
}
|
|
}
|
|
m_BNodeList.RemoveAll();
|
|
m_BNodeList.AddTail(&tempList);
|
|
|
|
ClearUp();
|
|
ReCalcSValue();
|
|
return 1;
|
|
}
|
|
|
|
TBNode* TBPloyLine::GetNodeRangedAt(double ds,double deta,BOOL bPercent)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
double tLen = GetLength();
|
|
if (bPercent)
|
|
{
|
|
deta = fabs(tLen * deta);
|
|
}
|
|
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posTemp = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (fabs(pNode->m_s - ds) < deta)
|
|
{
|
|
return pNode;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void TBPloyLine::ResetHead(TBNode* pHead)
|
|
{
|
|
if (!pHead)
|
|
{
|
|
return;
|
|
}
|
|
if (!m_bClosed)
|
|
{
|
|
return;
|
|
}
|
|
if (m_BNodeList.GetCount() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TBNode* pNodeH = m_BNodeList.GetHead();
|
|
if (pNodeH == pHead)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TBNodeList list1,list2;
|
|
BOOL bfront = 1;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode == pHead)
|
|
{
|
|
bfront = 0;
|
|
}
|
|
if (bfront)
|
|
{
|
|
list1.AddTail(pNode);
|
|
}
|
|
else if (pos != NULL)
|
|
{
|
|
list2.AddTail(pNode);
|
|
}
|
|
}
|
|
TBNode* pTail1 = list1.GetTail();
|
|
TBNode* pNewTail = new TBNode(pTail1->m_eType,0.,pHead->m_pt);
|
|
list1.AddTail(pNewTail);
|
|
m_BNodeList.RemoveAll();
|
|
m_BNodeList.AddTail(&list2);
|
|
m_BNodeList.AddTail(&list1);
|
|
ReCalcSValue();
|
|
}
|
|
|
|
void TBPloyLine::ClearUp(double tol)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
RmvOverlapPt(tol);
|
|
MergeCoLine(tol);
|
|
}
|
|
|
|
void TBPloyLine::MergeCoArc(double tol)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (GetLength(1) < TOL)
|
|
{
|
|
TBNode* pHead = Head();
|
|
TBNode* pTail = Tail();
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posTemp = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode != pHead && pNode != pTail)
|
|
{
|
|
delete pNode;
|
|
m_BNodeList.RemoveAt(posTemp);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
TBNode* pNodePrev = NULL;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posThis = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
TBNode* pNodeNext = NULL;
|
|
if (pos != NULL)
|
|
{
|
|
pNodeNext = m_BNodeList.GetAt(pos);
|
|
}
|
|
|
|
if (pNodePrev != NULL && pNodePrev->m_eType == BARCSEG &&
|
|
pNode->m_eType == BARCSEG && pNodePrev->m_pArc != NULL && pNode->m_pArc != NULL)
|
|
{
|
|
if (IsEqual(pNodePrev->m_pArc->m_centPt,pNode->m_pArc->m_centPt,tol) &&
|
|
(fabs(pNodePrev->m_pArc->m_R-pNode->m_pArc->m_R)<tol) &&
|
|
IsEqualSign(pNodePrev->m_pArc->m_centAngle,pNode->m_pArc->m_centAngle))
|
|
{
|
|
pNodePrev->m_pArc->m_centAngle += pNode->m_pArc->m_centAngle;
|
|
if (pNodeNext != NULL)
|
|
{
|
|
m_BNodeList.RemoveAt(posThis);
|
|
delete pNode;
|
|
pos = m_BNodeList.Find(pNodeNext);
|
|
continue;
|
|
}
|
|
else
|
|
{//末端点
|
|
delete pNode->m_pArc;
|
|
pNode->m_pArc = NULL;
|
|
}
|
|
}
|
|
}
|
|
pNodePrev = pNode;
|
|
}
|
|
if ((m_BNodeList.GetCount() > 2) && IsClosed())//去除首尾处多余的点。
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetHead();
|
|
POSITION pos = m_BNodeList.GetTailPosition();
|
|
TBNode* pTailNode = m_BNodeList.GetPrev(pos);
|
|
TBNode* pNodePrev = m_BNodeList.GetAt(pos);
|
|
|
|
if (pNodePrev->m_eType == BARCSEG && pNode->m_eType == BARCSEG
|
|
&& pNodePrev->m_pArc != NULL && pNode->m_pArc != NULL)
|
|
{
|
|
if (IsEqual(pNodePrev->m_pArc->m_centPt,pNode->m_pArc->m_centPt,tol) &&
|
|
(fabs(pNodePrev->m_pArc->m_R-pNode->m_pArc->m_R)<tol) &&
|
|
IsEqualSign(pNodePrev->m_pArc->m_centAngle,pNode->m_pArc->m_centAngle))
|
|
{
|
|
pNode->m_pt = pNodePrev->m_pt;
|
|
pNode->m_pArc->m_startAngle = pNodePrev->m_pArc->m_startAngle;
|
|
pNode->m_pArc->m_centAngle += pNodePrev->m_pArc->m_centAngle;
|
|
|
|
pNodePrev->m_eType = BLINESEG;
|
|
delete pNodePrev->m_pArc;
|
|
pNodePrev->m_pArc = NULL;
|
|
|
|
m_BNodeList.RemoveTail();
|
|
delete pTailNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReCalcSValue();
|
|
}
|
|
|
|
void TBPloyLine::MergeCoLine(double tol)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (GetLength(1) < TOL)
|
|
{
|
|
TBNode* pHead = Head();
|
|
TBNode* pTail = Tail();
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posTemp = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode != pHead && pNode != pTail)
|
|
{
|
|
delete pNode;
|
|
m_BNodeList.RemoveAt(posTemp);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
AcGeTol tol1;
|
|
tol1.setEqualPoint(tol);
|
|
TBNode* pNodePrev = NULL;
|
|
TBNode* pNodeNext = NULL;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
POSITION posTemp = pos;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pos == NULL)
|
|
{
|
|
pNodeNext = NULL;
|
|
}
|
|
else
|
|
{
|
|
pNodeNext = m_BNodeList.GetAt(pos);
|
|
}
|
|
|
|
if (pNodePrev == NULL && pNodeNext != NULL && m_bClosed)
|
|
{//第一接点且封闭
|
|
TBNode* pNodePrevPrev = NULL;
|
|
POSITION pos1 = m_BNodeList.GetTailPosition();
|
|
if (pos1 != NULL)
|
|
{
|
|
pNodePrev = m_BNodeList.GetPrev(pos1);
|
|
}
|
|
if (pos1 != NULL)
|
|
{
|
|
pNodePrevPrev = m_BNodeList.GetPrev(pos1);
|
|
}
|
|
if (pNodePrevPrev != NULL && pNodePrevPrev != pNode)
|
|
{
|
|
AcGeLine3d line(pNodePrevPrev->m_pt,pNode->m_pt);
|
|
if (line.isOn(pNodeNext->m_pt,tol1) == Adesk::kTrue)
|
|
{
|
|
pNode->m_pt = pNodePrevPrev->m_pt;
|
|
delete pNodePrev;
|
|
m_BNodeList.RemoveAt(m_BNodeList.GetTailPosition());
|
|
pNodePrev = NULL;
|
|
pos = m_BNodeList.GetHeadPosition();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else if (pNodeNext != NULL && pNodePrev != NULL && pNodePrev->m_eType == BLINESEG && pNode->m_eType == BLINESEG)
|
|
{
|
|
AcGeLine3d line(pNodePrev->m_pt,pNode->m_pt);
|
|
if (line.isOn(pNodeNext->m_pt,tol1) == Adesk::kTrue)
|
|
{
|
|
delete pNode;
|
|
m_BNodeList.RemoveAt(posTemp);
|
|
pos = m_BNodeList.Find(pNodeNext);
|
|
continue;
|
|
}
|
|
}
|
|
pNodePrev = pNode;
|
|
}
|
|
ReCalcSValue();
|
|
}
|
|
|
|
TBPloyLine TBPloyLine::operator + (const TBPloyLine& basLine) const
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return basLine;
|
|
}
|
|
if (basLine.IsEmpty())
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
if (m_bClosed || basLine.m_bClosed)
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
TBPloyLine blineThis(*this);
|
|
TBPloyLine blinePara(basLine);
|
|
|
|
TBNode* pHead1 = blineThis.m_BNodeList.GetHead();
|
|
TBNode* pTail1 = blineThis.m_BNodeList.GetTail();
|
|
TBNode* pHead2 = blinePara.m_BNodeList.GetHead();
|
|
TBNode* pTail2 = blinePara.m_BNodeList.GetTail();
|
|
|
|
if (pHead2 == NULL)
|
|
{
|
|
return *this;
|
|
}
|
|
if (pHead1 == NULL)
|
|
{
|
|
return blinePara;
|
|
}
|
|
|
|
if (IsEqual(pTail1->m_pt,pHead2->m_pt,TOL))
|
|
{
|
|
;
|
|
}
|
|
else if (IsEqual(pTail1->m_pt,pTail2->m_pt,TOL))
|
|
{
|
|
blinePara.Reverse();
|
|
}
|
|
else if (IsEqual(pHead1->m_pt,pHead2->m_pt,TOL))
|
|
{
|
|
blineThis.Reverse();
|
|
}
|
|
else if (IsEqual(pHead1->m_pt,pTail2->m_pt,TOL))
|
|
{
|
|
blineThis.Reverse();
|
|
blinePara.Reverse();
|
|
}
|
|
else
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
TBPloyLine BLine;
|
|
POSITION pos = blineThis.m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = blineThis.m_BNodeList.GetNext(pos);
|
|
if (pos == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
TBNode* pNodeNew = new TBNode;
|
|
*pNodeNew = *pNode;
|
|
BLine.m_BNodeList.AddTail(pNodeNew);
|
|
}
|
|
|
|
pos = blinePara.m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = blinePara.m_BNodeList.GetNext(pos);
|
|
TBNode* pNodeNew = new TBNode;
|
|
*pNodeNew = *pNode;
|
|
BLine.m_BNodeList.AddTail(pNodeNew);
|
|
}
|
|
BLine.ReCalcSValue();
|
|
return BLine;
|
|
}
|
|
|
|
TBPloyLine& TBPloyLine::Reverse()
|
|
{
|
|
if (m_BNodeList.IsEmpty())
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
TBNodeList tempList;
|
|
TBNode *pNodePre, *pNode;
|
|
double totLength;
|
|
POSITION pos = m_BNodeList.GetTailPosition();
|
|
|
|
pNode = m_BNodeList.GetPrev(pos);
|
|
totLength = pNode->m_s;
|
|
|
|
if (pNode->m_pArc != NULL)
|
|
{
|
|
if (pos == NULL)
|
|
{
|
|
delete pNode->m_pArc;
|
|
}
|
|
else if (pNode->m_pArc != m_BNodeList.GetAt(pos)->m_pArc)
|
|
{
|
|
delete pNode->m_pArc;
|
|
}
|
|
|
|
pNode->m_pArc = NULL;
|
|
}
|
|
|
|
for(pos = m_BNodeList.GetTailPosition(); pos; )
|
|
{
|
|
pNode = m_BNodeList.GetPrev(pos);
|
|
pNodePre = NULL;
|
|
if (pos != NULL)
|
|
{
|
|
pNodePre = m_BNodeList.GetAt(pos);
|
|
}
|
|
if (pNodePre != NULL)
|
|
{//不是第一点
|
|
pNode->m_s = totLength-pNode->m_s;
|
|
|
|
if (pNodePre->m_eType == BLINESEG)
|
|
{
|
|
pNode->m_eType = BLINESEG;
|
|
pNode->m_pArc = NULL;
|
|
}
|
|
else
|
|
{
|
|
pNode->m_pArc = pNodePre->m_pArc;
|
|
if (pNode->m_pArc != NULL)
|
|
{
|
|
pNode->m_eType = BARCSEG;
|
|
double startAng = pNode->m_pArc->m_startAngle + pNode->m_pArc->m_centAngle;
|
|
while (startAng >= 2 * PI)
|
|
{
|
|
startAng -= 2 * PI;
|
|
}
|
|
while (startAng < 0)
|
|
{
|
|
startAng += 2 * PI;
|
|
}
|
|
|
|
pNode->m_pArc->m_startAngle = startAng;
|
|
pNode->m_pArc->m_centAngle = -pNode->m_pArc->m_centAngle;
|
|
}
|
|
else
|
|
{
|
|
pNode->m_eType = BLINESEG;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{//原来的第一点
|
|
pNode->m_s = totLength;
|
|
pNode->m_eType = BLINESEG;
|
|
pNode->m_pArc = NULL;
|
|
}
|
|
tempList.AddTail(pNode);
|
|
}
|
|
//在链表中的位置反向
|
|
m_BNodeList.RemoveAll();
|
|
m_BNodeList.AddTail(&tempList);
|
|
tempList.RemoveAll();
|
|
|
|
return *this;
|
|
}
|
|
|
|
BOOL TBPloyLine::CheckClose()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
m_bClosed = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (GetLength() < TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
TBNode* pStartNode = m_BNodeList.GetHead();
|
|
TBNode* pEndNode = m_BNodeList.GetTail();
|
|
double dist = (pEndNode->m_pt - pStartNode->m_pt).length();
|
|
if (( dist <= TOL) && (pEndNode != pStartNode))
|
|
{
|
|
m_bClosed = 1;
|
|
}
|
|
else
|
|
{
|
|
m_bClosed = 0;
|
|
}
|
|
return m_bClosed;
|
|
}
|
|
|
|
int TBPloyLine::IsWhere(TBPloyLine* pBLine)
|
|
{
|
|
if (pBLine == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
TBPloyLine BLine(*pBLine);
|
|
BLine.LinearizePLine(PI / 36.);
|
|
|
|
int bInternal0 = 1,count = 1,bInternal,HasOnePointIn = 0,HasOnePointOut = 0;
|
|
for(POSITION ps = BLine.m_BNodeList.GetHeadPosition(); ps;)
|
|
{
|
|
AcGePoint3d pt = BLine.m_BNodeList.GetNext(ps)->m_pt;
|
|
bInternal = IsPtInPolygon(pt);
|
|
if (count == 1)
|
|
{
|
|
bInternal0 = bInternal;
|
|
if (bInternal0 == 1)
|
|
{
|
|
HasOnePointIn = 1;
|
|
}
|
|
else if (bInternal0 == 0)
|
|
{
|
|
HasOnePointOut = 1;
|
|
}
|
|
count++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (bInternal0 == 0 && bInternal == 1 || bInternal0 == 1 && bInternal == 0)
|
|
{
|
|
return 3;//相交
|
|
}
|
|
bInternal0 = bInternal;
|
|
if (bInternal0 == 1)
|
|
{
|
|
HasOnePointIn = 1;
|
|
}
|
|
else if (bInternal0 == 0)
|
|
{
|
|
HasOnePointOut = 1;
|
|
}
|
|
}
|
|
}
|
|
if (HasOnePointOut)
|
|
{//BLine在THIS外部
|
|
return 2;
|
|
}
|
|
else
|
|
{//BLine在THIS内部
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
BOOL TBPloyLine::Create(const TGGePolygonEx& polySrc)
|
|
{
|
|
TGGePolygonEx poly(polySrc);
|
|
int nCount = poly.Length();
|
|
if (nCount < 2)
|
|
{
|
|
return FALSE;
|
|
}
|
|
double SLength = 0.0;
|
|
TBNode* pNodePrevious = NULL;
|
|
AcGePoint3d pt1;
|
|
for(int i = 0; i < nCount; i++)
|
|
{
|
|
pt1 = (*poly[i]).AsAcGePoint3d();
|
|
if (pNodePrevious)
|
|
{
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
|
|
//wlw临时注释，3d炸碎崩
|
|
pNode->m_bVisible = *(poly.GetVisibleFlag()[i]);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
|
|
//封闭最后一点和第一点
|
|
pt1 = (*poly[0]).AsAcGePoint3d();
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
|
|
pNode->m_bVisible = *(poly.GetVisibleFlag()[nCount - 1]);
|
|
m_BNodeList.AddTail(pNode);
|
|
|
|
m_bClosed = TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TBPloyLine::Create(const TGGePoly2D& poly)
|
|
{
|
|
//方法2：直接转换（高效率）,缺点是不考虑poly的弧度
|
|
int nCount = poly.Length();
|
|
if (nCount < 2)
|
|
{
|
|
return FALSE;
|
|
}
|
|
double SLength = 0.0;
|
|
TBNode* pNodePrevious = NULL;
|
|
|
|
for(int i = 0; i < nCount; i++)
|
|
{
|
|
AcGePoint3d pt1 = poly[i];
|
|
if (pNodePrevious)
|
|
{
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
|
|
//封闭最后一点和第一点
|
|
if(poly.IsClosed())
|
|
{
|
|
AcGePoint3d pt1 = poly[0];
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
|
|
m_bClosed = TRUE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//新增函数，支持LINE,PLINE,CIRCLE,TRACE
|
|
BOOL TBPloyLine::Create(const AcDbEntity* pEntity)
|
|
{
|
|
if (pEntity == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
ReleaseBasLst();
|
|
|
|
double startUCSAng = 0;
|
|
int ret = 1;
|
|
|
|
if(pEntity->isKindOf(AcDbLine::desc()))
|
|
{
|
|
AcDbLine *pLine = AcDbLine::cast(pEntity);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d pt1 = pLine->startPoint();
|
|
AcGePoint3d pt2 = pLine->endPoint();
|
|
TBNode* pNode = new TBNode(BLINESEG,0.0,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
double len = pt1.distanceTo(pt2);
|
|
pNode = new TBNode(BLINESEG,len,pt2);
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
}
|
|
else if(pEntity->isKindOf(AcDbArc::desc()))
|
|
{
|
|
AcDbArc *pArc = AcDbArc::cast(pEntity);
|
|
if (pArc != NULL)
|
|
{
|
|
AcGePoint3d cent = pArc->center();
|
|
double startAng = pArc->startAngle();
|
|
double endAng = pArc->endAngle();
|
|
//圆心角
|
|
double EntcAng;
|
|
if (endAng >= startAng)
|
|
{
|
|
EntcAng = endAng - startAng;
|
|
}
|
|
else
|
|
{
|
|
EntcAng = 2 * PI + endAng - startAng;
|
|
}
|
|
double radius = pArc->radius();
|
|
TBArc* pArcTemp = new TBArc(cent,radius,startAng,EntcAng);//ECS
|
|
AcGePoint3d ptStart = pArcTemp->GetStartPoint();//ECS
|
|
AcGePoint3d ptEnd = pArcTemp->GetEndPoint();//ECS
|
|
delete pArcTemp;
|
|
ads_point ads_pt1,ads_pt2,ads_pt3;
|
|
ARX2AdsPt(cent,ads_pt1);
|
|
ARX2AdsPt(ptStart,ads_pt2);
|
|
ARX2AdsPt(ptEnd,ads_pt3);
|
|
startAng = acutAngle(ads_pt1,ads_pt2);//UCS
|
|
endAng = acutAngle(ads_pt1,ads_pt3);//UCS
|
|
|
|
TBArc* pBLArc = new TBArc(cent,radius,startAng,EntcAng);
|
|
TBNode* pNode = new TBNode(BARCSEG,0.0,pBLArc->GetStartPoint(),pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNode = new TBNode(BARCSEG,pBLArc->Length(),pBLArc->GetEndPoint());
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
}
|
|
else if(pEntity->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
AcDbCircle *pCircle = AcDbCircle::cast(pEntity);
|
|
if (pCircle != NULL)
|
|
{
|
|
//当是圆时，需要指定UCS起始角。
|
|
AcGePoint3d cent = pCircle->center();
|
|
//圆心角
|
|
double EntcAng = 2 * PI;
|
|
m_bClosed = 1;
|
|
TBArc* pBLArc = new TBArc(cent,pCircle->radius(),startUCSAng,EntcAng);
|
|
TBNode* pNode = new TBNode(BARCSEG,0.0,pBLArc->GetStartPoint(),pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNode = new TBNode(BARCSEG,pBLArc->Length(),pBLArc->GetEndPoint());
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
}
|
|
else if(pEntity->isKindOf(AcDbTrace::desc()))
|
|
{
|
|
AcDbTrace *pTrace = AcDbTrace::cast(pEntity);
|
|
if (pTrace != NULL)
|
|
{
|
|
AcGePoint3d pt1,pt2,pt3,pt4,ptStart,ptEnd;
|
|
pTrace->getPointAt(0,pt1);
|
|
pTrace->getPointAt(1,pt2);
|
|
pTrace->getPointAt(2,pt3);
|
|
pTrace->getPointAt(3,pt4);
|
|
ptStart.x = (pt1.x + pt2.x) / 2.;
|
|
ptStart.y = (pt1.y + pt2.y) / 2.;
|
|
ptEnd.x = (pt3.x + pt4.x) / 2.;
|
|
ptEnd.y = (pt3.y + pt4.y) / 2.;
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,0.0,ptStart);
|
|
m_BNodeList.AddTail(pNode);
|
|
double len = ptStart.distanceTo(ptEnd);
|
|
pNode = new TBNode(BLINESEG,len,ptEnd);
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
}
|
|
else if(pEntity->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
AcDbPolyline *pPoly = AcDbPolyline::cast(pEntity);
|
|
if (pPoly != NULL)
|
|
{
|
|
double SLength = 0.;
|
|
int nVerts = pPoly->numVerts();
|
|
|
|
if (nVerts < 2)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double Level = pPoly->elevation();
|
|
|
|
TBNode* pNodePrevious = NULL;
|
|
for (int i = 0; i < nVerts; i++)
|
|
{
|
|
AcDbPolyline::SegType eSegType = pPoly->segType(i);
|
|
double Bulge = 0.0;
|
|
if (pPoly->getBulgeAt(i, Bulge) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AcGePoint2d pt2d;
|
|
if (pPoly->getPointAt(i, pt2d) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
AcGePoint3d pt1, pt2;
|
|
pt1.set(pt2d.x, pt2d.y, Level);
|
|
|
|
if (pNodePrevious)
|
|
{
|
|
if (pNodePrevious->m_pArc)
|
|
{
|
|
SLength += pNodePrevious->m_pArc->m_R * fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
}
|
|
else
|
|
{
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
}
|
|
|
|
if (eSegType != AcDbPolyline::kArc || fabs(Bulge) < fTOL)
|
|
{
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
else
|
|
{
|
|
if (i != nVerts - 1)
|
|
{
|
|
if (pPoly->getPointAt(i+1, pt2d) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pPoly->getPointAt(0, pt2d) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
pt2.set(pt2d.x, pt2d.y, Level);
|
|
|
|
double CenterAng = 4 * atan(Bulge);
|
|
double angx, ang1, ang2;
|
|
|
|
angx = AngleToX(pt1, pt2);
|
|
if (Bulge > 0)
|
|
{
|
|
ang1 = angx + (PI - CenterAng) / 2.0;
|
|
ang2 = ang1 + CenterAng;
|
|
}
|
|
else
|
|
{
|
|
ang1 = angx - (PI + CenterAng) / 2.0;
|
|
ang2 = ang1 + CenterAng;
|
|
}
|
|
while (ang1 >= 2 * PI) ang1 -= 2 * PI;
|
|
while (ang1 < 0) ang1 += 2 * PI;
|
|
while (ang2 >= 2 * PI) ang2 -= 2 * PI;
|
|
while (ang2 < 0) ang2 += 2 * PI;
|
|
|
|
AcGePoint3d pt0, pt11, pt22, pt12, pt3, pt13, pt23;
|
|
double angxx, ll = pt1.distanceTo(pt2) / 2.0;
|
|
pt12.x = (pt1.x + pt2.x) / 2.0;
|
|
pt12.y = (pt1.y + pt2.y) / 2.0;
|
|
pt12.z = (pt1.z + pt2.z) / 2.0;
|
|
|
|
if (Bulge>0)
|
|
{
|
|
angxx = angx - PI / 2.0;
|
|
while (angxx < 0)
|
|
{
|
|
angxx += 2 * PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
angxx = angx + PI / 2.0;
|
|
while (angxx >= 2 * PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
}
|
|
pt3 = polar(pt12, angxx, ll*fabs(Bulge));
|
|
|
|
pt13.x = (pt1.x+pt3.x) / 2.0;
|
|
pt13.y = (pt1.y+pt3.y) / 2.0;
|
|
pt13.z = (pt1.z+pt3.z) / 2.0;
|
|
|
|
pt23.x = (pt2.x+pt3.x) / 2.0;
|
|
pt23.y = (pt2.y+pt3.y) / 2.0;
|
|
pt23.z = (pt2.z+pt3.z) / 2.0;
|
|
|
|
angxx = AngleToX(pt1, pt3) + PI / 2.0;
|
|
while (angxx >= 2 * PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
pt11 = polar(pt13, angxx, ll);
|
|
|
|
angxx = AngleToX(pt3, pt2) + PI / 2.0;
|
|
while (angxx >= 2 * PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
pt22 = polar(pt23, angxx, ll);
|
|
|
|
ads_point ads_pt1, ads_pt11, ads_pt2, ads_pt22, ads_pt0;
|
|
|
|
ARX2AdsPt(pt13, ads_pt1);
|
|
ARX2AdsPt(pt11, ads_pt11);
|
|
ARX2AdsPt(pt23, ads_pt2);
|
|
ARX2AdsPt(pt22, ads_pt22);
|
|
|
|
if (acdbInters(ads_pt1, ads_pt11, ads_pt2, ads_pt22, FALSE, ads_pt0) == RTNORM)
|
|
{
|
|
Ads2ARXPt(ads_pt0, pt0);
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ang1 += PI;
|
|
ang2 += PI;
|
|
while (ang1 >= 2 * PI)
|
|
{
|
|
ang1 -= 2 * PI;
|
|
}
|
|
|
|
while (ang2 >= 2 * PI)
|
|
{
|
|
ang2 -= 2 * PI;
|
|
}
|
|
|
|
double radius = pt0.distanceTo(pt1);
|
|
TBArc* pBLArc = new TBArc;
|
|
pBLArc->m_centPt = pt0;
|
|
pBLArc->m_R = radius;
|
|
pBLArc->m_startAngle = ang1;
|
|
pBLArc->m_centAngle = CenterAng;
|
|
pBLArc->m_startPt = pt1;
|
|
pBLArc->m_endPt = pt2;
|
|
|
|
TBNode* pNode = new TBNode(BARCSEG,SLength,pt1,pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
|
|
if (pPoly->isClosed())
|
|
{
|
|
AcGePoint2d pt2d;
|
|
if (pPoly->getPointAt(0, pt2d) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
AcGePoint3d pt1, pt2;
|
|
pt1.set(pt2d.x, pt2d.y, Level);
|
|
|
|
if (pNodePrevious->m_pArc)
|
|
{
|
|
SLength+=pNodePrevious->m_pArc->m_R*fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
}
|
|
else
|
|
{
|
|
SLength+=pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
}
|
|
else if(pEntity->isKindOf(AcDb2dPolyline::desc()))
|
|
{
|
|
AcDb2dPolyline *pPoly = AcDb2dPolyline::cast(pEntity);
|
|
if(pPoly != NULL)
|
|
{
|
|
AcDbObjectIterator *pVertIter = pPoly->vertexIterator();
|
|
double SLength = 0.;
|
|
AcDbObjectId vertxId;
|
|
AcDb2dVertex *pVertex;
|
|
TBNode* pNodePrevious = NULL;
|
|
AcGePoint3d FirstPt;
|
|
double Level = pPoly->elevation();
|
|
BOOL bLast = 0;
|
|
for (int vertexNumber = 0; !pVertIter->done();vertexNumber++, pVertIter->step())
|
|
{
|
|
vertxId = pVertIter->objectId();
|
|
if (acdbOpenObject(pVertex, vertxId,AcDb::kForRead) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
if (vertexNumber == 0)
|
|
{
|
|
FirstPt = pVertex->position();
|
|
}
|
|
|
|
double Bulge = pVertex->bulge();//凸度
|
|
AcGePoint3d pt1,pt2;
|
|
|
|
pt1 = pVertex->position();//ECS
|
|
pVertex->close();
|
|
pVertIter->step();
|
|
if (!pVertIter->done())
|
|
{//不是最后一点
|
|
AcDbObjectId vertxId2 = pVertIter->objectId();
|
|
AcDb2dVertex *pVertex2 = NULL;
|
|
if (acdbOpenObject(pVertex2, vertxId2,AcDb::kForRead) != Acad::eOk)
|
|
{
|
|
return 0;
|
|
}
|
|
pt2 = pVertex2->position();//ECS
|
|
pVertex2->close();
|
|
}
|
|
else
|
|
{
|
|
bLast = 1;
|
|
pt2 = FirstPt;
|
|
}
|
|
pVertIter->step(true);
|
|
pt1.z = Level;
|
|
pt2.z = Level;
|
|
|
|
if (pNodePrevious)
|
|
{
|
|
if (pNodePrevious->m_pArc)
|
|
{
|
|
SLength += pNodePrevious->m_pArc->m_R * fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
}
|
|
else
|
|
{
|
|
SLength+=pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
}
|
|
if (bLast && !pPoly->isClosed())
|
|
{
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
break;
|
|
}
|
|
if (fabs(Bulge) < fTOL)
|
|
{
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
if (bLast)
|
|
{
|
|
SLength += pt2.distanceTo(pt1);
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt2);
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
pNodePrevious = pNode;
|
|
}
|
|
else
|
|
{
|
|
double CenterAng = 4 * atan(Bulge);
|
|
double angx, ang1, ang2;
|
|
|
|
angx = AngleToX(pt1, pt2);
|
|
if (Bulge > 0)
|
|
{
|
|
ang1 = angx + (PI - CenterAng) / 2.0;
|
|
ang2 = ang1 + CenterAng;
|
|
}
|
|
else
|
|
{
|
|
ang1 = angx - (PI + CenterAng) / 2.0;
|
|
ang2 = ang1 + CenterAng;
|
|
}
|
|
while (ang1 >= 2 * PI)
|
|
{
|
|
ang1 -= 2 * PI;
|
|
}
|
|
while (ang1 < 0)
|
|
{
|
|
ang1 += 2 * PI;
|
|
}
|
|
while (ang2 >= 2 * PI)
|
|
{
|
|
ang2 -= 2 * PI;
|
|
}
|
|
while (ang2 < 0)
|
|
{
|
|
ang2 += 2 * PI;
|
|
}
|
|
|
|
AcGePoint3d pt0, pt11, pt22, pt12, pt3, pt13, pt23;
|
|
double angxx, ll = pt1.distanceTo(pt2) / 2.0;
|
|
pt12.x = (pt1.x + pt2.x) / 2.0;
|
|
pt12.y = (pt1.y + pt2.y) / 2.0;
|
|
pt12.z = (pt1.z + pt2.z) / 2.0;
|
|
|
|
if (Bulge > 0)
|
|
{
|
|
angxx = angx - PI / 2.0;
|
|
while (angxx < 0)
|
|
{
|
|
angxx += 2 * PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
angxx = angx + PI / 2.0;
|
|
while (angxx >= 2 * PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
}
|
|
pt3 = polar(pt12, angxx, ll * fabs(Bulge));
|
|
|
|
pt13.x = (pt1.x + pt3.x) / 2.0;
|
|
pt13.y = (pt1.y + pt3.y) / 2.0;
|
|
pt13.z = (pt1.z + pt3.z) / 2.0;
|
|
|
|
pt23.x = (pt2.x + pt3.x) / 2.0;
|
|
pt23.y = (pt2.y + pt3.y) / 2.0;
|
|
pt23.z = (pt2.z + pt3.z) / 2.0;
|
|
angxx = AngleToX(pt1, pt3) + PI / 2.0;
|
|
while (angxx >= 2*PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
pt11 = polar(pt13, angxx, ll);
|
|
|
|
angxx = AngleToX(pt3, pt2) + PI / 2.0;
|
|
while (angxx >= 2 * PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
pt22 = polar(pt23, angxx, ll);
|
|
|
|
ads_point ads_pt1, ads_pt11, ads_pt2, ads_pt22, ads_pt0;
|
|
|
|
ARX2AdsPt(pt13, ads_pt1);
|
|
ARX2AdsPt(pt11, ads_pt11);
|
|
ARX2AdsPt(pt23, ads_pt2);
|
|
ARX2AdsPt(pt22, ads_pt22);
|
|
|
|
if (acdbInters(ads_pt1, ads_pt11, ads_pt2, ads_pt22, FALSE, ads_pt0) == RTNORM)
|
|
{
|
|
Ads2ARXPt(ads_pt0, pt0);
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ang1 += PI;
|
|
ang2 += PI;
|
|
while (ang1 >= 2*PI)
|
|
{
|
|
ang1 -= 2*PI;
|
|
}
|
|
while (ang2 >= 2*PI)
|
|
{
|
|
ang2 -= 2*PI;
|
|
}
|
|
|
|
double radius = pt0.distanceTo(pt1);
|
|
TBArc* pBLArc = new TBArc;
|
|
pBLArc->m_centPt = pt0;
|
|
pBLArc->m_R = radius;
|
|
pBLArc->m_startAngle = ang1;
|
|
pBLArc->m_centAngle = CenterAng;
|
|
pBLArc->m_startPt = pt1;
|
|
pBLArc->m_endPt = pt2;
|
|
|
|
TBNode* pNode = new TBNode(BARCSEG,SLength,pt1,pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
if (pPoly->isClosed())
|
|
{
|
|
AcGePoint3d pt1 = FirstPt;
|
|
if (pNodePrevious->m_pArc)
|
|
{
|
|
SLength += pNodePrevious->m_pArc->m_R * fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
}
|
|
else
|
|
{
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
TBNode* pStartNode = m_BNodeList.GetHead();
|
|
TBNode* pEndNode = m_BNodeList.GetTail();
|
|
double dist = (pEndNode->m_pt - pStartNode->m_pt).length();
|
|
|
|
if (!pEntity->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
if (( dist <= TOL) && (pEndNode != pStartNode))
|
|
{
|
|
m_bClosed = 1;
|
|
}
|
|
else
|
|
{
|
|
m_bClosed = 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BOOL TBPloyLine::Create(AcDbObjectId& objId)
|
|
{
|
|
if (objId == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
double startUCSAng = 0;
|
|
ReleaseBasLst();
|
|
|
|
AcDbEntity* pEntity;
|
|
Acad::ErrorStatus retStat;
|
|
if ((retStat = acdbOpenObject(pEntity, objId, AcDb::kForRead)) != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("acdbOpenEntity failed! retStat:%d"), retStat);
|
|
return 0;
|
|
}
|
|
CString strLineType = pEntity->isA()->dxfName();
|
|
int isParal = IsZParalECSAndUcs(objId);
|
|
if (!isParal && strLineType != _T("LINE"))
|
|
{//判断实体坐标系与用户坐标系的Z轴是否平行
|
|
AfxMessageBox(_T("ECS与UCS的Z轴不平行!"));
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
int ret = 1;
|
|
|
|
if (strLineType == _T("LINE"))
|
|
{
|
|
AcDbLine* pLine = (AcDbLine*)(pEntity);
|
|
AcGePoint3d pt1 = pLine->startPoint();
|
|
AcGePoint3d pt2 = pLine->endPoint();
|
|
WCS2UCS(pt1);
|
|
WCS2UCS(pt2);
|
|
TBNode* pNode = new TBNode(BLINESEG,0.0,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
double len = pt1.distanceTo(pt2);
|
|
pNode = new TBNode(BLINESEG,len,pt2);
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
else if (strLineType == _T("ARC"))
|
|
{
|
|
AcDbArc* pArc = (AcDbArc*)(pEntity);
|
|
AcGePoint3d cent = pArc->center();
|
|
double startAng = pArc->startAngle();
|
|
double endAng = pArc->endAngle();
|
|
double EntcAng; //圆心角
|
|
if (endAng >= startAng)
|
|
{
|
|
EntcAng = endAng - startAng;
|
|
}
|
|
else
|
|
{
|
|
EntcAng = 2 * PI + endAng - startAng;
|
|
}
|
|
if (isParal == 2)
|
|
{
|
|
EntcAng = -EntcAng;//反向
|
|
}
|
|
double radius = pArc->radius();
|
|
WCS2ECS(cent,objId);//先从WCS到ECS
|
|
TBArc* pArcTemp = new TBArc(cent,radius,startAng,EntcAng);//ECS
|
|
AcGePoint3d ptStart = pArcTemp->GetStartPoint();//ECS
|
|
AcGePoint3d ptEnd = pArcTemp->GetEndPoint();//ECS
|
|
delete pArcTemp;
|
|
ECS2UCS(cent,objId);//UCS
|
|
ECS2UCS(ptStart,objId);//UCS
|
|
ECS2UCS(ptEnd,objId);//UCS
|
|
ads_point ads_pt1,ads_pt2,ads_pt3;
|
|
ARX2AdsPt(cent,ads_pt1);
|
|
ARX2AdsPt(ptStart,ads_pt2);
|
|
ARX2AdsPt(ptEnd,ads_pt3);
|
|
startAng = acutAngle(ads_pt1,ads_pt2);//UCS
|
|
endAng = acutAngle(ads_pt1,ads_pt3);//UCS
|
|
|
|
TBArc* pBLArc = new TBArc(cent,radius,startAng,EntcAng);
|
|
TBNode* pNode = new TBNode(BARCSEG,0.0,pBLArc->GetStartPoint(),pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNode = new TBNode(BARCSEG,pBLArc->Length(),pBLArc->GetEndPoint());
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
else if (strLineType == _T("CIRCLE"))
|
|
{//当是圆时，需要指定UCS起始角。
|
|
AcDbCircle* pCircle = (AcDbCircle*)(pEntity);
|
|
AcGePoint3d cent = pCircle->center();
|
|
WCS2UCS(cent);
|
|
double EntcAng = 2 * PI;//圆心角
|
|
m_bClosed = 1;
|
|
TBArc* pBLArc = new TBArc(cent,pCircle->radius(),startUCSAng,EntcAng);
|
|
TBNode* pNode = new TBNode(BARCSEG,0.0,pBLArc->GetStartPoint(),pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNode = new TBNode(BARCSEG,pBLArc->Length(),pBLArc->GetEndPoint());
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
else if (strLineType == _T("TRACE"))
|
|
{
|
|
AcDbTrace* pTrace = (AcDbTrace*)(pEntity);
|
|
AcGePoint3d pt1,pt2,pt3,pt4,ptStart,ptEnd;
|
|
pTrace->getPointAt(0,pt1);
|
|
pTrace->getPointAt(1,pt2);
|
|
pTrace->getPointAt(2,pt3);
|
|
pTrace->getPointAt(3,pt4);
|
|
ptStart.x = (pt1.x + pt2.x) / 2.;
|
|
ptStart.y = (pt1.y + pt2.y) / 2.;
|
|
ptEnd.x = (pt3.x + pt4.x) / 2.;
|
|
ptEnd.y = (pt3.y + pt4.y) / 2.;
|
|
|
|
WCS2UCS(ptStart);
|
|
WCS2UCS(ptEnd);
|
|
TBNode* pNode = new TBNode(BLINESEG,0.0,ptStart);
|
|
m_BNodeList.AddTail(pNode);
|
|
double len = ptStart.distanceTo(ptEnd);
|
|
pNode = new TBNode(BLINESEG,len,ptEnd);
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
else if (strLineType == _T("LWPOLYLINE"))
|
|
{
|
|
AcDbPolyline* pPoly = (AcDbPolyline*)(pEntity);
|
|
double SLength = 0.;
|
|
int nVerts = pPoly->numVerts();
|
|
|
|
if (nVerts < 2)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
|
|
double Level = pPoly->elevation();
|
|
|
|
TBNode* pNodePrevious = NULL;
|
|
for (int i = 0; i < nVerts; i++)
|
|
{
|
|
AcDbPolyline::SegType eSegType = pPoly->segType(i);
|
|
double Bulge = 0.0;
|
|
if (pPoly->getBulgeAt(i, Bulge) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
if (isParal == 2)
|
|
{
|
|
Bulge = -Bulge;
|
|
}
|
|
AcGePoint2d pt2d;
|
|
if (pPoly->getPointAt(i, pt2d) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
AcGePoint3d pt1, pt2;
|
|
pt1.set(pt2d.x, pt2d.y, Level);
|
|
ECS2UCS(pt1, objId);//UCS
|
|
|
|
if (pNodePrevious)
|
|
{
|
|
if (pNodePrevious->m_pArc)
|
|
{
|
|
SLength += pNodePrevious->m_pArc->m_R * fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
}
|
|
else
|
|
{
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
}
|
|
|
|
if (eSegType != AcDbPolyline::kArc || fabs(Bulge) < fTOL)
|
|
{
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
else
|
|
{
|
|
if (i != nVerts - 1)
|
|
{
|
|
if (pPoly->getPointAt(i + 1, pt2d) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pPoly->getPointAt(0, pt2d) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
}
|
|
pt2.set(pt2d.x, pt2d.y, Level);
|
|
ECS2UCS(pt2, objId);//UCS
|
|
|
|
double CenterAng = 4 * atan(Bulge);
|
|
double angx, ang1, ang2;
|
|
|
|
angx=AngleToX(pt1, pt2);
|
|
if (Bulge > 0)
|
|
{
|
|
ang1 = angx + (PI - CenterAng) / 2.0;
|
|
ang2 = ang1 + CenterAng;
|
|
}
|
|
else
|
|
{
|
|
ang1 = angx - (PI + CenterAng) / 2.0;
|
|
ang2 = ang1 + CenterAng;
|
|
}
|
|
while (ang1 >= 2 * PI)
|
|
{
|
|
ang1 -= 2 * PI;
|
|
}
|
|
while (ang1 < 0)
|
|
{
|
|
ang1 += 2 * PI;
|
|
}
|
|
while (ang2 >= 2*PI)
|
|
{
|
|
ang2 -= 2*PI;
|
|
}
|
|
while (ang2 < 0)
|
|
{
|
|
ang2 += 2*PI;
|
|
}
|
|
|
|
AcGePoint3d pt0, pt11, pt22, pt12, pt3, pt13, pt23;
|
|
double angxx, ll = pt1.distanceTo(pt2) / 2.0;
|
|
pt12.x = (pt1.x + pt2.x) / 2.0;
|
|
pt12.y = (pt1.y + pt2.y) / 2.0;
|
|
pt12.z = (pt1.z + pt2.z) / 2.0;
|
|
|
|
if (Bulge > 0)
|
|
{
|
|
angxx= angx - PI / 2.0;
|
|
while (angxx < 0)
|
|
{
|
|
angxx += 2 * PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
angxx = angx + PI / 2.0;
|
|
while (angxx >= 2 * PI)
|
|
{
|
|
angxx -= 2 * PI;
|
|
}
|
|
}
|
|
pt3 = polar(pt12, angxx, ll*fabs(Bulge));
|
|
|
|
pt13.x = (pt1.x + pt3.x) / 2.0;
|
|
pt13.y = (pt1.y + pt3.y) / 2.0;
|
|
pt13.z = (pt1.z + pt3.z) / 2.0;
|
|
|
|
pt23.x = (pt2.x + pt3.x) / 2.0;
|
|
pt23.y = (pt2.y + pt3.y) / 2.0;
|
|
pt23.z = (pt2.z + pt3.z) / 2.0;
|
|
|
|
angxx = AngleToX(pt1, pt3) + PI / 2.0;
|
|
while (angxx >= 2*PI)
|
|
{
|
|
angxx -= 2*PI;
|
|
}
|
|
pt11 = polar(pt13, angxx, ll);
|
|
|
|
angxx = AngleToX(pt3, pt2) + PI / 2.0;
|
|
while (angxx >= 2*PI)
|
|
{
|
|
angxx -= 2*PI;
|
|
}
|
|
pt22 = polar(pt23, angxx, ll);
|
|
|
|
ads_point ads_pt1, ads_pt11, ads_pt2, ads_pt22, ads_pt0;
|
|
|
|
ARX2AdsPt(pt13, ads_pt1);
|
|
ARX2AdsPt(pt11, ads_pt11);
|
|
ARX2AdsPt(pt23, ads_pt2);
|
|
ARX2AdsPt(pt22, ads_pt22);
|
|
|
|
if (acdbInters(ads_pt1, ads_pt11, ads_pt2, ads_pt22, FALSE, ads_pt0) == RTNORM)
|
|
{
|
|
Ads2ARXPt(ads_pt0, pt0);
|
|
}
|
|
else
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
|
|
ang1 += PI;
|
|
ang2 += PI;
|
|
while (ang1 >= 2*PI)
|
|
{
|
|
ang1 -= 2*PI;
|
|
}
|
|
while (ang2 >= 2*PI)
|
|
{
|
|
ang2 -= 2*PI;
|
|
}
|
|
|
|
double radius = pt0.distanceTo(pt1);
|
|
TBArc* pBLArc = new TBArc;
|
|
pBLArc->m_centPt = pt0;
|
|
pBLArc->m_R = radius;
|
|
pBLArc->m_startAngle = ang1;
|
|
pBLArc->m_centAngle = CenterAng;
|
|
pBLArc->m_startPt = pt1;
|
|
pBLArc->m_endPt = pt2;
|
|
|
|
TBNode* pNode=new TBNode(BARCSEG,SLength,pt1,pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
|
|
if (pPoly->isClosed())
|
|
{
|
|
AcGePoint2d pt2d;
|
|
if (pPoly->getPointAt(0, pt2d) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
AcGePoint3d pt1, pt2;
|
|
pt1.set(pt2d.x, pt2d.y, Level);
|
|
ECS2UCS(pt1, objId);//UCS
|
|
|
|
if (pNodePrevious->m_pArc)
|
|
SLength += pNodePrevious->m_pArc->m_R*fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
else
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
else if (strLineType == _T("POLYLINE"))
|
|
{
|
|
AcDb2dPolyline* pPoly = (AcDb2dPolyline*)(pEntity);
|
|
AcDbObjectIterator *pVertIter = pPoly->vertexIterator();
|
|
double SLength = 0.;
|
|
AcDbObjectId vertxId;
|
|
AcDb2dVertex *pVertex;
|
|
TBNode* pNodePrevious = NULL;
|
|
AcGePoint3d FirstPt;
|
|
double Level = pPoly->elevation();
|
|
BOOL bLast = 0;
|
|
for (int vertexNumber = 0; !pVertIter->done();vertexNumber++, pVertIter->step())
|
|
{
|
|
vertxId = pVertIter->objectId();
|
|
if (acdbOpenObject(pVertex, vertxId,AcDb::kForRead) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
if (vertexNumber == 0) FirstPt = pVertex->position();
|
|
|
|
double Bulge = pVertex->bulge();//凸度
|
|
if (isParal == 2) Bulge = -Bulge;//UCS与ECS的Z轴反向平行
|
|
AcGePoint3d pt1,pt2;
|
|
|
|
pt1 = pVertex->position();//ECS
|
|
pVertex->close();
|
|
pVertIter->step();
|
|
if (!pVertIter->done())
|
|
{//不是最后一点
|
|
AcDbObjectId vertxId2 = pVertIter->objectId();
|
|
AcDb2dVertex *pVertex2 = NULL;
|
|
if (acdbOpenObject(pVertex2, vertxId2,AcDb::kForRead) != Acad::eOk)
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
pt2 = pVertex2->position();//ECS
|
|
pVertex2->close();
|
|
}
|
|
else
|
|
{
|
|
bLast = 1;
|
|
pt2 = FirstPt;
|
|
}
|
|
pVertIter->step(true); //back
|
|
pt1.z = Level;
|
|
pt2.z = Level;
|
|
ECS2UCS(pt1,objId);//UCS
|
|
ECS2UCS(pt2,objId);//UCS
|
|
|
|
if (pNodePrevious)
|
|
{
|
|
if (pNodePrevious->m_pArc)
|
|
SLength += pNodePrevious->m_pArc->m_R*fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
else
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
}
|
|
if (bLast && !pPoly->isClosed())
|
|
{
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
break;
|
|
}
|
|
if (fabs(Bulge)<fTOL)
|
|
{
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
if (bLast)
|
|
{
|
|
SLength += pt2.distanceTo(pt1);
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt2);
|
|
m_BNodeList.AddTail(pNode);
|
|
}
|
|
pNodePrevious = pNode;
|
|
}
|
|
else
|
|
{
|
|
double CenterAng = 4*atan(Bulge);
|
|
double angx, ang1, ang2;
|
|
|
|
angx = AngleToX(pt1, pt2);
|
|
if (Bulge>0)
|
|
{
|
|
ang1 = angx+(PI-CenterAng)/2.0;
|
|
ang2 = ang1+CenterAng;
|
|
}
|
|
else
|
|
{
|
|
ang1 = angx-(PI+CenterAng)/2.0;
|
|
ang2 = ang1+CenterAng;
|
|
}
|
|
while (ang1 >= 2*PI) ang1 -= 2*PI;
|
|
while (ang1<0) ang1 += 2*PI;
|
|
while (ang2 >= 2*PI) ang2 -= 2*PI;
|
|
while (ang2<0) ang2 += 2*PI;
|
|
|
|
AcGePoint3d pt0, pt11, pt22, pt12, pt3, pt13, pt23;
|
|
double angxx, ll = pt1.distanceTo(pt2)/2.0;
|
|
pt12.x = (pt1.x+pt2.x)/2.0;
|
|
pt12.y = (pt1.y+pt2.y)/2.0;
|
|
pt12.z = (pt1.z+pt2.z)/2.0;
|
|
|
|
if (Bulge>0)
|
|
{
|
|
angxx = angx-PI/2.0;
|
|
while (angxx<0) angxx += 2*PI;
|
|
}
|
|
else
|
|
{
|
|
angxx = angx+PI/2.0;
|
|
while (angxx >= 2*PI) angxx -= 2*PI;
|
|
}
|
|
pt3 = polar(pt12, angxx, ll*fabs(Bulge));
|
|
|
|
pt13.x = (pt1.x+pt3.x)/2.0;
|
|
pt13.y = (pt1.y+pt3.y)/2.0;
|
|
pt13.z = (pt1.z+pt3.z)/2.0;
|
|
|
|
pt23.x = (pt2.x+pt3.x)/2.0;
|
|
pt23.y = (pt2.y+pt3.y)/2.0;
|
|
pt23.z = (pt2.z+pt3.z)/2.0;
|
|
angxx = AngleToX(pt1, pt3)+PI/2.0;
|
|
while (angxx >= 2*PI) angxx -= 2*PI;
|
|
pt11 = polar(pt13, angxx, ll);
|
|
|
|
angxx = AngleToX(pt3, pt2)+PI/2.0;
|
|
while (angxx >= 2*PI) angxx -= 2*PI;
|
|
pt22 = polar(pt23, angxx, ll);
|
|
|
|
ads_point ads_pt1, ads_pt11, ads_pt2, ads_pt22, ads_pt0;
|
|
|
|
ARX2AdsPt(pt13, ads_pt1);
|
|
ARX2AdsPt(pt11, ads_pt11);
|
|
ARX2AdsPt(pt23, ads_pt2);
|
|
ARX2AdsPt(pt22, ads_pt22);
|
|
|
|
if (acdbInters(ads_pt1, ads_pt11, ads_pt2, ads_pt22, FALSE, ads_pt0) == RTNORM)
|
|
Ads2ARXPt(ads_pt0, pt0);
|
|
else
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
|
|
ang1 += PI;
|
|
ang2 += PI;
|
|
while (ang1 >= 2*PI) ang1 -= 2*PI;
|
|
while (ang2 >= 2*PI) ang2 -= 2*PI;
|
|
|
|
double radius = pt0.distanceTo(pt1);
|
|
TBArc* pBLArc = new TBArc;
|
|
pBLArc->m_centPt = pt0;
|
|
pBLArc->m_R = radius;
|
|
pBLArc->m_startAngle = ang1;
|
|
pBLArc->m_centAngle = CenterAng;
|
|
pBLArc->m_startPt = pt1;
|
|
pBLArc->m_endPt = pt2;
|
|
|
|
TBNode* pNode = new TBNode(BARCSEG,SLength,pt1,pBLArc);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
if (pPoly->isClosed())
|
|
{
|
|
AcGePoint3d pt1 = FirstPt;
|
|
ECS2UCS(pt1, objId);//UCS
|
|
|
|
if (pNodePrevious->m_pArc)
|
|
SLength += pNodePrevious->m_pArc->m_R*fabs(pNodePrevious->m_pArc->m_centAngle);
|
|
else
|
|
SLength += pNodePrevious->m_pt.distanceTo(pt1);
|
|
|
|
TBNode* pNode = new TBNode(BLINESEG,SLength,pt1);
|
|
m_BNodeList.AddTail(pNode);
|
|
pNodePrevious = pNode;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEntity->close();
|
|
return 0;
|
|
}
|
|
|
|
TBNode* pStartNode = m_BNodeList.GetHead();
|
|
TBNode* pEndNode = m_BNodeList.GetTail();
|
|
double dist = (pEndNode->m_pt - pStartNode->m_pt).length();
|
|
if (strLineType != _T("CIRCLE"))
|
|
{
|
|
if (( dist <= TOL) && (pEndNode != pStartNode))
|
|
m_bClosed = 1;
|
|
else m_bClosed = 0;
|
|
}
|
|
pEntity->close();
|
|
return 1;
|
|
}
|
|
|
|
TBNode* TBPloyLine::Head()
|
|
{
|
|
if (m_BNodeList.IsEmpty()) return NULL;
|
|
else return m_BNodeList.GetHead();
|
|
}
|
|
|
|
TBNode* TBPloyLine::Tail()
|
|
{
|
|
if (m_BNodeList.IsEmpty()) return NULL;
|
|
else return m_BNodeList.GetTail();
|
|
}
|
|
|
|
TBNode* TBPloyLine::GetNextNode(const TBNode* pNode)
|
|
{
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNodeCur = m_BNodeList.GetNext(pos);
|
|
if (pNodeCur == pNode)
|
|
{
|
|
if (pos == NULL) return NULL;
|
|
return m_BNodeList.GetAt(pos);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
TBNode* TBPloyLine::GetPreNode(const TBNode* pNode)
|
|
{
|
|
POSITION pos = m_BNodeList.GetTailPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNodeCur = m_BNodeList.GetPrev(pos);
|
|
if (pNodeCur == pNode)
|
|
{
|
|
if (pos == NULL) return NULL;
|
|
return m_BNodeList.GetAt(pos);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL TBPloyLine::GetDNode(double s,TDNode* pDivNode)
|
|
{
|
|
if (m_BNodeList.IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double TotaLen = GetLength();
|
|
if (TotaLen < TOL)
|
|
{
|
|
TBNode* pNode = Head();
|
|
if (pNode == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
pDivNode->m_angTng = 0.;
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
pDivNode->m_s = 0.;
|
|
return 1;
|
|
}
|
|
|
|
if (s < -TOL || s - TotaLen > TOL )
|
|
{
|
|
return 0;
|
|
}
|
|
else if ( fabs(TotaLen - s) <= TOL )
|
|
{
|
|
s = TotaLen;
|
|
}
|
|
else if ( fabs(s) <= TOL)
|
|
{
|
|
s = 0.;
|
|
}
|
|
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
TBNode* pNodePre = NULL;
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
double len = pNode->m_s;
|
|
|
|
if (((len - s) >= TOL) && pNodePre != NULL)
|
|
{
|
|
//等分点处于两拐点之间
|
|
//pNodePre == NULL则len一定为0
|
|
//从结点pNodePre处的相对S坐标
|
|
double relatedS = s - pNodePre->m_s;
|
|
if (pNodePre->m_eType == BLINESEG)
|
|
{
|
|
double lineSegLen = pNode->m_s - pNodePre->m_s;
|
|
pDivNode->m_angTng = AngleToX(pNodePre->m_pt,pNode->m_pt);
|
|
pDivNode->m_pt.x = pNodePre->m_pt.x + relatedS*cos(pDivNode->m_angTng);
|
|
pDivNode->m_pt.y = pNodePre->m_pt.y + relatedS*sin(pDivNode->m_angTng);
|
|
|
|
pDivNode->m_s = s;
|
|
return 1;
|
|
}
|
|
else if (pNodePre->m_eType == BARCSEG && pNodePre->m_pArc != NULL)
|
|
{
|
|
pDivNode->m_pt = pNodePre->m_pArc->GetPtAtS(relatedS);
|
|
double ang = AngleToX(pNodePre->m_pArc->m_centPt,pDivNode->m_pt);
|
|
if (pNodePre->m_pArc->m_centAngle<0)
|
|
{//顺时针
|
|
pDivNode->m_angTng = ang - PI / 2.;
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDivNode->m_angTng = ang + PI / 2.;
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
}
|
|
pDivNode->m_s = s;
|
|
return 1;
|
|
}
|
|
}
|
|
else if (fabs(s - len) < TOL)
|
|
{
|
|
//等分点处于基线拐点上
|
|
TBNode* pNodeNext = NULL;
|
|
if (pos != NULL)
|
|
{
|
|
pNodeNext = m_BNodeList.GetNext(pos);
|
|
}
|
|
if (pNodePre == NULL)
|
|
{//处于第一点
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
if (pNodeNext == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
pDivNode->m_angTng = AngleToX(pNode->m_pt,pNodeNext->m_pt);
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
pDivNode->m_s = s;
|
|
}
|
|
else if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
double ang = AngleToX(pNode->m_pArc->m_centPt,pDivNode->m_pt);
|
|
if (pNode->m_pArc->m_centAngle < 0)
|
|
{//顺时针
|
|
pDivNode->m_angTng = ang - PI / 2.;
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDivNode->m_angTng = ang + PI / 2.;
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
}
|
|
pDivNode->m_s = s;
|
|
}
|
|
return 1;
|
|
}
|
|
else if (pNodeNext == NULL)
|
|
{//处于最后一个结点上pNodeFirst
|
|
if (pNodePre == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
if (pNodePre->m_eType == BLINESEG)
|
|
{
|
|
pDivNode->m_angTng = AngleToX(pNodePre->m_pt,pNode->m_pt);
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
pDivNode->m_s = s;
|
|
}
|
|
else if (pNodePre->m_eType == BARCSEG)
|
|
{
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
double ang = AngleToX(pNodePre->m_pArc->m_centPt,pDivNode->m_pt);
|
|
if (pNodePre->m_pArc->m_centAngle < 0)
|
|
{//顺时针
|
|
pDivNode->m_angTng = ang - PI / 2.;
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDivNode->m_angTng = ang + PI / 2.;
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
}
|
|
pDivNode->m_s = s;
|
|
}
|
|
return 1;
|
|
}
|
|
else
|
|
{//处于中间结点上
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
double angIn;
|
|
double angOut = AngleToX(pNode->m_pt,pNodeNext->m_pt);
|
|
if (pNodePre->m_eType == BLINESEG)
|
|
{
|
|
angIn = AngleToX(pNodePre->m_pt,pNode->m_pt);
|
|
}
|
|
else
|
|
{
|
|
angIn = GetActAngOfArcOut(pNodePre);
|
|
}
|
|
|
|
if (fabs(angOut-angIn) <= PI)
|
|
{
|
|
pDivNode->m_angTng = (angOut + angIn) / 2.;
|
|
}
|
|
else
|
|
{
|
|
pDivNode->m_angTng = (angOut + angIn) / 2. + PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
|
|
pDivNode->m_s = s;
|
|
return 1;
|
|
}
|
|
else if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
double angIn;
|
|
double angOut = GetActAngOfArcIn(pNode);
|
|
if (pNodePre->m_eType == BLINESEG)
|
|
{
|
|
AcGePoint3d pPre = pNodePre->m_pt;
|
|
AcGePoint3d pThis = pNode->m_pt;
|
|
UCS2WCS(pPre);
|
|
UCS2WCS(pThis);
|
|
angIn = AngleToX(pNodePre->m_pt,pNode->m_pt);
|
|
}
|
|
else
|
|
{
|
|
angIn = GetActAngOfArcOut(pNodePre);
|
|
}
|
|
if (fabs(angOut - angIn) <= PI)
|
|
{
|
|
pDivNode->m_angTng = (angOut + angIn) / 2.;
|
|
}
|
|
else
|
|
{
|
|
pDivNode->m_angTng = (angOut + angIn) /2. + PI;
|
|
}
|
|
while (pDivNode->m_angTng >= 2*PI)
|
|
{
|
|
pDivNode->m_angTng -= 2*PI;
|
|
}
|
|
while (pDivNode->m_angTng < 0)
|
|
{
|
|
pDivNode->m_angTng += 2*PI;
|
|
}
|
|
pDivNode->m_pt = pNode->m_pt;
|
|
|
|
pDivNode->m_s = s;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
pNodePre = pNode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
double TBPloyLine::GetActAngOfArcIn(TBNode* pNode)
|
|
{
|
|
if (pNode == NULL)
|
|
{
|
|
return 0.;
|
|
}
|
|
if (pNode->m_pArc->m_centAngle >= 0)
|
|
{//逆时针
|
|
double ang = pNode->m_pArc->m_startAngle + PI / 2.;
|
|
while (ang >= 2*PI)
|
|
{
|
|
ang -= 2*PI;
|
|
}
|
|
return ang;
|
|
}
|
|
else
|
|
{
|
|
double ang = pNode->m_pArc->m_startAngle - PI / 2.;
|
|
while (ang < 0)
|
|
{
|
|
ang += 2*PI;
|
|
}
|
|
return ang;
|
|
}
|
|
}
|
|
|
|
double TBPloyLine::GetActAngOfArcOut(TBNode* pNode)
|
|
{
|
|
if (pNode == NULL)
|
|
{
|
|
return 0.;
|
|
}
|
|
if (pNode->m_pArc->m_centAngle >= 0)
|
|
{//逆时针
|
|
double ang = pNode->m_pArc->m_startAngle + PI/2. + pNode->m_pArc->m_centAngle;
|
|
while (ang >= 2*PI)
|
|
{
|
|
ang -= 2*PI;
|
|
}
|
|
return ang;
|
|
}
|
|
else
|
|
{
|
|
double ang = pNode->m_pArc->m_startAngle - PI/2. + pNode->m_pArc->m_centAngle;
|
|
while (ang < 0)
|
|
{
|
|
ang += 2*PI;
|
|
}
|
|
return ang;
|
|
}
|
|
}
|
|
|
|
void TBPloyLine::LinearizePLine(double dAng)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
ReleaseDivLst();
|
|
|
|
DivideByAng(dAng);
|
|
ReleaseBasLst();
|
|
|
|
double length = 0.;
|
|
TDNode* pNodePre = NULL;
|
|
for(POSITION pos = m_DNodeList.GetHeadPosition(); pos;)
|
|
{
|
|
TDNode* pNode = m_DNodeList.GetNext(pos);
|
|
if (m_bClosed && pos == NULL)
|
|
{
|
|
pNode = m_DNodeList.GetHead();
|
|
}
|
|
if (pNodePre != NULL)
|
|
{
|
|
length += pNodePre->m_pt.distanceTo(pNode->m_pt);
|
|
}
|
|
|
|
TBNode* pBasNode = new TBNode(BLINESEG,length,pNode->m_pt);
|
|
m_BNodeList.AddTail(pBasNode);
|
|
pNodePre = pNode;
|
|
}
|
|
}
|
|
|
|
void TBPloyLine::LinearizePLine(int nSegs)
|
|
{
|
|
if (IsEmpty()) return;
|
|
|
|
ReleaseDivLst();
|
|
|
|
DivideBySegs(nSegs,0);
|
|
ReleaseBasLst();
|
|
|
|
double length = 0.;
|
|
TDNode* pNodePre = NULL;
|
|
for(POSITION pos = m_DNodeList.GetHeadPosition(); pos;)
|
|
{
|
|
TDNode* pNode = m_DNodeList.GetNext(pos);
|
|
if (m_bClosed && pos == NULL)
|
|
{
|
|
pNode=m_DNodeList.GetHead();
|
|
}
|
|
if (pNodePre != NULL)
|
|
{
|
|
length += pNodePre->m_pt.distanceTo(pNode->m_pt);
|
|
}
|
|
TBNode* pBasNode = new TBNode(BLINESEG,length,pNode->m_pt);
|
|
m_BNodeList.AddTail(pBasNode);
|
|
pNodePre = pNode;
|
|
}
|
|
}
|
|
|
|
void TBPloyLine::DivideByAng(const double detaAng)
|
|
{//按角度，只划分圆弧
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
if (detaAng < TOL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double Z0 = 0;
|
|
|
|
ReleaseDivLst();
|
|
double TotLength = GetLength();
|
|
if (TotLength < TOL)
|
|
{
|
|
int n = m_BNodeList.GetCount();
|
|
double detaZ = 0;
|
|
int i = 0;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
TDNode* pDieNode = new TDNode;
|
|
pDieNode->m_pt = pNode->m_pt;
|
|
pDieNode->m_pt.z = Z0+i*detaZ;
|
|
pDieNode->m_s = 0.;
|
|
pDieNode->m_angTng = 0.;
|
|
m_DNodeList.AddTail(pDieNode);
|
|
i++;
|
|
}
|
|
return;
|
|
}
|
|
|
|
double unitZ = 0;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
POSITION posTemp = pos;
|
|
TBNode* pNodeNext = NULL;
|
|
if (posTemp != NULL)
|
|
{
|
|
pNodeNext = m_BNodeList.GetNext(posTemp);//得到下一结点但不增加pos
|
|
}
|
|
double s = pNode->m_s;//结点S坐标
|
|
if (pNode->m_eType == BLINESEG)
|
|
{//直线
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s,pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0+unitZ*s;
|
|
}
|
|
}
|
|
else
|
|
{//圆弧
|
|
if (pNodeNext != NULL)
|
|
{//不是最后一点
|
|
if (pNode->m_pArc != NULL)
|
|
{
|
|
double s0 = pNode->m_s;
|
|
double len = pNodeNext->m_s - s0; //线段长度
|
|
int nSeg = abs((int)(pNode->m_pArc->m_centAngle / detaAng + 0.5));//等分数
|
|
if (nSeg == 0)
|
|
{
|
|
nSeg = 1;
|
|
}
|
|
double detaS = len / nSeg;
|
|
if (detaS > TOL)
|
|
{//等分
|
|
for (int i = 0; i < nSeg; i++)
|
|
{
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s0 + i * detaS,pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0 + unitZ * (s0 + i * detaS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{//最后一点
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s,pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0 + unitZ * s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TBPloyLine::DivideBySegs(const int nSegs,BOOL flag)
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
if (nSegs == 0)
|
|
{
|
|
return;
|
|
}
|
|
double Z0 = 0;
|
|
|
|
ReleaseDivLst();
|
|
|
|
double TotLength = GetLength();
|
|
if (TotLength < TOL)
|
|
{
|
|
TBNode* pHead = Head();
|
|
if (pHead == NULL) return;
|
|
int n = nSegs;
|
|
double detaZ = 0;
|
|
for (int i = 0;i <= n;i++)
|
|
{
|
|
TDNode* pDieNode = new TDNode;
|
|
pDieNode->m_pt = pHead->m_pt;
|
|
pDieNode->m_pt.z = Z0 + i * detaZ;
|
|
pDieNode->m_s = 0.;
|
|
pDieNode->m_angTng = 0.;
|
|
m_DNodeList.AddTail(pDieNode);
|
|
}
|
|
return;
|
|
}
|
|
|
|
double unitZ = 0;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
POSITION posTemp = pos;
|
|
TBNode* pNodeNext = NULL;
|
|
if (posTemp != NULL)
|
|
{
|
|
pNodeNext = m_BNodeList.GetNext(posTemp);//得到下一结点但不增加pos
|
|
}
|
|
double s = pNode->m_s;//结点S坐标
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
if (flag && pNodeNext != NULL)
|
|
{//不是最后一个结点
|
|
double s0 = pNode->m_s;
|
|
double len = pNodeNext->m_s - s0; //线段长度
|
|
double detaS = len / nSegs;
|
|
if (detaS > TOL)
|
|
{//等分
|
|
for (int i = 0; i < nSegs; i++)
|
|
{
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s0 + i * detaS,pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0 + unitZ * (s0 + i * detaS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{//不等分直线或pNodeNext == NULL（最后一点）
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s,pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0 + unitZ * s;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{//圆弧
|
|
if (pNodeNext != NULL)
|
|
{//不是最后一点
|
|
double s0 = pNode->m_s;
|
|
double len = pNodeNext->m_s - s0; //线段长度
|
|
double detaS = len / nSegs;
|
|
if (detaS > TOL)
|
|
{//等分
|
|
for (int i = 0;i < nSegs; i++)
|
|
{
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s0 + i * detaS, pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0 + unitZ * (s0 + i * detaS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{//最后一点
|
|
TDNode* pDieNode = new TDNode;
|
|
if (GetDNode(s,pDieNode))
|
|
{
|
|
m_DNodeList.AddTail(pDieNode);
|
|
pDieNode->m_pt.z = Z0 + unitZ * s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
double TBPloyLine::GetLength(BOOL bReCalSCoord) const
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (bReCalSCoord)
|
|
{
|
|
const_cast<TBPloyLine*>(this)->ReCalcSValue();
|
|
}
|
|
TBNode* pNode = m_BNodeList.GetTail();
|
|
if (pNode != NULL)
|
|
{
|
|
return pNode->m_s;
|
|
}
|
|
return 0.;
|
|
}
|
|
|
|
TBNode* TBPloyLine::GetMostLeftNode()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
TBNode* temp = m_BNodeList.GetHead();
|
|
double value = temp->m_pt.x;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
double xMin;
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
xMin = pNode->m_pArc->GetMinX();
|
|
}
|
|
else xMin = pNode->m_pt.x;
|
|
if (xMin < value)
|
|
{
|
|
value = xMin;
|
|
temp = pNode;
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
double TBPloyLine::GetMaxX()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double value = m_BNodeList.GetHead()->m_pt.x;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
if (pNode->m_pt.x > value)
|
|
{
|
|
value = pNode->m_pt.x;
|
|
}
|
|
}
|
|
else if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
double arcMax = pNode->m_pArc->GetMaxX();
|
|
if (arcMax > value)
|
|
{
|
|
value = arcMax;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
double TBPloyLine::GetMinX()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double value = m_BNodeList.GetHead()->m_pt.x;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
if (pNode->m_pt.x < value)
|
|
{
|
|
value = pNode->m_pt.x;
|
|
}
|
|
}
|
|
else if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
double arcMin = pNode->m_pArc->GetMinX();
|
|
if (arcMin < value)
|
|
{
|
|
value = arcMin;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
double TBPloyLine::GetMinY()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double value = m_BNodeList.GetHead()->m_pt.y;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
if (pNode->m_pt.y < value)
|
|
{
|
|
value = pNode->m_pt.y;
|
|
}
|
|
}
|
|
else if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
double arcMin = pNode->m_pArc->GetMinY();
|
|
if (arcMin < value)
|
|
{
|
|
value = arcMin;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
double TBPloyLine::GetMaxY()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double value = m_BNodeList.GetHead()->m_pt.y;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode=m_BNodeList.GetNext(pos);
|
|
if (pNode->m_eType == BLINESEG)
|
|
{
|
|
if (pNode->m_pt.y > value)
|
|
{
|
|
value = pNode->m_pt.y;
|
|
}
|
|
}
|
|
else if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
double arcMax = pNode->m_pArc->GetMaxY();
|
|
if (arcMax > value)
|
|
{
|
|
value = arcMax;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
BOOL TBPloyLine::GetClockwise()
|
|
{
|
|
if (!m_bClosed)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (GetLength() < TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (isCircle())
|
|
{
|
|
TBNode* pHead = Head();
|
|
if (pHead->m_pArc->m_centAngle > 0)
|
|
{
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
int nNode = 0;
|
|
AcGePoint3d pt0(0,0,0);
|
|
TBNode* pNodePrev = NULL;
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
pt0.x += pNode->m_pt.x;
|
|
pt0.y += pNode->m_pt.y;
|
|
pt0.z += pNode->m_pt.z;
|
|
nNode++;
|
|
}
|
|
pt0.x /= nNode;
|
|
pt0.y /= nNode;
|
|
pt0.z /= nNode;
|
|
|
|
double xigmaS = 0.;
|
|
pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNodePrev != NULL)
|
|
{
|
|
AcGePoint3d pt1 = pNodePrev->m_pt;
|
|
AcGePoint3d pt2 = pNode->m_pt;
|
|
double s = 0;
|
|
s = pt0.x * (pt1.y - pt2.y) + pt1.x * (pt2.y - pt0.y) + pt2.x * (pt0.y - pt1.y);
|
|
xigmaS += s;
|
|
}
|
|
pNodePrev = pNode;
|
|
}
|
|
if (xigmaS > fTOL)
|
|
{
|
|
return 2;
|
|
}
|
|
else if (xigmaS < -fTOL)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
BOOL TBPloyLine::IsEmpty() const
|
|
{
|
|
return m_BNodeList.IsEmpty();
|
|
}
|
|
|
|
BOOL TBPloyLine::IsIntersectWith(double x,AcGePoint3d pt1,AcGePoint3d pt2) const
|
|
{
|
|
if (GetLength() < TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AcGeLineSeg3d line3d1(pt1,pt2);
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
TBNode* pNodePre = NULL;
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNodePre != NULL)
|
|
{
|
|
if ((pNode->m_pt.x < x - fTOL) || (pNodePre->m_pt.x < x - fTOL))
|
|
{
|
|
if (IsEqual(pNode->m_pt,pt1) || IsEqual(pNode->m_pt,pt2) ||
|
|
IsEqual(pNodePre->m_pt,pt1) || IsEqual(pNodePre->m_pt,pt2))
|
|
{
|
|
pNodePre = pNode;
|
|
continue;
|
|
}
|
|
AcGeLineSeg3d line3d2(pNodePre->m_pt,pNode->m_pt);
|
|
AcGePoint3d secPt;
|
|
if (line3d1.intersectWith(line3d2,secPt) == Adesk::kTrue)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
pNodePre = pNode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL TBPloyLine::IsPtInPolygon(AcGePoint3d& pt) const
|
|
{
|
|
if (IsEmpty() || !(IsClosed()))
|
|
{
|
|
return 0;
|
|
}
|
|
if (GetLength() < TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AcGeTol tol;
|
|
tol.setEqualPoint(TOL);
|
|
|
|
TBPloyLine* pNew = new TBPloyLine;
|
|
*pNew = *this;
|
|
if (pNew->HasArc())
|
|
{
|
|
pNew->LinearizePLine(PI / 36.);
|
|
}
|
|
AcGePoint3d pt1 = pt;
|
|
pt1.x += 100;
|
|
|
|
AcGeRay3d rayLine(pt,pt1); //以pt为起点的水平射线
|
|
POSITION pos = pNew->m_BNodeList.GetHeadPosition();
|
|
TBNode* pNodePre = NULL;
|
|
int nTotpt = 0; //射线与多边形的交点数
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = pNew->m_BNodeList.GetNext(pos);
|
|
if (pNodePre != NULL)
|
|
{
|
|
AcGeLineSeg3d line3d(pNodePre->m_pt,pNode->m_pt); //得到直线段
|
|
AcGePoint3d secPt;
|
|
if (line3d.isOn(pt,tol))
|
|
{
|
|
return 2; //点在边上
|
|
}
|
|
if (IsOverlap(pt,pt1,pNodePre->m_pt,pNode->m_pt))
|
|
{
|
|
continue;
|
|
}
|
|
else if (rayLine.isOn(pNodePre->m_pt,tol) && (pNodePre->m_pt.y<pNode->m_pt.y))
|
|
{
|
|
nTotpt++;
|
|
}
|
|
else if (rayLine.isOn(pNode->m_pt,tol) && (pNode->m_pt.y<pNodePre->m_pt.y))
|
|
{
|
|
nTotpt++;
|
|
}
|
|
else if (line3d.intersectWith(rayLine,secPt) == Adesk::kTrue &&
|
|
!rayLine.isOn(pNode->m_pt,tol) && !rayLine.isOn(pNodePre->m_pt,tol))
|
|
{
|
|
nTotpt++;
|
|
}
|
|
}
|
|
pNodePre = pNode;
|
|
}
|
|
delete pNew;
|
|
if ((nTotpt + 1) % 2 == 0)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
BOOL TBPloyLine::HasArc() const
|
|
{
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL TBPloyLine::isCircle() const
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
TBPloyLine tempLine = *this;
|
|
tempLine.ClearUp();
|
|
TBNode* pHead = tempLine.Head();
|
|
if (pHead == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
if (tempLine.HasArc() && tempLine.m_BNodeList.GetCount() == 2 &&
|
|
fabs(fabs(pHead->m_pArc->m_centAngle) - 2 * PI) < TOL)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL TBPloyLine::IsInXYPlane() const
|
|
{
|
|
TBNode* pHead = m_BNodeList.GetHead();
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (fabs(pHead->m_pt.z - pNode->m_pt.z) > TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void TBPloyLine::MoveTo(AcGeVector3d& disp)
|
|
{
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
pNode->m_pt = pNode->m_pt + disp;
|
|
if (pNode->m_eType == BARCSEG && pNode->m_pArc != NULL)
|
|
{
|
|
pNode->m_pArc->m_centPt = pNode->m_pArc->m_centPt + disp;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TBPloyLine::ReCalcSValue()
|
|
{
|
|
if (IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
POSITION pos = m_BNodeList.GetHeadPosition();
|
|
double len = 0.0;
|
|
TBNode* pNodePre = NULL;
|
|
while (pos != NULL)
|
|
{
|
|
TBNode* pNode = m_BNodeList.GetNext(pos);
|
|
if (pNodePre != NULL)
|
|
{
|
|
if (pNodePre->m_eType == BLINESEG)
|
|
{
|
|
len += pNodePre->m_pt.distanceTo(pNode->m_pt);
|
|
}
|
|
else if (pNodePre->m_eType == BARCSEG && pNodePre->m_pArc != NULL)
|
|
{
|
|
len += pNodePre->m_pArc->Length();
|
|
}
|
|
}
|
|
pNode->m_s = len;
|
|
pNodePre = pNode;
|
|
}
|
|
}
|
|
|
|
int TBPloyLine::IsZParalECSAndUcs(AcDbObjectId& objId)
|
|
{
|
|
AcDbEntity *pEnt;
|
|
acdbOpenObject(pEnt, objId, AcDb::kForRead);
|
|
|
|
CString DxfName = pEnt->isA()->dxfName();
|
|
if (DxfName == _T("LINE"))
|
|
{
|
|
AcDbLine* pLine = (AcDbLine*)(pEnt);
|
|
|
|
AcGePoint3d pt1 = pLine->startPoint();
|
|
AcGePoint3d pt2 = pLine->endPoint();
|
|
WCS2UCS(pt1);
|
|
WCS2UCS(pt2);
|
|
|
|
pEnt->close();
|
|
|
|
double d = pt1.distanceTo(pt2);
|
|
if (d <= TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (fabs(pt1[Z] - pt2[Z]) / d >= TOL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
pEnt->close();
|
|
ads_point ads_ret,ads_pt = {0.,0.,1.};
|
|
ads_name pEntName;
|
|
acdbGetAdsName(pEntName,objId);
|
|
|
|
struct resbuf from,to;
|
|
from.restype = RTENAME;
|
|
ads_name_set(pEntName,from.resval.rlname); //ECS
|
|
to.restype = RTSHORT;
|
|
to.resval.rint = 1; //UCS
|
|
acedTrans(ads_pt,&from,&to,1,ads_ret); //按矢量转换
|
|
|
|
double tol = TOL;
|
|
if (fabs(ads_ret[X]) < TOL && fabs(ads_ret[Y]) < TOL && ads_ret[Z] >= 0.)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (fabs(ads_ret[X]) < TOL && fabs(ads_ret[Y]) < TOL && ads_ret[Z] < 0.)
|
|
{
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TBPloyLine::WCS2ECS(AcGePoint3d& pt,AcDbObjectId& objId,BOOL bVer)
|
|
{
|
|
ads_point ads_pt1,ads_ret;
|
|
ARX2AdsPt(pt,ads_pt1);
|
|
|
|
ads_name pEntName;
|
|
acdbGetAdsName(pEntName,objId);
|
|
|
|
struct resbuf from,to;
|
|
from.restype = RTSHORT;
|
|
from.resval.rint = 0;
|
|
to.restype = RTENAME;
|
|
ads_name_set(pEntName,to.resval.rlname); //ECS
|
|
acedTrans(ads_pt1,&from,&to,bVer,ads_ret);
|
|
|
|
Ads2ARXPt(ads_ret,pt);
|
|
}
|
|
|
|
void TBPloyLine::WCS2UCS(AcGePoint3d& pt,BOOL bVer)
|
|
{
|
|
ads_point ads_pt1,ads_ret;
|
|
ARX2AdsPt(pt,ads_pt1);
|
|
|
|
struct resbuf from,to;
|
|
from.restype = RTSHORT;
|
|
from.resval.rint = 0; //WCS
|
|
to.restype = RTSHORT;
|
|
to.resval.rint = 1; //UCS
|
|
|
|
acedTrans(ads_pt1,&from,&to,bVer,ads_ret);
|
|
Ads2ARXPt(ads_ret,pt);
|
|
}
|
|
|
|
void TBPloyLine::ECS2UCS(AcGePoint3d& pt,AcDbObjectId& objId,BOOL bVer)
|
|
{
|
|
ads_point ads_pt1,ads_ret;
|
|
ARX2AdsPt(pt,ads_pt1);
|
|
|
|
ads_name pEntName;
|
|
acdbGetAdsName(pEntName,objId);
|
|
|
|
struct resbuf from,to;
|
|
from.restype = RTENAME;
|
|
ads_name_set(pEntName,from.resval.rlname); //ECS
|
|
to.restype = RTSHORT;
|
|
to.resval.rint = 1;
|
|
|
|
acedTrans(ads_pt1,&from,&to,bVer,ads_ret);
|
|
Ads2ARXPt(ads_ret,pt);
|
|
}
|
|
|
|
AcGePoint3d TBPloyLine::polar(AcGePoint3d& pt0,double ang,double dist)
|
|
{
|
|
AcGePoint3d pt3d;
|
|
ads_point ads_pt,ads_ret;
|
|
ARX2AdsPt(pt0,ads_pt);
|
|
acutPolar(ads_pt,ang,dist,ads_ret);
|
|
Ads2ARXPt(ads_ret,pt3d);
|
|
return pt3d;
|
|
}
|
|
|
|
BOOL TBPloyLine::IsEqualSign(double x1,double x2)
|
|
{
|
|
if (x1 > fTOL && x2 > fTOL)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (x1 < fTOL && x2 < fTOL)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|