2330 lines
58 KiB
C++
2330 lines
58 KiB
C++
#include "StdAfx.h"
|
|
#include "UnfoldInstallSanitarySys.h"
|
|
|
|
#define WALL_MAX_THICK (DocGetCurMeterUnitDraw() ? 1 : 1000) // 墙体最大厚度
|
|
|
|
UnfoldInstallSanitarySys::UnfoldInstallSanitarySys()
|
|
{
|
|
m_dElev = 0.0;
|
|
m_pNodeStart = NULL;
|
|
m_nInstallType = 0;
|
|
m_bErrorNote = false;
|
|
m_bCreatPipe = true;
|
|
m_bPipeDir = true;
|
|
m_tolVec.setEqualVector(0.01);
|
|
}
|
|
|
|
void UnfoldInstallSanitarySys::IsCreatPipe(bool bCreatPipe)
|
|
{
|
|
m_bCreatPipe = bCreatPipe;
|
|
}
|
|
|
|
bool UnfoldInstallSanitarySys::GetErrorNote()
|
|
{
|
|
return m_bErrorNote;
|
|
}
|
|
|
|
void UnfoldInstallSanitarySys::SetErrorNote(bool bErrorNote)
|
|
{
|
|
m_bErrorNote = bErrorNote;
|
|
}
|
|
|
|
// 设置明装还是安装方式
|
|
void UnfoldInstallSanitarySys::SetInstallType(int nInstallType)
|
|
{
|
|
m_nInstallType = nInstallType;
|
|
}
|
|
|
|
void UnfoldInstallSanitarySys::AutoLinkSanitary( const SanitarySysData &data )
|
|
{
|
|
m_dPipeDn = GetPipeDn(data.id);
|
|
m_sysPipe = data.type;
|
|
m_idPipe = data.id;
|
|
m_ptFeed = data.pt;
|
|
m_ptFeed.z = 0;
|
|
InitWallEnt();
|
|
ModifyUsefulWall();
|
|
|
|
// 将洁具按距离给水点远近排序
|
|
SanitarySysData sanData = data;
|
|
std::vector<SanitaryNode> &vecSanNode = sanData.vecSanitaryNode;
|
|
Sort(vecSanNode, sanData.pt);
|
|
|
|
// 按洁具点距给水点远近连接洁具
|
|
LinkSanitary(sanData);
|
|
}
|
|
|
|
void UnfoldInstallSanitarySys::LinkSanitary(const SanitarySysData &data)
|
|
{
|
|
// 获得最远洁具给水点 洁具id
|
|
std::vector<SanitaryNode> vecNode = data.vecSanitaryNode;
|
|
std::vector<SanitaryNode>::iterator it = vecNode.begin();
|
|
AcGePoint3d ptSan = it->pt;
|
|
ptSan.z = 0;
|
|
AcDbObjectId idSan = it->idSanitary;
|
|
AcGePoint3d ptFeed = data.pt;
|
|
ptFeed.z = 0;
|
|
|
|
AcGeVector3d vtPipe = AcGeVector3d::kXAxis, vtDir;
|
|
AcDbLine lineStart, lineEnd;
|
|
double dWallThick = 0.0;
|
|
|
|
bool bIsParallel = false;
|
|
bool bExtendFeedPipe = true;
|
|
AcGeVector3d vtSan;
|
|
bIsParallel = IsSanPtsParallel(vecNode, vtSan);
|
|
m_tolVec.setEqualVector(0.01);
|
|
CString sNote = _T("供水明装无法检测到可用上华墙体 ");
|
|
// 设定主干方向
|
|
if (ConfirmPipeDir(vtPipe, ptSan, vtDir))
|
|
{
|
|
AcGePoint3d ptFar;
|
|
if (!IsVertivalPipe(m_idPipe))// 更新供水管
|
|
{
|
|
AcGePoint3d ptS, ptE, ptOnLine;
|
|
GetPipePoint(m_idPipe, ptS, ptE);
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
ptS = Wcs2Ucs(ptS);
|
|
ptE = Wcs2Ucs(ptE);
|
|
AcGeVector3d vt = ptE - ptS;
|
|
vt.normalize();
|
|
ptS = Ucs2Wcs(ptS);
|
|
ptE = Ucs2Wcs(ptE);
|
|
AcDbLine lineFeed;
|
|
lineFeed.setStartPoint(ptS);
|
|
lineFeed.setEndPoint(ptE);
|
|
lineFeed.getClosestPointTo(ptSan, ptOnLine, Adesk::kTrue);
|
|
if (fabs(ptS.distanceTo(ptE) - ptOnLine.distanceTo(ptS) - ptOnLine.distanceTo(ptE)) < 0.001)// 洁具点在管线上的投影点在管线上
|
|
{
|
|
bExtendFeedPipe = false;
|
|
}
|
|
vtPipe.normalize();
|
|
if (vtPipe.isEqualTo(vt, m_tolVec))
|
|
{
|
|
ptFar = ptS;
|
|
AddPipeLine(ptS, ptE, PipeType::eMainPipe);
|
|
}
|
|
else
|
|
{
|
|
ptFar = ptE;
|
|
m_bPipeDir = false;
|
|
}
|
|
}
|
|
// 查找给水点的起始墙体
|
|
if (!GetIntersectWall(ptFar, vtDir, lineStart, vtPipe, true))
|
|
{
|
|
if (bIsParallel)
|
|
{
|
|
LinkSanWithoutWall(vecNode, vtPipe, bExtendFeedPipe, vtSan);
|
|
}
|
|
else if (!m_bErrorNote)
|
|
{
|
|
AfxMessageBox(sNote, MB_OK);
|
|
m_bErrorNote = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 主干方向无法确定时，查找最近墙体
|
|
if (!GetWallMiddleLine(ptFeed, lineStart))
|
|
{
|
|
if (bIsParallel)
|
|
{
|
|
LinkSanWithoutWall(vecNode, vtPipe, bExtendFeedPipe, vtSan);
|
|
}
|
|
else if (!m_bErrorNote)
|
|
{
|
|
AfxMessageBox(sNote, MB_OK);
|
|
m_bErrorNote = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// 查找最远洁具点的终止墙体
|
|
GetSanitaryDir(vtDir, idSan);
|
|
if (!GetIntersectWall(ptSan, vtDir.perpVector(), lineEnd, vtDir.negate(), false))
|
|
{
|
|
if (!GetWallMiddleLine(ptSan, lineEnd))
|
|
{
|
|
if (bIsParallel)
|
|
{
|
|
LinkSanWithoutWall(vecNode, vtPipe, bExtendFeedPipe, vtSan);
|
|
}
|
|
else if (!m_bErrorNote)
|
|
{
|
|
AfxMessageBox(sNote, MB_OK);
|
|
m_bErrorNote = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// 搜寻最短路径
|
|
std::vector<WallData *> vecRoad;
|
|
if (!GetWallRoad(lineStart, lineEnd, vecRoad))
|
|
{
|
|
if (!m_bErrorNote)
|
|
{
|
|
AfxMessageBox(sNote, MB_OK);
|
|
m_bErrorNote = true;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// 设定主干
|
|
if (!SetMainPipe(vecRoad, vecNode))
|
|
{
|
|
return;
|
|
}
|
|
m_vecRoad = vecRoad;
|
|
|
|
// 连接洁具
|
|
LinkSanitary(vecRoad, vecNode);
|
|
|
|
// 设定管线标高
|
|
SetLinkableNode();
|
|
|
|
if (!IsVertivalPipe(m_idPipe))// 更新供水管
|
|
{
|
|
Entity ent;
|
|
ads_name name;
|
|
acdbGetAdsName(name, m_idPipe);
|
|
ent = name;
|
|
ent.Erase();
|
|
}
|
|
}
|
|
|
|
// 连接无墙洁具
|
|
void UnfoldInstallSanitarySys::LinkSanWithoutWall(std::vector<SanitaryNode> &vecNode, AcGeVector3d &vtPipe, bool bExtendFeedPipe, AcGeVector3d &vtSan)
|
|
{
|
|
std::vector<SanitaryNode>::iterator it;
|
|
it = vecNode.begin();
|
|
AcGePoint3d ptSan = it->pt, ptInter, ptE;
|
|
ptSan.z = 0;
|
|
ptSan = Wcs2Ucs(ptSan);
|
|
m_ptFeed = Wcs2Ucs(m_ptFeed);
|
|
|
|
AcGePoint3d ptX, ptY;
|
|
ptX.x = ptSan.x;
|
|
ptX.y = m_ptFeed.y;
|
|
ptX.z = 0;
|
|
ptY.x = m_ptFeed.x;
|
|
ptY.y = ptSan.y;
|
|
ptY.z = 0;
|
|
|
|
if (IsVertivalPipe(m_idPipe))
|
|
{
|
|
if (vecNode.size() > 1)
|
|
{
|
|
vtPipe = vtSan;
|
|
}
|
|
else
|
|
{
|
|
vtPipe = ptX - m_ptFeed;
|
|
}
|
|
}
|
|
AcDbLine lineMain;
|
|
lineMain.setStartPoint(m_ptFeed);
|
|
AcGeVector3d vtX, vtY;
|
|
vtX = ptY - m_ptFeed;
|
|
vtY = ptX - m_ptFeed;
|
|
if (vtX.isParallelTo(vtPipe, m_tolVec))
|
|
{
|
|
lineMain.setEndPoint(ptY);
|
|
ptSan = Ucs2Wcs(ptSan);
|
|
m_ptFeed = Ucs2Wcs(m_ptFeed);
|
|
ptY = Ucs2Wcs(ptY);
|
|
ptE = ptY;
|
|
if (bExtendFeedPipe)
|
|
{
|
|
AddPipeLine(m_ptFeed, ptY, PipeType::eMainPipe);
|
|
}
|
|
}
|
|
else if (vtY.isParallelTo(vtPipe, m_tolVec))
|
|
{
|
|
lineMain.setEndPoint(ptX);
|
|
ptSan = Ucs2Wcs(ptSan);
|
|
m_ptFeed = Ucs2Wcs(m_ptFeed);
|
|
ptX = Ucs2Wcs(ptX);
|
|
ptE = ptX;
|
|
if (bExtendFeedPipe)
|
|
{
|
|
AddPipeLine(m_ptFeed, ptX, PipeType::eMainPipe);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 存储洁具点结构
|
|
for (it = vecNode.begin(); it != vecNode.end(); it++)
|
|
{
|
|
m_mapSanPt.insert(std::make_pair(it->idSanitary, it->pt));
|
|
}
|
|
|
|
if (vecNode.size() > 1 && vtSan.isPerpendicularTo(vtPipe))// 供水管和洁具线垂直，管线直接穿过洁具点
|
|
{
|
|
LinkSanCrossPipe(vecNode, ptE);
|
|
}
|
|
else// 供水管和洁具线平行，直接投影
|
|
{
|
|
LinkSan2Proj(vecNode, lineMain);
|
|
}
|
|
|
|
if (!IsVertivalPipe(m_idPipe))// 更新供水管
|
|
{
|
|
Entity ent;
|
|
ads_name name;
|
|
acdbGetAdsName(name, m_idPipe);
|
|
ent = name;
|
|
ent.Erase();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// 连接管线直接穿过洁具点的洁具
|
|
void UnfoldInstallSanitarySys::LinkSanCrossPipe(std::vector<SanitaryNode> &vecNode, AcGePoint3d &ptCross)
|
|
{
|
|
if (!IsVertivalPipe(m_idPipe))
|
|
{
|
|
AcGePoint3d ptStart, ptEnd;
|
|
GetPipePoint(m_idPipe, ptStart, ptEnd);
|
|
ptStart.z = 0;
|
|
m_ptFeed = ptStart;
|
|
}
|
|
|
|
LinkNode *pNodeS = new LinkNode;
|
|
LinkNode *pNodeFeed = new LinkNode;
|
|
|
|
pNodeS->ptCur = ptCross;
|
|
pNodeS->type = Point_Int;
|
|
pNodeS->pPreNode = pNodeFeed;
|
|
|
|
pNodeFeed->ptCur = m_ptFeed;
|
|
pNodeFeed->type = Point_Feed;
|
|
pNodeFeed->pPreNode = NULL;
|
|
pNodeFeed->m_vecNode.push_back(pNodeS);
|
|
|
|
AcGePoint3d ptSan;
|
|
std::vector<SanitaryNode>::reverse_iterator itRev;
|
|
for (itRev = vecNode.rbegin(); itRev != vecNode.rend(); itRev++)
|
|
{
|
|
ptSan = (*itRev).pt;
|
|
ptSan.z = 0;
|
|
LinkNode *pNode = new LinkNode;
|
|
LinkNode *pNodeSan = new LinkNode;
|
|
pNode->ptCur = ptSan;
|
|
pNode->type = Point_Int | Point_KW;
|
|
pNode->m_vecNode.push_back(pNodeSan);
|
|
|
|
pNodeS->m_vecNode.push_back(pNode);
|
|
pNode->pPreNode = pNodeS;
|
|
|
|
pNodeSan->ptCur = ptSan;
|
|
pNodeSan->type = Point_Sanitary;
|
|
pNodeSan->pPreNode = pNode;
|
|
|
|
pNodeS = pNode;
|
|
}
|
|
m_pNodeStart = pNodeFeed;
|
|
ModifyPipeElve();// 设定管线标高
|
|
}
|
|
|
|
// 连接投影到管线的洁具点
|
|
void UnfoldInstallSanitarySys::LinkSan2Proj(std::vector<SanitaryNode> &vecNode, AcDbLine &lineMain)
|
|
{
|
|
AcGePoint3d ptSan, ptInter;
|
|
std::vector<SanitaryNode>::iterator it;
|
|
while (!vecNode.empty())
|
|
{
|
|
it = vecNode.begin();
|
|
ptSan = (*it).pt;
|
|
ptSan.z = 0;
|
|
ptSan = Wcs2Ucs(ptSan);
|
|
lineMain.getClosestPointTo(ptSan, ptInter, Adesk::kTrue);
|
|
ptSan = Ucs2Wcs(ptSan);
|
|
ptInter = Ucs2Wcs(ptInter);
|
|
if (ptSan.distanceTo(ptInter) < 0.001)
|
|
{
|
|
ptSan.z = 100;
|
|
}
|
|
AddPipeLine(ptInter, ptSan, PipeType::eBranch);
|
|
vecNode.erase(it);
|
|
}
|
|
// 设定管线标高
|
|
SetLinkableNode();
|
|
}
|
|
|
|
// 判断所有洁具点是否共线
|
|
bool UnfoldInstallSanitarySys::IsSanPtsParallel(std::vector<SanitaryNode> &vecNode, AcGeVector3d &vtSan)
|
|
{
|
|
m_tolVec.setEqualVector(0.001);
|
|
if (vecNode.size() < 2)
|
|
{
|
|
return true;
|
|
}
|
|
std::vector<SanitaryNode>::iterator it;
|
|
it = vecNode.begin();
|
|
|
|
AcGeVector3d vtFirst, vtSecond;
|
|
AcGePoint3d ptFirst, ptSecond, ptThird;
|
|
ptFirst = it->pt;
|
|
ptFirst.z = 0;
|
|
it++;
|
|
ptSecond = it->pt;
|
|
ptSecond.z = 0;
|
|
vtFirst = ptFirst - ptSecond;
|
|
ptFirst = Wcs2Ucs(ptFirst);
|
|
ptSecond = Wcs2Ucs(ptSecond);
|
|
it++;
|
|
vtSan = ptFirst - ptSecond;
|
|
ptSecond = Ucs2Wcs(ptSecond);
|
|
|
|
while (it != vecNode.end())
|
|
{
|
|
ptThird = it->pt;
|
|
ptThird.z = 0;
|
|
vtSecond = ptSecond - ptThird;
|
|
if (!vtFirst.isParallelTo(vtSecond, m_tolVec))
|
|
{
|
|
return false;
|
|
}
|
|
ptSecond = ptThird;
|
|
it++;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 设定主干
|
|
bool UnfoldInstallSanitarySys::SetMainPipe(std::vector<WallData *> &vecRoad, std::vector<SanitaryNode> &vecNode)
|
|
{
|
|
if (vecRoad.size() < 1)
|
|
{
|
|
return false;
|
|
}
|
|
std::vector<WallData *>::iterator itWall;
|
|
AcGePoint3d ptOnLine, ptS, ptE, ptPerS, ptPerE;
|
|
AcGeVector3d vt, vtPer, vtStart, vtCur;
|
|
std::vector<AcDbLine *> vecLine;
|
|
AcDbLine line;
|
|
double dWidth = 0.0, dDistPipe2Wall = 0.0, dDistOldPipe2Wall = m_dDistPipe2Wall;;
|
|
AcDbLine *pLine = NULL;
|
|
bool bNotTurned = false;
|
|
for (itWall = vecRoad.begin(); itWall != vecRoad.end(); itWall++)
|
|
{
|
|
if (NULL == (*itWall))
|
|
{
|
|
continue;
|
|
}
|
|
dWidth = (*itWall)->dWidth / 2;
|
|
ptS = (*itWall)->ptS;
|
|
ptE = (*itWall)->ptE;
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
pLine = new AcDbLine();
|
|
line.setStartPoint(ptS);
|
|
line.setEndPoint(ptE);
|
|
|
|
// 起始墙体和终止墙体需要特殊设定
|
|
if (itWall == vecRoad.begin())// 起始墙体
|
|
{
|
|
if (!IsVertivalPipe(m_idPipe))// 给水管为非立管时
|
|
{
|
|
// 根据墙体两侧是否有洁具 确定管线与墙体的位置(即管线安置在墙体有洁具的一侧)
|
|
bool bSeted = false;// 能否确定管线与墙的关系
|
|
std::vector<SanitaryNode>::iterator itSan;
|
|
for (itSan = vecNode.begin(); itSan != vecNode.end(); itSan++)
|
|
{
|
|
AcGePoint3d ptSan = (*itSan).pt;
|
|
ptSan.z = 0;
|
|
if (line.getClosestPointTo(ptSan, ptOnLine) == Acad::eOk && ptOnLine.distanceTo(ptSan) < m_dDistSearchWall)
|
|
{
|
|
AcGeVector3d vtLine = ptE - ptS;
|
|
vt = ptSan - ptOnLine;
|
|
vt.normalize();
|
|
if (vtLine.isPerpendicularTo(vt, m_tolVec))
|
|
{
|
|
bSeted = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
GetPipePoint(m_idPipe, ptS, ptE);
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
if (line.getClosestPointTo(m_ptFeed, ptOnLine) == Acad::eOk)
|
|
{
|
|
if (!bSeted)// 无法确定管线沿墙方向，穿墙布线
|
|
{
|
|
vt = ptOnLine - m_ptFeed;
|
|
if (!IsVertivalPipe(m_idPipe))
|
|
{
|
|
vt = ptE - ptS;
|
|
if (!m_bPipeDir)
|
|
{
|
|
vt = ptS - ptE;
|
|
}
|
|
}
|
|
vt.normalize();
|
|
}
|
|
ptOnLine = ptOnLine + vt * ((*itWall)->dWidth / 2 + m_dDistPipe2Wall);
|
|
}
|
|
// 延长管线从给水点到关联墙体
|
|
AcDbLine lineStart;
|
|
lineStart.setStartPoint(ptS);
|
|
lineStart.setEndPoint(ptE);
|
|
AcGePoint3d ptTmp;
|
|
lineStart.getClosestPointTo(ptOnLine, ptTmp);
|
|
if (ptTmp.distanceTo(ptOnLine) > 0.001 && ptOnLine.distanceTo(m_ptFeed) > 0.001)
|
|
{
|
|
AcDbLine *pLineNew = new AcDbLine();
|
|
pLineNew->setStartPoint(m_ptFeed);
|
|
pLineNew->setEndPoint(ptOnLine);
|
|
vecLine.push_back(pLineNew);
|
|
}
|
|
m_ptFeed = ptOnLine;
|
|
}
|
|
else// 给水管为立管时，偏移距离为立管距墙距离
|
|
{
|
|
vtStart = ptE - ptS;
|
|
bNotTurned = true;
|
|
line.getClosestPointTo(m_ptFeed, ptOnLine);
|
|
dDistPipe2Wall = ptOnLine.distanceTo(m_ptFeed) - (*itWall)->dWidth / 2;
|
|
}
|
|
ptS = line.startPoint();
|
|
ptE = line.endPoint();
|
|
SetStartPipe(pLine, m_ptFeed, line, vtPer);
|
|
if ((*itWall)->id == vecRoad.back()->id)// 路径只存在一个墙体
|
|
{
|
|
AcGePoint3d ptStart = pLine->startPoint();
|
|
if (bNotTurned)// 墙体和起始墙体平行
|
|
{
|
|
vtCur = ptE - ptS;
|
|
if (vtCur.isParallelTo(vtStart, m_tolVec))
|
|
{
|
|
m_dDistPipe2Wall = dDistPipe2Wall;
|
|
}
|
|
}
|
|
SetEndPipe(pLine, (*vecNode.begin()).pt, line, dWidth);
|
|
m_dDistPipe2Wall = dDistOldPipe2Wall;
|
|
pLine->setStartPoint(ptStart);
|
|
AcGePoint3dArray arryPts;
|
|
arryPts.setLogicalLength(0);
|
|
pLine->intersectWith(&line, AcDb::kOnBothOperands, arryPts);
|
|
if (arryPts.length() > 0)// 主干和墙体相交，无法连接
|
|
{
|
|
AfxMessageBox(_T("无法获取最优路径 "), MB_OK);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else if ((*itWall)->id == vecRoad.back()->id)// 终止墙体
|
|
{
|
|
if (bNotTurned)// 墙体和起始墙体平行
|
|
{
|
|
vtCur = ptE - ptS;
|
|
if (vtCur.isParallelTo(vtStart, m_tolVec))
|
|
{
|
|
m_dDistPipe2Wall = dDistPipe2Wall;
|
|
}
|
|
}
|
|
SetEndPipe(pLine, (*vecNode.begin()).pt, line, dWidth);
|
|
m_dDistPipe2Wall = dDistOldPipe2Wall;
|
|
}
|
|
else // 中间墙体
|
|
{
|
|
if (bNotTurned)// 墙体和起始墙体平行
|
|
{
|
|
vtCur = ptE - ptS;
|
|
if (vtCur.isParallelTo(vtStart, m_tolVec))
|
|
{
|
|
m_dDistPipe2Wall = dDistPipe2Wall;
|
|
}
|
|
else
|
|
{
|
|
m_dDistPipe2Wall = dDistOldPipe2Wall;
|
|
bNotTurned = false;
|
|
}
|
|
}
|
|
SetMiddlePipe(ptS, ptE, line, vecNode, dWidth, ptPerS, ptPerE, vtPer);
|
|
pLine->setStartPoint(ptS);
|
|
pLine->setEndPoint(ptE);
|
|
}
|
|
|
|
vecLine.push_back(pLine);
|
|
ptPerS = ptS;
|
|
ptPerE = ptE;
|
|
}
|
|
ModifyPipe(vecLine, dWidth);
|
|
std::vector<AcDbLine *>::iterator it;
|
|
for (it = vecLine.begin(); it != vecLine.end(); it++)
|
|
{
|
|
if (NULL == (*it) || (*it)->startPoint().distanceTo((*it)->endPoint()) < 0.001)
|
|
{
|
|
continue;
|
|
}
|
|
AddPipeLine((*it)->startPoint(), (*it)->endPoint(), PipeType::eMainPipe);
|
|
}
|
|
FreeLine(vecLine);
|
|
return true;
|
|
}
|
|
|
|
// 根据主干 设定分支管和小支管
|
|
void UnfoldInstallSanitarySys::LinkSanitary(std::vector<WallData *> &vecRoad, std::vector<SanitaryNode> &vecNode)
|
|
{
|
|
std::vector<SanitaryNode>::iterator it;
|
|
AcGePoint3d ptSan, ptS, ptE;
|
|
AcDbObjectId idSan;
|
|
AcDbLine line;
|
|
AcGeVector3d vt;
|
|
while (!vecNode.empty())
|
|
{
|
|
it = vecNode.begin();
|
|
ptSan = (*it).pt;
|
|
ptSan.z = 0;
|
|
idSan = (*it).idSanitary;
|
|
GetSanitaryDir(vt, idSan);
|
|
if (!GetIntersectWall(ptSan, vt.perpVector(), line, vt.negate(), false))
|
|
{
|
|
if (!GetWallMiddleLine(ptSan, line))
|
|
{
|
|
vecNode.erase(it);
|
|
continue;
|
|
}
|
|
}
|
|
ptS = line.startPoint();
|
|
ptE = line.endPoint();
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
if (LinkSanitary2MainPipe(ptSan, ptS, ptE, vecNode))
|
|
{
|
|
m_mapSanPt.insert(std::make_pair(it->idSanitary, it->pt));// 存储洁具点结构
|
|
}
|
|
vecNode.erase(it);
|
|
}
|
|
}
|
|
|
|
#define MAX_DIST 100000
|
|
// 添加支管和小支管
|
|
bool UnfoldInstallSanitarySys::LinkSanitary2MainPipe(const AcGePoint3d &ptSan, const AcGePoint3d &ptS, const AcGePoint3d &ptE, const std::vector<SanitaryNode> vecNode)
|
|
{
|
|
AcDbLine line;
|
|
line.setStartPoint(ptS);
|
|
line.setEndPoint(ptE);
|
|
|
|
AcDbLine lineCheck;
|
|
AcGePoint3d ptOnLine, ptCheck, ptOnPipe, ptStart, ptEnd;
|
|
if (line.getClosestPointTo(ptSan, ptOnLine) != Acad::eOk)
|
|
{
|
|
return false;
|
|
}
|
|
AcGeVector3d vtCheck = ptSan - ptOnLine, vtPipe;
|
|
vtCheck.normalize();
|
|
ptCheck = ptOnLine + vtCheck * 1000;
|
|
lineCheck.setStartPoint(ptOnLine);
|
|
lineCheck.setEndPoint(ptCheck);
|
|
|
|
std::vector<WallData *> vecRoad;
|
|
double dDist = 0.0, dLen = 0.0, dDist1 = 0.0, dDist2 = 0.0;
|
|
std::map<double, LinkedLine> mapPipe;
|
|
std::map<double, LinkedLine>::iterator itMap;
|
|
if (GetExtendPipe(mapPipe, lineCheck, ptSan, false))// 获取到可直接连接的主干
|
|
{
|
|
itMap = mapPipe.begin();
|
|
ptOnPipe = (*itMap).second.ptIntersect;
|
|
AcDbLine *pLine = (*itMap).second.pLine;
|
|
if (NULL == pLine)
|
|
{
|
|
return false;
|
|
}
|
|
ptStart = pLine->startPoint();
|
|
ptEnd = pLine->endPoint();
|
|
dLen = ptStart.distanceTo(ptEnd);
|
|
dDist1 = ptStart.distanceTo(ptOnPipe);
|
|
dDist2 = ptEnd.distanceTo(ptOnPipe);
|
|
AcGeVector3d vt = ptSan - ptOnLine;
|
|
vt.normalize();
|
|
if (CheckPipe2Wall(ptEnd, ptOnPipe, line))
|
|
{
|
|
if (fabs(dLen - dDist1 - dDist2) < 0.001)// 交点在管线上
|
|
{
|
|
;
|
|
}
|
|
else if (fabs(dDist1 - dLen - dDist2) < 0.001)// 交点在终点的延长线上
|
|
{
|
|
if (!CheckPipePos(ptEnd, ptOnPipe))
|
|
{
|
|
AcGePoint3d ptPer = ptEnd;
|
|
ptEnd = ptEnd + vt * m_dDistPipe2Wall;
|
|
ptOnPipe = ptOnPipe + vt * m_dDistPipe2Wall;
|
|
AddPipeLine(ptPer, ptEnd, PipeType::eBranch);
|
|
}
|
|
|
|
AddPipeLine(ptEnd, ptOnPipe, PipeType::eMainPipe);
|
|
}
|
|
else if (fabs(dDist2 - dLen - dDist1) < 0.001)// 交点在起点的延长线上
|
|
{
|
|
if (!CheckPipePos(ptStart, ptOnPipe))
|
|
{
|
|
AcGePoint3d ptPer = ptStart;
|
|
ptStart = ptStart + vt * m_dDistPipe2Wall;
|
|
ptOnPipe = ptOnPipe + vt * m_dDistPipe2Wall;
|
|
AddPipeLine(ptPer, ptStart, PipeType::eBranch);
|
|
}
|
|
AddPipeLine(ptStart, ptOnPipe, PipeType::eMainPipe);
|
|
}
|
|
|
|
AcGePoint3d ptSanitary = ptSan;
|
|
if (ptOnPipe.distanceTo(ptSanitary) < 0.001)// 洁具直接穿过主干线
|
|
{
|
|
ptSanitary.z = 100;
|
|
}
|
|
AddPipeLine(ptOnPipe, ptSanitary, PipeType::eSmallPipe);// 小支管不用偏移
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 得到所有与墙线相交的主干
|
|
if (GetExtendPipe(mapPipe, line, ptSan, false))
|
|
{
|
|
if(ExtendPipe2San(mapPipe, ptSan, ptOnLine, line))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 延长墙体 得到主干
|
|
if (GetExtendPipe(mapPipe, line, ptSan, true))
|
|
{
|
|
if(ExtendPipe2San(mapPipe, ptSan, ptOnLine, line))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 未找到可连接管线,继续寻找最短路径
|
|
if (!GetBranchWallRoad(line, vecRoad))
|
|
{
|
|
return false;
|
|
}
|
|
SetNewMainPipe(ptSan, vecRoad, vecNode);
|
|
return true;
|
|
}
|
|
|
|
// 沿墙体延长管线 连接洁具
|
|
bool UnfoldInstallSanitarySys::ExtendPipe2San(std::map<double, LinkedLine> &mapPipe, const AcGePoint3d &ptSan, AcGePoint3d &ptOnLine, AcDbLine &line)
|
|
{
|
|
AcGePoint3d ptS, ptE, ptSanitary = ptSan;
|
|
double dLen = 0.0, dDist1 = 0.0, dDist2 = 0.0 , dWallThick = 0.0;
|
|
AcGePoint3d ptMainEnd;
|
|
AcGePoint3d ptMainStart;
|
|
std::map<double, LinkedLine>::iterator itMap;
|
|
AcDbLine line1, line2;
|
|
bool bRet1 = false, bRet2 = false;
|
|
m_vtSan = ptSanitary - ptOnLine;
|
|
while (!mapPipe.empty())
|
|
{
|
|
itMap = mapPipe.begin();
|
|
ptMainEnd = ptOnLine;
|
|
ptMainStart = (*itMap).second.ptIntersect;
|
|
bRet1 = GetNearestWall(ptMainEnd, ptMainEnd - ptMainStart, line1, dWallThick);
|
|
ptS = (*itMap).second.pLine->startPoint();
|
|
ptE = (*itMap).second.pLine->endPoint();
|
|
bRet2 = GetNearestWall(ptS, ptE - ptS, line2, dWallThick);
|
|
|
|
if (bRet2 && bRet1)
|
|
{
|
|
if (CheckPipe2Wall(ptMainStart, ptMainEnd, line1) && CheckPipe2Wall(ptS, ptMainStart, line2))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if (bRet1 && CheckPipe2Wall(ptMainStart, ptMainEnd, line1) && (*itMap).second.nId == 0)// 与供水管相交时，不用考虑供水管延长线是否穿越墙体
|
|
{
|
|
break;
|
|
}
|
|
mapPipe.erase(itMap);
|
|
}
|
|
if (mapPipe.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
AcDbObjectId id;
|
|
WallData *pNode = NULL;
|
|
GetWallId(m_vecAllWall, line, id);
|
|
CheckWallInLst(m_vecAllWall, id, pNode);
|
|
if (NULL == pNode)
|
|
{
|
|
return false;
|
|
}
|
|
OffSetPipe(ptMainStart, ptMainEnd, ptSan - ptMainEnd, pNode->dWidth / 2);
|
|
AddPipeLine(ptMainEnd, ptSanitary, PipeType::eSmallPipe);
|
|
AddPipeLine(ptMainStart, ptMainEnd, PipeType::eMainPipe);
|
|
dLen = ptS.distanceTo(ptE);
|
|
dDist1 = ptS.distanceTo(ptMainStart);
|
|
dDist2 = ptE.distanceTo(ptMainStart);
|
|
AcGeVector3d vt = ptSan - ptOnLine;
|
|
vt.normalize();
|
|
if (fabs(dDist1 - dLen - dDist2) < 0.001)
|
|
{
|
|
AddPipeLine(ptE, ptMainStart, PipeType::eMainPipe);
|
|
}
|
|
else if (fabs(dDist2 - dLen - dDist1) < 0.001)
|
|
{
|
|
AddPipeLine(ptS, ptMainStart, PipeType::eMainPipe);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 释放管线节点
|
|
void UnfoldInstallSanitarySys::FreeLine(std::vector<AcDbLine *> &vecLine)
|
|
{
|
|
std::vector<AcDbLine *>::iterator it;
|
|
for (it = vecLine.begin(); it != vecLine.end(); it++)
|
|
{
|
|
if ((*it) != NULL)
|
|
{
|
|
delete *it;
|
|
*it = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 释放路径节点
|
|
void UnfoldInstallSanitarySys::FreeNode(std::vector<WallData *> &vecNode)
|
|
{
|
|
std::vector<WallData *>::iterator it;
|
|
for (it = vecNode.begin(); it != vecNode.end(); it++)
|
|
{
|
|
if ((*it) != NULL)
|
|
{
|
|
delete *it;
|
|
*it = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 连接次级主干
|
|
void UnfoldInstallSanitarySys::SetNewMainPipe(const AcGePoint3d &pt, std::vector<WallData *> &vecRoad, const std::vector<SanitaryNode> &vecNode)
|
|
{
|
|
WallData *pNodeS = NULL, *pNodeE = NULL;
|
|
AcGePoint3d ptNodeS, ptNodeS2, ptNodeE, ptNodeE2;
|
|
std::vector<WallData *>::reverse_iterator itCur;
|
|
std::vector<WallData *>::iterator itNor;
|
|
if (vecRoad.empty())
|
|
{
|
|
return;
|
|
}
|
|
// 查找本路线相连的已存在的管线
|
|
itCur = vecRoad.rbegin();
|
|
// 记录修改前的墙体数据
|
|
pNodeS = *itCur;
|
|
ptNodeS = pNodeS->ptS;
|
|
ptNodeS2 = pNodeS->ptE;
|
|
|
|
AcDbLine line;
|
|
AcGePoint3d ptS = (*itCur)->ptS;
|
|
AcGePoint3d ptE = (*itCur)->ptE;
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
line.setStartPoint(ptS);
|
|
line.setEndPoint(ptE);
|
|
AcGePoint3d ptOnLine, ptPerS, ptPerE, ptStart, ptEnd;
|
|
AcGeVector3d vtPer;
|
|
|
|
double dLen = 0.0, dDist1 = 0.0, dDist2 = 0.0, dDist = 0.0;
|
|
std::map<double, LinkedLine> mapLink;
|
|
// 得到所有与起始墙线相交的主干
|
|
bool bExtendWall = false;
|
|
if (!GetExtendPipe(mapLink, line, pt, false))// 找不到相关管线
|
|
{
|
|
bExtendWall = true;
|
|
GetExtendPipe(mapLink, line, pt, true);// 延长墙体
|
|
}
|
|
// 设定起始墙体
|
|
if (mapLink.empty())
|
|
{
|
|
return;
|
|
}
|
|
std::map<double, LinkedLine>::iterator itMap = mapLink.begin();
|
|
ptOnLine = (*itMap).second.ptIntersect;
|
|
AcGePoint3d ptMainEnd = ptOnLine;
|
|
AcGePoint3d ptMainStart;
|
|
ptPerS = (*itMap).second.pLine->startPoint();
|
|
ptPerE = (*itMap).second.pLine->endPoint();
|
|
vtPer = ptPerE - ptPerS;
|
|
vtPer = vtPer.perpVector();
|
|
|
|
(*itCur)->ptE = ptOnLine;
|
|
// 设置结束管线
|
|
itNor = vecRoad.begin();
|
|
pNodeE = *itNor;
|
|
ptNodeE = pNodeE->ptS;
|
|
ptNodeE2 = pNodeE->ptE;
|
|
ptS = vecRoad.front()->ptS;
|
|
ptE = vecRoad.front()->ptE;
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
line.setStartPoint(ptS);
|
|
line.setEndPoint(ptE);
|
|
AcGePoint3d ptOnWall;
|
|
line.getClosestPointTo(pt, ptOnWall);
|
|
(*itNor)->ptS = ptOnWall;
|
|
ptEnd = ptOnWall;
|
|
|
|
// 连接次级主干
|
|
LinkNewMainPipe(vecRoad, vecNode, mapLink, pt, ptOnLine, ptPerS, ptPerE, vtPer);
|
|
// 恢复墙体数据
|
|
pNodeE->ptS = ptNodeE;
|
|
pNodeE->ptE = ptNodeE2;
|
|
pNodeE->ptS = ptNodeE;
|
|
pNodeE->ptE = ptNodeE2;
|
|
}
|
|
|
|
void UnfoldInstallSanitarySys::LinkNewMainPipe(std::vector<WallData *> &vecRoad, const std::vector<SanitaryNode> &vecNode, std::map<double, LinkedLine> &mapLink,
|
|
const AcGePoint3d &pt, AcGePoint3d &ptOnLine, AcGePoint3d &ptPerS, AcGePoint3d ptPerE, AcGeVector3d &vtPer)
|
|
{
|
|
AcGePoint3d ptMainEnd = ptOnLine;
|
|
AcGePoint3d ptMainStart;
|
|
std::vector<WallData *>::reverse_iterator itCur;
|
|
std::map<double, LinkedLine>::iterator itMap = mapLink.begin();
|
|
double dWidth = 0.0;
|
|
std::vector<AcDbLine *> vecLine;
|
|
AcDbLine line;
|
|
AcGePoint3d ptS, ptE;
|
|
for (itCur = vecRoad.rbegin(); itCur != vecRoad.rend(); itCur++)
|
|
{
|
|
if (NULL == *itCur)
|
|
{
|
|
continue;
|
|
}
|
|
ptE = (*itCur)->ptS;
|
|
ptS = (*itCur)->ptE;
|
|
ptS.z = 0;
|
|
ptE.z = 0;
|
|
line.setStartPoint(ptS);
|
|
line.setEndPoint(ptE);
|
|
|
|
AcDbLine *pLine = new AcDbLine;
|
|
dWidth = (*itCur)->dWidth / 2;
|
|
SetMiddlePipe(ptS, ptE, line, vecNode, dWidth, ptPerS, ptPerE, vtPer);
|
|
|
|
if (itCur == vecRoad.rbegin() && fabs((*itMap).first - MAX_DIST) < 0.001)// 与主干延长线相交时，延长主干
|
|
{
|
|
AcDbLine *pLineExtend = new AcDbLine;
|
|
ptMainStart = (*itMap).second.pLine->endPoint();
|
|
// 交点在主干反方向时
|
|
if (ptMainEnd.distanceTo((*itMap).second.pLine->endPoint()) - (*itMap).second.pLine->startPoint().distanceTo((*itMap).second.pLine->endPoint()))
|
|
{
|
|
ptMainStart = (*itMap).second.pLine->startPoint();
|
|
}
|
|
|
|
AcGeVector3d vt = ptE - ptS;
|
|
vt.normalize();
|
|
if (!CheckPipePos(ptMainStart, ptMainEnd))// 判断延长线是否与其他管线碰撞
|
|
{
|
|
AcGePoint3d ptOld = ptMainStart;
|
|
ptMainStart = ptMainStart + vt * m_dDistPipe2Wall;
|
|
ptMainEnd = ptMainEnd + vt * m_dDistPipe2Wall;
|
|
AddPipeLine(ptOld, ptMainStart, PipeType::eMainPipe);
|
|
}
|
|
pLineExtend->setStartPoint(ptMainStart);
|
|
pLineExtend->setEndPoint(ptMainEnd);
|
|
vecLine.push_back(pLineExtend);
|
|
}
|
|
|
|
pLine->setStartPoint(ptS);
|
|
pLine->setEndPoint(ptE);
|
|
vecLine.push_back(pLine);
|
|
ptPerE = pLine->endPoint();
|
|
ptPerS = pLine->startPoint();
|
|
}
|
|
|
|
// 设定洁具点到管线的连线
|
|
AddPipeLine(ptE, pt, PipeType::eBranch);
|
|
|
|
ModifyPipe(vecLine, dWidth);
|
|
std::vector<AcDbLine *>::iterator it;
|
|
for (it = vecLine.begin(); it != vecLine.end(); it++)
|
|
{
|
|
if (*it == NULL || (*it)->startPoint().distanceTo((*it)->endPoint()) < 0.001)
|
|
{
|
|
continue;
|
|
}
|
|
AddPipeLine((*it)->startPoint(), (*it)->endPoint(), PipeType::eMainPipe);
|
|
}
|
|
FreeLine(vecLine);
|
|
}
|
|
|
|
// 检查管线是否沿墙敷设
|
|
bool UnfoldInstallSanitarySys::CheckPipe2Wall(const AcGePoint3d &ptS, const AcGePoint3d &ptE, const AcDbLine &lineStartWall)
|
|
{
|
|
AcDbLine line;
|
|
line.setStartPoint(ptS);
|
|
line.setEndPoint(ptE);
|
|
AcGeVector3d vtLine = ptS - ptE, vtPipe2Wall, vtWall, vt;
|
|
vtLine.normalize();
|
|
AcGePoint3d ptStart, ptEnd, ptOnLine1, ptOnLine2;
|
|
double dLen = 0.0, dDist2Start = 0.0, dDist2End = 0.0, dLength = 0.0, dDist2End2 = 0.0, dDist2Start2 = 0.0, dWallLen = 0.0;
|
|
dLen = ptS.distanceTo(ptE);
|
|
|
|
const double dDist = DocGetMeterUnitDim() ? 0.70 : 700;
|
|
AcDbLine lineWall;
|
|
lineWall.setStartPoint(lineStartWall.startPoint());
|
|
lineWall.setEndPoint(lineStartWall.endPoint());
|
|
lineWall.getClosestPointTo(ptS, ptOnLine1, Adesk::kTrue);
|
|
if (ptS.distanceTo(ptOnLine1) > 0.001)
|
|
{
|
|
vtPipe2Wall = ptOnLine1 - ptS;
|
|
}
|
|
else
|
|
{
|
|
vtPipe2Wall = m_vtSan;
|
|
}
|
|
vtPipe2Wall.normalize();
|
|
double dDist2Wall = ptS.distanceTo(ptOnLine1);
|
|
// 找到所有与管线平行墙体
|
|
std::vector<WallData *>::iterator it;
|
|
for (it = m_vecAllWall.begin(); it != m_vecAllWall.end(); it++)
|
|
{
|
|
// 墙体和管线的关系
|
|
ptStart = (*it)->ptS;
|
|
ptEnd = (*it)->ptE;
|
|
dLength = ptStart.distanceTo(ptEnd);
|
|
lineWall.setStartPoint(ptStart);
|
|
lineWall.setEndPoint(ptEnd);
|
|
lineWall.getClosestPointTo(ptS, ptOnLine1, Adesk::kTrue);
|
|
if (ptS.distanceTo(ptOnLine1) > 0.001)
|
|
{
|
|
vt = ptOnLine1 - ptS;
|
|
}
|
|
else
|
|
{
|
|
vt = m_vtSan;
|
|
}
|
|
vt.normalize();
|
|
vtWall = ptStart - ptEnd;
|
|
vtWall.normalize();
|
|
double dDistPipe2Wall = GetDistLines(&lineWall, &line);
|
|
// 平行墙体 且墙体距离管线距离为 初始墙体到管线距离 且在管线同侧
|
|
if (vtWall.isParallelTo(vtLine, m_tolVec) && fabs(dDistPipe2Wall - dDist2Wall) < dDist && vt.isEqualTo(vtPipe2Wall, m_tolVec))
|
|
{
|
|
// 墙体长度
|
|
lineWall.getClosestPointTo(ptS, ptOnLine1, Adesk::kTrue);
|
|
dDist2Start = ptOnLine1.distanceTo(ptStart);
|
|
dDist2End = ptOnLine1.distanceTo(ptEnd);
|
|
|
|
lineWall.getClosestPointTo(ptE, ptOnLine2, Adesk::kTrue);
|
|
dDist2Start2 = ptOnLine2.distanceTo(ptStart);
|
|
dDist2End2 = ptOnLine2.distanceTo(ptEnd);
|
|
|
|
double dDistWall2Pipe = 0.0, dDistWall2Pipe2 = 0.0;
|
|
AcGePoint3d ptTmp;
|
|
line.getClosestPointTo(ptStart, ptTmp, Adesk::kTrue);
|
|
dDistWall2Pipe = ptStart.distanceTo(ptTmp);
|
|
line.getClosestPointTo(ptStart, ptTmp, Adesk::kFalse);
|
|
dDistWall2Pipe2 = ptStart.distanceTo(ptTmp);
|
|
if (fabs(dLength - dDist2Start - dDist2End) < 0.001 && fabs(dLength - dDist2Start2 - dDist2End2) < 0.001)// 既是起始墙体 又是结束墙体
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (fabs(dLength - dDist2Start - dDist2End) < 0.001)// 起始墙体
|
|
{
|
|
if (vtLine.isEqualTo(vtWall))
|
|
{
|
|
dWallLen += ptEnd.distanceTo(ptOnLine1);
|
|
}
|
|
else
|
|
{
|
|
dWallLen += ptStart.distanceTo(ptOnLine1);
|
|
}
|
|
}
|
|
else if (fabs(dLength - dDist2Start2 - dDist2End2) < 0.001)// 结束墙体
|
|
{
|
|
if (vtLine.isEqualTo(vtWall))
|
|
{
|
|
dWallLen += ptStart.distanceTo(ptOnLine2);
|
|
}
|
|
else
|
|
{
|
|
dWallLen += ptEnd.distanceTo(ptOnLine2);
|
|
}
|
|
}
|
|
else if (fabs(dDistWall2Pipe - dDistWall2Pipe2) < 0.001)// 中间墙体
|
|
{
|
|
line.getClosestPointTo(ptStart, ptOnLine1);
|
|
dDist2Start = ptOnLine1.distanceTo(ptS);
|
|
dDist2End = ptOnLine1.distanceTo(ptE);
|
|
|
|
line.getClosestPointTo(ptEnd, ptOnLine2);
|
|
dDist2Start2 = ptOnLine2.distanceTo(ptS);
|
|
dDist2End2 = ptOnLine2.distanceTo(ptE);
|
|
if (fabs(dLen - dDist2Start - dDist2End) < 0.001 && fabs(dLen - dDist2Start2 - dDist2End2) < 0.001)
|
|
{
|
|
dWallLen += ptStart.distanceTo(ptEnd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (fabs(dWallLen - dLen) < dDist)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 分别延长管线和墙体 求交点
|
|
bool UnfoldInstallSanitarySys::GetExtendPipe(std::map<double, LinkedLine> &mapLink, AcDbLine &line, const AcGePoint3d &pt, bool bExtend)
|
|
{
|
|
mapLink.clear();
|
|
double dDist = 0.0, dLen = 0.0, dDist1 = 0.0, dDist2 = 0.0;
|
|
AcGePoint3d ptOnLine, ptS, ptE, ptLineS, ptLineE;
|
|
AcGePoint3dArray arryPts;
|
|
std::vector<PipeData>::iterator itPipe;
|
|
ptLineS = line.startPoint();
|
|
ptLineE = line.endPoint();
|
|
ptLineE = Wcs2Ucs(ptLineE);
|
|
ptLineS = Wcs2Ucs(ptLineS);
|
|
AcGeVector3d vtWall = ptLineE - ptLineS, vtPipe;
|
|
vtWall.normalize();
|
|
for (itPipe = m_vecPipeData.begin(); itPipe != m_vecPipeData.end(); itPipe++)
|
|
{
|
|
if ((*itPipe).type != PipeType::eMainPipe || (*itPipe).pLine == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
arryPts.setLogicalLength(0);
|
|
Acad::ErrorStatus es1, es2;
|
|
if (bExtend)
|
|
{
|
|
es1 = (*itPipe).pLine->intersectWith(&line, AcDb::kExtendBoth, arryPts);
|
|
}
|
|
else
|
|
{
|
|
// 只延长管线和 墙体本身 求交点
|
|
es2 = (*itPipe).pLine->intersectWith(&line, AcDb::kExtendThis, arryPts);
|
|
}
|
|
|
|
ptS = (*itPipe).pLine->startPoint();
|
|
ptE = (*itPipe).pLine->endPoint();
|
|
ptS = Wcs2Ucs(ptS);
|
|
ptE = Wcs2Ucs(ptE);
|
|
vtPipe = ptE - ptS;
|
|
vtPipe.normalize();
|
|
if (arryPts.length() == 1 && vtWall.isPerpendicularTo(vtPipe, m_tolVec))
|
|
{
|
|
ptOnLine = arryPts[0];
|
|
ptOnLine.z = 0;
|
|
|
|
dDist = 0.0;
|
|
ptS = (*itPipe).pLine->startPoint();
|
|
ptE = (*itPipe).pLine->endPoint();
|
|
dLen = ptS.distanceTo(ptE);
|
|
dDist1 = ptS.distanceTo(ptOnLine);
|
|
dDist2 = ptE.distanceTo(ptOnLine);
|
|
if (fabs(dLen - dDist1 - dDist2) < 0.001 && ptOnLine.distanceTo(ptS) > 0.001)// 与管线本身相交
|
|
{
|
|
dDist = ptOnLine.distanceTo(pt);
|
|
}
|
|
else// 与管线延长线相交
|
|
{
|
|
dDist = MAX_DIST;
|
|
}
|
|
|
|
LinkedLine WallData;
|
|
WallData.pLine = (*itPipe).pLine;
|
|
WallData.ptIntersect = ptOnLine;
|
|
WallData.nId = itPipe->nId;
|
|
mapLink.insert(std::make_pair(dDist, WallData));
|
|
}
|
|
}
|
|
|
|
if (mapLink.empty())
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
// 添加管线
|
|
void UnfoldInstallSanitarySys::AddPipeLine(const AcGePoint3d &ptS, const AcGePoint3d &ptE, PipeType type)
|
|
{
|
|
if (ptS.distanceTo(ptE) < 0.001)
|
|
{
|
|
return;
|
|
}
|
|
AcDbLine *pLine = new AcDbLine;
|
|
pLine->setStartPoint(ptS);
|
|
pLine->setEndPoint(ptE);
|
|
AcGePoint3d pt1 = ptS, pt2 = ptE;
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis;
|
|
AcGeVector3d vtY = AcGeVector3d::kYAxis;
|
|
AcGeVector3d vt = pt1 - pt2;
|
|
PipeData data;
|
|
if (vt.isParallelTo(vtX, m_tolVec))
|
|
{
|
|
data.drection = PipeDir::eParallelX;
|
|
}
|
|
else if (vt.isParallelTo(vtY, m_tolVec))
|
|
{
|
|
data.drection = PipeDir::eParallelY;
|
|
}
|
|
else
|
|
{
|
|
data.drection = PipeDir::eParallelX;
|
|
}
|
|
|
|
data.pLine = pLine;
|
|
data.type = type;
|
|
data.nId = m_nId++;
|
|
m_vecPipeData.push_back(data);
|
|
}
|
|
|
|
// 在XOY平面内与vtDir平行,并且在pt点的vtPipe方向的墙体
|
|
bool UnfoldInstallSanitarySys::GetIntersectWall( const AcGePoint3d &pt, const AcGeVector3d &vtDir, AcDbLine &line, AcGeVector3d &vtPipe, bool bExtend)
|
|
{
|
|
vtPipe.normalize();
|
|
AcGeVector3d vt = vtDir;
|
|
vt.z = 0.0;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> > vecWall;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it;
|
|
AcGeVector3d vtWall, vtLine;
|
|
AcDbLine lineWall;
|
|
AcGePoint3d ptOnLine, ptEnt = pt;
|
|
ptEnt.z = 0;
|
|
AcGeTol tolVec;
|
|
tolVec.setEqualVector(0.1);
|
|
for (it = m_vecWallSide.begin(); it != m_vecWallSide.end(); it++)
|
|
{
|
|
if (it->first.GetCurveType() == CURVE_LINE)
|
|
{
|
|
lineWall.setStartPoint(it->first.StartPoint());
|
|
lineWall.setEndPoint(it->first.EndPoint());
|
|
lineWall.getClosestPointTo(ptEnt, ptOnLine);
|
|
double dDist = ptEnt.distanceTo(ptOnLine);
|
|
ptOnLine.z = 0;
|
|
ptOnLine = Wcs2Ucs(ptOnLine);
|
|
AcGePoint3d ptSan = pt;
|
|
ptSan = Wcs2Ucs(ptSan);
|
|
vtLine = ptOnLine - ptSan;
|
|
vtLine.normalize();
|
|
vtLine.z = 0;
|
|
vtWall = Wcs2Ucs(it->first.StartPoint()) - Wcs2Ucs(it->first.EndPoint());
|
|
vtWall.z = 0.0;
|
|
if (vtWall.isParallelTo(vt, tolVec) && (vtLine.isEqualTo(vtPipe, tolVec)))
|
|
{
|
|
vecWall.push_back(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 找到距离pt最近的墙体
|
|
XCurveSegment segNear, segFar;
|
|
if (GetWallSide(pt, vecWall, segNear, segFar))
|
|
{
|
|
// 墙体厚度
|
|
AcGePoint3d ptS = segFar.StartPoint();
|
|
AcGePoint3d ptE = segFar.EndPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine lineTemp(ptS, ptE);
|
|
AcGePoint3d pt = segNear.StartPoint();
|
|
pt.z = 0.0;
|
|
AcGePoint3d ptPrj;
|
|
const double dDist = DocGetMeterUnitDim() ? 1.0 : 1000;
|
|
double dDistWall2San = 0.0;
|
|
if (lineTemp.getClosestPointTo(pt, ptPrj, Adesk::kTrue) == Acad::eOk)
|
|
{
|
|
double dWallThick = pt.distanceTo(ptPrj);
|
|
if (!bExtend)
|
|
{
|
|
// 墙体距离Pt点距离大于1000时，查找失败
|
|
lineTemp.getClosestPointTo(ptEnt, ptOnLine, Adesk::kTrue);
|
|
dDistWall2San = ptEnt.distanceTo(ptOnLine);
|
|
if (dDistWall2San - dWallThick / 2 > dDist + dWallThick * 0.5)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
AcGeVector3d vt = pt - ptPrj;
|
|
vt.normalize();
|
|
line.setStartPoint(segFar.StartPoint() + vt * dWallThick * 0.5);
|
|
line.setEndPoint(segFar.EndPoint() + vt * dWallThick * 0.5);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// 设置起始管线
|
|
void UnfoldInstallSanitarySys::SetStartPipe(AcDbLine *pLine, AcGePoint3d &ptStart, const AcDbLine &line, AcGeVector3d &vtPer)
|
|
{
|
|
AcGePoint3d ptTmp;
|
|
if (line.getClosestPointTo(ptStart, ptTmp) != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
AcGeVector3d vt = ptStart - ptTmp;
|
|
vt.normalize();
|
|
AcGePoint3d ptEnd;
|
|
ptEnd = line.endPoint() + vt * ptStart.distanceTo(ptTmp);
|
|
|
|
if (!CheckPipePos(ptStart, ptEnd))
|
|
{
|
|
ptTmp = ptStart;
|
|
ptStart = ptStart + vt * m_dDistPipe2Wall;
|
|
ptEnd = ptEnd + vt * m_dDistPipe2Wall;
|
|
AddPipeLine(ptTmp, ptStart, PipeType::eMainPipe);
|
|
}
|
|
vtPer = vt;
|
|
pLine->setEndPoint(ptEnd);
|
|
pLine->setStartPoint(ptStart);
|
|
}
|
|
|
|
// 设置中间管线
|
|
void UnfoldInstallSanitarySys::SetMiddlePipe(AcGePoint3d &ptStart, AcGePoint3d &ptEnd, const AcDbLine &line, const std::vector<SanitaryNode> &vecNode, double dWidth, AcGePoint3d &ptPerS, AcGePoint3d &ptPerE, AcGeVector3d &vtPer)
|
|
{
|
|
AcGePoint3d ptS = line.startPoint();
|
|
AcGePoint3d ptE = line.endPoint();
|
|
AcGePoint3d ptOnLine;
|
|
bool bSeted = false;
|
|
AcGeVector3d vt;
|
|
std::vector<SanitaryNode>::const_iterator itSan;
|
|
// 根据墙体两侧是否有洁具 确定管线与墙体的位置(即管线安置在墙体有洁具的一侧)
|
|
for (itSan = vecNode.begin(); itSan != vecNode.end(); itSan++)
|
|
{
|
|
AcGePoint3d ptSan = (*itSan).pt;
|
|
ptSan.z = 0;
|
|
if (line.getClosestPointTo(ptSan, ptOnLine) == Acad::eOk && ptOnLine.distanceTo(ptSan) < m_dDistSearchWall)
|
|
{
|
|
AcGeVector3d vtLine = ptE - ptS;
|
|
vt = ptSan - ptOnLine;
|
|
vt.normalize();
|
|
if (vtLine.isPerpendicularTo(vt, m_tolVec))
|
|
{
|
|
OffSetPipe(ptS, ptE, vt, dWidth);
|
|
vtPer = vt;
|
|
bSeted = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!bSeted)// 墙体两侧1000范围无洁具
|
|
{
|
|
// 和上游墙体平行时，按照上游偏移方向 偏移. 垂直时，向上游方向偏移
|
|
AcGeVector3d vtNor = ptE - ptS;
|
|
vt = ptPerE - ptPerS;
|
|
if (!vt.isParallelTo(vtNor, m_tolVec))
|
|
{
|
|
vtPer = -vt;
|
|
}
|
|
OffSetPipe(ptS, ptE, vtPer, dWidth);
|
|
}
|
|
ptStart = ptS;
|
|
ptEnd = ptE;
|
|
}
|
|
|
|
// 设置终止管线
|
|
void UnfoldInstallSanitarySys::SetEndPipe(AcDbLine *pLine, AcGePoint3d &ptEnd, const AcDbLine &line, double dWidth)
|
|
{
|
|
AcGePoint3d ptTmp;
|
|
ptEnd.z = 0;
|
|
if (line.getClosestPointTo(ptEnd, ptTmp) != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
AcGeVector3d vt = ptEnd - ptTmp;
|
|
AcGePoint3d ptStart;
|
|
ptStart = line.startPoint();
|
|
|
|
OffSetPipe(ptStart, ptTmp, vt, dWidth);
|
|
|
|
pLine->setEndPoint(ptTmp);
|
|
pLine->setStartPoint(ptStart);
|
|
}
|
|
|
|
// 从链表起点生成管网
|
|
void UnfoldInstallSanitarySys::CreatePipeFromStart(LinkNode *pNode, std::vector<LinkNode *> &vecNode)
|
|
{
|
|
LinkNode *pNodeNext = NULL;
|
|
if (NULL != pNode)
|
|
{
|
|
std::vector<LinkNode *>::iterator it;
|
|
if (pNode->m_vecNode.empty())
|
|
{
|
|
vecNode.push_back(pNode);
|
|
return;
|
|
}
|
|
for (it = pNode->m_vecNode.begin(); it != pNode->m_vecNode.end(); it++)
|
|
{
|
|
pNodeNext = *it;
|
|
CString sLayer = GetPipeLayer(m_sysPipe);
|
|
TDbPipe *pPipe = new TDbPipe();
|
|
XLine x;
|
|
x.SetStartPoint(pNode->ptCur);
|
|
x.SetEndPoint(pNodeNext->ptCur);
|
|
x.Make();
|
|
CreatePipeFromStart(pNodeNext, vecNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 生成管线
|
|
void UnfoldInstallSanitarySys::CreatePipe()
|
|
{
|
|
std::vector<PipeData>::iterator it;
|
|
CString sLayer = GetPipeLayer(m_sysPipe);
|
|
InitPipeLayer(sLayer);
|
|
AcGePoint3d ptS, ptE;
|
|
for (it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
|
|
{
|
|
TDbPipe *pPipe = new TDbPipe();
|
|
ptS = it->pLine->startPoint();
|
|
ptE = it->pLine->endPoint();
|
|
ptS.z = m_dElev;
|
|
ptE.z = m_dElev;
|
|
pPipe->SetStartPoint(ptS);
|
|
pPipe->SetEndPoint(ptE);
|
|
pPipe->SetFlowDir(TPipeSys::kFromStart);
|
|
pPipe->SetDnDiameter(m_dPipeDn);
|
|
pPipe->setLayer(sLayer);
|
|
pPipe->SetSysType(GetPipeSysByLayer(sLayer));
|
|
AddToCurrentSpace(pPipe, Adesk::kTrue);
|
|
}
|
|
}
|
|
|
|
// 偏移管线
|
|
void UnfoldInstallSanitarySys::OffSetPipe(AcGePoint3d &ptS, AcGePoint3d &ptE, AcGeVector3d vt, double dWidth)
|
|
{
|
|
// 发生碰撞时，最多偏移2次
|
|
vt.normalize();
|
|
ptS = ptS + vt * (m_dDistPipe2Wall + dWidth);
|
|
ptE = ptE + vt * (m_dDistPipe2Wall + dWidth);
|
|
if (!CheckPipePos(ptS, ptE))
|
|
{
|
|
ptS = ptS + vt * m_dDistPipe2Wall;
|
|
ptE = ptE + vt * m_dDistPipe2Wall;
|
|
if (!CheckPipePos(ptS, ptE))
|
|
{
|
|
ptS = ptS + vt * m_dDistPipe2Wall;
|
|
ptE = ptE + vt * m_dDistPipe2Wall;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 校准管线
|
|
void UnfoldInstallSanitarySys::ModifyPipe(std::vector<AcDbLine *> &vecLine, double dDist)
|
|
{
|
|
AcGePoint3dArray arryPts;
|
|
AcGePoint3d ptTmp, ptS, ptE;
|
|
AcGeVector3d vt;
|
|
|
|
int n = vecLine.size();
|
|
std::vector<AcDbLine *> vecNew;
|
|
std::vector<AcDbLine *>::iterator it;
|
|
it = vecLine.begin();
|
|
if ((*it) == NULL)
|
|
{
|
|
return;
|
|
}
|
|
AcDbLine *pLineFirst = NULL, *pLineSecond = NULL;
|
|
pLineFirst = *it;
|
|
it++;
|
|
while (it != vecLine.end())
|
|
{
|
|
arryPts.setLogicalLength(0);
|
|
if ((*it) == NULL || (*it)->startPoint().distanceTo((*it)->endPoint()) < (dDist + 200))
|
|
{
|
|
it = vecLine.erase(it);
|
|
continue;
|
|
}
|
|
pLineSecond = *it;
|
|
Acad::ErrorStatus es = pLineFirst->intersectWith(pLineSecond,AcDb::kExtendBoth, arryPts);
|
|
if (arryPts.length() == 1)
|
|
{
|
|
ptTmp = arryPts[0];
|
|
pLineFirst->setEndPoint(ptTmp);
|
|
pLineSecond->setStartPoint(ptTmp);
|
|
}
|
|
else if (pLineFirst->endPoint().distanceTo(pLineSecond->startPoint()) > 0.001)// 前后两根管线平行
|
|
{
|
|
ptS = pLineFirst->startPoint();
|
|
ptE = pLineFirst->endPoint();
|
|
ptS = Wcs2Ucs(ptS);
|
|
ptE = Wcs2Ucs(ptE);
|
|
double dDist2Pipe = GetDistLines(pLineFirst, pLineSecond);
|
|
if (dDist2Pipe - (200 - m_dDistPipe2Wall) < 0.001)// 平行管线距离小于80时，平移第二根对齐第一根管
|
|
{
|
|
ptE = Ucs2Wcs(ptE);
|
|
pLineSecond->getClosestPointTo(ptE, ptTmp, Adesk::kTrue);
|
|
pLineSecond->setStartPoint(ptE);
|
|
|
|
ptE = Wcs2Ucs(ptE);
|
|
ptTmp = Wcs2Ucs(ptTmp);
|
|
vt = ptE - ptTmp;
|
|
ptE = pLineSecond->endPoint();
|
|
ptE = Wcs2Ucs(ptE);
|
|
ptE += vt;
|
|
ptE = Ucs2Wcs(ptE);
|
|
pLineSecond->setEndPoint(ptE);
|
|
}
|
|
else
|
|
{
|
|
vt = ptE - ptS;
|
|
vt.normalize();
|
|
ptS = pLineSecond->startPoint();
|
|
|
|
pLineFirst->getClosestPointTo(ptS, ptE, Adesk::kTrue);
|
|
OffSetPipe(ptS, ptE, vt, dDist / 2);
|
|
pLineFirst->setEndPoint(ptE);
|
|
pLineSecond->setStartPoint(ptS);
|
|
|
|
AcDbLine *pLine = new AcDbLine;
|
|
pLine->setStartPoint(ptE);
|
|
pLine->setEndPoint(ptS);
|
|
vecNew.push_back(pLine);
|
|
}
|
|
}
|
|
pLineFirst = pLineSecond;
|
|
it++;
|
|
}
|
|
|
|
for (it = vecNew.begin(); it != vecNew.end(); it++)
|
|
{
|
|
if ((*it) == NULL || (*it)->startPoint().distanceTo((*it)->endPoint()) < 0.001)
|
|
{
|
|
continue;
|
|
}
|
|
vecLine.push_back(*it);
|
|
}
|
|
|
|
for (it = vecLine.begin(); it != vecLine.end();)
|
|
{
|
|
if ((*it) == NULL || (*it)->startPoint().distanceTo((*it)->endPoint()) < 0.001)
|
|
{
|
|
it = vecLine.erase(it);
|
|
}
|
|
else
|
|
{
|
|
it++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 判定管线位置是否合适
|
|
bool UnfoldInstallSanitarySys::CheckPipePos(const AcGePoint3d &ptS, const AcGePoint3d &ptE)
|
|
{
|
|
AcDbLine line(ptS, ptE);
|
|
if ((!PassParallelWall(ptS, ptE)) // 没有穿过平行墙体
|
|
&& !IsPassOtherSanitarySysPt(ptS, ptE) // 没有穿过其他系统洁具点
|
|
&& !IsCollidePipe(&line, m_dDistPipe2Pipe))// 没有与其他系统平行管线发生碰撞
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 给水管是立管时 确定主干方向
|
|
bool UnfoldInstallSanitarySys::ConfirmPipeDir(AcGeVector3d &vtPipe, const AcGePoint3d &ptSan, AcGeVector3d &vtDir)
|
|
{
|
|
AcGePoint3d ptS, ptE, pt = ptSan;
|
|
GetPipePoint(m_idPipe, ptS, ptE);
|
|
m_dElev = ptS.z;
|
|
ptE.z = 0;
|
|
ptS.z = 0;
|
|
ptE = Wcs2Ucs(ptE);
|
|
ptS = Wcs2Ucs(ptS);
|
|
pt.z = 0;
|
|
pt = Wcs2Ucs(pt);
|
|
|
|
AcGePoint3d ptX, ptY;
|
|
ptX.x = pt.x;
|
|
ptX.y = ptS.y;
|
|
ptX.z = 0;
|
|
ptY.x = ptS.x;
|
|
ptY.y = pt.y;
|
|
ptY.z = 0;
|
|
if (IsVertivalPipe(m_idPipe))// 立管
|
|
{
|
|
m_dElev = 0.0;
|
|
int nIndX = PassVertivalPipeNumByLine(ptS, ptX);
|
|
int nIndY = PassVertivalPipeNumByLine(ptS, ptY);
|
|
// 都经过立管或都不经过立管时
|
|
if ((nIndX > 0 && nIndY > 0) || (nIndX == 0 && nIndY == 0))
|
|
{
|
|
return false;
|
|
}
|
|
else if (nIndX > 0)
|
|
{
|
|
vtDir = ptY - ptS;
|
|
}
|
|
else
|
|
{
|
|
vtDir = ptX - ptS;
|
|
}
|
|
}
|
|
else// 直管
|
|
{
|
|
vtPipe = ptE - ptS;
|
|
if (vtPipe.isParallelTo(ptY - ptS, m_tolVec))
|
|
{
|
|
vtPipe = ptY - ptS;
|
|
}
|
|
else if (vtPipe.isParallelTo(ptX - ptS, m_tolVec))
|
|
{
|
|
vtPipe = ptX - ptS;
|
|
}
|
|
vtPipe.normalize();
|
|
vtDir = vtPipe.perpVector();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 获取全部有用墙体边线,过滤掉厚度小于100的墙体
|
|
void UnfoldInstallSanitarySys::ModifyUsefulWall()
|
|
{
|
|
m_vecAllWallSide = m_vecWallSide;
|
|
m_vecWallSide.clear();
|
|
XCurveSegment segNear, segFar;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it;
|
|
double dWallThick = 0.0;
|
|
const double dThick = DocGetMeterUnitDim() ? 0.07 : 70;
|
|
for (it = m_vecAllWallSide.begin(); it != m_vecAllWallSide.end(); it++)
|
|
{
|
|
segNear = it->first;
|
|
segFar = it->second;
|
|
// 墙体厚度
|
|
AcGePoint3d ptS = segFar.StartPoint();
|
|
AcGePoint3d ptE = segFar.EndPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine lineTemp(ptS, ptE);
|
|
AcGePoint3d pt = segNear.StartPoint();
|
|
pt.z = 0.0;
|
|
AcGePoint3d ptPrj;
|
|
if (lineTemp.getClosestPointTo(pt, ptPrj, Adesk::kTrue) == Acad::eOk)
|
|
{
|
|
dWallThick = pt.distanceTo(ptPrj);
|
|
if (dWallThick - dThick > 0.001)
|
|
{
|
|
m_vecWallSide.push_back(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
Entity ent;
|
|
PickSet ssWall(SS_FREE);
|
|
for(long i = 0; i < m_ssDoorWall.Length(); i++)
|
|
{
|
|
ent = m_ssDoorWall[i];
|
|
if (ent.Is(_T("TCH_Wall")))
|
|
{
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if(pWall && pWall->GetWidth(4) - 100.0 < 0.001)
|
|
{
|
|
ssWall += ent;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
|
|
m_ssDoorWall -= ssWall;
|
|
}
|
|
|
|
// 获取距离点最近的墙体的中线
|
|
bool UnfoldInstallSanitarySys::GetWallMiddleLine(const AcGePoint3d &pt, AcDbLine &line)
|
|
{
|
|
XCurveSegment segNear, segFar;
|
|
if (!GetNearestWall(pt, m_dDistSearchWall, segNear, segFar))
|
|
{
|
|
return false;
|
|
}
|
|
AcGePoint3d ptS = segFar.StartPoint();
|
|
AcGePoint3d ptE = segFar.EndPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine lineTemp(ptS, ptE);
|
|
AcGePoint3d ptNear = segNear.StartPoint();
|
|
ptNear.z = 0.0;
|
|
AcGePoint3d ptPrj;
|
|
if (lineTemp.getClosestPointTo(ptNear, ptPrj, Adesk::kTrue) == Acad::eOk)
|
|
{
|
|
double dWallThick = ptNear.distanceTo(ptPrj);
|
|
AcGeVector3d vt = ptNear - ptPrj;
|
|
vt.normalize();
|
|
line.setStartPoint(segFar.StartPoint() + vt * dWallThick * 0.5);
|
|
line.setEndPoint(segFar.EndPoint() + vt * dWallThick * 0.5);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 判断该ID是否存在于墙体链表中，若存在，则返回指向该节点的链表
|
|
bool UnfoldInstallSanitarySys::CheckWallInLst(const std::vector<WallData *> &vecNode, const AcDbObjectId &id, WallData *&pNodeFind)
|
|
{
|
|
pNodeFind = NULL;
|
|
std::vector<WallData *>::const_iterator it;
|
|
for (it = vecNode.begin(); it != vecNode.end(); it++)
|
|
{
|
|
if ((*it)->id == id)
|
|
{
|
|
pNodeFind = *it;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 判断两个墙体节点之间是否有关联关系
|
|
bool UnfoldInstallSanitarySys::CheckRelation(WallData *pNode, WallData *pNodeFind)
|
|
{
|
|
for (int i = 0; i < pNode->lstNode.Length(); i++)
|
|
{
|
|
if (pNode->lstNode[i] == pNodeFind)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 把墙体关系转换为链表
|
|
void UnfoldInstallSanitarySys::SetWallMap(PickSet &ss, WallData *&pNode, std::vector<WallData *> &vecNode)
|
|
{
|
|
if (NULL == pNode)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptS, ptE;
|
|
for (long l = 0; l < ss.Length(); l++)
|
|
{
|
|
Entity ent = ss[l];// 找出一个墙体
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if(NULL != pWall)
|
|
{
|
|
ptS = pWall->StartPoint();
|
|
ptS.z = 0.0;
|
|
ptE = pWall->EndPoint();
|
|
ptE.z = 0.0;
|
|
if ((ptS.distanceTo(pNode->ptS) < 0.001 || ptS.distanceTo(pNode->ptE) < 0.001
|
|
|| ptE.distanceTo(pNode->ptS) < 0.001 || ptE.distanceTo(pNode->ptE) < 0.001)
|
|
&& (pWall->id() != pNode->id))
|
|
{
|
|
// 该墙体和当前链表节点相连
|
|
WallData *pNodeFind = NULL;
|
|
if (CheckWallInLst(vecNode, pWall->id(), pNodeFind))// 墙体在链表中
|
|
{
|
|
if (NULL != pNodeFind && pNodeFind->id != pNode->id)
|
|
{
|
|
// 检查关联是否存在，不存在则创建关联
|
|
if (!CheckRelation(pNode, pNodeFind))
|
|
{
|
|
pNode->lstNode.Append(pNodeFind);
|
|
}
|
|
|
|
if (!CheckRelation(pNodeFind, pNode))
|
|
{
|
|
pNodeFind->lstNode.Append(pNode);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// 墙体不在链表中，创建新节点
|
|
WallData *pNewNode = new WallData;
|
|
pNewNode->dWidth = pWall->GetWidth(4);
|
|
pNewNode->id = pWall->id();
|
|
pNewNode->ptE = ptE;
|
|
pNewNode->ptS = ptS;
|
|
pNewNode->nNum = pWall->GetOpeningIdList().Length();
|
|
|
|
pNode->lstNode.Append(pNewNode);
|
|
pNewNode->lstNode.Append(pNode);
|
|
|
|
vecNode.push_back(pNewNode);
|
|
SetWallMap(ss, pNewNode, vecNode);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
|
|
// 查找该节点到最近主干的所有路径
|
|
void UnfoldInstallSanitarySys::GetBranchRoad(WallData *pNode, std::map<double, std::vector<WallData *> > &mapRoad, std::vector<WallData *> &vecRoad, double dLen, WallData *pNodePre = NULL)
|
|
{
|
|
if (NULL != pNode)
|
|
{
|
|
WallData *pNextNode = NULL;
|
|
std::vector<WallData *> vecRef;
|
|
|
|
// 排除掉该节点的父节点及兄弟节点
|
|
std::vector<WallData *> vecCheck = vecRoad;
|
|
if (NULL != pNodePre)
|
|
{
|
|
for (int j = 0; j < pNodePre->lstNode.Length(); j++)
|
|
{
|
|
vecCheck.push_back(pNodePre->lstNode[j]);
|
|
}
|
|
}
|
|
|
|
double dDist = 0.0;
|
|
for (int i = 0; i < pNode->lstNode.Length(); i++)
|
|
{
|
|
vecRef = vecRoad;
|
|
dDist = dLen;
|
|
pNextNode = pNode->lstNode[i];
|
|
|
|
if (NULL == pNextNode)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
WallData *pNodeFind = NULL;
|
|
if (CheckWallInLst(m_vecRoad, pNextNode->id, pNodeFind))// 当前节点为主干墙体时，存储路径
|
|
{
|
|
vecRoad = vecRef;
|
|
dLen = dDist;
|
|
mapRoad.insert(std::make_pair(dLen, vecRoad));
|
|
break;
|
|
}
|
|
|
|
if (CheckWallInLst(vecCheck, pNextNode->id, pNodeFind))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
dDist += pNextNode->ptS.distanceTo(pNextNode->ptE);
|
|
vecRef.push_back(pNextNode);
|
|
GetBranchRoad(pNextNode, mapRoad, vecRef, dDist, pNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 获取起始墙体到终止墙体之间的所有路径
|
|
void UnfoldInstallSanitarySys::GetRoad(WallData *pNode, const AcDbObjectId &idEnd, std::map<double, std::vector<WallData *> > &mapRoad, std::vector<WallData *> vecRoad, double dLen, WallData *pNodePre = NULL)
|
|
{
|
|
if (NULL != pNode)
|
|
{
|
|
WallData *pNextNode = NULL;
|
|
std::vector<WallData *> vecRef;
|
|
|
|
// 排除掉该节点的父节点及兄弟节点
|
|
std::vector<WallData *> vecCheck = vecRoad;
|
|
if (NULL != pNodePre)
|
|
{
|
|
for (int j = 0; j < pNodePre->lstNode.Length(); j++)
|
|
{
|
|
vecCheck.push_back(pNodePre->lstNode[j]);
|
|
}
|
|
}
|
|
|
|
double dDist = 0.0;
|
|
for (int i = 0; i < pNode->lstNode.Length(); i++)
|
|
{
|
|
vecRef = vecRoad;
|
|
dDist = dLen;
|
|
pNextNode = pNode->lstNode[i];
|
|
|
|
if (NULL == pNextNode)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (pNextNode->id == idEnd)// 当前节点为终止墙体时，存储路径
|
|
{
|
|
vecRef.push_back(pNextNode);
|
|
vecRoad = vecRef;
|
|
dDist += pNextNode->ptS.distanceTo(pNextNode->ptE);
|
|
dLen = dDist;
|
|
mapRoad.insert(std::make_pair(dLen, vecRoad));
|
|
break;
|
|
}
|
|
|
|
WallData *pNodeFind = NULL;
|
|
if (CheckWallInLst(vecCheck, pNextNode->id, pNodeFind))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
dDist += pNextNode->ptS.distanceTo(pNextNode->ptE);
|
|
vecRef.push_back(pNextNode);
|
|
GetRoad(pNextNode, idEnd, mapRoad, vecRef, dDist, pNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获得路径的转折点总数
|
|
int UnfoldInstallSanitarySys::GetTurnNum(const std::vector<WallData *> &vecPt)
|
|
{
|
|
if (vecPt.size() < 2)
|
|
{
|
|
return 0;
|
|
}
|
|
int nNum = 0;
|
|
std::vector<WallData *>::const_iterator it = vecPt.begin();
|
|
AcGeVector3d vt1 = (*it)->ptS - (*it)->ptE, vt2;
|
|
it++;
|
|
while (it != vecPt.end())
|
|
{
|
|
vt2 = (*it)->ptS - (*it)->ptE;
|
|
if (!vt1.isParallelTo(vt2))
|
|
{
|
|
nNum++;
|
|
}
|
|
vt1 = vt2;
|
|
it++;
|
|
}
|
|
return nNum;
|
|
}
|
|
|
|
// 根据路径长度和转折点数量 取得最短路径
|
|
void UnfoldInstallSanitarySys::GetShortestRoad(std::map<double, std::vector<WallData *> > &mapRoad, std::vector<WallData *> &vecRoad)
|
|
{
|
|
std::map<double, std::vector<WallData *> >::iterator itMap = mapRoad.begin();
|
|
|
|
double dLen = (*itMap++).first;
|
|
const double dDist = DocGetMeterUnitDim() ? 0.20 : 200;
|
|
if (mapRoad.size() > 1)
|
|
{
|
|
while ((*itMap).first - dLen < dDist && itMap != mapRoad.end())
|
|
{
|
|
itMap++;
|
|
}
|
|
}
|
|
mapRoad.erase(itMap, mapRoad.end());
|
|
|
|
std::map<double, std::vector<WallData *> > mapSorted;
|
|
for (itMap = mapRoad.begin(); itMap != mapRoad.end(); itMap++)
|
|
{
|
|
double dNum = GetTurnNum((*itMap).second);
|
|
mapSorted.insert(std::make_pair(dNum, (*itMap).second));
|
|
}
|
|
|
|
itMap = mapSorted.begin();
|
|
vecRoad = (*itMap).second;
|
|
}
|
|
|
|
// 用墙体的起点和终点 获取墙体ID
|
|
bool UnfoldInstallSanitarySys::GetWallId(const std::vector<WallData *> &vecWall, const AcDbLine &line, AcDbObjectId &id)
|
|
{
|
|
std::vector<WallData *>::const_iterator it;
|
|
XPoint ptS, ptE;
|
|
ptS = line.startPoint();
|
|
ptE = line.endPoint();
|
|
|
|
const double dDist = DocGetMeterUnitDim() ? 0.35 : 350;
|
|
for (it = vecWall.begin(); it != vecWall.end(); it++)
|
|
{
|
|
if (*it == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
if (((*it)->ptS.distanceTo(ptS) - dDist < 0.001 && (*it)->ptE.distanceTo(ptE) - dDist < 0.001)
|
|
|| ((*it)->ptS.distanceTo(ptE) - dDist < 0.001 && (*it)->ptE.distanceTo(ptS) - dDist < 0.001))
|
|
{
|
|
id = (*it)->id;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 查找距离该墙体最近的主干管
|
|
bool UnfoldInstallSanitarySys::GetBranchWallRoad(AcDbLine &line, std::vector<WallData *> &vecRoad)
|
|
{
|
|
AcDbObjectId idStart;
|
|
AcGePoint3d ptS = line.startPoint();
|
|
AcGePoint3d ptE = line.endPoint();
|
|
std::vector<WallData *> vecAllRoad = m_vecAllWall;
|
|
if (!GetWallId(vecAllRoad, line, idStart))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
WallData *pNodeS = NULL;
|
|
if (CheckWallInLst(m_vecRoad, idStart, pNodeS))
|
|
{
|
|
return false;
|
|
}
|
|
if (!CheckWallInLst(vecAllRoad, idStart, pNodeS))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
vecRoad.clear();
|
|
vecRoad.push_back(pNodeS);
|
|
|
|
std::map<double, std::vector<WallData *> > mapRoad;
|
|
double dLen = 0.0;
|
|
GetBranchRoad(pNodeS, mapRoad, vecRoad, dLen);
|
|
GetShortestRoad(mapRoad, vecRoad);
|
|
ModifyRoad(vecRoad);
|
|
return true;
|
|
}
|
|
|
|
// 获取两个墙体之间的最短路径 并初始化墙体节点结构
|
|
bool UnfoldInstallSanitarySys::GetWallRoad(AcDbLine &lineStart, AcDbLine &lineEnd, std::vector<WallData *> &vecRoad)
|
|
{
|
|
Entity ent;
|
|
PickSet ssWall(SS_FREE);
|
|
for(long i = 0; i < m_ssDoorWall.Length(); i++)// 获取所有上华墙体
|
|
{
|
|
ent = m_ssDoorWall[i];
|
|
if (ent.Is(_T("TCH_Wall")))
|
|
{
|
|
ssWall += ent;
|
|
}
|
|
}
|
|
|
|
ent = ssWall[0l];
|
|
WallData *pNode = new WallData;
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if(pWall)
|
|
{
|
|
pNode->dWidth = pWall->GetWidth(4);
|
|
pNode->id = pWall->id();
|
|
pNode->ptE = pWall->GetEndPoint();
|
|
pNode->ptE.z = 0.0;
|
|
pNode->ptS = pWall->GetStartPoint();
|
|
pNode->ptS.z = 0.0;
|
|
pNode->nNum = pWall->GetOpeningIdList().Length();
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
std::vector<WallData *> vecNode;
|
|
vecNode.push_back(pNode);
|
|
SetWallMap(ssWall, pNode, vecNode);// 初始化墙体节点结构
|
|
|
|
AcDbObjectId idStart, idEnd;
|
|
if (!GetWallId(vecNode, lineEnd, idEnd) || !GetWallId(vecNode, lineStart, idStart))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_vecAllWall = vecNode;
|
|
WallData *pNodeS = NULL;
|
|
if (!CheckWallInLst(vecNode, idStart, pNodeS))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
vecRoad.clear();
|
|
vecRoad.push_back(pNodeS);
|
|
if (idStart == idEnd)// 系统只有一个墙体
|
|
{
|
|
return true;
|
|
}
|
|
|
|
std::map<double, std::vector<WallData *> > mapRoad;
|
|
double dLen = 0.0;
|
|
GetRoad(pNodeS, idEnd, mapRoad, vecRoad, dLen);
|
|
vecRoad.clear();
|
|
GetShortestRoad(mapRoad, vecRoad);
|
|
|
|
// 获取不到路径
|
|
if (vecRoad.front()->id != pNodeS->id || vecRoad.back()->id != idEnd)
|
|
{
|
|
return false;
|
|
}
|
|
ModifyRoad(vecRoad);
|
|
vecNode.clear();
|
|
return true;
|
|
}
|
|
|
|
// 校准墙体路径的起点到终点顺序
|
|
void UnfoldInstallSanitarySys::ModifyRoad(std::vector<WallData *> &vecRoad)
|
|
{
|
|
AcGePoint3d ptS, ptE, ptS2, ptE2;
|
|
std::vector<WallData *>::iterator it = vecRoad.begin();
|
|
ptS = (*it)->ptS;
|
|
ptE = (*it)->ptE;
|
|
while (++it != vecRoad.end())
|
|
{
|
|
ptS2 = (*it)->ptS;
|
|
ptE2 = (*it)->ptE;
|
|
|
|
if (ptS.distanceTo(ptS2) < 0.001)
|
|
{
|
|
it--;
|
|
(*it)->ptS = ptE;
|
|
(*it)->ptE = ptS;
|
|
it++;
|
|
}
|
|
else if (ptS.distanceTo(ptE2) < 0.001)
|
|
{
|
|
it--;
|
|
(*it)->ptS = ptE;
|
|
(*it)->ptE = ptS;
|
|
it++;
|
|
(*it)->ptS = ptE2;
|
|
(*it)->ptE = ptS2;
|
|
}
|
|
else if (ptE.distanceTo(ptE2) < 0.001)
|
|
{
|
|
(*it)->ptS = ptE2;
|
|
(*it)->ptE = ptS2;
|
|
}
|
|
ptS = ptS2;
|
|
ptE = ptE2;
|
|
}
|
|
}
|
|
|
|
// 设定管线标高
|
|
void UnfoldInstallSanitarySys::ModifyPipeElve()
|
|
{
|
|
UnfoldInstallAdjustElevation Elev;
|
|
Elev.SetLinkNode(m_pNodeStart);
|
|
Elev.SetFeedElevation(1.0);
|
|
Elev.SetFeedPipe(m_idPipe);
|
|
Elev.SetSanitaryPt(m_mapSanPt);
|
|
Elev.SetPipeSysType(m_sysPipe);
|
|
Elev.AdjustElevation();
|
|
}
|
|
|
|
// 从交点处打断管线，构造管网
|
|
void UnfoldInstallSanitarySys::SetLinkableNode()
|
|
{
|
|
std::vector<PipeData>::iterator it;
|
|
std::vector<PipeData>::iterator itCheck;
|
|
std::map<double, AcGePoint3d>::iterator itMap;
|
|
|
|
std::vector<AcDbLine *> vecLine;// 保存打断后的管线
|
|
// 打断连接有多个分支的管线
|
|
AcDbLine *pLine = NULL, *pLineCheck = NULL;
|
|
AcGePoint3d ptCheck, ptOnLine;
|
|
for (it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
|
|
{
|
|
std::map<double, AcGePoint3d> mapPts;
|
|
pLine = it->pLine;
|
|
for (itCheck = m_vecPipeData.begin(); itCheck != m_vecPipeData.end(); itCheck++)
|
|
{
|
|
pLineCheck = itCheck->pLine;
|
|
ptCheck = pLineCheck->startPoint();
|
|
pLine->getClosestPointTo(ptCheck, ptOnLine);
|
|
if (ptCheck.distanceTo(ptOnLine) < 0.01 && ptOnLine.distanceTo(pLine->startPoint()) > 0.01 && ptOnLine.distanceTo(pLine->endPoint()) > 0.01)
|
|
{
|
|
mapPts.insert(std::make_pair(pLine->startPoint().distanceTo(ptOnLine), ptOnLine));
|
|
}
|
|
}
|
|
|
|
if (mapPts.size() > 0)
|
|
{
|
|
itMap = mapPts.begin();
|
|
ptCheck = itMap->second;
|
|
AcGePoint3d ptEnd = pLine->endPoint();
|
|
pLine->setEndPoint(ptCheck);
|
|
itMap++;
|
|
for (; itMap != mapPts.end(); itMap++)
|
|
{
|
|
AcDbLine *pLineNew = new AcDbLine;
|
|
pLineNew->setStartPoint(ptCheck);
|
|
pLineNew->setEndPoint(itMap->second);
|
|
vecLine.push_back(pLineNew);
|
|
ptCheck = itMap->second;
|
|
}
|
|
AcDbLine *pLineEnd = new AcDbLine;
|
|
pLineEnd->setStartPoint(ptCheck);
|
|
pLineEnd->setEndPoint(ptEnd);
|
|
vecLine.push_back(pLineEnd);
|
|
}
|
|
}
|
|
|
|
std::vector<AcDbLine *>::iterator itLine;
|
|
for (itLine = vecLine.begin(); itLine != vecLine.end(); itLine++)
|
|
{
|
|
if ((*itLine)->startPoint().distanceTo((*itLine)->endPoint()) < 0.001)
|
|
{
|
|
continue;
|
|
}
|
|
AddPipeLine((*itLine)->startPoint(), (*itLine)->endPoint(), PipeType::eMainPipe);
|
|
}
|
|
|
|
std::vector<LinkNode *> vecNode;
|
|
GetNodeLst(vecNode);
|
|
|
|
ModifyNode(vecNode);
|
|
//CreatePipeFromStart(m_pNodeStart, vecNode);
|
|
ModifyPipeElve();// 设定管线标高
|
|
}
|
|
|
|
// 校准标高点
|
|
void UnfoldInstallSanitarySys::ModifyNode(std::vector<LinkNode *> &vecNode)
|
|
{
|
|
m_pNodeStart = vecNode.front();
|
|
while (m_pNodeStart->pPreNode != NULL)
|
|
{
|
|
m_pNodeStart = m_pNodeStart->pPreNode;
|
|
}
|
|
m_pNodeStart->type = Point_Feed;
|
|
|
|
std::vector<LinkNode *>::iterator itNode;
|
|
std::vector<LinkNode *>::iterator itN;
|
|
std::vector<LinkNode *> vecEnd;
|
|
LinkNode *pNode = NULL, *pNodePer = NULL, *pNodeNext = NULL;
|
|
AcGeVector3d vtPer, vtNext;
|
|
// 设定各个点的属性
|
|
for (itNode = vecNode.begin(); itNode != vecNode.end(); )
|
|
{
|
|
if ((*itNode)->m_vecNode.empty())
|
|
{
|
|
(*itNode)->type = Point_Sanitary;
|
|
if ((*itNode)->ptCur.z > 1.0)
|
|
{
|
|
(*itNode)->ptCur.z = 0;
|
|
}
|
|
|
|
if (m_nInstallType == 1)
|
|
{
|
|
(*itNode)->type = (*itNode)->type | Point_KW;
|
|
}
|
|
else if (m_nInstallType == 0)
|
|
{
|
|
(*itNode)->pPreNode->type = Point_Int | Point_KW;
|
|
}
|
|
vecEnd.push_back(*itNode);
|
|
}
|
|
|
|
pNode = *itNode;
|
|
pNodePer = pNode->pPreNode;
|
|
if (pNodePer != NULL && pNode->m_vecNode.size() == 1)
|
|
{
|
|
pNodeNext = pNode->m_vecNode.front();
|
|
vtPer = pNodePer->ptCur - pNode->ptCur;
|
|
vtNext = pNode->ptCur - pNodeNext->ptCur;
|
|
if (vtNext.isParallelTo(vtPer, m_tolVec))
|
|
{
|
|
pNodeNext->pPreNode = pNodePer;
|
|
for (itN = pNodePer->m_vecNode.begin(); itN != pNodePer->m_vecNode.end(); itN++)
|
|
{
|
|
if ((*itN) == pNode)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
pNodePer->m_vecNode.erase(itN);
|
|
pNodePer->m_vecNode.push_back(pNodeNext);
|
|
itNode = vecNode.erase(itNode);
|
|
}
|
|
else
|
|
{
|
|
itNode++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
itNode++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 根据管线构造管网
|
|
void UnfoldInstallSanitarySys::GetNodeLst(std::vector<LinkNode *> &vecNode)
|
|
{
|
|
std::vector<PipeData>::iterator it;
|
|
std::vector<PipeData>::iterator itCheck;
|
|
AcDbLine *pLine = NULL, *pLineCheck = NULL;
|
|
for (it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
|
|
{
|
|
pLine = it->pLine;
|
|
LinkNode *pNodeS = NULL, *pNodeE = NULL, *pNodePer = NULL, *pNodeNext = NULL, *pNodeFind = NULL;
|
|
// 获取起始节点
|
|
if (!CheckPtInLst(vecNode, pNodeS, pLine->startPoint()))
|
|
{
|
|
pNodeS = new LinkNode;
|
|
pNodeS->ptCur = pLine->startPoint();
|
|
pNodeS->type = Point_Int;
|
|
pNodeS->pPreNode = NULL;
|
|
vecNode.push_back(pNodeS);
|
|
}
|
|
// 获取终止节点
|
|
if (!CheckPtInLst(vecNode, pNodeE, pLine->endPoint()))
|
|
{
|
|
pNodeE = new LinkNode;
|
|
pNodeE->ptCur = pLine->endPoint();
|
|
pNodeE->type = Point_Int;
|
|
vecNode.push_back(pNodeE);
|
|
}
|
|
pNodeE->pPreNode = pNodeS;
|
|
if (!CheckPtInLst(pNodeS->m_vecNode, pNodeFind, pNodeE->ptCur))
|
|
{
|
|
pNodeS->m_vecNode.push_back(pNodeE);
|
|
}
|
|
|
|
for (itCheck = m_vecPipeData.begin(); itCheck != m_vecPipeData.end(); itCheck++)
|
|
{
|
|
if (it->nId == itCheck->nId)
|
|
{
|
|
continue;
|
|
}
|
|
pLineCheck = itCheck->pLine;
|
|
// 根据管线起点 设定其前节点
|
|
if (pNodeS->ptCur.distanceTo(pLineCheck->endPoint()) < 0.01)
|
|
{
|
|
if (!CheckPtInLst(vecNode, pNodePer, pLineCheck->startPoint()))
|
|
{
|
|
pNodePer = new LinkNode;
|
|
pNodePer->ptCur = pLineCheck->startPoint();
|
|
pNodePer->type = Point_Int;
|
|
pNodePer->pPreNode = NULL;
|
|
pNodePer->m_vecNode.push_back(pNodeS);
|
|
vecNode.push_back(pNodePer);
|
|
}
|
|
else if (!CheckPtInLst(pNodePer->m_vecNode, pNodeFind, pNodeS->ptCur))
|
|
{
|
|
pNodePer->m_vecNode.push_back(pNodeS);
|
|
}
|
|
pNodeS->pPreNode = pNodePer;
|
|
}
|
|
else if (pNodeE->ptCur.distanceTo(pLineCheck->startPoint()) < 0.01)// 根据管线终点 设定其后续节点
|
|
{
|
|
if (!CheckPtInLst(vecNode, pNodeNext, pLineCheck->endPoint()))
|
|
{
|
|
pNodeNext = new LinkNode;
|
|
pNodeNext->ptCur = pLineCheck->endPoint();
|
|
pNodeNext->type = Point_Int;
|
|
pNodeE->m_vecNode.push_back(pNodeNext);
|
|
vecNode.push_back(pNodeNext);
|
|
}
|
|
else if (!CheckPtInLst(pNodeE->m_vecNode, pNodeFind, pNodeNext->ptCur))
|
|
{
|
|
pNodeE->m_vecNode.push_back(pNodeNext);
|
|
}
|
|
pNodeNext->pPreNode = pNodeE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 判断点是否在链表中，若在 ，返回该节点
|
|
bool UnfoldInstallSanitarySys::CheckPtInLst(std::vector<LinkNode *> &vecNode, LinkNode *&pNode, AcGePoint3d pt)
|
|
{
|
|
std::vector<LinkNode *>::iterator it;
|
|
AcGePoint3d ptCur;
|
|
for (it = vecNode.begin(); it != vecNode.end(); it++)
|
|
{
|
|
ptCur = (*it)->ptCur;
|
|
if (ptCur.distanceTo(pt) < 0.01)
|
|
{
|
|
pNode = *it;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
} |