824 lines
16 KiB
C++
824 lines
16 KiB
C++
#include "StdAfx.h"
|
|
#include "globalfunc.h"
|
|
#include "GePolygonEx.h"
|
|
#include "GeCurveInline.h"
|
|
|
|
GePolygonEx::GePolygonEx(GePoly &src)
|
|
{
|
|
for (int i = 0; i < src.Length(); i++)
|
|
{
|
|
AppendNode(*src[i], 1);
|
|
}
|
|
}
|
|
|
|
GePolygonEx::GePolygonEx(EntitySet &ent)
|
|
{
|
|
int nFlag0 = 0;
|
|
ent.GetData(70, &nFlag0);
|
|
|
|
if (nFlag0 > 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
GePoly2D poly(ent);
|
|
if (!poly)
|
|
{
|
|
return;
|
|
}
|
|
|
|
poly.MapToPolygon(*this);
|
|
|
|
if (!nFlag0)
|
|
{
|
|
ADSGePoint3d &ptStart = *(*this)[0];
|
|
ADSGePoint3d &ptEnd = *Tail();
|
|
if (ptStart == ptEnd)
|
|
{
|
|
int nTail = Length() - 1;
|
|
Remove(nTail);
|
|
|
|
if (!*this)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Reset();
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < Length(); i++)
|
|
{
|
|
m_lstVisibleFlag.Append(new int(1));
|
|
}
|
|
}
|
|
|
|
GePolygonEx::GePolygonEx()
|
|
{
|
|
|
|
}
|
|
|
|
GePolygonEx::GePolygonEx(const GePolygonEx &src)
|
|
{
|
|
*this = src;
|
|
}
|
|
|
|
GePolygonEx::~GePolygonEx()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
void GePolygonEx::CopyFrom(const GeEntity* pSrc)
|
|
{
|
|
if (this != pSrc && pSrc->IsKindOf(GeEntity::ePolygonEx))
|
|
{
|
|
Reset();
|
|
m_lstVisibleFlag.Reset();
|
|
assert(((GePolygonEx*)pSrc)->Length() == m_lstVisibleFlag.Length());
|
|
|
|
ADSGePoint3d pt;
|
|
int nindex;
|
|
for (int i = 0; i < ((GePolygonEx*)pSrc)->Length(); i++)
|
|
{
|
|
pt = *(*(GePolygonEx*)pSrc)[i];
|
|
nindex = *((GePolygonEx*)pSrc)->m_lstVisibleFlag[i];
|
|
AppendNode(pt,nindex);
|
|
}
|
|
}
|
|
else if (this != pSrc && pSrc->IsKindOf(GeEntity::ePoly))
|
|
{
|
|
Reset();
|
|
for (int i = 0; i < ((GePoly*)pSrc)->Length(); i++)
|
|
{
|
|
Append(new ADSGePoint3d(*(*(GePoly*)pSrc)[i]));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
GePolygonEx & GePolygonEx::operator = (const GePolygonEx &src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
CopyFrom(&src);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
SHLoopList<int>& GePolygonEx::GetVisibleFlag()
|
|
{
|
|
return m_lstVisibleFlag;
|
|
}
|
|
|
|
// 求第 nIndex 个点, 支持循环
|
|
ADSGePoint3d * GePolygonEx::operator [](int nIndex)
|
|
{
|
|
int nLen = Length();
|
|
nIndex = GlobalFunc::LimitCycle(nIndex, nLen);
|
|
return GePoly::operator[](nIndex);
|
|
}
|
|
|
|
// 求第 nIndex 个点, 支持循环
|
|
const ADSGePoint3d & GePolygonEx::operator [](int nIndex) const
|
|
{
|
|
int nLen = Length();
|
|
nIndex = GlobalFunc::LimitCycle(nIndex, nLen);
|
|
const GePoly &rThis = *this;
|
|
return rThis[nIndex];
|
|
}
|
|
|
|
void GePolygonEx::RemoveNode(int nIndex)
|
|
{
|
|
int nEdge = Length();
|
|
nIndex = GlobalFunc::LimitCycle(nIndex, nEdge);
|
|
Remove(nIndex);
|
|
m_lstVisibleFlag.Remove(nIndex);
|
|
}
|
|
|
|
// 求法向量，用来作为坐标变换
|
|
int GePolygonEx::GetNormal(TVector3D &vtNormal) const
|
|
{
|
|
int nEdgeNum = Length();
|
|
if (nEdgeNum < 3)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
ADSGePoint3d pt0 = GetVertex(0);
|
|
ADSGePoint3d pt1, pt2;
|
|
int nFlag = 0;
|
|
for (int i = 1; i < nEdgeNum; i++)
|
|
{
|
|
ADSGePoint3d pt = GetVertex(i);
|
|
if (pt0.Distance(pt) < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!nFlag)
|
|
{
|
|
pt1 = pt;
|
|
nFlag++;
|
|
}
|
|
else
|
|
{
|
|
GeLine ln(pt0, pt1);
|
|
if ((pt & ln) == PR_OUTSIDE)
|
|
{
|
|
pt2 = pt;
|
|
nFlag++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nFlag < 2)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
TVector3D vt1 = pt1 - pt0;
|
|
TVector3D vt2 = pt2 - pt0;
|
|
BOOL b1 = (vt1.Length() < 1.0E-6);
|
|
BOOL b2 = (vt2.Length() < 1.0E-6);
|
|
if (b1 || b2)
|
|
{
|
|
#ifndef NDEBUG
|
|
g_Option::instance().adsout << _T("\n不好的GePolygonEx!");
|
|
#endif
|
|
}
|
|
|
|
using namespace GlobalFunc;
|
|
vtNormal = vt1 * vt2;
|
|
((AcGeVector3d &)vtNormal).normalize();
|
|
|
|
// Add on 2002/10/11，上面的vtNormal可能与实际方向相反
|
|
//GePolygonExImp tmp(*this);
|
|
GePolygonEx tmp(*this);
|
|
tmp.Wcs2Ecs(vtNormal);
|
|
|
|
double nPathArea = tmp.PathArea();
|
|
//GePolygonExImp tmp1;
|
|
GePolygonEx tmp1;
|
|
tmp1.AppendNode(pt0);
|
|
tmp1.AppendNode(pt1);
|
|
tmp1.AppendNode(pt2);
|
|
tmp1.Wcs2Ecs(vtNormal);
|
|
|
|
double nPathArea1 = tmp1.PathArea();
|
|
if ((nPathArea > 0 && nPathArea1 < 0) || (nPathArea < 0 && nPathArea1 > 0))
|
|
{
|
|
vtNormal.Reverse();
|
|
}
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
void GePolygonEx::Ecs2Wcs(TVector3D vtEcs)
|
|
{
|
|
GePoly &poly = *this;
|
|
for (int i = 0; i < Length(); i++)
|
|
{
|
|
*poly[i] = GlobalFunc::Ecs2Wcs(*poly[i], vtEcs);
|
|
}
|
|
}
|
|
|
|
void GePolygonEx::Wcs2Ecs(TVector3D vtEcs)
|
|
{
|
|
GePoly &poly = *this;
|
|
for (int i = 0; i < Length(); i++)
|
|
{
|
|
*poly[i] = GlobalFunc::Wcs2Ecs(*poly[i], vtEcs);
|
|
}
|
|
}
|
|
|
|
int GePolygonEx::Trianglize(PtrList<GeTriangle> &lstTris, BOOL b2D) const
|
|
{
|
|
GePolygonEx polyEx(*this);
|
|
TVector3D vtNormal;
|
|
if (!b2D)
|
|
{
|
|
if (GetNormal(vtNormal) != RTNORM)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
polyEx.Wcs2Ecs(vtNormal);
|
|
}
|
|
|
|
if (polyEx.PathArea() > 1.0E-6)
|
|
{
|
|
polyEx.Reverse();
|
|
}
|
|
|
|
int nRet = polyEx.SubTrianglize(lstTris);
|
|
|
|
if (!b2D)
|
|
{
|
|
int num = lstTris.Length();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
lstTris[i]->Ecs2Wcs(vtNormal);
|
|
}
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
int GePolygonEx::GetInsidePoint(ADSGePoint3d &ptRet, BOOL b2D) const
|
|
{
|
|
GePolygonEx polyEx(*this);
|
|
TVector3D vtNormal;
|
|
if (!b2D)
|
|
{
|
|
if (GetNormal(vtNormal) != RTNORM)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
polyEx.Wcs2Ecs(vtNormal);
|
|
}
|
|
|
|
if (polyEx.PathArea() > 1.0E-6)
|
|
{
|
|
polyEx.Reverse();
|
|
vtNormal.Reverse(); // 2003/2/27，修改以便正确解决ECS转化
|
|
}
|
|
|
|
int nRet = polyEx.SubGetInsidePoint(ptRet);
|
|
if (nRet == RTNORM && !b2D)
|
|
{
|
|
ptRet = GlobalFunc::Ecs2Wcs(ptRet, vtNormal);
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
// 求第i个顶点的夹角
|
|
double GePolygonEx::GetAngle(int idx) const
|
|
{
|
|
int nEdge = Length();
|
|
ASSERT(nEdge >= 3);
|
|
|
|
int nNext = -1;
|
|
int nPre = -1;
|
|
|
|
nNext = idx + 1;
|
|
nPre = idx - 1;
|
|
if (idx == 0)
|
|
{
|
|
nPre = nEdge - 1;
|
|
}
|
|
if (idx == nEdge - 1)
|
|
{
|
|
nNext = 0;
|
|
}
|
|
|
|
ADSGePoint3d ptCur = (*this)[idx];
|
|
ADSGePoint3d ptPrev = (*this)[nPre];
|
|
ADSGePoint3d ptNext = (*this)[nNext];
|
|
double nPrevAng = GlobalFunc::AngleRangeTo2PI(ads_angle(ptCur, ptPrev) - ads_angle(ptCur, ptNext));
|
|
return nPrevAng;
|
|
}
|
|
|
|
//是否为凸多边形，2D
|
|
BOOL GePolygonEx::IsConvex() const
|
|
{
|
|
for (int i = 0; i < Length(); i++)
|
|
{
|
|
double nAng = GetAngle(i);
|
|
if (nAng < g_DimOption::instance()._angSnap || nAng > PI - g_DimOption::instance()._angSnap)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#if ARX > 19
|
|
static int MakeCallBack(void* pData)
|
|
{
|
|
if( NULL == pData )
|
|
return 0 ;
|
|
|
|
resbuf *rb = (resbuf*)pData;
|
|
if( acedCmdCWasCancelled() )
|
|
{
|
|
acutRelRb(rb);
|
|
return 0 ;
|
|
}
|
|
|
|
resbuf *rbData = rb->rbnext;
|
|
rb->rbnext = NULL;
|
|
if( NULL == rbData )
|
|
acedCommandC(MakeCallBack, rbData , RT3DPOINT , rb->resval.rpoint, RTSTR , _T("C"), RTNONE);
|
|
else
|
|
acedCommandC(MakeCallBack, rbData , RT3DPOINT , rb->resval.rpoint, RTNONE );
|
|
acutRelRb(rb);
|
|
acedCallBackOnCancel();
|
|
|
|
return 1;
|
|
}
|
|
|
|
// 测试用
|
|
int GePolygonEx::Make(const TCHAR *szLay)
|
|
{
|
|
GlobalFunc::PushAcadVar<CString,true> clayer(_T("CLAYER"), szLay);
|
|
GlobalFunc::PushAcadVar<int> vOsMode(_T("OSMODE"), 0);
|
|
resbuf *resTep, *resData;
|
|
int iLen = Length();
|
|
if( iLen > 0 )
|
|
{
|
|
resTep = resData = acutNewRb(RT3DPOINT);
|
|
ads_point_set(*(*this)[0], resTep->resval.rpoint);
|
|
for( int i=1; i<iLen; ++i )
|
|
{
|
|
resTep = resTep->rbnext = acutNewRb(RT3DPOINT);
|
|
ads_point_set(*(*this)[i], resTep->resval.rpoint);
|
|
}
|
|
}
|
|
return acedCommandC(MakeCallBack, resData, RTSTR, _T(".PLINE"), RTNONE);
|
|
}
|
|
|
|
#else
|
|
|
|
int GePolygonEx::Make(const TCHAR *szLay)
|
|
{
|
|
GlobalFunc::PushAcadVar<CString,true> clayer(_T("CLAYER"), szLay);
|
|
GlobalFunc::PushAcadVar<int> vOsMode(_T("OSMODE"), 0);
|
|
ads_command(RTSTR, _T(".PLINE"), RTNONE);
|
|
|
|
for (int i = 0; i < Length(); i++)
|
|
{
|
|
ads_command(RT3DPOINT, (*this)[i], RTNONE);
|
|
}
|
|
|
|
return ads_command(RTSTR, _T("C"), RTNONE);
|
|
}
|
|
|
|
#endif
|
|
|
|
void GePolygonEx::Reverse()
|
|
{
|
|
GePoly::Reverse();
|
|
m_lstVisibleFlag.Reverse();
|
|
}
|
|
|
|
double GePolygonEx::GetEdgeLength(int idx) const
|
|
{
|
|
const ADSGePoint3d &pt = (*this)[idx];
|
|
//最后一点与第一个点求距离
|
|
if (idx == Length() - 1)
|
|
{
|
|
idx = -1;
|
|
}
|
|
const ADSGePoint3d &ptNext = (*this)[idx + 1];
|
|
|
|
return pt.Distance(ptNext);
|
|
}
|
|
|
|
BOOL GePolygonEx::IsVisible(int idx) const
|
|
{
|
|
return (m_lstVisibleFlag[idx]);
|
|
}
|
|
|
|
void GePolygonEx::SetVisible(int idx, BOOL bVis)
|
|
{
|
|
*(m_lstVisibleFlag[idx]) = bVis;
|
|
}
|
|
|
|
ADSGePoint3d GePolygonEx::GetVertex(int idx) const
|
|
{
|
|
return (*this)[idx];
|
|
}
|
|
|
|
void GePolygonEx::AppendNode(const ADSGePoint3d &pt, int nIndex/* = 1*/)
|
|
{
|
|
Append(new ADSGePoint3d(pt));
|
|
m_lstVisibleFlag.Append(new int(nIndex));
|
|
}
|
|
|
|
void GePolygonEx::Reset()
|
|
{
|
|
GePoly::Reset();
|
|
m_lstVisibleFlag.Reset();
|
|
}
|
|
|
|
int GePolygonEx::SubTrianglize(PtrList<GeTriangle> &lstTris)
|
|
{
|
|
LAB_START:
|
|
int nEdge = Length();
|
|
if (nEdge < 3)
|
|
{
|
|
return RTNORM;
|
|
}
|
|
|
|
// 消除长度为0的边
|
|
for (int i = 0; i < nEdge; i++)
|
|
{
|
|
if (GetEdgeLength(i) < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
RemoveNode(i);
|
|
nEdge--;
|
|
i--;
|
|
}
|
|
}
|
|
|
|
// 消除0和PI的顶点，可能没有必要
|
|
for (i = 9; i < nEdge; i++)
|
|
{
|
|
if (nEdge < 3)
|
|
{
|
|
return RTNORM;
|
|
}
|
|
|
|
double nAng = GetAngle(i);
|
|
if (fabs(nAng) < g_DimOption::instance()._angSnap) //夹角为0
|
|
{
|
|
BOOL bVis = IsVisible(i - 1);
|
|
if (GetEdgeLength(i - 1) < GetEdgeLength(i))
|
|
{
|
|
bVis = IsVisible(i);
|
|
}
|
|
|
|
SetVisible(i - 1, bVis);
|
|
RemoveNode(i);
|
|
nEdge--;
|
|
i--;
|
|
if (fabs(nAng) < g_DimOption::instance()._angSnap) //消除0度的夹角，可能导致边长为0
|
|
{
|
|
goto LAB_START;
|
|
}
|
|
}
|
|
else if (fabs(nAng - PI) < g_DimOption::instance()._angSnap) //夹角为PI
|
|
{
|
|
BOOL bVis1 = IsVisible(i - 1);
|
|
BOOL bVis2 = IsVisible(i);
|
|
|
|
if (bVis1 == bVis2) //可见性相同，可以消除
|
|
{
|
|
SetVisible(i - 1, bVis1);
|
|
RemoveNode(i);
|
|
nEdge--;
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nEdge < 3)
|
|
{
|
|
return RTNORM;
|
|
}
|
|
|
|
if (nEdge == 3)
|
|
{
|
|
i = 0;
|
|
int nVisFlag = SIDE1_INVISIBLE * (!IsVisible(i - 1))
|
|
+ SIDE2_INVISIBLE * (!IsVisible(i))
|
|
+ SIDE3_INVISIBLE * (!IsVisible(i + 1));
|
|
|
|
lstTris.Append(new GeTriangle(GetVertex(i - 1), GetVertex(i), GetVertex(i + 1), nVisFlag));
|
|
Reset();
|
|
return RTNORM;
|
|
}
|
|
|
|
// 消除小于180的凸角
|
|
for (i = 0; i < nEdge; i++)
|
|
{
|
|
double nAng = GetAngle(i);
|
|
if (nAng < PI - g_DimOption::instance()._angSnap)
|
|
{
|
|
int nVisFlag = SIDE1_INVISIBLE * (!IsVisible(i - 1))
|
|
+ SIDE2_INVISIBLE * (!IsVisible(i))
|
|
+ SIDE3_INVISIBLE;
|
|
|
|
GeTriangle tri(GetVertex(i - 1), GetVertex(i), GetVertex(i + 1), nVisFlag);
|
|
|
|
BOOL bAllow = TRUE;
|
|
// 其他顶点都在tri外部或第3边，则可以消除
|
|
for (int n = i + 2; n < i - 1 + nEdge; n++)
|
|
{
|
|
ADSGePoint3d ptTest = GetVertex(n);
|
|
int nHitFlag = tri.HitTest2d(ptTest);
|
|
int nFlag = 1; //第一个端点到末尾端点的路径（除首末点外）都需要重新测定
|
|
switch(nHitFlag)
|
|
{
|
|
case 0: //外部
|
|
break;
|
|
case 1: //第一点
|
|
break;
|
|
case 2: //第2点
|
|
nFlag = 2;
|
|
break;
|
|
case 3: //第3点
|
|
break;
|
|
case -1: //第1边
|
|
nFlag = 2;
|
|
break;
|
|
case -2: //第2边
|
|
nFlag = 2;
|
|
break;
|
|
case -3: //第3边
|
|
break;
|
|
case 4:
|
|
nFlag = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (!nFlag)
|
|
{
|
|
bAllow = FALSE;
|
|
break;
|
|
}
|
|
|
|
if (nFlag == 2) //测定ptTest的2边是否和tri的第三边有交点，且交点在线内
|
|
{
|
|
GeLine lnSect(tri.vertex3, tri.vertex1, LS_FINITE);
|
|
GeLine lnOut(ptTest, GetVertex(n + 1), LS_FINITE);
|
|
GeLine lnIn(GetVertex(n - 1), ptTest, LS_FINITE);
|
|
ADSGePoint3d ptInt1, ptInt2;
|
|
BOOL bInt1 = (lnSect.Intersection(&lnOut, ptInt1) > 0); //比ads_inters更加可靠
|
|
|
|
if (bInt1)
|
|
{
|
|
if (lnSect.GetStartPoint().Distance2d(ptInt1) > g_Option::instance()._DIST_SNAP
|
|
&& lnSect.GetEndPoint().Distance2d(ptInt1) > g_Option::instance()._DIST_SNAP)
|
|
{
|
|
bAllow = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
BOOL bInt2 = (lnSect.Intersection(&lnIn, ptInt2) > 0); //比ads_inters更加可靠
|
|
if (bInt2)
|
|
{
|
|
if (lnSect.GetStartPoint().Distance2d(ptInt2) > g_Option::instance()._DIST_SNAP
|
|
&& lnSect.GetEndPoint().Distance2d(ptInt2) > g_Option::instance()._DIST_SNAP)
|
|
{
|
|
bAllow = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bAllow)
|
|
{
|
|
lstTris.Append(new GeTriangle(tri));
|
|
SetVisible(i - 1, FALSE); //必须在顶点移除前更改可见性，否则如果首点被移除导致序号的变化
|
|
RemoveNode(i);
|
|
|
|
goto LAB_START;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
g_Option::instance().adsout << _T("\n警告：多边形三角化可能不合适, 还有") << Length() << _T("个边未三角化!");
|
|
Make(_T("1"));
|
|
#endif
|
|
|
|
return RTERROR;
|
|
}
|
|
|
|
int GePolygonEx::SubGetInsidePoint(ADSGePoint3d &ptRet)
|
|
{
|
|
LAB_START:
|
|
int nEdge = Length();
|
|
if (nEdge < 3)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
// 消除长度为0的边
|
|
for (int i = 0; i < nEdge; i++)
|
|
{
|
|
if (GetEdgeLength(i) < g_Option::instance()._DIST_SNAP)
|
|
{
|
|
RemoveNode(i);
|
|
nEdge--;
|
|
i--;
|
|
}
|
|
}
|
|
|
|
// 消除0和PI的顶点
|
|
for (i = 0; i < nEdge; i++)
|
|
{
|
|
if (nEdge < 3)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
double nAng = GetAngle(i);
|
|
if (fabs(nAng) < g_DimOption::instance()._angSnap) //夹角为0
|
|
{
|
|
BOOL bVis = IsVisible(i - 1);
|
|
if (GetEdgeLength(i - 1) < GetEdgeLength(i))
|
|
{
|
|
bVis = IsVisible(i);
|
|
}
|
|
|
|
SetVisible(i - 1, bVis);
|
|
RemoveNode(i);
|
|
nEdge--;
|
|
i--;
|
|
|
|
if (fabs(nAng) < g_DimOption::instance()._angSnap) //消除0度的夹角，可能导致边长为0
|
|
{
|
|
goto LAB_START;
|
|
}
|
|
}
|
|
else if (fabs(nAng - PI) < g_DimOption::instance()._angSnap) //夹角为PI
|
|
{
|
|
BOOL bVis1 = IsVisible(i - 1);
|
|
BOOL bVis2 = IsVisible(i);
|
|
|
|
if (bVis1 == bVis2) //可见性相同，可以消除
|
|
{
|
|
SetVisible(i - 1, bVis1);
|
|
RemoveNode(i);
|
|
nEdge--;
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nEdge < 3)
|
|
{
|
|
return RTERROR;
|
|
}
|
|
|
|
BOOL bAoJiao = FALSE;
|
|
double nPi = PI - 1.0E-6;
|
|
|
|
// 还没有优化，应当同时向前、向后消除
|
|
// 消除凹角, 向前
|
|
for (i = 0; i < nEdge; i++)
|
|
{
|
|
double nAng = GetAngle(i);
|
|
double nAngNext = GetAngle(i+1);
|
|
if (!bAoJiao)
|
|
{
|
|
bAoJiao = (nAng > nPi);
|
|
}
|
|
|
|
if (nAng > nPi && nAngNext < nPi)
|
|
{
|
|
BOOL bCanCut = TRUE;
|
|
GeLine ln(GetVertex(i), GetVertex(i + 2), LS_FINITE);
|
|
|
|
//判断i+3到i-2是否的边是否有交点
|
|
for (int n = i + 3; n <= i - 2 + nEdge; n++)
|
|
{
|
|
ADSGePoint3d ptInt;
|
|
GeLine ln1(GetVertex(n), GetVertex(n + 1), LS_FINITE);
|
|
if (ln.Intersection(&ln1, ptInt))
|
|
{
|
|
int nFlag1 = (ptInt & ln);
|
|
int nFlag2 = (ptInt & ln1);
|
|
if (nFlag1 == PR_INSIDE && nFlag2 == PR_INSIDE)
|
|
{
|
|
bCanCut = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bCanCut)
|
|
{
|
|
ADSGePoint3d pt1 = GetVertex(i);
|
|
ADSGePoint3d pt2 = GetVertex(i + 1);
|
|
ADSGePoint3d pt3 = GetVertex(i + 2);
|
|
|
|
ptRet.x = (pt1.x + pt2.x + pt3.x) / 3.0;
|
|
ptRet.y = (pt1.y + pt2.y + pt3.y) / 3.0;
|
|
ptRet.z = (pt1.z + pt2.z + pt3.z) / 3.0;
|
|
|
|
return RTNORM;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bAoJiao)
|
|
{
|
|
// 消除凹角, 向后
|
|
for (i = nEdge - 1; i >= 0; i--)
|
|
{
|
|
double nAng = GetAngle(i);
|
|
double nAngPrev = GetAngle(i - 1);
|
|
|
|
if (nAng > nPi && nAngPrev < nPi)
|
|
{
|
|
BOOL bCanCut = TRUE;
|
|
GeLine ln(GetVertex(i), GetVertex(i - 2), LS_FINITE); //消i-1
|
|
|
|
//判断i+1到i-4边是否有交点
|
|
for (int n = i + 1; n <= i - 4 + nEdge; n++)
|
|
{
|
|
ADSGePoint3d ptInt;
|
|
GeLine ln1(GetVertex(n), GetVertex(n + 1), LS_FINITE);
|
|
if (ln.Intersection(&ln1, ptInt))
|
|
{
|
|
int nFlag1 = (ptInt & ln);
|
|
int nFlag2 = (ptInt & ln1);
|
|
if (nFlag1 == PR_INSIDE && nFlag2 == PR_INSIDE)
|
|
{
|
|
bCanCut = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bCanCut)
|
|
{
|
|
ADSGePoint3d pt1 = GetVertex(i - 2);
|
|
ADSGePoint3d pt2 = GetVertex(i - 1);
|
|
ADSGePoint3d pt3 = GetVertex(i);
|
|
|
|
ptRet.x = (pt1.x + pt2.x + pt3.x) / 3.0;
|
|
ptRet.y = (pt1.y + pt2.y + pt3.y) / 3.0;
|
|
ptRet.z = (pt1.z + pt2.z + pt3.z) / 3.0;
|
|
|
|
return RTNORM;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ADSGePoint3d pt1 = GetVertex(0);
|
|
ADSGePoint3d pt2 = GetVertex(1);
|
|
ADSGePoint3d pt3 = GetVertex(2);
|
|
|
|
ptRet.x = (pt1.x + pt2.x + pt3.x) / 3.0;
|
|
ptRet.y = (pt1.y + pt2.y + pt3.y) / 3.0;
|
|
ptRet.z = (pt1.z + pt2.z + pt3.z) / 3.0;
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
bool GePolygonEx::IsKindOf(GeEntity::TEntityId entType) const
|
|
{
|
|
switch(entType)
|
|
{
|
|
case GeEntity::eEntity:
|
|
case GeEntity::eCurve:
|
|
case GeEntity::ePoly:
|
|
case GeEntity::eShape:
|
|
case GeEntity::ePolygonEx:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
GeEntity::TEntityId GePolygonEx::Type() const
|
|
{
|
|
return GeEntity::ePolygonEx;
|
|
}
|