#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);
		}
	}
}