gjm/envi-code
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
345044cb46bab74ed842bf88fe9f33a6cf080037
envi-code/SourceCode/Code2026/tg_shs/shs_TwtKernal/PartitionSanitarySys.cpp
T
gjm 345044cb46 初始化提交
2026-09-28 15:28:50 +08:00

1348 lines
37 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "PartitionSanitarySys.h"
#include "NewSanitaryDefineDlg.h"
extern int GetSanitaryDataSourceType(Entity ent);
extern bool GetLocSanitaryData(Entity ent, CSanitaryInfo &data, AcGePoint3d &ptFeed,
AcGePoint3d &ptHeatFeed, AcGePoint3d &ptDrain, AcGePoint3d &ptDir);
extern bool GetSanitaryInfo(Entity ent, XPoint &ptRet, CString &csBlk, CString &csSysBlk, double &nRadius,
double &nDang, double &nBigQ, double &dEle, int iType, CString &sDwbName, CString &sFeedElev, CString &sHotElev);
extern void GetDwbInfo(CString sPicName, int &iCurType);
extern bool GetSanitaryDwbSerial(Entity ent,CString &sDwbName);
// 按污水0-废水1-给水2-热给水3-中水4顺序排序
void PartitionSanitarySys::Sort(std::vector<SanitarySysData> &vec)
{
std::map<int, SanitarySysData> mapData;
std::vector<SanitarySysData>::iterator it;
TPipeSys::SysType sys;
for (it = vec.begin(); it != vec.end(); it++)
{
sys = (*it).type;
if (sys == TPipeSys::kDirtWater)
{
mapData.insert(std::make_pair(0, *it));
}
else if (sys == TPipeSys::kUselessWater)
{
mapData.insert(std::make_pair(1, *it));
}
else if (sys == TPipeSys::kFeedWater || sys == TPipeSys::kFeedWater2 || sys == TPipeSys::kFeedWater3)
{
mapData.insert(std::make_pair(2, *it));
}
else if (sys == TPipeSys::kHeatFeedWater || sys == TPipeSys::kHeatFeedWater2 || sys == TPipeSys::kHeatFeedWater3)
{
mapData.insert(std::make_pair(3, *it));
}
else if (sys == TPipeSys::kUsedWater || sys == TPipeSys::kUsedWater2 || sys == TPipeSys::kUsedWater3)
{
mapData.insert(std::make_pair(4, *it));
}
}
vec.clear();
std::map<int, SanitarySysData>::iterator itMap;
for (itMap = mapData.begin(); itMap != mapData.end(); itMap++)
{
vec.push_back((*itMap).second);
}
}
//检查系统是否具有 洁具和管线
bool PartitionSanitarySys::CheckSys(PickSet &ss)
{
bool bSan = false;
bool bPipe = false;
Entity ent;
for (long l = 0; l < ss.Length(); l++ )
{
ent = ss[l];
if (!bPipe && ent.Is(_T("ATS_PIPE")))//管线或立管
{
bPipe = true;
}
else if (!bSan)
{
CString sSanName;
if (GetSanitaryDwbSerial(ent, sSanName))//定义过的洁具
{
bSan = true;
}
else//给排水附件
{
CString csTmp1, csTmp2, sDwbName, sFeedElev, sHotElev;
double nTmp(0), dDang(0), dRateQ(0), dPtFeedElev(0);
// zxl 2012.12.11 modify 获取洁具数据源
int nDataSourceType = GetSanitaryDataSourceType(ent);
XPoint ptHeatFeed, ptFeed, ptDrain, ptDir;
CSanitaryInfo sanInfo;
if (nDataSourceType == 1 || nDataSourceType == 0)
{
GetSanitaryInfo(ent, ptFeed, csTmp1, csTmp2, nTmp, dDang, dRateQ, dPtFeedElev, 0,
sDwbName, sFeedElev, sHotElev);
}
else
{
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
sDwbName = sanInfo.sDwbName;
}
if (!!ptFeed || !!ptDrain)
{
bSan = true;
}
else//地漏
{
TCHAR szEqLay[256];
ent.GetData(8, szEqLay);
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
if(pEquip)
{
if (_tcsicmp(szEqLay, LAY_EQ_FEED) == 0 || _tcsicmp(szEqLay, LAY_EQ_HEADFEED) == 0 || (_tcsicmp(szEqLay, LAY_EQ_DIRT) == 0 || _tcsicmp(szEqLay, LAY_EQ_USELESS) == 0 || _tcsicmp(szEqLay, LAY_EQUIP_LEAK) == 0))
{
bSan = true;
}
}
OPENOBJ_END();
}
}
}
if (bSan && bPipe)
{
return true;
}
}
return false;
}
bool PartitionSanitarySys::IsLinkedWithPipe(TDbPipe *&pPipe)
{
AcDbObjectId id1, id2;
id1 = pPipe->GetNode(0);
id2 = pPipe->GetNode(1);
int iCount = 0;
OPENOBJ_BEGIN(id1, AcDb::kForRead, TDbPipeNode, pNode);
if(pNode)
{
int num = pNode->GetInterfaceNum();
if(num > 1)
iCount++;
}
OPENOBJ_END();
OPENOBJ_BEGIN(id2, AcDb::kForRead, TDbPipeNode, pNode);
if(pNode)
{
int num = pNode->GetInterfaceNum();
if(num > 1)
iCount++;
}
OPENOBJ_END();
if (iCount > 0)
{
return true;
}
return false;
}
bool PartitionSanitarySys::IsLinkedWithPipe(TDbEquipment *&pEquip, bool bIsFeedPipe = true)
{
AcGePoint3d ptLoc = pEquip->GetLocation();
RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
XPoint pt1, pt2, pt3, pt4;
AcGeVector3d vecX = AcGeVector3d::kXAxis;
vecX.normalize();
AcGeVector3d vecY = AcGeVector3d::kYAxis;
vecY.normalize();
pt1 = ptLoc + vecX * 5;
pt1 = pt1 + vecY * 5;
pt2 = pt1 - vecX * 10;
pt3 = pt2 - vecY * 10;
pt4 = pt3 + vecX * 10;
PickSet ss(SS_FREE);
struct resbuf *pointlist;
pointlist = ads_buildlist(RTPOINT, &pt1, RTPOINT, &pt2, RTPOINT, &pt3, RTPOINT, &pt4, RTPOINT, &pt1, NULL);
ss.Get(_T("CP"), pointlist, NULL, rbMask);
ads_relrb(pointlist);
if (ss.Length() == 0)
{
return false;
}
Entity ent;
TPipeSys::SysType sysPipe;
for (long l = 0; l < ss.Length(); l++ )//遍历集合，确定某类型系统的主管线
{
ent = ss[l];
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
if(pPipe)
{
sysPipe = pPipe->GetSysType();
if (bIsFeedPipe &&(sysPipe == TPipeSys::kFeedWater || sysPipe == TPipeSys::kFeedWater2 || sysPipe == TPipeSys::kFeedWater3
|| sysPipe == TPipeSys::kUsedWater || sysPipe == TPipeSys::kUsedWater2 || sysPipe == TPipeSys::kUsedWater3
|| sysPipe == TPipeSys::kHeatFeedWater || sysPipe == TPipeSys::kHeatFeedWater2 || sysPipe == TPipeSys::kHeatFeedWater3))
{
return true;
}
else if (!bIsFeedPipe && (sysPipe == TPipeSys::kDirtWater || sysPipe == TPipeSys::kUselessWater))
{
return true;
}
}
OPENOBJ_END();
}
return false;
}
bool PartitionSanitarySys::PartitionSanitary(PickSet &ss, std::vector<SanitarySysData> &vec)
{
// 检查洁具系统连接管
PickSet ss2(SS_FREE); // 记录划分后各系统的排水管或给水管
ss2 += ss;
if(!CheckSys(ss2))//系统中只有洁具或只有管线时 退出
{
return false;
}
if (!CheckLinkPipe(ss2, vec))
{
return false;
}
PickSet ssDel(SS_FREE);
Entity ent;
TDbPipe *pPipe = NULL;
//判断是单洁具还是多洁具系统
bool bIsSingle = CheckSanSys(ss2);
// 根据洁具分类规则和排水点或给水点类型，进行分类
for (long l = 0; l < ss.Length(); l++ )
{
ent = ss[l];
AcDbObjectId idSanitary;
acdbGetObjectId(idSanitary, ent);
SanitaryNode node;
node.idSanitary = idSanitary;
if (ent.Is(_T("ATS_PIPE")))//管线或立管
{
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
if (pPipe)
{
std::vector<SanitarySysData>::iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if ((*it).id == pPipe->id())
{
break;
}
}
bool bIsVertical = false;
if (it == vec.end())
{
it = vec.begin();
if (pPipe->IsVertical())
{
//判断立管是否连接排水管或者给水管
for (; it != vec.end(); it++)
{
if ((*it).type == pPipe->GetSysType())
{
TDbPipe *pPipeInSys = NULL;
acdbOpenObject(pPipeInSys, (*it).id, AcDb::kForRead);
if (pPipeInSys)
{
if (pPipeInSys->GetStartPoint().Distance(pPipe->GetStartPoint()) < 0.001 || pPipeInSys->GetEndPoint().Distance(pPipe->GetStartPoint()) < 0.001
|| pPipeInSys->GetStartPoint().Distance(pPipe->GetEndPoint()) < 0.001 || pPipeInSys->GetEndPoint().Distance(pPipe->GetEndPoint()) < 0.001)
{
pPipeInSys->close();
bIsVertical = true;
ssDel += ent;
break;
}
pPipeInSys->close();
}
}
}
if (!bIsVertical)
{
if (!IsLinkedWithPipe(pPipe))
{
node.pt = pPipe->GetStartPoint();
SetPt2Sys(pPipe->GetSysType(), node, vec);
}
}
}
}
}
OPENOBJ_END();
}
else//洁具或排水附件，给水附件
{
int nType = 0;
bool bFeedWater = false, bHeatFeedWater = false, bUserWater = false, bDirtWater = false, bUseless = false;
bFeedWater = (CheckPipeSys(TPipeSys::kFeedWater, vec) || CheckPipeSys(TPipeSys::kFeedWater2, vec) || CheckPipeSys(TPipeSys::kFeedWater3, vec));
bUserWater = (CheckPipeSys(TPipeSys::kUsedWater, vec) || CheckPipeSys(TPipeSys::kUsedWater2, vec) || CheckPipeSys(TPipeSys::kUsedWater3, vec));
bHeatFeedWater = (CheckPipeSys(TPipeSys::kHeatFeedWater, vec) || CheckPipeSys(TPipeSys::kHeatFeedWater2, vec) || CheckPipeSys(TPipeSys::kHeatFeedWater3, vec));
bDirtWater = CheckPipeSys(TPipeSys::kDirtWater, vec);
bUseless = CheckPipeSys(TPipeSys::kUselessWater, vec);
CString csTmp1, csTmp2, sDwbName, sHotElev, sFeedElev;
double nTmp, dEle(0), dDang(0), dBigQ(0), dRateQ(0), dPtFeedElev(0), dNg(0);
XPoint ptHeatFeed, ptFeed, ptDrain, ptDir;
CSanitaryInfo sanInfo;
// zxl 2012.12.11 modify 获取洁具数据源
int nDataSourceType = GetSanitaryDataSourceType(ent);
if (nDataSourceType == 1 || nDataSourceType == 0)
{
GetSanitaryInfo(ent, ptHeatFeed, csTmp1, csTmp2, nTmp, dDang, dBigQ, dEle, 1,
sDwbName, sFeedElev, sHotElev);//热给水点信息
GetSanitaryInfo(ent, ptFeed, csTmp1, csTmp2, nTmp, dDang, dRateQ, dPtFeedElev, 0,
sDwbName, sFeedElev, sHotElev);//给水点信息
GetSanitaryInfo(ent, ptDrain, csTmp1, csTmp2, nTmp, dNg, dBigQ, dEle, 2,
sDwbName, sFeedElev, sHotElev);//排水点信息
}
else
{
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
sDwbName = sanInfo.sDwbName;
}
GetDwbInfo(sDwbName, nType);//洁具类型
if (sDwbName.IsEmpty())//未定义洁具或排水附件 给水附件
{
if (!ptDrain && !ptFeed)
{
TCHAR szEqLay[256];
ent.GetData(8, szEqLay);
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
if(pEquip)
{
if (_tcsicmp(szEqLay, LAY_EQ_FEED) == 0)
{
ptFeed = pEquip->GetLocation();
if (IsLinkedWithPipe(pEquip))
{
continue;
}
}
else if (_tcsicmp(szEqLay, LAY_EQ_HEADFEED) == 0)
{
ptHeatFeed = pEquip->GetLocation();
if (IsLinkedWithPipe(pEquip))
{
continue;
}
}
else if (_tcsicmp(szEqLay, LAY_EQ_DIRT) == 0 || _tcsicmp(szEqLay, LAY_EQ_USELESS) == 0 || _tcsicmp(szEqLay, LAY_EQUIP_LEAK) == 0)
{//地漏
ptDrain = pEquip->GetLocation();
nType = 13;
if (IsLinkedWithPipe(pEquip, false))
{
continue;
}
}
}
else
{
continue;
}
OPENOBJ_END();
}
}
ssDel += ent;
//设置给水点
if (bFeedWater && bHeatFeedWater && bUserWater)//给水、热给水、中水给水点同时存在
{
if (nType == 1 || nType == 6 || nType == 8 || nType == 9 || nType == 10 || nType == 11)//洗脸盆等与给水点连接
{
node.pt = ptFeed;
SetFeedPt2Sys(node, vec);
node.pt = ptHeatFeed;
SetFeedHeatPt2Sys(node, vec);
}
else if (nType == 2 || nType == 3 || nType == 4 || nType == 5)//坐便器、小便器、蹲便器（自闭式、高水箱）与中水管相连接
{
node.pt = ptFeed;
SetUsedWaterPt2Sys(node, vec);
}
else
{
if (!!ptFeed)
{
node.pt = ptFeed;
SetFeedPt2Sys(node, vec);
}
if (!!ptHeatFeed)
{
node.pt = ptHeatFeed;
SetFeedHeatPt2Sys(node, vec);
}
}
}
else if (bFeedWater && bHeatFeedWater && !!ptHeatFeed)//给水和热给水同时存在时，给水连接给水点，热给水连接热给水点
{
if (!!ptFeed)
{
node.pt = ptFeed;
SetFeedPt2Sys(node, vec);
}
if (!!ptHeatFeed)
{
node.pt = ptHeatFeed;
SetFeedHeatPt2Sys(node, vec);
}
}
else if (bFeedWater && bUserWater)//给水和中水同时存在时，坐便器、小便器、蹲便器（自闭式、高水箱）中水管相连接，其他连接给水管
{
if (nType == 2 || nType == 3 || nType == 4 || nType == 5)
{
node.pt = ptFeed;
SetUsedWaterPt2Sys(node, vec);
}
else if (!!ptFeed)
{
node.pt = ptFeed;
SetFeedPt2Sys(node, vec);
}
}
else if (bHeatFeedWater && bUserWater)//热给水和中水同时存在时，中水连接给水点，热给水连接热给水点
{
if (!!ptHeatFeed)
{
node.pt = ptHeatFeed;
SetFeedHeatPt2Sys(node, vec);
}
else if (!!ptFeed)
{
node.pt = ptFeed;
SetUsedWaterPt2Sys(node, vec);
}
}
else if (bFeedWater && !!ptFeed)//单一管线的类型给水点与给水、中水管线连接，热给水点与热给水管连接
{
node.pt = ptFeed;
SetFeedPt2Sys(node, vec);
}
else if (bHeatFeedWater)
{
if (!!ptHeatFeed)
{
node.pt = ptHeatFeed;
SetFeedHeatPt2Sys(node, vec);
}
}
else if (bUserWater)
{
if (!ptHeatFeed && !!ptFeed || bIsSingle)
{
node.pt = ptFeed;
SetUsedWaterPt2Sys(node, vec);
}
}
//设置排水点
node.pt = ptDrain;
if (bDirtWater && bUseless && !!ptDrain)//污废同时存在时
{
if (nType == 1 || nType == 6 || nType == 11 || nType == 13)//洗脸盆、浴盆、淋浴器排水点优先废水管线相连接。
{
SetPt2Sys(TPipeSys::kUselessWater, node, vec);
}
else//其他与污水管连接
{
SetPt2Sys(TPipeSys::kDirtWater, node, vec);
}
}
else if (bDirtWater && !!ptDrain)//单一管线的类型 排水点接污水
{
SetPt2Sys(TPipeSys::kDirtWater, node, vec);
}
else if (bUseless && !!ptDrain)//单一管线的类型 排水点接废水
{
SetPt2Sys(TPipeSys::kUselessWater, node, vec);
}
}
}
ss = ss - ssDel;//删除集合中的主管线和洁具
//遍历数据集合，清除洁具点的管线类型
std::vector<SanitarySysData>::iterator it = vec.begin();
int nIndex = 0;
for (; it != vec.end(); )
{
if ((*it).vecSanitaryNode.size() < 1)//清除 无洁具点的 排水点或给水点
{
it = vec.erase(it);
continue;
}
else
{
// if ((*it).type == TPipeSys::kDirtWater)
// {
// nIndex = 2;
// }
// else if ((*it).type == TPipeSys::kUselessWater)
// {
// nIndex = 1;
// }
// else if ((*it).type == TPipeSys::kFeedWater || (*it).type == TPipeSys::kFeedWater2 || (*it).type == TPipeSys::kFeedWater3)
// {
// nIndex = 3;
// }
// else if ((*it).type == TPipeSys::kHeatFeedWater || (*it).type == TPipeSys::kHeatFeedWater2 || (*it).type == TPipeSys::kHeatFeedWater3)
// {
// nIndex = 4;
// }
// else if ((*it).type == TPipeSys::kUsedWater || (*it).type == TPipeSys::kUsedWater2 || (*it).type == TPipeSys::kUsedWater3)
// {
// nIndex = 5;
// }
//
// double dRadius = 150;
// AcGeVector3d vt(1, 1, 0);
// AcDbLine *pLine = new AcDbLine;
// pLine->setStartPoint((*it).pt + vt * 150);
// pLine->setEndPoint((*it).pt - vt * 150);
// pLine->setColorIndex(nIndex);
// AddToCurrentSpace(pLine, Adesk::kTrue);
//
// std::vector<AcGePoint3d>::iterator itPt = (*it).vecSanitaryPt.begin();
// for (; itPt != (*it).vecSanitaryPt.end(); itPt++)
// {
// AcDbCircle *pCir = new AcDbCircle;
// pCir->setCenter(*itPt);
// pCir->setRadius(dRadius);
// pCir->setColorIndex(nIndex);
// AddToCurrentSpace(pCir, Adesk::kTrue);
// }
it++;
}
}
return true;
}
//判断是否为单一洁具系统（即只包含一个含有热水点的洁具）
bool PartitionSanitarySys::CheckSanSys(PickSet &ss)
{
Entity ent;
int nSanNum = 0;
for (long l = 0; l < ss.Length(); l++ )
{
ent = ss[l];
if (!ent.Is(_T("ATS_PIPE")))
{
CString csTmp1, csTmp2, sDwbName, sHotElev, sFeedElev;
double nTmp, dEle(0), dDang(0), dBigQ(0), dNg(0), dRateQ(0), dPtFeedElev(0);
XPoint ptHeatFeed, ptFeed;
GetSanitaryInfo(ent, ptFeed, csTmp1, csTmp2, nTmp, dDang, dRateQ, dPtFeedElev, 0,
sDwbName, sFeedElev, sHotElev);
GetSanitaryInfo(ent, ptHeatFeed, csTmp1, csTmp2, nTmp, dDang, dBigQ, dEle, 1,
sDwbName, sFeedElev, sHotElev);//热给水点信息
if (!!ptHeatFeed || !!ptFeed)
{
nSanNum++;
}
}
if (nSanNum > 1)
{
return false;
}
}
return true;
}
//设定洁具本身连接给水点的点
void PartitionSanitarySys::SetFeedPt2Sys(SanitaryNode node, std::vector<SanitarySysData> &vec)
{
std::vector<SanitarySysData>::iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if ((*it).type == TPipeSys::kFeedWater || (*it).type == TPipeSys::kFeedWater2 || (*it).type == TPipeSys::kFeedWater3)
{
(*it).vecSanitaryNode.push_back(node);
break;
}
}
}
//设定洁具本身连接热给水水点的点
void PartitionSanitarySys::SetFeedHeatPt2Sys(SanitaryNode node, std::vector<SanitarySysData> &vec)
{
std::vector<SanitarySysData>::iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if ((*it).type == TPipeSys::kHeatFeedWater || (*it).type == TPipeSys::kHeatFeedWater2 || (*it).type == TPipeSys::kHeatFeedWater3)
{
(*it).vecSanitaryNode.push_back(node);
break;
}
}
}
//设定洁具本身连接中水点的点
void PartitionSanitarySys::SetUsedWaterPt2Sys(SanitaryNode node, std::vector<SanitarySysData> &vec)
{
std::vector<SanitarySysData>::iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if ((*it).type == TPipeSys::kUsedWater || (*it).type == TPipeSys::kUsedWater2 || (*it).type == TPipeSys::kUsedWater3)
{
(*it).vecSanitaryNode.push_back(node);
break;
}
}
}
//设定某一类排水点或给水点
void PartitionSanitarySys::SetPt2Sys(TPipeSys::SysType sys, SanitaryNode node, std::vector<SanitarySysData> &vec)
{
std::vector<SanitarySysData>::iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if ((*it).type == sys)
{
(*it).vecSanitaryNode.push_back(node);
return;
}
}
}
//检查管线信息中是否包含某一类型的管线
bool PartitionSanitarySys::CheckPipeSys(TPipeSys::SysType sys, const std::vector<SanitarySysData> &vec)
{
std::vector<SanitarySysData>::const_iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if ((*it).type == sys)
{
return true;
}
}
return false;
}
// 注意选择的排水管为立管时，选择管线标高最大点，否则选择管道流向中的流入端;
// 选择给水管为立管时，选择标高最小点，否则选择管道流向中的流出端
bool PartitionSanitarySys::CheckLinkPipe(PickSet &ss, std::vector<SanitarySysData> &vec)
{
// 检查各类管线是否唯一或不存在，存在多跟同类管线时，提示用户选择(参考文档)
Entity ent;
TDbPipe *pPipe = NULL;
std::map<TPipeSys::SysType, AcGePoint3d> mapPipe;
std::map<TPipeSys::SysType, AcDbObjectId> mapPipeId;
TPipeSys::SysType sysPipe;
std::vector<AcDbObjectId> vecAllPipe;
int nFeedWater = 0, nHeatFeedWater = 0, nUserWater = 0, nDirtWater = 0, nUseless = 0;//记录同类型管线的个数
for (long l = 0; l < ss.Length(); l++ )//遍历集合，确定某类型系统的主管线
{
ent = ss[l];
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
if(pPipe)
{
sysPipe = pPipe->GetSysType();
vecAllPipe.push_back(pPipe->id());
if (sysPipe == TPipeSys::kFeedWater || sysPipe == TPipeSys::kFeedWater2 || sysPipe == TPipeSys::kFeedWater3)
{
SetPipePt(nFeedWater, pPipe, mapPipe, mapPipeId);
}
else if (sysPipe == TPipeSys::kHeatFeedWater || sysPipe == TPipeSys::kHeatFeedWater2 || sysPipe == TPipeSys::kHeatFeedWater3)
{
SetPipePt(nHeatFeedWater, pPipe, mapPipe, mapPipeId);
}
else if (sysPipe == TPipeSys::kUsedWater || sysPipe == TPipeSys::kUsedWater2 || sysPipe == TPipeSys::kUsedWater3)
{
SetPipePt(nUserWater, pPipe, mapPipe, mapPipeId);
}
else if (sysPipe == TPipeSys::kDirtWater)
{
SetPipePt(nDirtWater, pPipe, mapPipe, mapPipeId);
}
else if (sysPipe == TPipeSys::kUselessWater)
{
SetPipePt(nUseless, pPipe, mapPipe, mapPipeId);
}
}
OPENOBJ_END();
}
//同类型存在多跟管线时，提示用户选择主干道
if (nFeedWater > 1)
{
SetSelPipe(vecAllPipe, TPipeSys::kFeedWater, mapPipe, mapPipeId);
}
if (nHeatFeedWater > 1)
{
SetSelPipe(vecAllPipe, TPipeSys::kHeatFeedWater, mapPipe, mapPipeId);
}
if (nUserWater > 1)
{
SetSelPipe(vecAllPipe, TPipeSys::kUsedWater, mapPipe, mapPipeId);
}
if (nDirtWater > 1)
{
SetSelPipe(vecAllPipe, TPipeSys::kDirtWater, mapPipe, mapPipeId);
}
if (nUseless > 1)
{
SetSelPipe(vecAllPipe, TPipeSys::kUselessWater, mapPipe, mapPipeId);
}
//根据管线类型 区分各种类型的给水点或排水点
SanitarySysData sanData;
std::map<TPipeSys::SysType, AcGePoint3d>::iterator itPt = mapPipe.begin();
std::map<TPipeSys::SysType, AcDbObjectId>::iterator itId = mapPipeId.begin();
for (; itPt != mapPipe.end(); itPt++)
{
sanData.type = itPt->first;
sanData.pt = itPt->second;
itId = mapPipeId.find(itPt->first);
if (itId != mapPipeId.end())
{
sanData.id = itId->second;
}
vec.push_back(sanData);
}
return true;
}
//用户选择主给水管或排水管
void PartitionSanitarySys::SetSelPipe(std::vector<AcDbObjectId> &vec, TPipeSys::SysType sys,
std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId)
{
std::vector<AcDbObjectId> vecCur;
std::vector<AcDbObjectId>::iterator it = vec.begin();
TDbPipe *pPipe = NULL;
bool bIsSameType = false;
for (; it != vec.end(); it++)
{
acdbOpenObject(pPipe, *it, AcDb::kForRead);
if (pPipe)
{
//根据管线类型 划分管线
bIsSameType = (pPipe->GetSysType() == sys);
if (sys == TPipeSys::kFeedWater || sys == TPipeSys::kFeedWater2 || sys == TPipeSys::kFeedWater3)
{
bIsSameType = (pPipe->GetSysType() == TPipeSys::kFeedWater || pPipe->GetSysType() == TPipeSys::kFeedWater2 || pPipe->GetSysType() == TPipeSys::kFeedWater3);
}
else if (sys == TPipeSys::kHeatFeedWater || sys == TPipeSys::kHeatFeedWater2 || sys == TPipeSys::kHeatFeedWater3)
{
bIsSameType = (pPipe->GetSysType() == TPipeSys::kHeatFeedWater || pPipe->GetSysType() == TPipeSys::kHeatFeedWater2 || pPipe->GetSysType() == TPipeSys::kHeatFeedWater3);
}
else if (sys == TPipeSys::kUsedWater || sys == TPipeSys::kUsedWater2 || sys == TPipeSys::kUsedWater3)
{
bIsSameType = (pPipe->GetSysType() == TPipeSys::kUsedWater || pPipe->GetSysType() == TPipeSys::kUsedWater2 || pPipe->GetSysType() == TPipeSys::kUsedWater3);
}
if (bIsSameType)
{
vecCur.push_back(*it);
}
}
pPipe->close();
}
if (CheckVPipe(vecCur, mapPipe, mapPipeId))//判断是否是立管接干管
{
return;
}
else
{
SetPipeColor(vecCur, true);//高亮显示管线
SetPipeByCustom(sys, mapPipe, mapPipeId, vecCur);//用户设定主干管
SetPipeColor(vecCur, false);//高亮显示管线
}
}
//获取管线信息
bool PartitionSanitarySys::GetPipeInfo(bool &bVertical, XPoint &ptStart, XPoint &ptEnd, AcDbObjectId &id, TPipeSys::SysType &sys)
{
TDbPipe *pPipe = NULL;
acdbOpenObject(pPipe, id, AcDb::kForRead);
if (pPipe != NULL)
{
ptStart = pPipe->GetStartPoint();
ptEnd = pPipe->GetEndPoint();
if (pPipe->IsVertical())
{
bVertical = true;
}
else
{
bVertical = false;
}
sys = pPipe->GetSysType();
pPipe->close();
return true;
}
return false;
}
//判断立管和干管是否相连（考虑干管和立管的连接点在立管中部的特殊情况），若相连 重新设定给水点或排水点
bool PartitionSanitarySys::CheckVPipe(std::vector<AcDbObjectId> &vec, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId)
{
if (vec.size() > 3)//某一类型管线条数小于等于3根（包含干管和立管的连接点在立管中部的情况（此时有3根管线））时，判断其是否是3根相连的管线
{
return false;
}
std::map<TPipeSys::SysType, AcGePoint3d>::iterator it = mapPipe.begin();
std::map<TPipeSys::SysType, AcDbObjectId>::iterator itId = mapPipeId.begin();
AcDbObjectId id1 = vec[0], id2 = vec[1], id3;
bool bPipe1 = false, bPipe2 = false, bPipe3 = false;
bool bVertical1 = false, bVertical2 = false, bVertical3 = false;
XPoint ptStart1, ptStart2, ptStart3, ptEnd1, ptEnd2, ptEnd3;
TPipeSys::SysType sys1, sys2, sys3;
bPipe1 = GetPipeInfo(bVertical1, ptStart1, ptEnd1, id1, sys1);
bPipe2 = GetPipeInfo(bVertical2, ptStart2, ptEnd2, id2, sys2);
if (vec.size() == 3)//若存在第三根管线,获取其信息
{
id3 = vec[2];
bPipe3 = GetPipeInfo(bVertical3, ptStart3, ptEnd3, id3, sys3);
}
if (bPipe1 && bPipe2)
{
if (bVertical1)
{
if (!bVertical2)//一根立管、一根干管
{
//两根管线首尾相连
if(ptStart1.Distance(ptStart2) - 0.01 < 0.0 || ptStart1.Distance(ptEnd2) - 0.01 < 0.0
|| ptEnd1.Distance(ptStart2) - 0.01 < 0.0 || ptEnd1.Distance(ptEnd2) - 0.01 < 0.0)
{
if (bPipe3)
{
if (bVertical3)//存在第3根且是立管
{
AcGePoint3d pt1, pt2;
pt1 = ptStart1;
pt2 = ptStart3;
pt1.z = 0;
pt2.z = 0;
if (pt1.distanceTo(pt2) - 0.001 > 0.0)//该立管和第一根立管共线，可视为同一根立管
{
return false;
}
}
else
{
return false;
}
}
it = mapPipe.find(sys2);
if (it != mapPipe.end())
{
GetPipePt(id1, it->second);
it->second.z = ptStart2.z;
}
itId = mapPipeId.find(sys2);
if (itId != mapPipeId.end())
{
itId->second = id2;
return true;
}
}
}
else//2根立管
{
AcGePoint3d pt1, pt2;
pt1 = ptStart1;
pt2 = ptStart2;
pt1.z = 0;
pt2.z = 0;
if (pt1.distanceTo(pt2) < 0.001)//两根立管共线
{
if (bPipe3)
{
if (!bVertical3)//第3根为干管
{
//干管和立管首尾相连接
if (ptStart2.Distance(ptStart3) < 0.01 || ptStart2.Distance(ptEnd3) < 0.01
|| ptEnd2.Distance(ptStart3) < 0.01 || ptEnd2.Distance(ptEnd3) < 0.01)
{
it = mapPipe.find(sys2);
if (it != mapPipe.end())
{
GetPipePt(id1, it->second);
it->second.z = ptStart3.z;
}
itId = mapPipeId.find(sys2);
if (itId != mapPipeId.end())
{
itId->second = id3;
return true;
}
}
}
}
}
}
}
else if (bVertical2)//第一根为干管，第二根为立管
{
//干管和立管首尾相连
if (ptStart2.Distance(ptStart1) < 0.01 || ptStart2.Distance(ptEnd1) < 0.01
|| ptEnd2.Distance(ptStart1) < 0.01 || ptEnd2.Distance(ptStart1) < 0.01)
{
//第三根为立管 且和 第一根立管共线
if (bPipe3)
{
if (bVertical3)
{
AcGePoint3d pt1, pt2;
pt1 = ptStart1;
pt2 = ptStart3;
pt1.z = 0;
pt2.z = 0;
if (pt1.distanceTo(pt2) > 0.001)
{
return false;
}
}
else
{
return false;
}
}
it = mapPipe.find(sys2);
if (it != mapPipe.end())
{
GetPipePt(id2, it->second);
it->second.z = ptStart1.z;
}
itId = mapPipeId.find(sys2);
if (itId != mapPipeId.end())
{
itId->second = id1;
return true;
}
}
}
}
return false;
}
//高亮显示提供给用户选择的管线
void PartitionSanitarySys::SetPipeColor(std::vector<AcDbObjectId> &vec, bool bTrue)
{
std::vector<AcDbObjectId>::iterator it = vec.begin();
TDbPipe *pPipe = NULL;
for (; it != vec.end(); it++)
{
Acad::ErrorStatus es = acdbOpenObject(pPipe, *it, AcDb::kForWrite);
if (pPipe)
{
if (bTrue)
{
pPipe->setColorIndex(1);
}
else
{
pPipe->setColor(AcCmColor());
}
pPipe->close();
}
}
}
//设置某一类型系统的给水点或排水点
bool PartitionSanitarySys::SetPipePt(int &nNum, TDbPipe *&pPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId)
{
AcGePoint3d ptPipe;
if (nNum == 0)//第一次遇到某一类型管线，设定该类型管线给水点或排水点
{
GetPipePt(pPipe, ptPipe);
mapPipe.insert(std::make_pair(pPipe->GetSysType(), ptPipe));
mapPipeId.insert(std::make_pair(pPipe->GetSysType(), pPipe->id()));
}
nNum++;
return true;
}
//获取管线的排水点或给水点
void PartitionSanitarySys::GetPipePt(TDbPipe *&pPipe, AcGePoint3d &ptPipe)
{
if (pPipe->IsVertical())
{
ptPipe = pPipe->GetStartPoint();
}
else
{
if (pPipe->GetFlowDir() == TPipeSys::kFromStart)
{
pPipe->getEndPoint(ptPipe);
if (pPipe->GetSysType() == TPipeSys::kDirtWater || pPipe->GetSysType() == TPipeSys::kUselessWater)
{
pPipe->getStartPoint(ptPipe);
}
}
else
{
pPipe->getStartPoint(ptPipe);
if (pPipe->GetSysType() == TPipeSys::kDirtWater || pPipe->GetSysType() == TPipeSys::kUselessWater)
{
pPipe->getEndPoint(ptPipe);
}
}
}
}
void PartitionSanitarySys::GetPipePt(AcDbObjectId &id, AcGePoint3d &ptPipe)
{
TDbPipe *pPipe = NULL;
acdbOpenObject(pPipe, id, AcDb::kForRead);
if (pPipe == NULL)
{
return;
}
GetPipePt(pPipe, ptPipe);
pPipe->close();
}
//判断某管线是否在管线系统选择集中
bool PartitionSanitarySys::CheckPipeInVec(Entity &ent, std::vector<AcDbObjectId> &vec)
{
AcDbObjectId id;
acdbGetObjectId(id, ent);
std::vector<AcDbObjectId>::iterator it = vec.begin();
for (; it != vec.end(); it++)
{
if (id == *it)
{
return true;
}
}
return false;
}
bool PartitionSanitarySys::SetFeedPipeByCust(Entity &entPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId, std::vector<AcDbObjectId> &vec)
{
CString sNote;
RBList rbMask = ads_buildlist( -4, _T("<or"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_FEED, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_FEED2, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_FEED3, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_FEED, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_FEED2, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_FEED3, -4, _T("and>"),
-4, _T("or>"), NULL);
sNote = _T("\n存在多根给水管线，请选择主给水管:");
while (true)
{
int nRet = SelectEntity(sNote, entPipe, rbMask);
if (nRet == RTNORM)
{
if (!CheckPipeInVec(entPipe, vec))//所选管线不在选择集中,继续选择
{
continue;
}
else
{
break;
}
}
else if (nRet == RTCAN || nRet == RTERROR)//取消操作，清空容器中该类型系统
{
mapPipe.erase(TPipeSys::kFeedWater);
mapPipe.erase(TPipeSys::kFeedWater2);
mapPipe.erase(TPipeSys::kFeedWater3);
mapPipeId.erase(TPipeSys::kFeedWater);
mapPipeId.erase(TPipeSys::kFeedWater2);
mapPipeId.erase(TPipeSys::kFeedWater3);
return false;
}
}
return true;
}
bool PartitionSanitarySys::SetHeadFeedPipeByCust(Entity &entPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId, std::vector<AcDbObjectId> &vec)
{
CString sNote;
RBList rbMask = ads_buildlist( -4, _T("<or"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_HEADFEED, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_HEADFEED2, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_HEADFEED3, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_HEADFEED, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_HEADFEED2, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_HEADFEED3, -4, _T("and>"),
-4, _T("or>"), NULL);
sNote = _T("\n存在多根热给水管线，请选择主热给水管:");
while (true)
{
int nRet = SelectEntity(sNote, entPipe, rbMask);
if (nRet == RTNORM)
{
if (!CheckPipeInVec(entPipe, vec))//所选管线不在选择集中
{
continue;
}
else
{
break;
}
}
else if (nRet == RTCAN || nRet == RTERROR)
{
mapPipe.erase(TPipeSys::kHeatFeedWater);
mapPipe.erase(TPipeSys::kHeatFeedWater2);
mapPipe.erase(TPipeSys::kHeatFeedWater3);
mapPipeId.erase(TPipeSys::kHeatFeedWater);
mapPipeId.erase(TPipeSys::kHeatFeedWater2);
mapPipeId.erase(TPipeSys::kHeatFeedWater3);
return false;
}
}
return true;
}
bool PartitionSanitarySys::SetusedPipeByCust(Entity &entPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId, std::vector<AcDbObjectId> &vec)
{
CString sNote;
RBList rbMask = ads_buildlist( -4, _T("<or"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USED, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USED2, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USED3, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_USED, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_USED2, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_USED3, -4, _T("and>"),
-4, _T("or>"), NULL);
sNote = _T("\n存在多根中水管线，请选择主中水管:");
while (true)
{
int nRet = SelectEntity(sNote, entPipe, rbMask);
if (nRet == RTNORM)
{
if (!CheckPipeInVec(entPipe, vec))//所选管线不在选择集中
{
continue;
}
else
{
break;
}
}
else if (nRet == RTCAN || nRet == RTERROR)
{
mapPipe.erase(TPipeSys::kUsedWater);
mapPipe.erase(TPipeSys::kUsedWater2);
mapPipe.erase(TPipeSys::kUsedWater3);
mapPipeId.erase(TPipeSys::kUsedWater);
mapPipeId.erase(TPipeSys::kUsedWater2);
mapPipeId.erase(TPipeSys::kUsedWater3);
return false;
}
}
return true;
}
bool PartitionSanitarySys::SetDirtPipeByCust(Entity &entPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId, std::vector<AcDbObjectId> &vec)
{
CString sNote;
RBList rbMask = ads_buildlist( -4, _T("<or"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_DIRT, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_DIRT, -4, _T("and>"),
-4, _T("or>"), NULL);
sNote = _T("\n存在多根污水管线，请选择主污水管:");
while (true)
{
int nRet = SelectEntity(sNote, entPipe, rbMask);
if (nRet == RTNORM)
{
if (!CheckPipeInVec(entPipe, vec))//所选管线不在选择集中
{
continue;
}
else
{
break;
}
}
else if (nRet == RTCAN || nRet == RTERROR)
{
mapPipe.erase(TPipeSys::kDirtWater);
mapPipeId.erase(TPipeSys::kDirtWater);
return false;
}
}
return true;
}
bool PartitionSanitarySys::SetUselessPipeByCust(Entity &entPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId, std::vector<AcDbObjectId> &vec)
{
CString sNote;
RBList rbMask = ads_buildlist( -4, _T("<or"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USELESS, -4, _T("and>"),
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_VPIPE_USELESS, -4, _T("and>"),
-4, _T("or>"), NULL);
sNote = _T("\n存在多根废水管线，请选择主废水管:");
while (true)
{
int nRet = SelectEntity(sNote, entPipe, rbMask);
if (nRet == RTNORM)
{
if (!CheckPipeInVec(entPipe, vec))//所选管线不在选择集中
{
continue;
}
else
{
break;
}
}
else if (nRet == RTCAN || nRet == RTERROR)
{
mapPipe.erase(TPipeSys::kUselessWater);
mapPipeId.erase(TPipeSys::kUselessWater);
return false;
}
}
return true;
}
//存在多跟同类管线时，提示用户选择
bool PartitionSanitarySys::SetPipeByCustom(TPipeSys::SysType sysPipe, std::map<TPipeSys::SysType, AcGePoint3d> &mapPipe, std::map<TPipeSys::SysType, AcDbObjectId> &mapPipeId, std::vector<AcDbObjectId> &vec)
{
AcGePoint3d pt;
Entity entPipe;
if (sysPipe == TPipeSys::kFeedWater || sysPipe == TPipeSys::kFeedWater2 || sysPipe == TPipeSys::kFeedWater3)
{
if (!SetFeedPipeByCust(entPipe, mapPipe, mapPipeId, vec))//用户选择失败
{
return false;
}
}
else if (sysPipe == TPipeSys::kHeatFeedWater || sysPipe == TPipeSys::kHeatFeedWater2 || sysPipe == TPipeSys::kHeatFeedWater3)
{
if (!SetHeadFeedPipeByCust(entPipe, mapPipe, mapPipeId, vec))
{
return false;
}
}
else if (sysPipe == TPipeSys::kUsedWater || sysPipe == TPipeSys::kUsedWater2 || sysPipe == TPipeSys::kUsedWater3)
{
if (!SetusedPipeByCust(entPipe, mapPipe, mapPipeId, vec))
{
return false;
}
}
else if (sysPipe == TPipeSys::kDirtWater)
{
if (!SetDirtPipeByCust(entPipe, mapPipe, mapPipeId, vec))
{
return false;
}
}
else if (sysPipe == TPipeSys::kUselessWater)
{
if (!SetUselessPipeByCust(entPipe, mapPipe, mapPipeId, vec))
{
return false;
}
}
//根据用户选择，设定相应的排水点或给水点
OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
if (pPipe != NULL)
{
TPipeSys::SysType sys = pPipe->GetSysType();
GetPipePt(pPipe, pt);
std::map<TPipeSys::SysType, AcGePoint3d>::iterator it = mapPipe.begin();
std::map<TPipeSys::SysType, AcDbObjectId>::iterator itId = mapPipeId.begin();
it = mapPipe.find(pPipe->GetSysType());
itId = mapPipeId.find(pPipe->GetSysType());
//选择成功，修改该类型排水点或给水点
if (it != mapPipe.end() && itId != mapPipeId.end())
{
it->second = pt;
itId->second = pPipe->id();
}
else//选择成功，但类型不相符（比如： 系统类型为给水低区，但用户选择给水中区），尊重用户选择
{
if (sys == TPipeSys::kFeedWater || sys == TPipeSys::kFeedWater2 || sys == TPipeSys::kFeedWater3)
{
mapPipe.erase(TPipeSys::kFeedWater);
mapPipe.erase(TPipeSys::kFeedWater2);
mapPipe.erase(TPipeSys::kFeedWater3);
mapPipeId.erase(TPipeSys::kFeedWater);
mapPipeId.erase(TPipeSys::kFeedWater2);
mapPipeId.erase(TPipeSys::kFeedWater3);
}
else if (sys == TPipeSys::kHeatFeedWater || sys == TPipeSys::kHeatFeedWater2 || sys == TPipeSys::kHeatFeedWater3)
{
mapPipe.erase(TPipeSys::kHeatFeedWater);
mapPipe.erase(TPipeSys::kHeatFeedWater2);
mapPipe.erase(TPipeSys::kHeatFeedWater3);
mapPipeId.erase(TPipeSys::kHeatFeedWater);
mapPipeId.erase(TPipeSys::kHeatFeedWater2);
mapPipeId.erase(TPipeSys::kHeatFeedWater3);
}
else if (sys == TPipeSys::kUsedWater || sys == TPipeSys::kUsedWater2 || sys == TPipeSys::kUsedWater3)
{
mapPipe.erase(TPipeSys::kUsedWater);
mapPipe.erase(TPipeSys::kUsedWater2);
mapPipe.erase(TPipeSys::kUsedWater3);
mapPipeId.erase(TPipeSys::kUsedWater);
mapPipeId.erase(TPipeSys::kUsedWater2);
mapPipeId.erase(TPipeSys::kUsedWater3);
}
mapPipe.insert(std::make_pair(pPipe->GetSysType(), pt));
mapPipeId.insert(std::make_pair(pPipe->GetSysType(), pPipe->id()));
}
}
OPENOBJ_END();
return true;
}
void PartitionSanitarySys::GetOtherSanitaryPt( TPipeSys::SysType sys, const std::vector<SanitarySysData> &vec, std::vector<AcGePoint3d> &vecPt )
{
std::vector<SanitarySysData>::const_iterator it;
std::vector<SanitaryNode>::const_iterator itN;
for (it = vec.begin(); it != vec.end(); it++)
{
if ((*it).type == sys)
{
continue;
}
for (itN = (*it).vecSanitaryNode.begin(); itN != (*it).vecSanitaryNode.end(); itN++)
{
vecPt.push_back((*itN).pt);
}
}
}
Reference in new issue View Git Blame Copy Permalink