1684 lines
45 KiB
C++
1684 lines
45 KiB
C++
#include "StdAfx.h"
|
|
#ifdef TASD
|
|
#include "TBaseWallIntegrateTool.h"
|
|
#include "TBaseWallLine.h"
|
|
|
|
double dTol = _AS_SYS_UNIT(20);
|
|
|
|
|
|
typedef struct BaseWallLineParam
|
|
{
|
|
TBaseWallLine baseWallLine;
|
|
double dParam;
|
|
}BASEWALLLINEPARAM;
|
|
|
|
static bool GreaterCompare(BaseWallLineParam& param1,BaseWallLineParam& param2)
|
|
{
|
|
if (param1.dParam - param2.dParam > 1.e-10)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 判断是否是端点融合
|
|
// 返回值：0：两端不相交；1:起始端相交；2：终止端相交；3：两端都相交；
|
|
int TBaseWallIntegrateTool::IsIntegrateAtTail(const TGGeCurveSegment& cvThis, const TGGeCurveSegment& cvThat)
|
|
{
|
|
int nRet = 0;
|
|
|
|
//起始端
|
|
if(cvThis.StartPoint().Distance2d(cvThat.StartPoint()) < _DIST_SNAP
|
|
||cvThis.StartPoint().Distance2d(cvThat.EndPoint())< _DIST_SNAP)
|
|
{
|
|
nRet += 1;
|
|
}
|
|
|
|
//终止端
|
|
if(cvThis.EndPoint().Distance2d(cvThat.StartPoint()) < _DIST_SNAP
|
|
||cvThis.EndPoint().Distance2d(cvThat.EndPoint())< _DIST_SNAP)
|
|
{
|
|
nRet += 2;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
// 双线普通融合
|
|
// 返回值：FALSE：融合不成功；1:融合成功；
|
|
BOOL TBaseWallIntegrateTool::Integrate(TBaseWallLine& baseWallThis, const TBaseWallLine& baseWallThat)
|
|
{
|
|
TGGeVisibilityPoly2D lPoly = baseWallThis.GetLeftLine();
|
|
TGGeVisibilityPoly2D rPoly = baseWallThis.GetRightLine();
|
|
TGGeVisibilityPoly2D lPolyThat = baseWallThat.GetLeftLine();
|
|
TGGeVisibilityPoly2D rPolyThat = baseWallThat.GetRightLine();
|
|
|
|
BOOL nRet = FALSE; //函数状态，融合是否成功
|
|
bool bRetL = false; //左线是否修改
|
|
bool bRetR = false; //右线是否修改
|
|
|
|
AcGePoint3dArray ptArray, ptArray2, ptArray3, ptArray4;
|
|
int nRet1 = InterSectWith(lPoly, lPolyThat, ptArray, AcDb::kOnBothOperands);
|
|
int nRet2 = InterSectWith(lPoly, rPolyThat, ptArray2, AcDb::kOnBothOperands);
|
|
int nRet3 = InterSectWith(rPoly, lPolyThat, ptArray3, AcDb::kOnBothOperands);
|
|
int nRet4 = InterSectWith(rPoly, rPolyThat, ptArray4, AcDb::kOnBothOperands);
|
|
|
|
if (nRet1 && nRet2 && nRet3 && nRet4) //双线十字相交
|
|
{
|
|
if (baseWallThis.GetWeight() > baseWallThat.GetWeight())
|
|
{
|
|
return TRUE; //当前双线优先级高，无需修改
|
|
}
|
|
else
|
|
{
|
|
if (ptArray.length() > 0 && ptArray2.length() > 0)
|
|
{
|
|
//if(lPoly.PathDistance2d(ptArray[0]) > lPoly.PathDistance2d(ptArray2[0]))
|
|
//{
|
|
// lPoly.InsertNodeAt(ptArray2[0], AcDb::kInvisible);
|
|
// lPoly.InsertNodeAt(ptArray[0], AcDb::kVisible);
|
|
//}
|
|
//else
|
|
//{
|
|
// lPoly.InsertNodeAt(ptArray[0], AcDb::kInvisible);
|
|
// lPoly.InsertNodeAt(ptArray2[0], AcDb::kVisible);
|
|
//}
|
|
lPoly.InsertNodeAt(ptArray[0], ptArray2[0], AcDb::kInvisible);
|
|
bRetL = true;
|
|
}
|
|
|
|
if (ptArray3.length() > 0 && ptArray4.length() > 0)
|
|
{
|
|
//if(rPoly.PathDistance2d(ptArray3[0]) > rPoly.PathDistance2d(ptArray4[0]))
|
|
//{
|
|
// rPoly.InsertNodeAt(ptArray4[0], AcDb::kInvisible);
|
|
// rPoly.InsertNodeAt(ptArray3[0], AcDb::kVisible);
|
|
//}
|
|
//else
|
|
//{
|
|
// rPoly.InsertNodeAt(ptArray3[0], AcDb::kInvisible);
|
|
// rPoly.InsertNodeAt(ptArray4[0], AcDb::kVisible);
|
|
//}
|
|
rPoly.InsertNodeAt(ptArray3[0], ptArray4[0], AcDb::kInvisible);
|
|
bRetR = true;
|
|
}
|
|
}
|
|
}
|
|
else if (!(nRet1 || nRet2 || nRet3 || nRet4)) //不相交
|
|
{
|
|
return FALSE;
|
|
}
|
|
else //丁字相交
|
|
{
|
|
if ((nRet1 && nRet2) || (nRet3 && nRet4)) //丁字型中的横线
|
|
{
|
|
if (baseWallThis.GetWeight() == baseWallThat.GetWeight())
|
|
{
|
|
// 左线融合
|
|
if (ptArray.length() > 0 && ptArray2.length() > 0)
|
|
{
|
|
//if(lPoly.PathDistance2d(ptArray[0]) > lPoly.PathDistance2d(ptArray2[0]))
|
|
//{
|
|
// lPoly.InsertNodeAt(ptArray2[0], AcDb::kInvisible);
|
|
// lPoly.InsertNodeAt(ptArray[0], AcDb::kVisible);
|
|
//}
|
|
//else
|
|
//{
|
|
// lPoly.InsertNodeAt(ptArray[0], AcDb::kInvisible);
|
|
// lPoly.InsertNodeAt(ptArray2[0], AcDb::kVisible);
|
|
//}
|
|
lPoly.InsertNodeAt(ptArray[0], ptArray2[0], AcDb::kInvisible);
|
|
bRetL = true;
|
|
}
|
|
|
|
// 右线融合
|
|
if (ptArray3.length() > 0 && ptArray4.length() > 0)
|
|
{
|
|
//if(rPoly.PathDistance2d(ptArray3[0]) > rPoly.PathDistance2d(ptArray4[0]))
|
|
//{
|
|
// rPoly.InsertNodeAt(ptArray4[0], AcDb::kInvisible);
|
|
// rPoly.InsertNodeAt(ptArray3[0], AcDb::kVisible);
|
|
//}
|
|
//else
|
|
//{
|
|
// rPoly.InsertNodeAt(ptArray3[0], AcDb::kInvisible);
|
|
// rPoly.InsertNodeAt(ptArray4[0], AcDb::kVisible);
|
|
//}
|
|
rPoly.InsertNodeAt(ptArray3[0], ptArray4[0], AcDb::kInvisible);
|
|
bRetR = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return TRUE; //当前双线优先级不同，无需修改
|
|
}
|
|
}
|
|
else //丁字型竖线，不显示
|
|
{
|
|
if (nRet1 > 0)
|
|
{
|
|
double dist = lPoly.PathDistance2d(ptArray[0]);
|
|
if (dist < lPoly.GetLength() - dist) //起始端不可见
|
|
{
|
|
//lPoly.SetVisibleAt(0, AcDb::kInvisible);
|
|
//lPoly.InsertNodeAt(ptArray[0], AcDb::kVisible);
|
|
lPoly.InsertNodeAt(*lPoly[0], ptArray[0], AcDb::kInvisible);
|
|
}
|
|
else
|
|
{
|
|
//lPoly.InsertNodeAt(ptArray[0], AcDb::kInvisible);
|
|
lPoly.InsertNodeAt(ptArray[0], *lPoly[lPoly.Length()-1], AcDb::kInvisible);
|
|
}
|
|
bRetL = true;
|
|
}
|
|
|
|
if (nRet2 > 0)
|
|
{
|
|
double dist = lPoly.PathDistance2d(ptArray2[0]);
|
|
if (dist < lPoly.GetLength() - dist) //起始端不可见
|
|
{
|
|
//lPoly.SetVisibleAt(0, AcDb::kInvisible);
|
|
//lPoly.InsertNodeAt(ptArray2[0], AcDb::kVisible);
|
|
lPoly.InsertNodeAt(*lPoly[0], ptArray2[0], AcDb::kInvisible);
|
|
}
|
|
else
|
|
{
|
|
//lPoly.InsertNodeAt(ptArray2[0], AcDb::kInvisible);
|
|
lPoly.InsertNodeAt(ptArray2[0], *lPoly[lPoly.Length()-1], AcDb::kInvisible);
|
|
}
|
|
bRetL = true;
|
|
}
|
|
|
|
if (nRet3 > 0)
|
|
{
|
|
double dist = rPoly.PathDistance2d(ptArray3[0]);
|
|
if (dist < rPoly.GetLength() - dist) //起始端不可见
|
|
{
|
|
//rPoly.SetVisibleAt(0, AcDb::kInvisible);
|
|
//rPoly.InsertNodeAt(ptArray3[0], AcDb::kVisible);
|
|
rPoly.InsertNodeAt(*rPoly[0], ptArray3[0], AcDb::kInvisible);
|
|
}
|
|
else
|
|
{
|
|
//rPoly.InsertNodeAt(ptArray3[0], AcDb::kInvisible);
|
|
rPoly.InsertNodeAt(ptArray3[0], *rPoly[rPoly.Length()-1], AcDb::kInvisible);
|
|
}
|
|
bRetR = true;
|
|
}
|
|
|
|
if (nRet4 > 0)
|
|
{
|
|
double dist = rPoly.PathDistance2d(ptArray4[0]);
|
|
if (dist < rPoly.GetLength() - dist) //起始端不可见
|
|
{
|
|
//rPoly.SetVisibleAt(0, AcDb::kInvisible);
|
|
//rPoly.InsertNodeAt(ptArray4[0], AcDb::kVisible);
|
|
rPoly.InsertNodeAt(*rPoly[0], ptArray4[0], AcDb::kInvisible);
|
|
}
|
|
else
|
|
{
|
|
//rPoly.InsertNodeAt(ptArray4[0], AcDb::kInvisible);
|
|
rPoly.InsertNodeAt(ptArray4[0], *rPoly[rPoly.Length()-1], AcDb::kInvisible);
|
|
}
|
|
bRetR = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bRetL)
|
|
{
|
|
baseWallThis.SetLeftLine(lPoly);
|
|
nRet = TRUE;
|
|
}
|
|
|
|
if (bRetR)
|
|
{
|
|
baseWallThis.SetRightLine(rPoly);
|
|
nRet = TRUE;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
// 双线尾端融合，baseWall2为实际发生相交的线，只在转角的情况考虑优先级，多分支暂时不考虑
|
|
BOOL TBaseWallIntegrateTool::IntegrateAtTail(bool bStart, TBaseWallLine& baseWallThis, const TBaseWallLine& baseWallThat)
|
|
{
|
|
using namespace std;
|
|
TBaseWallLine* pSrcWall = &baseWallThis; // 原始墙线
|
|
const TBaseWallLine* pDesWall = &baseWallThat;
|
|
if (pSrcWall == NULL || pDesWall == NULL)
|
|
return FALSE;
|
|
|
|
TGGeVisibilityPoly2D& plSrcLeft = pSrcWall->GetLeftLine();
|
|
TGGeVisibilityPoly2D& plSrcRight = pSrcWall->GetRightLine();
|
|
TGGeVisibilityPoly2D& plDesLeft = pDesWall->GetLeftLine();
|
|
TGGeVisibilityPoly2D& plDesRight = pDesWall->GetRightLine();
|
|
const int iWeightSrc = pSrcWall->GetWeight();
|
|
const int iWeightDes = pDesWall->GetWeight();
|
|
TGGeVisibilityPoly2D plRetLeft, plRetRight;
|
|
|
|
vector<pair<TGGeVisibilityPoly2D*, TGGeVisibilityPoly2D*> > vPlRef;
|
|
if (!ConfirmRelation(iWeightSrc - iWeightDes, &plSrcLeft, &plSrcRight, &plDesLeft, &plDesRight, vPlRef, bStart))
|
|
return FALSE;
|
|
|
|
if (vPlRef.size() == 2)
|
|
{
|
|
pair<TGGeVisibilityPoly2D*, TGGeVisibilityPoly2D*>& pairTmp1 = vPlRef.at(0);
|
|
TGGeVisibilityPoly2D* pSrc1 = pairTmp1.first;
|
|
const TGGeVisibilityPoly2D* pDes1 = pairTmp1.second;
|
|
if (pSrc1 != NULL && pDes1 != NULL)
|
|
if (ModifyPoly2D(*pSrc1, *pDes1, bStart))
|
|
plRetLeft = *pSrc1;
|
|
|
|
pair<TGGeVisibilityPoly2D*, TGGeVisibilityPoly2D*>& pairTmp2 = vPlRef.at(1);
|
|
TGGeVisibilityPoly2D* pSrc2 = pairTmp2.first;
|
|
const TGGeVisibilityPoly2D* pDes2 = pairTmp2.second;
|
|
if (pSrc2 != NULL && pDes2 != NULL)
|
|
if (ModifyPoly2D(*pSrc2, *pDes2, bStart))
|
|
plRetRight = *pSrc2;
|
|
}
|
|
|
|
baseWallThis.SetLeftLine(plRetLeft);
|
|
baseWallThis.SetRightLine(plRetRight);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// 双线与poly2D的融合
|
|
// 返回值：FALSE：融合不成功；1:融合成功；
|
|
BOOL TBaseWallIntegrateTool::Integrate(TBaseWallLine& baseWall, const TGGePoly2D& polyHole)
|
|
{
|
|
TGGeVisibilityPoly2D lPoly = baseWall.GetLeftLine();
|
|
TGGeVisibilityPoly2D rPoly = baseWall.GetRightLine();
|
|
TGGePoly2D poly = polyHole;
|
|
if (lPoly.Length() > 0)
|
|
{
|
|
poly.SetElevation(lPoly[0]->z);
|
|
}
|
|
|
|
BOOL nRet = FALSE;
|
|
AcGePoint3dArray ptArray;
|
|
int nRet1 = InterSectWith(lPoly, poly, ptArray,AcDb::kOnBothOperands);
|
|
if (nRet1 == 2)
|
|
{
|
|
if(ptArray[0].distanceTo(ptArray[1]) > _DIST_SNAP)
|
|
{
|
|
lPoly.InsertNodeAt(ptArray[0], ptArray[1], AcDb::kInvisible);
|
|
baseWall.SetLeftLine(lPoly);
|
|
nRet = TRUE;
|
|
}
|
|
}
|
|
else if (nRet1 == 1) //1个交点时有可能交点是polyHole的顶点
|
|
{
|
|
TADSGePoint3d ptStart = *lPoly[0];
|
|
TADSGePoint3d ptEnd = *lPoly[lPoly.Length()-1];
|
|
if ((ptEnd & polyHole) == PR_INSIDE) //终止端在polyHole内部
|
|
{
|
|
lPoly.InsertNodeAt(ptArray[0], *lPoly[lPoly.Length()-1], AcDb::kInvisible);
|
|
baseWall.SetLeftLine(lPoly);
|
|
nRet = TRUE;
|
|
}
|
|
else if ((ptStart & polyHole) == PR_INSIDE) //起始端在polyHole内部
|
|
{
|
|
lPoly.InsertNodeAt(*lPoly[0], ptArray[0], AcDb::kInvisible);
|
|
baseWall.SetLeftLine(lPoly);
|
|
nRet = TRUE;
|
|
}
|
|
}
|
|
|
|
ptArray.setLogicalLength(0);
|
|
if (rPoly.Length() > 0)
|
|
{
|
|
poly.SetElevation(rPoly[0]->z);
|
|
}
|
|
|
|
nRet1 = InterSectWith(rPoly, poly, ptArray,AcDb::kOnBothOperands);
|
|
if (nRet1 == 2)
|
|
{
|
|
//if(rPoly.PathDistance2d(ptArray[0]) > rPoly.PathDistance2d(ptArray[1]))
|
|
//{
|
|
// rPoly.InsertNodeAt(ptArray[1], AcDb::kInvisible);
|
|
// rPoly.InsertNodeAt(ptArray[0], AcDb::kVisible);
|
|
//}
|
|
//else
|
|
//{
|
|
// rPoly.InsertNodeAt(ptArray[0], AcDb::kInvisible);
|
|
// rPoly.InsertNodeAt(ptArray[1], AcDb::kVisible);
|
|
//}
|
|
if(ptArray[0].distanceTo(ptArray[1]) > _DIST_SNAP)
|
|
{
|
|
rPoly.InsertNodeAt(ptArray[0], ptArray[1], AcDb::kInvisible);
|
|
baseWall.SetRightLine(rPoly);
|
|
nRet = TRUE;
|
|
}
|
|
}
|
|
else if (nRet1 == 1)
|
|
{
|
|
TADSGePoint3d ptStart = *rPoly[0];
|
|
if ((ptStart & polyHole) == PR_OUTSIDE) //终止端在polyHole内部
|
|
{
|
|
//rPoly.InsertNodeAt(ptArray[0], AcDb::kInvisible);
|
|
rPoly.InsertNodeAt(ptArray[0], *rPoly[rPoly.Length()-1], AcDb::kInvisible);
|
|
}
|
|
else
|
|
{
|
|
//rPoly.InsertNodeAt(ptArray[0], AcDb::kVisible);
|
|
//rPoly.SetVisibleAt(0, AcDb::kInvisible);
|
|
rPoly.InsertNodeAt(*rPoly[0], ptArray[0], AcDb::kInvisible);
|
|
}
|
|
baseWall.SetRightLine(rPoly);
|
|
nRet = TRUE;
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
int TBaseWallIntegrateTool::InterSectWith(const TGGePoly2D& polyThis, const TGGePoly2D& polyThat, AcGePoint3dArray &ptArray, AcDb::Intersect intType)
|
|
{
|
|
AcDbCurve* pCurveThis = polyThis.AsAcDbCurve();
|
|
AcDbCurve* pCurveThat = polyThat.AsAcDbCurve();
|
|
|
|
ptArray.setLogicalLength(0);
|
|
if (pCurveThis && pCurveThat)
|
|
{
|
|
pCurveThis->intersectWith(pCurveThat, intType, ptArray);
|
|
}
|
|
|
|
if (pCurveThis)
|
|
{
|
|
delete pCurveThis;
|
|
}
|
|
|
|
if (pCurveThat)
|
|
{
|
|
delete pCurveThat;
|
|
}
|
|
|
|
return ptArray.length();
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
const TGGePoly2D* TBaseWallIntegrateTool::GetNearestPoly2DByTail(const TGGePoly2D* plSrc, const TGGePoly2D* pl1, const TGGePoly2D* pl2, bool bNearest)
|
|
{
|
|
if (plSrc == NULL || pl1 == NULL || pl2 == NULL)
|
|
return NULL;
|
|
|
|
if (plSrc->TotalSegments() < 1 || pl1->TotalSegments() < 1 || pl2->TotalSegments() < 1)
|
|
return NULL;
|
|
|
|
// 构造plSrc尾端线段
|
|
const TGGePoly2D& SrcPline = *plSrc;
|
|
int iLen = SrcPline.TotalSegments();
|
|
const TADSGePoint3d& ptE = SrcPline[0]; // 从plSrc起始点计算到pl1和pl2的距离, 因为plSrc尾端可能在pl1和pl2的中间!
|
|
|
|
const TGGePoly2D& plDes1 = *pl1;
|
|
const TGGePoly2D& plDes2 = *pl2;
|
|
int idx(-1);
|
|
TGGeCurveSegment seg1(LS_INFINITE), seg2(LS_INFINITE);
|
|
if (!GetSegByNearestPt(plDes1, ptE, seg1, idx))
|
|
return FALSE;
|
|
if (!GetSegByNearestPt(plDes2, ptE, seg2, idx))
|
|
return FALSE;
|
|
|
|
TADSGePoint3d ptProj1, ptProj2;
|
|
seg1.ProjectToMe(ptE, ptProj1);
|
|
seg2.ProjectToMe(ptE, ptProj2);
|
|
|
|
double dDist1 = ptProj1.Distance2d(ptE);
|
|
double dDist2 = ptProj2.Distance2d(ptE);
|
|
if (bNearest)
|
|
return (dDist1 - dDist2 <= _DIST_SNAP) ? pl1 : pl2;
|
|
else
|
|
return (dDist1 - dDist2 <= _DIST_SNAP) ? pl2 : pl1;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const TGGePoly2D* TBaseWallIntegrateTool::GetDesPoly2D(const TGGePoly2D* plSrc,
|
|
const TGGePoly2D* pl1,
|
|
const TGGePoly2D* pl2,
|
|
bool bStart,
|
|
bool bNearest)
|
|
{
|
|
if (plSrc == NULL || pl1 == NULL || pl2 == NULL)
|
|
return NULL;
|
|
|
|
int iSrc = plSrc->TotalSegments();
|
|
int iDes1 = pl1->TotalSegments();
|
|
int iDes2 = pl2->TotalSegments();
|
|
if (iSrc < 1 || iDes2 < 1 || iDes1 < 1)
|
|
return NULL;
|
|
|
|
const AcGePoint3d& ptRef = bStart ? (*plSrc)[0] : (*plSrc)[iSrc]; // src上面定位指定端点
|
|
|
|
const TGGePoly2D& SrcPline = *plSrc;
|
|
const TGGePoly2D& plDes1 = *pl1;
|
|
const TGGePoly2D& plDes2 = *pl2;
|
|
|
|
int idx(-1);
|
|
TGGeCurveSegment seg1(LS_INFINITE), seg2(LS_INFINITE);
|
|
if (!GetSegByNearestPt(plDes1, ptRef, seg1, idx))
|
|
return FALSE;
|
|
if (!GetSegByNearestPt(plDes2, ptRef, seg2, idx))
|
|
return FALSE;
|
|
|
|
TADSGePoint3d ptProj1, ptProj2;
|
|
seg1.ProjectToMe(ptRef, ptProj1);
|
|
seg2.ProjectToMe(ptRef, ptProj2);
|
|
|
|
double dDist1 = ptProj1.Distance2d(ptRef);
|
|
double dDist2 = ptProj2.Distance2d(ptRef);
|
|
if (bNearest)
|
|
return (dDist1 - dDist2 <= _DIST_SNAP) ? pl1 : pl2;
|
|
else
|
|
return (dDist1 - dDist2 <= _DIST_SNAP) ? pl2 : pl1;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool TBaseWallIntegrateTool::ModifyPoly2D(TGGeVisibilityPoly2D& plSrc, const TGGeVisibilityPoly2D& plDes, bool bStart)
|
|
{
|
|
const int iSrcLen = plSrc.TotalSegments();
|
|
const int iDesLen = plDes.TotalSegments();
|
|
if (iSrcLen < 1 || iDesLen < 1)
|
|
return false;
|
|
|
|
AcGePoint3d& ptSrcRef = bStart ? *plSrc[0] : *plSrc[iSrcLen]; // 起点或者终点
|
|
TGGeCurveSegment segSrc(LS_INFINITE), segDes(LS_INFINITE);
|
|
// 获得src的延伸段儿
|
|
if (plSrc.Nth(bStart ? 0 : iSrcLen - 1, segSrc) != RTNORM)
|
|
return false;
|
|
|
|
// 选择des的延伸段儿
|
|
int iDes(-1);
|
|
if (!GetSegByNearestPt(plDes, ptSrcRef, segDes, iDes))
|
|
return false;
|
|
|
|
TGGeVisibilityPoly2D& pl = const_cast<TGGeVisibilityPoly2D&>(plDes);
|
|
double dLeft(0), dRight(0);
|
|
if (!(plSrc.GetIDirection(ptSrcRef, dLeft) && pl.GetIDirection(ptSrcRef, dRight)))
|
|
return false;
|
|
dLeft = AngleRangeTo2PI(dLeft - dRight);
|
|
if (fabs(dLeft - PI) < g_angleZero)
|
|
{
|
|
// 尾端平行情况
|
|
if (segSrc.Is(CURVE_LINE) && segDes.Is(CURVE_ARC))
|
|
{
|
|
const AcGePoint3d& ptDes = GetDesPt(ptSrcRef, *pl[0], *pl[iDesLen]);
|
|
TADSGePoint3d ptRet;
|
|
segSrc.ProjectToMe(ptDes, ptRet);
|
|
|
|
return MovePoly2DDesPt(plSrc, ptRet, bStart);
|
|
}
|
|
else if (segSrc.Is(CURVE_ARC))
|
|
return true; // src弧线不做任何修改
|
|
}
|
|
|
|
|
|
// 延伸求交点, 求出需要延伸到的1个交点
|
|
TADSGePoint3d ptExt1, ptExt2; // 延伸求交的两个点
|
|
int iRetExt = segSrc.Intersection(segDes, ptExt1, ptExt2);
|
|
if (iRetExt == 2)
|
|
ptExt1 = GetDesPt(ptSrcRef, ptExt1, ptExt2);
|
|
else if (iRetExt == 0)
|
|
{
|
|
// 没有交点, 进行投影求
|
|
const AcGePoint3d& ptVisual = GetDesPt(ptSrcRef, segDes.StartPoint(), segDes.EndPoint());
|
|
if (segSrc.ProjectToMe(ptVisual, ptExt1) != RTNORM)
|
|
return false;
|
|
}
|
|
|
|
// 移动多段线的端点
|
|
return MovePoly2DDesPt(plSrc, ptExt1, bStart);
|
|
}
|
|
|
|
// iSeg指示在原来多短线上面的第几段
|
|
// ptNearest距离pt最近的点
|
|
bool TBaseWallIntegrateTool::GetSegByNearestPt(const TGGePoly2D& plDes, const AcGePoint3d& pt, TGGeCurveSegment& seg, int& iSeg)
|
|
{
|
|
int iLen = plDes.TotalSegments();
|
|
if (iLen < 1)
|
|
return false;
|
|
|
|
const AcGePoint3d& ptS = plDes[0];
|
|
const AcGePoint3d& ptE = plDes[iLen];
|
|
|
|
double dDist1 = pt.distanceTo(ptS);
|
|
double dDist2 = pt.distanceTo(ptE);
|
|
|
|
iSeg = 0;
|
|
if (dDist2 - dDist1 < _DIST_SNAP)
|
|
{
|
|
iSeg = iLen - 1;
|
|
}
|
|
|
|
if (plDes.Nth(iSeg, seg) != RTNORM)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TBaseWallIntegrateTool::ConfirmRelation(int nEqual, TGGeVisibilityPoly2D* pSrcLeft, TGGeVisibilityPoly2D* pSrcRight, \
|
|
TGGeVisibilityPoly2D* pDesLeft, TGGeVisibilityPoly2D* pDesRight, \
|
|
std::vector<std::pair<TGGeVisibilityPoly2D*, TGGeVisibilityPoly2D*> >& vPlRef, \
|
|
bool bStart)
|
|
{
|
|
if (pSrcLeft == NULL || pSrcRight == NULL || pDesLeft == NULL || pDesRight == NULL)
|
|
return false;
|
|
|
|
int iLenLeft = pSrcLeft->TotalSegments();
|
|
int iLenRight = pSrcRight->TotalSegments();
|
|
int iDesLeft = pDesLeft->TotalSegments();
|
|
int iDesRight = pDesRight->TotalSegments();
|
|
if (iLenLeft < 1 || iLenRight < 1 || iDesLeft < 1 || iDesRight < 1)
|
|
return false;
|
|
|
|
const AcGePoint3d& ptSrcRef = bStart ? *(*pSrcLeft)[0] : *(*pSrcLeft)[iLenLeft]; // src左线参考点
|
|
const AcGePoint3d& ptDesS = *(*pDesLeft)[0]; // des起始点
|
|
const AcGePoint3d& ptDesE = *(*pDesLeft)[iDesLeft]; // des终止点
|
|
double dDist1 = ptSrcRef.distanceTo(ptDesS);
|
|
double dDist2 = ptSrcRef.distanceTo(ptDesE);
|
|
|
|
typedef std::pair<TGGeVisibilityPoly2D*, TGGeVisibilityPoly2D*> pairPLine;
|
|
pairPLine pair1, pair2;
|
|
|
|
bool bAsEqual(nEqual == 0);
|
|
if (dDist1 - dDist2 <= _DIST_SNAP)
|
|
{
|
|
// Des的起始端
|
|
if (nEqual != 0)
|
|
{
|
|
// 不等优先级
|
|
double dLeft(0), dRight(0);
|
|
if (!(pSrcLeft->GetIDirection(ptSrcRef, dLeft)&&pDesLeft->GetIDirection(ptSrcRef, dRight)))
|
|
return false;
|
|
dLeft = AngleRangeTo2PI(dLeft - dRight);
|
|
|
|
if (fabs(dLeft-PI) < g_angleZero)
|
|
{
|
|
// 尾端平行情况
|
|
bAsEqual = true;
|
|
}
|
|
else
|
|
{
|
|
TGGeCurveSegment segSrcL(LS_INFINITE), segSrcR(LS_INFINITE), segDes(LS_INFINITE);
|
|
pSrcLeft->Nth(bStart ? 0 : iLenLeft - 1, segSrcL);
|
|
pSrcRight->Nth(bStart ? 0 : iLenRight - 1, segSrcR);
|
|
|
|
if (dLeft < PI)
|
|
{
|
|
if (nEqual < 0)
|
|
{
|
|
pDesLeft->Nth(iDesLeft - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesLeft);
|
|
pair2 = pairPLine(pSrcRight, pDesLeft);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDesRight->Nth(iDesRight - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesRight);
|
|
pair2 = pairPLine(pSrcRight, pDesRight);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nEqual < 0)
|
|
{
|
|
pDesRight->Nth(iDesRight - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesRight);
|
|
pair2 = pairPLine(pSrcRight, pDesRight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDesLeft->Nth(iDesLeft - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesLeft);
|
|
pair2 = pairPLine(pSrcRight, pDesLeft);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bAsEqual)
|
|
{
|
|
// 等优先级处理
|
|
if (bStart)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesRight);
|
|
pair2 = pairPLine(pSrcRight, pDesLeft);
|
|
}
|
|
else
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesLeft);
|
|
pair2 = pairPLine(pSrcRight, pDesRight);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Des的终止端
|
|
if (nEqual != 0)
|
|
{
|
|
double dLeft(0), dRight(0);
|
|
if (!(pSrcLeft->GetIDirection(ptSrcRef, dLeft)&&pDesLeft->GetIDirection(ptSrcRef, dRight)))
|
|
return false;
|
|
dLeft = AngleRangeTo2PI(dLeft - dRight);
|
|
|
|
if (fabs(dLeft-PI) < g_angleZero)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
else
|
|
{
|
|
TGGeCurveSegment segSrcL(LS_INFINITE), segSrcR(LS_INFINITE), segDes(LS_INFINITE);
|
|
pSrcLeft->Nth(bStart ? 0 : iLenLeft - 1, segSrcL);
|
|
pSrcRight->Nth(bStart ? 0 : iLenRight - 1, segSrcR);
|
|
|
|
if (dLeft < PI)
|
|
{
|
|
if (nEqual < 0)
|
|
{
|
|
pDesRight->Nth(iDesRight - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesRight);
|
|
pair2 = pairPLine(pSrcRight, pDesRight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDesLeft->Nth(iDesLeft - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesLeft);
|
|
pair2 = pairPLine(pSrcRight, pDesLeft);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nEqual < 0)
|
|
{
|
|
pDesLeft->Nth(iDesLeft - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesLeft);
|
|
pair2 = pairPLine(pSrcRight, pDesLeft);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pDesRight->Nth(iDesRight - 1, segDes);
|
|
if (segSrcL.Is(CURVE_ARC)||segDes.Is(CURVE_ARC))
|
|
{
|
|
if (segDes.Intersection(segSrcL, TADSGePoint3d(), TADSGePoint3d()) == 0 || segDes.Intersection(segSrcR, TADSGePoint3d(), TADSGePoint3d()) == 0)
|
|
{
|
|
bAsEqual = true;
|
|
}
|
|
}
|
|
|
|
if (!bAsEqual)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesRight);
|
|
pair2 = pairPLine(pSrcRight, pDesRight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bAsEqual)
|
|
{
|
|
if (bStart)
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesLeft);
|
|
pair2 = pairPLine(pSrcRight, pDesRight);
|
|
}
|
|
else
|
|
{
|
|
pair1 = pairPLine(pSrcLeft, pDesRight);
|
|
pair2 = pairPLine(pSrcRight, pDesLeft);
|
|
}
|
|
}
|
|
}
|
|
|
|
vPlRef.push_back(pair1);
|
|
vPlRef.push_back(pair2);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TBaseWallIntegrateTool::GetCenterPoly(const TGGePoly2D& pl1, const TGGePoly2D& pl2, TGGePoly2D& plRet)
|
|
{
|
|
if (pl1.TotalSegments() == pl2.TotalSegments())
|
|
{
|
|
AcGePoint3d ptMid;
|
|
plRet.Reset();
|
|
for (int i = 0; i < pl1.Length(); i++)
|
|
{
|
|
Midpoint(pl1[i], pl2[i], ptMid);
|
|
plRet.AppendNode(ptMid, pl1.GetBulge(i));
|
|
}
|
|
|
|
return plRet.Length() > 0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool TBaseWallIntegrateTool::GetCenterPoly(const TGGeCurveSegment& seg1, const TGGeCurveSegment& seg2, TGGeCurveSegment& segRet)
|
|
{
|
|
Midpoint(seg1.StartPoint(), seg2.StartPoint(), segRet.StartPoint());
|
|
Midpoint(seg1.EndPoint(), seg2.EndPoint(), segRet.EndPoint());
|
|
segRet.SetBulge(seg1.GetBulge());
|
|
|
|
return true;
|
|
}
|
|
|
|
AcGePoint3d& TBaseWallIntegrateTool::GetDesPt(const AcGePoint3d& ptGiven, const AcGePoint3d& ptDesc1, const AcGePoint3d& ptDesc2, bool bNearest)
|
|
{
|
|
double dDist1 = ptGiven.distanceTo(ptDesc1);
|
|
double dDist2 = ptGiven.distanceTo(ptDesc2);
|
|
|
|
if (bNearest)
|
|
return (AcGePoint3d&)(dDist1 - dDist2 <= _DIST_SNAP ? ptDesc1 : ptDesc2);
|
|
|
|
return (AcGePoint3d&)(dDist1 - dDist2 <= _DIST_SNAP ? ptDesc2 : ptDesc1);
|
|
}
|
|
|
|
bool TBaseWallIntegrateTool::GetLeftPoly2D(TGGeVisibilityPoly2D& pl1, TGGeVisibilityPoly2D& pl2)
|
|
{
|
|
if (pl1.TotalSegments() < 1 || pl2.TotalSegments() < 1)
|
|
return false;
|
|
|
|
const AcGePoint3d& ptS1 = *pl1[0];
|
|
const AcGePoint3d& ptS2 = *pl2[0];
|
|
|
|
TGGeCurveSegment seg;
|
|
if (pl1.Nth(0, seg) != RTNORM)
|
|
return false;
|
|
int iRet = seg.OnWhichSide1(ptS2);
|
|
if (seg.Is(CURVE_LINE))
|
|
{
|
|
if (iRet == 0)
|
|
{
|
|
// pl2在左侧
|
|
TGGeVisibilityPoly2D plTmp = pl1;
|
|
pl1 = pl2;
|
|
pl2 = plTmp;
|
|
}
|
|
}
|
|
else if (seg.Is(CURVE_ARC))
|
|
{
|
|
if (seg.StartPoint().Distance2d(ptS1) <= _DIST_SNAP)
|
|
{
|
|
// 弧线的起点就是多段线起点
|
|
if (iRet == 0)
|
|
{
|
|
TGGeVisibilityPoly2D plTmp = pl1;
|
|
pl1 = pl2;
|
|
pl2 = plTmp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 弧线的起点就是多段线终点
|
|
if (iRet == 1)
|
|
{
|
|
TGGeVisibilityPoly2D plTmp = pl1;
|
|
pl1 = pl2;
|
|
pl2 = plTmp;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TBaseWallIntegrateTool::MovePoly2DDesPt(TGGeVisibilityPoly2D& pl, const TADSGePoint3d& ptGiven, bool bStart)
|
|
{
|
|
int iLen = pl.TotalSegments();
|
|
if (iLen < 1)
|
|
return false;
|
|
|
|
TGGeCurveSegment seg(0);
|
|
if (pl.Nth(bStart ? 0 : iLen - 1, seg) != RTNORM)
|
|
return false;
|
|
|
|
AcGePoint3d& ptMove = *pl[bStart ? 0 : iLen];
|
|
|
|
if (seg.Is(CURVE_ARC))
|
|
{
|
|
// 弧线修正凸度值
|
|
TGGeArc arc = seg.GetArc();
|
|
if (fabs(ptGiven.Distance2d(arc.GetCenterPt()) - arc.GetRadius()) <= _DIST_SNAP)
|
|
{
|
|
// 点在圆上
|
|
|
|
// 多段线的有序两个点
|
|
const TADSGePoint3d& ptPlTo = bStart ? *pl[1] : *pl[iLen];
|
|
const TADSGePoint3d& ptPlFrom = bStart ? *pl[0] : *pl[iLen - 1];
|
|
|
|
TADSGePoint3d pt;
|
|
arc.GetStartPoint(pt);
|
|
const TADSGePoint3d ptCenter = arc.GetCenterPt();
|
|
double dAngle = 0.0;
|
|
|
|
AcGeVector3d vt1 = AcGeVector3d::kIdentity;
|
|
AcGeVector3d vt2 = AcGeVector3d::kIdentity;
|
|
if (!bStart)
|
|
{
|
|
// 修改多段线终点
|
|
|
|
if (ptPlFrom.Distance2d(pt) <= _DIST_SNAP)
|
|
{
|
|
// pl逆时针绘制
|
|
vt1 = ptPlFrom - ptCenter;
|
|
vt2 = ptGiven - ptCenter;
|
|
}
|
|
else
|
|
{
|
|
// pl顺时针绘制
|
|
vt1 = ptGiven - ptCenter;
|
|
vt2 = ptPlFrom - ptCenter;
|
|
}
|
|
|
|
dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
// 修改多段线起点
|
|
|
|
if (ptPlFrom.Distance2d(pt) <= _DIST_SNAP)
|
|
{
|
|
// pl逆时针绘制
|
|
vt1 = ptGiven - ptCenter;
|
|
vt2 = ptPlTo - ptCenter;
|
|
}
|
|
else
|
|
{
|
|
// pl顺时针绘制
|
|
vt1 = ptPlTo - ptCenter;
|
|
vt2 = ptGiven - ptCenter;
|
|
}
|
|
|
|
dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
}
|
|
|
|
|
|
double dBugle = tan(dAngle / 4);
|
|
|
|
// 根据原弧的凸度正负值确定新弧凸度值
|
|
int idx = bStart ? 0 : iLen - 1;
|
|
double dBugleTmp = tan((pl.GetBulge(idx)) / 4);
|
|
dBugle = dBugleTmp > g_fZero ? fabs(dBugle) : fabs(dBugle) * (-1);
|
|
dAngle = atan(dBugle) * 4;
|
|
|
|
pl.SetBulge(idx, dAngle);
|
|
}
|
|
}
|
|
|
|
ptMove = ptGiven;
|
|
|
|
return true;
|
|
}
|
|
|
|
// 取得指向poly内部的方向，线和弧不支持圆，pt：起点或终点，dDir:方向弧度
|
|
// 返回值：true：成功，false：失败
|
|
// 对arBaseWallLines数组以bwLine为基准，逆时针排序
|
|
void TBaseWallIntegrateTool::SortBwl(bool bStart,const TBaseWallLine & bwLine,TDPtrList<TBaseWallLine>& arBaseWallLines)
|
|
{
|
|
if (arBaseWallLines.Length() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TGGeVisibilityPoly2D vPoly = bwLine.GetLeftLine();
|
|
if (vPoly.Length() < 2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGeVector3d vcBase;
|
|
AcGePoint3d ptInter;
|
|
TGGeCurveSegment cvSeg;
|
|
if (bStart)
|
|
{
|
|
ptInter = *vPoly[0];
|
|
}
|
|
else
|
|
{
|
|
ptInter = *vPoly[vPoly.Length()-1];
|
|
}
|
|
|
|
double dDir=0;
|
|
if(!vPoly.GetIDirection(ptInter, dDir))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//建立数组
|
|
double dParam = 0.0;
|
|
BaseWallLineParam bwlParam;
|
|
std::vector<BaseWallLineParam> vtBwlParams;
|
|
|
|
double dIDir = 0;
|
|
for (int i = 0;i < arBaseWallLines.Length();i++)
|
|
{
|
|
TBaseWallLine bwl = *arBaseWallLines[i];
|
|
if (!bwl.GetLeftLine().GetIDirection(ptInter ,dIDir))
|
|
{
|
|
continue;
|
|
}
|
|
if (dDir > dIDir)
|
|
{
|
|
dIDir += 2.0*PI;
|
|
}
|
|
|
|
bwlParam.dParam = dIDir;
|
|
bwlParam.baseWallLine = bwl;
|
|
vtBwlParams.push_back(bwlParam);
|
|
}
|
|
|
|
//排序
|
|
std::sort(vtBwlParams.begin(),vtBwlParams.end(),GreaterCompare);
|
|
|
|
//调整
|
|
arBaseWallLines.Reset();
|
|
typedef std::vector<BaseWallLineParam>::iterator IT;
|
|
for (IT it = vtBwlParams.begin();it != vtBwlParams.end();it++)
|
|
{
|
|
TBaseWallLine *pBwl = new TBaseWallLine();
|
|
*pBwl = (*it).baseWallLine;
|
|
arBaseWallLines.Append(pBwl);
|
|
}
|
|
}
|
|
|
|
// 优先级数组
|
|
void TBaseWallIntegrateTool::GetStyleKindArray(const TDPtrList<TBaseWallLine>& arBaseWallLines, AcDbIntArray& intArray)
|
|
{
|
|
int nStyle = 0;
|
|
for (int i = 0; i < arBaseWallLines.Length(); i++)
|
|
{
|
|
nStyle = arBaseWallLines[i].GetWeight();
|
|
if (!intArray.contains(nStyle))
|
|
{
|
|
intArray.append(nStyle);
|
|
}
|
|
}
|
|
}
|
|
// 获得与nThisStyle同优先级的双线数
|
|
// 返回值：与nThisStyle同优先级的双线个数
|
|
int TBaseWallIntegrateTool::GetStyleCount(int nThisStyle, const TDPtrList<TBaseWallLine>& arBaseWallLines)
|
|
{
|
|
int nCount = 0;
|
|
for (int i = 0; i < arBaseWallLines.Length(); i++)
|
|
{
|
|
if (arBaseWallLines[i].GetWeight() == nThisStyle)
|
|
{
|
|
nCount++;
|
|
}
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
// 获得另外一种材质的优先级
|
|
// 返回值：与nThisStyle不同材质的双线的优先级
|
|
int TBaseWallIntegrateTool::GetAnotherStyle(int nThisStyle, const TDPtrList<TBaseWallLine>& arBaseWallLines)
|
|
{
|
|
for (int i = 0; i < arBaseWallLines.Length(); i++)
|
|
{
|
|
int iWeight = arBaseWallLines[i].GetWeight();
|
|
if (iWeight != nThisStyle)
|
|
{
|
|
return iWeight;
|
|
}
|
|
}
|
|
|
|
return nThisStyle;
|
|
}
|
|
// 正或反方向获得同优先级的关联双线
|
|
bool TBaseWallIntegrateTool::GetSameStyleLine(int nThisStyle, BOOL bReverse, const TDPtrList<TBaseWallLine> &arBaseWallLines, TBaseWallLine& bwl)
|
|
{
|
|
bool bRet = false;
|
|
if (bReverse)
|
|
{
|
|
// 反向
|
|
for (int i = arBaseWallLines.Length() - 1; i >= 0; i--)
|
|
{
|
|
TBaseWallLine wall = arBaseWallLines[i];
|
|
if (wall.GetWeight() == nThisStyle)
|
|
{
|
|
bwl = wall;
|
|
bRet = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 正向
|
|
for (int i = 0; i < arBaseWallLines.Length(); i++)
|
|
{
|
|
TBaseWallLine wall = arBaseWallLines[i];
|
|
if (wall.GetWeight() == nThisStyle)
|
|
{
|
|
bwl = wall;
|
|
bRet = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
// 双线尾端融合，baseWallThis为实际发生相交的线，arBaseWallLine为关联双线数组,支持多分支
|
|
// 多分支常规情况为1种材料；多分支超过2种材质暂不处理；
|
|
// 2种材料:以双线数多的材质为优先级高，数目相同时，以实际材质优先级为准
|
|
// 返回值：TRUE:成功；FALSE:失败
|
|
BOOL TBaseWallIntegrateTool::IntegrateAtTail(bool bStart, TBaseWallLine& baseWallThis, const TDPtrList<TBaseWallLine>& arBaseWallLine)
|
|
{
|
|
TDPtrList<TBaseWallLine> arBaseWallLines;
|
|
arBaseWallLines.copyFrom(arBaseWallLine);
|
|
|
|
int nLength = arBaseWallLines.Length();
|
|
if (nLength == 1)
|
|
{
|
|
return TBaseWallIntegrateTool::IntegrateAtTail(bStart, baseWallThis, *arBaseWallLines[0]);
|
|
}
|
|
else if (nLength < 1)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// 排序
|
|
SortBwl(bStart, baseWallThis, arBaseWallLines);
|
|
|
|
AcDbIntArray intArray;
|
|
GetStyleKindArray(arBaseWallLines, intArray);
|
|
|
|
int nThisStyle = baseWallThis.GetWeight();
|
|
if (!intArray.contains(nThisStyle))
|
|
{
|
|
intArray.append(nThisStyle);
|
|
}
|
|
|
|
bool bSuccess = false;
|
|
TBaseWallLine bwlS,bwlE; //正,反方向关联双线
|
|
|
|
int nKindCount = intArray.length();
|
|
if (nKindCount > 2) //超过2种以上的材料,暂不处理
|
|
{
|
|
|
|
}
|
|
else if (nKindCount == 1) //常规情况
|
|
{
|
|
bwlS = *arBaseWallLines[0];
|
|
bwlE = *arBaseWallLines[arBaseWallLines.Length()-1];
|
|
bSuccess = true;
|
|
}
|
|
else //2种材料
|
|
{
|
|
int nThisStyleCount = GetStyleCount(nThisStyle, arBaseWallLines);
|
|
int nOtherStyleCount = arBaseWallLines.Length()-nThisStyleCount;
|
|
nThisStyleCount++; //包括自己
|
|
|
|
BOOL bAdvance = TRUE;
|
|
if (nThisStyleCount > nOtherStyleCount) //当前优先
|
|
{
|
|
|
|
}
|
|
else if (nThisStyleCount == nOtherStyleCount)
|
|
{
|
|
int stOther = GetAnotherStyle(nThisStyle, arBaseWallLines);
|
|
if (nThisStyle < stOther)
|
|
{
|
|
bAdvance = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bAdvance = FALSE;
|
|
}
|
|
|
|
// 确定关联双线
|
|
if (bAdvance) //按正或反方向找同优先级双线
|
|
{
|
|
if(GetSameStyleLine(nThisStyle, FALSE, arBaseWallLines, bwlS))
|
|
{
|
|
bSuccess = true;
|
|
}
|
|
|
|
if(!GetSameStyleLine(nThisStyle, TRUE, arBaseWallLines, bwlE))
|
|
{
|
|
if (bSuccess)
|
|
{
|
|
bSuccess = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bwlS = *arBaseWallLines[0];
|
|
bwlE = *arBaseWallLines[arBaseWallLines.Length()-1];
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
|
|
if (!bSuccess)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
TGGeVisibilityPoly2D polyLeft = baseWallThis.GetLeftLine();
|
|
TGGeVisibilityPoly2D polyRight = baseWallThis.GetRightLine();
|
|
|
|
if(bStart)
|
|
{
|
|
TADSGePoint3d pt = *polyLeft[0];
|
|
|
|
//左线融合
|
|
TGGeVisibilityPoly2D vPoly = bwlS.GetLeftLine();
|
|
if (pt.Distance(*vPoly[0]) < pt.Distance(*vPoly[vPoly.Length()-1]))//连接vPoly起始端
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyLeft, bwlS.GetRightLine(), bStart);
|
|
}
|
|
else
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyLeft, vPoly, bStart);
|
|
}
|
|
|
|
// 右线融合
|
|
vPoly = bwlE.GetLeftLine();
|
|
if (pt.Distance(*vPoly[0]) < pt.Distance(*vPoly[vPoly.Length()-1]))//连接vPoly起始端
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyRight, vPoly, bStart);
|
|
}
|
|
else
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyRight, bwlE.GetRightLine(), bStart);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TADSGePoint3d pt = *polyLeft[polyLeft.Length()-1];
|
|
|
|
//左线融合
|
|
TGGeVisibilityPoly2D vPoly = bwlE.GetLeftLine();
|
|
if (pt.Distance(*vPoly[0]) < pt.Distance(*vPoly[vPoly.Length()-1]))//连接vPoly起始端
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyLeft, vPoly, bStart);
|
|
}
|
|
else
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyLeft, bwlE.GetRightLine(), bStart);
|
|
}
|
|
|
|
// 右线融合
|
|
vPoly = bwlS.GetLeftLine();
|
|
if (pt.Distance(*vPoly[0]) < pt.Distance(*vPoly[vPoly.Length()-1]))//连接vPoly起始端
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyRight, bwlS.GetRightLine(), bStart);
|
|
}
|
|
else
|
|
{
|
|
TBaseWallIntegrateTool::ModifyPoly2D(polyRight, vPoly,bStart);
|
|
}
|
|
}
|
|
|
|
baseWallThis.SetLeftLine(polyLeft);
|
|
baseWallThis.SetRightLine(polyRight);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TBaseWallIntegrateTool::IsIntegrate(TGGeLine &line1, TGGeLine &line2, double dSkipDistTol, double dTotalWidth)
|
|
{
|
|
bool bRet = false;
|
|
line1.m_nFlag = 1;
|
|
line2.m_nFlag = 1;
|
|
AcGeVector3d vt1 = line1.StartPoint() - line1.EndPoint();
|
|
AcGeVector3d vt2 = line2.StartPoint() - line2.EndPoint();
|
|
if (vt1.isParallelTo(vt2)) // 平行
|
|
{
|
|
TADSGePoint3d ptMid1, ptMid2, ptMid;
|
|
Midpoint(line1.StartPoint(), line1.EndPoint(), ptMid1);
|
|
Midpoint(line2.StartPoint(), line2.EndPoint(), ptMid2);
|
|
ptMid1.Project(&line2,ptMid);
|
|
double d =ptMid.Distance(ptMid2);
|
|
double dd = ptMid.Distance(ptMid1);
|
|
if (ptMid.Distance(ptMid2) < dTotalWidth * 0.5 // 两平行直线，一条直线到另一条直线的垂直投影是否有重合部分
|
|
&& ptMid.Distance(ptMid1) < dSkipDistTol) // 平行直线间距
|
|
{
|
|
bRet = true;
|
|
}
|
|
}
|
|
else if (line1.Intersection(&line2, TADSGePoint3d()) > 0) // 相交
|
|
{
|
|
bRet = true;
|
|
}
|
|
else // 延长线上相交
|
|
{
|
|
if (LineToLineDist(line1, line2) < dSkipDistTol) // 非相交直线的最短距离在误差范围内
|
|
{
|
|
bRet = true;
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
// 判断是否是端点融合
|
|
// 返回值：0：两端不相交；1:起始端相交；2：终止端相交；3：两端都相交；
|
|
int TBaseWallIntegrateTool::IsIntegrateAtTail(const TBaseWallLine& baseWallThis, const TBaseWallLine& baseWallThat)
|
|
{
|
|
int nRet = 0;
|
|
TGGeVisibilityPoly2D lPoly = baseWallThis.GetLeftLine();
|
|
TGGeVisibilityPoly2D rPoly = baseWallThis.GetRightLine();
|
|
TGGeVisibilityPoly2D lPolyThat = baseWallThat.GetLeftLine();
|
|
TGGeVisibilityPoly2D rPolyThat = baseWallThat.GetRightLine();
|
|
if (lPoly.TotalSegments() != 1 || rPoly.TotalSegments() != 1 || lPolyThat.TotalSegments() != 1 || rPolyThat.TotalSegments() != 1) // 墙线必须为一段线段（直线或弧线）
|
|
{
|
|
return nRet;
|
|
}
|
|
|
|
TGGeLine lineThisS(*(lPoly[0]), *(rPoly[0])); // 由墙线this起点构造直线
|
|
TGGeLine lineThisE(*(lPoly[1]), *(rPoly[1])); // 由墙线this终点构造直线
|
|
TGGeLine lineThatS(*(lPolyThat[0]), *(rPolyThat[0])); // 由墙线that起点构造直线
|
|
TGGeLine lineThatE(*(lPolyThat[1]), *(rPolyThat[1])); // 由墙线that终点构造直线
|
|
|
|
// 墙体宽度
|
|
TADSGePoint3d &ptWallThisLS = *(rPoly[0]), &ptWallThisRS = *(lPoly[0]); // baseWallThis的起点
|
|
TADSGePoint3d &ptWallThatLS = *(lPolyThat[0]), &ptWallThatRS = *(rPolyThat[0]); // baseWallThat的起点
|
|
double dWallThisWidth = ptWallThisLS.Distance(ptWallThisRS);
|
|
double dWallThatWidth = ptWallThatLS.Distance(ptWallThatRS);
|
|
|
|
double dSkipDistTol = dWallThisWidth > dWallThatWidth ? dWallThisWidth * 0.5 : dWallThatWidth * 0.5; // 可以融合时的最大误差值
|
|
double dTotalWidth = dWallThatWidth + dWallThisWidth;
|
|
// 墙体baseWallThis的起始端点处是否与墙体baseWallThat的起始端点处能融合
|
|
bool bInterSS = IsIntegrate(lineThisS, lineThatS, dSkipDistTol, dTotalWidth);
|
|
|
|
// 墙体baseWallThis的起始端点处是否与墙体baseWallThat的终止端点处能融合
|
|
bool bInterSE = IsIntegrate(lineThisS, lineThatE, dSkipDistTol, dTotalWidth);
|
|
|
|
// 墙体baseWallThis的终止端点处是否与墙体baseWallThat的起始端点处能融合
|
|
bool bInterES = IsIntegrate(lineThisE, lineThatS, dSkipDistTol, dTotalWidth);
|
|
|
|
// 墙体baseWallThis的终止端点处是否与墙体baseWallThat的终止端点处能融合
|
|
bool bInterEE = IsIntegrate(lineThisE, lineThatE, dSkipDistTol, dTotalWidth);
|
|
|
|
if (bInterSS && !bInterEE || bInterSE && !bInterES) // 起始端相交
|
|
{
|
|
nRet = 1;
|
|
}
|
|
else if (!bInterSS && bInterEE || !bInterSE && bInterES) // 终止端相交
|
|
{
|
|
nRet = 2;
|
|
}
|
|
else if (bInterSS && bInterEE || bInterSE && bInterES) // 两端都相交
|
|
{
|
|
nRet = 3;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
// 直线与直线间距算法(无交点)：首先，取两直线端点相互投影，当投影点在在直线上时，保留该点与投影点之间的距离；
|
|
// 其次，分别计算两直线端点间的距离；最后，取上述值中的最小值即为直线间距。
|
|
double TBaseWallIntegrateTool::LineToLineDist(const TGGeLine &line1, const TGGeLine &line2)
|
|
{
|
|
std::vector<double> vecDist;
|
|
TADSGePoint3d &ptS1 = line1.StartPoint(), &ptE1 = line1.EndPoint();
|
|
TADSGePoint3d &ptS2 = line2.StartPoint(), &ptE2 = line2.EndPoint();
|
|
double dLen1 = line1.GetLength(), dLen2 = line2.GetLength();
|
|
TADSGePoint3d pt; //投影点
|
|
ptS1.Project(&line2, pt);
|
|
if (fabs(pt.Distance(ptS2) + pt.Distance(ptE2) -dLen2) < g_distZero) // 投影点在直线上
|
|
{
|
|
vecDist.push_back(pt.Distance(ptS1));
|
|
}
|
|
|
|
ptE1.Project(&line2, pt);
|
|
if (fabs(pt.Distance(ptS2) + pt.Distance(ptE2) -dLen2) < g_distZero) // 投影点在直线上
|
|
{
|
|
vecDist.push_back(pt.Distance(ptE1));
|
|
}
|
|
|
|
ptS2.Project(&line1, pt);
|
|
if (fabs(pt.Distance(ptS1) + pt.Distance(ptE1) -dLen1) < g_distZero) // 投影点在直线上
|
|
{
|
|
vecDist.push_back(pt.Distance(ptS2));
|
|
}
|
|
|
|
ptE2.Project(&line1, pt);
|
|
if (fabs(pt.Distance(ptS1) + pt.Distance(ptE1) -dLen1) < g_distZero) // 投影点在直线上
|
|
{
|
|
vecDist.push_back(pt.Distance(ptE2));
|
|
}
|
|
|
|
// 直线端点间距
|
|
vecDist.push_back(ptS1.Distance(ptS2));
|
|
vecDist.push_back(ptS1.Distance(ptE2));
|
|
vecDist.push_back(ptE1.Distance(ptS2));
|
|
vecDist.push_back(ptE1.Distance(ptE2));
|
|
|
|
double dDist = 0.0;
|
|
std::vector<double>::iterator it;
|
|
it = std::min_element(vecDist.begin(), vecDist.end());
|
|
if (it != vecDist.end())
|
|
{
|
|
dDist = *it;
|
|
}
|
|
|
|
return dDist;
|
|
}
|
|
|
|
// 直线与弧线间距算法(无交点):1.取直线端点向弧线做投影，当投影点在弧线上时，保留端点到投影点的距离
|
|
// 2,取弧线的端点向直线做投影，当投影点在直线上时，保留端点到投影点的距离 3. 取弧线圆心点向直线做投影，
|
|
// 当投影点在直线上并且圆心点和投影点连线与弧线有交点时，保留交点与投影点的距离 4.计算直线与弧线端点间距
|
|
// 5. 取上述值中最小值即为直线与弧线间距
|
|
double TBaseWallIntegrateTool::LineToArcDist(const TGGeLine &line, const TGGeArc &arc)
|
|
{
|
|
std::vector<double> vecDist;
|
|
TADSGePoint3d &ptS1 = line.StartPoint(), &ptE1 = line.EndPoint();
|
|
TADSGePoint3d pt; //投影点
|
|
// line的起点到arc的投影
|
|
ptS1.Project(&arc, pt);
|
|
if (arc.PtOnArc(pt))
|
|
{
|
|
vecDist.push_back(pt.Distance(ptS1)) ;
|
|
}
|
|
|
|
// line的终点到arc的投影
|
|
ptE1.Project(&arc, pt);
|
|
if (arc.PtOnArc(pt))
|
|
{
|
|
vecDist.push_back(pt.Distance(ptE1)) ;
|
|
}
|
|
|
|
// 弧的圆心到线的投影
|
|
double dLen = line.GetLength();
|
|
TADSGePoint3d ptCenter = arc.GetCenterPt();
|
|
ptCenter.Project(&line, pt);
|
|
if (fabs(pt.Distance(ptS1) + pt.Distance(ptE1) -dLen) < g_distZero) // 投影点在直线上
|
|
{
|
|
TGGeLine lineTemp(ptCenter, pt);
|
|
lineTemp.m_nFlag = 1;
|
|
if (arc.Intersection(&lineTemp) > 0)
|
|
{
|
|
vecDist.push_back(fabs(pt.Distance(ptCenter) - arc.GetRadius())) ;
|
|
}
|
|
}
|
|
|
|
// 弧起点
|
|
TADSGePoint3d ptTemp;
|
|
arc.GetStartPoint(ptTemp);
|
|
ptTemp.Project(&line, pt);
|
|
if (fabs(pt.Distance(ptS1) + pt.Distance(ptE1) -dLen) < g_distZero) // 投影点在直线上
|
|
{
|
|
vecDist.push_back(ptTemp.Distance(pt));
|
|
}
|
|
|
|
// 弧终点
|
|
arc.GetEndPoint(ptTemp);
|
|
ptTemp.Project(&line, pt);
|
|
if (fabs(pt.Distance(ptS1) + pt.Distance(ptE1) -dLen) < g_distZero) // 投影点在直线上
|
|
{
|
|
vecDist.push_back(ptTemp.Distance(pt));
|
|
}
|
|
|
|
// 直线与弧线端点间距
|
|
arc.GetStartPoint(ptTemp);
|
|
vecDist.push_back(ptTemp.Distance(ptS1));
|
|
vecDist.push_back(ptTemp.Distance(ptE1));
|
|
arc.GetEndPoint(ptTemp);
|
|
vecDist.push_back(ptTemp.Distance(ptS1));
|
|
vecDist.push_back(ptTemp.Distance(ptE1));
|
|
|
|
double dDist = 0.0;
|
|
std::vector<double>::iterator it;
|
|
it = std::min_element(vecDist.begin(), vecDist.end());
|
|
if (it != vecDist.end())
|
|
{
|
|
dDist = *it;
|
|
}
|
|
|
|
return dDist;
|
|
}
|
|
|
|
// 弧线与弧线间距算法(无交点): 1.弧线端点相互投影，当投影点在弧线上时，保留端点到投影点的距离
|
|
// 2. 取弧线的圆心点向另一条弧做投影，当投影点在另一条弧线上并且圆心点和投影点连线与另一条弧
|
|
// 线有交点时，保留交点与投影点的距离 3. 计算弧线端点间的距离 4.取上述值中最小值即为弧线与弧线间距
|
|
double TBaseWallIntegrateTool::ArcToArcDist(const TGGeArc &arc1, const TGGeArc &arc2)
|
|
{
|
|
std::vector<double> vecDist;
|
|
TADSGePoint3d pt1, pt2;
|
|
// arc1的端点和圆心到arc2的投影
|
|
arc1.GetStartPoint(pt1);
|
|
pt1.Project(&arc2, pt2);
|
|
if (arc2.PtOnArc(pt2))
|
|
{
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
}
|
|
|
|
arc1.GetEndPoint(pt1);
|
|
pt1.Project(&arc2, pt2);
|
|
if (arc2.PtOnArc(pt2))
|
|
{
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
}
|
|
|
|
pt1 = arc1.GetCenterPt();
|
|
pt1.Project(&arc2, pt2);
|
|
if (arc2.PtOnArc(pt2))
|
|
{
|
|
TGGeLine lineTemp(pt1, pt2);
|
|
lineTemp.m_nFlag = 1;
|
|
if (arc1.Intersection(&lineTemp) > 0)
|
|
{
|
|
vecDist.push_back(fabs(pt1.Distance(pt2) - arc1.GetRadius())) ;
|
|
}
|
|
}
|
|
|
|
// arc2的端点和圆心到arc1的投影
|
|
arc2.GetStartPoint(pt1);
|
|
pt1.Project(&arc1, pt2);
|
|
if (arc1.PtOnArc(pt2))
|
|
{
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
}
|
|
|
|
arc2.GetEndPoint(pt1);
|
|
pt1.Project(&arc1, pt2);
|
|
if (arc1.PtOnArc(pt2))
|
|
{
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
}
|
|
|
|
pt1 = arc2.GetCenterPt();
|
|
pt1.Project(&arc1, pt2);
|
|
if (arc1.PtOnArc(pt2))
|
|
{
|
|
TGGeLine lineTemp(pt1, pt2);
|
|
lineTemp.m_nFlag = 1;
|
|
if (arc2.Intersection(&lineTemp) > 0)
|
|
{
|
|
vecDist.push_back(fabs(pt1.Distance(pt2) - arc2.GetRadius())) ;
|
|
}
|
|
}
|
|
|
|
// 弧线端点间距
|
|
arc1.GetStartPoint(pt1);
|
|
arc2.GetStartPoint(pt2);
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
arc2.GetEndPoint(pt2);
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
|
|
arc1.GetEndPoint(pt1);
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
arc2.GetStartPoint(pt2);
|
|
vecDist.push_back(pt1.Distance(pt2));
|
|
|
|
|
|
double dDist = 0.0;
|
|
std::vector<double>::iterator it;
|
|
it = std::min_element(vecDist.begin(), vecDist.end());
|
|
if (it != vecDist.end())
|
|
{
|
|
dDist = *it;
|
|
}
|
|
|
|
|
|
return dDist;
|
|
}
|
|
|
|
//求两个封闭区域的最小间隙
|
|
//返回值：true：成功；false：失败
|
|
bool TBaseWallIntegrateTool::GetMinGap(const TGGePoly2D& polyFirst, //[in]区域1
|
|
const TGGePoly2D& polySecond, //[in]区域2
|
|
double& dGap) //[out]最小间隙
|
|
{
|
|
if (polyFirst.GetFlag() != 1 || polySecond.GetFlag() != 1) // 非闭合
|
|
{
|
|
return false;
|
|
}
|
|
|
|
AcDbCurve *pCurveFirst = polyFirst.AsAcDbCurve();
|
|
AcDbCurve *pCurveSecond = polySecond.AsAcDbCurve();
|
|
if (pCurveFirst == NULL || pCurveSecond == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 检查是否相交
|
|
AcGePoint3dArray ptArray;
|
|
pCurveFirst->intersectWith(pCurveSecond,AcDb::kOnBothOperands, ptArray);
|
|
if (ptArray.length() > 0)
|
|
{
|
|
dGap = 0.0;
|
|
return true;
|
|
}
|
|
|
|
// 检查是否重叠
|
|
TADSGePoint3d pt1 = polyFirst[0]; // 任取一点
|
|
TADSGePoint3d pt2 = polySecond[0];
|
|
if ((pt2 & polyFirst) == PR_INSIDE || (pt1 & polySecond) == PR_INSIDE)
|
|
{
|
|
dGap = 0.0;
|
|
return true;
|
|
}
|
|
|
|
// TGGePoly2D 不相交不重叠时的间距
|
|
int nLineTypeFirst = 0, nLineTypeSecond = 0;
|
|
TGGeArc arcFirst, arcSecond;
|
|
TGGeLine lineFirst, lineSecond;
|
|
std::vector<double> vecDist;
|
|
for (int i = 0; i < polyFirst.Length(); i++)
|
|
{
|
|
nLineTypeFirst = polyFirst.Nth(i,lineFirst, arcFirst);
|
|
for(int j = 0; j < polySecond.Length(); j++)
|
|
{
|
|
nLineTypeSecond = polySecond.Nth(j, lineSecond, arcSecond);
|
|
|
|
if (nLineTypeFirst == LINE_SEGMENT && nLineTypeSecond == LINE_SEGMENT)
|
|
{
|
|
vecDist.push_back(LineToLineDist(lineFirst, lineSecond));
|
|
}
|
|
else if (nLineTypeFirst == LINE_SEGMENT && nLineTypeSecond == ARC_SEGMENT)
|
|
{
|
|
vecDist.push_back(LineToArcDist(lineFirst, arcSecond));
|
|
}
|
|
else if (nLineTypeFirst == ARC_SEGMENT && nLineTypeSecond == LINE_SEGMENT)
|
|
{
|
|
vecDist.push_back(LineToArcDist(lineSecond, arcFirst));
|
|
}
|
|
else if (nLineTypeFirst == ARC_SEGMENT && nLineTypeSecond == ARC_SEGMENT)
|
|
{
|
|
vecDist.push_back(ArcToArcDist(arcFirst, arcSecond));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool nRet = false;
|
|
std::vector<double>::iterator it;
|
|
it = std::min_element(vecDist.begin(), vecDist.end());
|
|
if (it != vecDist.end())
|
|
{
|
|
dGap = *it;
|
|
nRet = true;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
#endif |