1348 lines
38 KiB
C++
1348 lines
38 KiB
C++
#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);
|
|
}
|
|
}
|
|
}
|