#include "StdAfx.h"
#include "UnfoldInstallAdjustElevation.h"
#include "DbEquipment.h"
#include "NewSanitaryDefineDlg.h"

extern double GetEntDriection(const XPoint &ptStart, const XPoint &ptEnd);
extern int GetSanitaryDataSourceType(Entity ent);
extern bool GetLocSanitaryData(Entity ent, CSanitaryInfo &data, AcGePoint3d &ptFeed, 
							   AcGePoint3d &ptHeatFeed, AcGePoint3d &ptDrain, AcGePoint3d &ptDir);

UnfoldInstallAdjustElevation::UnfoldInstallAdjustElevation()
{
	m_pLinkNode = NULL;
	m_dToWallDist = 100;
	m_dFeedEle = 1000;
}

UnfoldInstallAdjustElevation::~UnfoldInstallAdjustElevation()
{
	// 找出根节点
	LinkNode *pNode = m_pLinkNode;
	while(pNode->pPreNode != NULL)
	{
		pNode = pNode->pPreNode;
	}
	// 从供水点开始依次删除本节点和其子节点
	DeleteNode(m_pLinkNode);	
}

void UnfoldInstallAdjustElevation::AdjustElevation()
{
	// 排序变高洁具顺序
	std::vector<LinkNode*> vecNode;
	SanitarySort(vecNode);
	if (vecNode.empty())
	{
		return;
	}

	// 先变高第一个洁具到供水点整条路径
	LinkNode *pFirstNode = vecNode[0];
	AdjustFirstSanEle(pFirstNode);
	vecNode.erase(vecNode.begin());

	// 其余洁具高过程中止于存在多个分支的点
	AdjustSanitaryElevation(vecNode);

//	DrawLine();
	DrawPipe();
}

void UnfoldInstallAdjustElevation::AdjustFirstSanEle(LinkNode *pFirstNode)
{
	AcGePoint3d ptCur, ptPre, ptSan; // 当前节点和上一个节点
	AcGePoint3d ptS, ptE;     // 产生的直线的起始点
	double dSanEle = 0.0, dPipeEle = 0.0; // 洁具点标高，洁具支管标高
	int nType;
	while(pFirstNode != NULL)
	{
		ptCur = pFirstNode->ptCur;
	    nType = pFirstNode->type;
		if (SearchPointType(Point_Sanitary, nType)) // 洁具点
		{
			ptPre = ptCur; // 保存当前节点
			// 洁具点标高
			AcDbObjectId idSan = GetSanitaryId(ptCur);
			if (IsSanitaryPtEleSamePipe(idSan)) // 洁具点标高随支管
			{
				if (!GetPipeEleForSanitary(idSan, dSanEle)) // 洁具标高随供水点标高
				{
					// 未定义标高时，以供水点标高为准
					dSanEle = GetFeedPtEle(); 
				}
				dPipeEle = dSanEle;
				ptPre.z = dSanEle;
			} 
			else // 用户指定了洁具点标高
			{
				if (!GetPipeEleForSanitary(idSan, dPipeEle))
				{
					// 未定义支管标高时，支管标高随供水管标高
					dPipeEle = GetFeedPtEle();	
				}

				if (!GetSanitaryPtEle(idSan, dSanEle))
				{
					// 未定义洁具点标高时，随支管标高
					dSanEle = dPipeEle; 
				}
				
				if (SearchPointType(Point_KW, nType)) // 在洁具点处产生扣弯, 水平连接方式
				{
					ptS = ptCur;
					ptE = ptCur;
					ptS.z = dPipeEle;
					ptE.z = dSanEle;
					CreateLine(ptS, ptE, eKWPipe);	
					AddPointElevation(ptCur, dPipeEle);
					AddPointElevation(ptCur, dSanEle);
				}
			}
			ptSan = ptCur;
			ptSan.z = dSanEle;
			ModifySanitaryPt(ptSan);
		}
		else if (SearchPointType(Point_Int, nType)) // 普通交点
		{
			if (SearchPointType(Point_KW, nType)) // 扣弯，垂直连接方式
			{
				ptS = ptCur;
				ptE = ptPre;
				ptS.z = dSanEle;
				ptE.z = dSanEle;
				CreateLine(ptS, ptE, eSmallPipe);
				ptS = ptCur;
				ptE = ptCur;
				ptS.z = dPipeEle;
				ptE.z = dSanEle;
				CreateLine(ptS, ptE, eKWPipe);
				AddPointElevation(ptCur, dSanEle);
				AddPointElevation(ptCur, dPipeEle);
				AddPointElevation(ptPre, dSanEle);
			}
			else 
			{
				ptS = ptCur;
				ptE = ptPre;
				ptS.z = dPipeEle;
				ptE.z = dPipeEle;
				CreateLine(ptS, ptE, ePipe);
				AddPointElevation(ptCur, dPipeEle);
				AddPointElevation(ptPre, dPipeEle);
			}
			ptPre = ptCur;
		}
		else if (SearchPointType(Point_Feed, nType)) // 供水点
		{
			double dFeedEle = GetFeedPtEle();
			if (IsFeedVPipe() || fabs(dFeedEle - dPipeEle) < 0.001) // 供水管为立管或供水点标高与洁具支管标高相同
			{
				ptS = ptCur;
				ptE = ptPre;
				ptS.z = dPipeEle;
				ptE.z = dPipeEle;
				CreateLine(ptS, ptE, ePipe);
				AddPointElevation(ptCur, dPipeEle);
				AddPointElevation(ptPre, dPipeEle);
			}
			else // 供水点标高与洁具支管标高不一致，需变高产生扣弯
			{
				AdjustEleBetweenPts(ptCur, ptPre, dFeedEle, dPipeEle);
			}
			ptPre = ptCur;
		}
		pFirstNode = pFirstNode->pPreNode;
	}
}

void UnfoldInstallAdjustElevation::AdjustSanitaryElevation(const std::vector<LinkNode*> vecNode)
{
	AcGePoint3d ptCur, ptPre, ptSan; // 当前节点和子节点
	AcGePoint3d ptS, ptE;     // 产生的直线的起始点
	double dSanEle = 0.0, dPipeEle = 0.0; // 洁具点标高，洁具支管标高
	int nType; // 点类型
	LinkNode *pNode = NULL;
	std::set<double> setEle;  // 点的标高值
	std::vector<LinkNode*>::const_iterator it;
	for (it = vecNode.begin(); it != vecNode.end(); it++)
	{
		pNode = *it;
		while(pNode != NULL)
		{
			ptCur = pNode->ptCur;
			nType = pNode->type;
			if (IsAdjustPointEle(ptCur)) // 该点已经被处理过
			{
				AdjustEleBetweenPts(ptCur, ptPre, dPipeEle);
				break;
			} 
			else 
			{
				if (SearchPointType(Point_Sanitary, nType)) // 洁具点
				{
					ptPre = ptCur; // 保存当前节点
					// 洁具点标高
					AcDbObjectId idSan = GetSanitaryId(ptCur);
					if (IsSanitaryPtEleSamePipe(idSan)) // 洁具点标高随支管
					{
						if (!GetPipeEleForSanitary(idSan, dSanEle)) // 洁具标高随供水点标高
						{
							dSanEle = GetParentNodeEle(ptCur);
						}
						dPipeEle = dSanEle;
						ptPre.z = dSanEle;
					} 
					else // 用户指定了洁具点标高
					{
						if (!GetPipeEleForSanitary(idSan, dPipeEle))
						{
							dPipeEle = GetParentNodeEle(ptCur);
						}

						if(!GetSanitaryPtEle(idSan, dSanEle))
						{
							dSanEle = dPipeEle;
						}

						if (SearchPointType(Point_KW, nType)) // 在洁具点处产生扣弯, 水平连接方式
						{
							ptS = ptCur;
							ptE = ptCur;
							ptS.z = dPipeEle;
							ptE.z = dSanEle;
							CreateLine(ptS, ptE, eKWPipe);	
							AddPointElevation(ptCur, dPipeEle);
							AddPointElevation(ptCur, dSanEle);
						}
					}
					ptSan = ptCur;
					ptSan.z = dSanEle;
		        	ModifySanitaryPt(ptSan);
				}
				else if (SearchPointType(Point_Int, nType)) // 普通交点
				{
					if (SearchPointType(Point_KW, nType)) // 扣弯，垂直连接方式
					{
						ptS = ptCur;
						ptE = ptPre;
						ptS.z = dSanEle;
						ptE.z = dSanEle;
						CreateLine(ptS, ptE, eSmallPipe);
						ptS = ptCur;
						ptE = ptCur;
						ptS.z = dPipeEle;
						ptE.z = dSanEle;
						CreateLine(ptS, ptE, eKWPipe);
						AddPointElevation(ptCur, dSanEle);
						AddPointElevation(ptCur, dPipeEle);
						AddPointElevation(ptPre, dSanEle);
					}
					else 
					{
						ptS = ptCur;
						ptE = ptPre;
						ptS.z = dPipeEle;
						ptE.z = dPipeEle;
						CreateLine(ptS, ptE, ePipe);
						AddPointElevation(ptCur, dPipeEle);
						AddPointElevation(ptPre, dPipeEle);
					}
					ptPre = ptCur;
				}
			}
			pNode = pNode->pPreNode;
		}
	}
}

void UnfoldInstallAdjustElevation::SetLinkNode( LinkNode *pNode )
{
	m_pLinkNode = pNode;
}

void UnfoldInstallAdjustElevation::SetFeedElevation( double dEle )
{
	m_dFeedEle = dEle;
	if (!DocGetMeterUnitDraw())
	{
		m_dFeedEle *= 1000;
	}
}

void UnfoldInstallAdjustElevation::SetFeedPipe( const AcDbObjectId &idPipe )
{
	m_idFeedPipe = idPipe;
}

void UnfoldInstallAdjustElevation::SetSanitaryPt( const std::map<AcDbObjectId,AcGePoint3d> &mapSan )
{
	m_mapSanPt = mapSan;
}

void UnfoldInstallAdjustElevation::SetPipeSysType( TPipeSys::SysType sys )
{
	m_sysPipeType = sys;
}

void UnfoldInstallAdjustElevation::SanitarySort(std::vector<LinkNode*> &vecNode)
{
	// 找出供水点
	LinkNode *pNode = m_pLinkNode;
	while(pNode->pPreNode != NULL)
	{
		pNode = pNode->pPreNode;
	}
	// 按流经洁具点先后顺序获得洁具点
	GetSanitaryNode(pNode, vecNode);
}

bool UnfoldInstallAdjustElevation::SearchPointType( int nType, int nOrignType )
{
	bool bRet = ((nOrignType & nType) != 0) ? true : false;
	return bRet;
}

void UnfoldInstallAdjustElevation::DeleteNode( LinkNode *pNode )
{
	if (pNode != NULL)
	{
		for (int i = 0; i < pNode->m_vecNode.size(); i++)
		{
			DeleteNode(pNode->m_vecNode[i]);
		}
		delete pNode;
	}
}

void UnfoldInstallAdjustElevation::GetSanitaryNode( LinkNode *pNode, std::vector<LinkNode*> &vecNode )
{
	if (pNode != NULL)
	{
		if (SearchPointType(Point_Sanitary, pNode->type)) // 洁具点
		{
			vecNode.push_back(pNode);
		}
		else if (pNode->m_vecNode.size() != 0)
		{
			int nLinkNum = pNode->m_vecNode.size();
			if (nLinkNum == 1)
			{
				GetSanitaryNode(pNode->m_vecNode[0], vecNode);
			}
			else  
			{
				if (pNode->pPreNode != NULL) // 前向节点存在，其中后续节点，前向节点，本节点共线的分支最后处理
				{
					LinkNode *pParallelNode = NULL; // 平行节点
					AcGePoint3d ptPre = pNode->pPreNode->ptCur;
					AcGePoint3d ptNext;
					for(int i = 0; i < pNode->m_vecNode.size(); i++)
					{
						ptNext = pNode->m_vecNode[i]->ptCur;
						if (!IsSameOnLine(ptNext, ptPre, pNode->ptCur))
						{
							GetSanitaryNode(pNode->m_vecNode[i], vecNode);
						}
						else
						{
							pParallelNode = pNode->m_vecNode[i];
						}
					}

					// 后处理平行节点
					if (pParallelNode != NULL)
					{
						GetSanitaryNode(pParallelNode, vecNode);
					}
				} 
				else // 前向节点不存在
				{
					for(int i = 0; i < pNode->m_vecNode.size(); i++)
					{
						GetSanitaryNode(pNode->m_vecNode[i], vecNode);
					}
				}
			}
		}
	}
}

bool UnfoldInstallAdjustElevation::IsSameOnLine( const AcGePoint3d &pt1, const AcGePoint3d &pt2, const AcGePoint3d &pt3 )
{
	if (pt1.distanceTo(pt3) < 0.001)
	{
		return false;
	}
	AcGeVector3d vt1 = pt1 - pt2;
	AcGeVector3d vt2 = pt3 - pt2;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	if (vt1.isParallelTo(vt2, tol))
	{
		return true;
	}
	return false;
}

bool UnfoldInstallAdjustElevation::IsFeedVPipe()
{
	bool bRet = false;
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idFeedPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		bRet = pPipe->IsVertical() ? true : false;
		pPipe->close();
	}
	return bRet;
}

double UnfoldInstallAdjustElevation::GetFeedPtEle()
{
	double dEle = 0.0;
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idFeedPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		if (pPipe->IsVertical()) // 供水管为立管
		{
			dEle = m_dFeedEle;
		} 
		else // 供水管为管线时，标高随管线标高
		{
			dEle = pPipe->StartPoint().z;
		}
		pPipe->close();
	}
	return dEle;
}

bool UnfoldInstallAdjustElevation::IsSanitaryPtEleSamePipe( const AcDbObjectId &idSan )
{
	double dPtFeedEle = 0.0;
	if (!GetSanitaryPtEle(idSan, dPtFeedEle))
	{
		return false;
	}

	double dRefVal = DocGetMeterUnitDraw() ? 1 : 1000;
	if (fabs(dPtFeedEle + dRefVal) < 0.001)
	{
		return true;
	}
	return false;
}

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);
bool UnfoldInstallAdjustElevation::GetSanitaryPtEle( const AcDbObjectId &idSan, double &dSanEle )
{
	ads_name name;
	acdbGetAdsName(name, idSan);
	XPoint ptFeed;
	CString sTmp1, sTmp2, sDwbName, sFeedElev, sHotElev;
	double dRadius = 0.0, dDang = 0.0, dRateQ = 0.0, dSanPtEle;
	Entity ent = name;

	// zxl 2012.12.11 modify 获取洁具数据源
	int nDataSourceType = GetSanitaryDataSourceType(ent);
	if (nDataSourceType == 1 || nDataSourceType == 0)
	{
		if (!GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dSanPtEle, 0, sDwbName, sFeedElev, sHotElev))
		{
			return false;
		}
	}
	else
	{
		CSanitaryInfo sanInfo;
		XPoint ptFeed, ptHeatFeed, ptDir, ptDrain;
		GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
		dSanPtEle = ptFeed.z;
	}

	if (!DocGetMeterUnitDraw())
	{
		dSanPtEle *= 1000;
	}
	dSanEle = dSanPtEle;
	return true;
}

bool UnfoldInstallAdjustElevation::GetPipeEleForSanitary( const AcDbObjectId &idSan, double &dPipeEle)
{
	ads_name name;
	acdbGetAdsName(name, idSan);
	XPoint ptFeed;
	CString sTmp1, sTmp2, sDwbName, sFeedElev, sHotElev;
	double dRadius = 0.0, dDang = 0.0, dRateQ = 0.0, dSanEle = 0.0;
	Entity ent = name;

	// zxl 2012.12.11 modify 获取洁具数据源
	int nDataSourceType = GetSanitaryDataSourceType(ent);
	if (nDataSourceType == 1 || nDataSourceType == 0)// 图纸取数据
	{
		if (m_sysPipeType == TPipeSys::kFeedWater || m_sysPipeType == TPipeSys::kFeedWater2 || m_sysPipeType == TPipeSys::kFeedWater3
			|| m_sysPipeType == TPipeSys::kUsedWater || m_sysPipeType == TPipeSys::kUsedWater2 || m_sysPipeType == TPipeSys::kUsedWater3)
		{
			if (!GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dSanEle, 0, sDwbName, sFeedElev, sHotElev))
			{
				return false;
			}
			dPipeEle = _tstof(sFeedElev);
		}
		else 
		{
			if (!GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dSanEle, 1, sDwbName, sFeedElev, sHotElev))
			{
				return false;
			}
			dPipeEle = _tstof(sHotElev);
		}
	}
	else// 本地取数据
	{
		CSanitaryInfo sanInfo;
		XPoint ptFeed, ptHeatFeed, ptDir, ptDrain;
		GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
		if (m_sysPipeType == TPipeSys::kFeedWater || m_sysPipeType == TPipeSys::kFeedWater2 || m_sysPipeType == TPipeSys::kFeedWater3
			|| m_sysPipeType == TPipeSys::kUsedWater || m_sysPipeType == TPipeSys::kUsedWater2 || m_sysPipeType == TPipeSys::kUsedWater3)
		{
			dPipeEle = _tstof(sanInfo.sFeedElev);
		}
		else 
		{
			dPipeEle = _tstof(sanInfo.sHotElev);
		}
	}

	if (!DocGetMeterUnitDraw())
	{
		dPipeEle *= 1000;
	}
	return true;
}

AcDbObjectId UnfoldInstallAdjustElevation::GetSanitaryId( const AcGePoint3d &ptSan )
{
	AcDbObjectId idSan = AcDbObjectId::kNull;
	std::map<AcDbObjectId,AcGePoint3d>::iterator it;
	AcGePoint3d ptTemp;
	for (it = m_mapSanPt.begin(); it != m_mapSanPt.end(); it++)
	{
		ptTemp = it->second;
		ptTemp.z = 0.0;
		if (ptSan.distanceTo(ptTemp) < 0.001)
		{
			idSan = it->first;
			break;
		}
	}
	return idSan;
}

void UnfoldInstallAdjustElevation::CreateLine( const AcGePoint3d &ptS, const AcGePoint3d &ptE, LineType type)
{
	LineInfo info;
	info.ptS = ptS;
	info.ptE = ptE;
	info.type = type;
	m_vecLineInfo.push_back(info);
}

void UnfoldInstallAdjustElevation::AddPointElevation( const AcGePoint3d &pt, double dEle )
{
	std::vector<PointNode>::iterator it;
	AcGePoint3d ptTemp = pt;
	ptTemp.z = 0.0;
	for (it = m_vecPtEle.begin(); it != m_vecPtEle.end(); it++)
	{
		if (ptTemp.distanceTo(it->pt) < 0.001)
		{
			it->setEle.insert(dEle);
			break;
		}
	}

	if (it == m_vecPtEle.end())
	{
		PointNode node;
		node.pt = ptTemp;
		node.setEle.insert(dEle);
		m_vecPtEle.push_back(node);
	}
}

bool UnfoldInstallAdjustElevation::GetPointElevation( const AcGePoint3d &pt, std::set<double> &setEle )
{
	std::vector<PointNode>::iterator it;
	AcGePoint3d ptTemp = pt;
	ptTemp.z = 0.0;
	for (it = m_vecPtEle.begin(); it != m_vecPtEle.end(); it++)
	{
		if (ptTemp.distanceTo(it->pt) < 0.001)
		{
			setEle = it->setEle;
			return true;
		}
	}
	return false;
}

bool UnfoldInstallAdjustElevation::IsCorner( const AcGePoint3d &pt )
{
	LinkNode *pNode = GetLinkNode(pt);
	if (pNode != NULL)
	{
		LinkNode *pPreNode = pNode->pPreNode;
		if (pPreNode != NULL && pNode->m_vecNode.size() == 1)
		{
			AcGePoint3d ptPre = pPreNode->ptCur;
			AcGePoint3d ptNext = pNode->m_vecNode[0]->ptCur;
			AcGePoint3d ptCur = pt;
			AcGeVector3d vt1 = ptPre - ptCur;
			AcGeVector3d vt2 = ptCur - ptNext;
			vt1.z = 0.0;
			vt2.z = 0.0;
			AcGeTol tol;
			tol.setEqualVector(0.001);
			if (!vt1.isParallelTo(vt2, tol))
			{
				return true;
			}
		}
	}
	return false;
}

bool UnfoldInstallAdjustElevation::IsPointKw( const AcGePoint3d &pt )
{
	bool bRet = false;
	LinkNode *pNode = GetLinkNode(pt);
	if (pNode != NULL && SearchPointType(Point_KW, pNode->type))
	{
		bRet = true;
	}
	return bRet;
}

LinkNode* UnfoldInstallAdjustElevation::GetLinkNode( const AcGePoint3d &pt )
{
	if (m_pLinkNode == NULL)
	{
		return NULL;
	}

	LinkNode *pRetNode = NULL;
	LinkNode *pTemp = m_pLinkNode;
	std::vector<LinkNode*> vecNode;
	vecNode.push_back(pTemp);
	while(!vecNode.empty())
	{
		pTemp = *(vecNode.begin());
		vecNode.erase(vecNode.begin());
		if (pt.distanceTo(pTemp->ptCur) < 0.001)
		{
			pRetNode = pTemp;
			break;
		}

		for (int i = 0; i < pTemp->m_vecNode.size(); i++)
		{
			vecNode.push_back(pTemp->m_vecNode[i]);
		}
	}
	return pRetNode;
}

bool UnfoldInstallAdjustElevation::IsExistPerpendicularWall( const AcGePoint3d &pt1, const AcGePoint3d &pt2, AcDbObjectId &idWall )
{
	PickSet ssName(SS_FREE);
	RBList rbMake = acutBuildList(RTDXF0, _T("ATS_WALL"), NULL);
	acedSSGet(_T("C"), Wcs2Ucs(pt1), Wcs2Ucs(pt2), rbMake, ssName);

	bool bRet = false;
	AcDbObjectId id;
	XCurveSegment segL,segR;
	AcGeVector3d vtWall;
	AcGeVector3d vt = pt1 - pt2; // 两点直线方向
	vt.z = 0.0;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	for (long i = 0; (i < ssName.Length()) && !bRet; i++)
	{
		acdbGetObjectId(id, ssName[i]);
		TDbWall *pWall = NULL;
		acdbOpenObject(pWall, id, AcDb::kForRead);
		if (pWall != NULL)
		{
			if (pWall->Is(CURVE_LINE))
			{
				pWall->GetSideCurve(segL,segR);
				vtWall = segR.StartPoint() - segR.EndPoint();
				vtWall.z = 0.0;
				if (vt.isPerpendicularTo(vtWall, tol))
				{
					bRet = true;
					idWall = id;
				}
			}
			pWall->close();
		}
	}
	return bRet;
}

bool UnfoldInstallAdjustElevation::GetAdjustPoint( const AcGePoint3d &ptS, const AcGePoint3d &ptE, const AcDbObjectId &idWall, AcGePoint3d &pt )
{
	bool bRet = false;
	TDbWall *pWall = NULL;
	acdbOpenObject(pWall, idWall, AcDb::kForRead);
	if (pWall != NULL)
	{
		if (pWall->Is(CURVE_LINE))
		{
			XCurveSegment segL,segR;
			pWall->GetSideCurve(segL,segR);
			XPoint pt1, pt2;
			Midpoint(segL.StartPoint(), segR.StartPoint(), pt1);
			Midpoint(segL.EndPoint(), segR.EndPoint(), pt2);
			pt1.z = 0.0;
			pt2.z = 0.0;
			AcDbLine line1(pt1, pt2);
			AcGePoint3d pt3 = ptS, pt4 = ptE;
			pt3.z = 0.0;
			pt4.z = 0.0;
			AcDbLine line2(pt3, pt4);
			AcGePoint3dArray arrPt;
			line1.intersectWith(&line2, AcDb::kOnBothOperands, arrPt);
			if (arrPt.length() == 1)
			{
				AcGePoint3d ptInt = arrPt[0];
				pt1 = segL.StartPoint();
				pt2 = segR.StartPoint();
				double dWitdh = pt1.Distance2d(pt2);
				double dDist = dWitdh / 2 + m_dToWallDist;
				double dMinDist = 0.1; // 变高点距端点的最小距离
				if (!DocGetMeterUnitDraw())
				{
					dMinDist *= 1000;
				}

				if (pt3.distanceTo(ptInt) > dDist + dMinDist)
				{
					AcGeVector3d vtDir = ptS - ptInt;
					vtDir.z = 0.0;
				    vtDir.normalize();
					pt = ptInt + vtDir * dDist;
					bRet = true;
				}
				else if (pt4.distanceTo(ptInt) > dDist + dMinDist)
				{
					AcGeVector3d vtDir = ptE - ptInt;
					vtDir.z = 0.0;
					vtDir.normalize();
					pt = ptInt + vtDir * dDist;
					bRet = true;
				}		
			}
		}
		pWall->close();
	}
	return bRet;
}

void UnfoldInstallAdjustElevation::DrawLine()
{
	std::vector<LineInfo>::iterator it;
	for (it = m_vecLineInfo.begin(); it != m_vecLineInfo.end(); it++)
	{
		AcGePoint3d ptS = it->ptS, ptE = it->ptE;
		if (ptS.distanceTo(ptE) < 0.001)
		{
			continue;
		}
		AcDbLine *pLine = new AcDbLine;
		pLine->setStartPoint(ptS);
		pLine->setEndPoint(ptE);
		AddToCurrentSpace(pLine, Adesk::kTrue);
	}
}

bool UnfoldInstallAdjustElevation::IsAdjustPointEle( const AcGePoint3d &pt )
{
	bool bRet = false;
	std::vector<PointNode>::iterator it;
	AcGePoint3d ptTemp = pt;
	ptTemp.z = 0.0;
	for (it = m_vecPtEle.begin(); it != m_vecPtEle.end(); it++)
	{
		if (ptTemp.distanceTo(it->pt) < 0.001)
		{
			bRet = true;
			break;
		}
	}
	return bRet;
}

bool UnfoldInstallAdjustElevation::FindParallelLine( const AcGePoint3d &ptS, const AcGePoint3d &ptE, double &dPipeEle )
{
	bool bRet = false;
	AcGePoint3d pt1 = ptS, pt2 = ptE;
	pt1.z = 0.0;
	pt2.z = 0.0;
	std::vector<LineInfo>::iterator it;
	AcGePoint3d ptTemp, ptTemp2;
	AcGeVector3d vt1 = pt1 - pt2, vt2;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	for (it = m_vecLineInfo.begin(); it != m_vecLineInfo.end(); it++)
	{
		if (it->type == eKWPipe)
		{
			continue;
		}
		ptTemp = it->ptE;
		ptTemp2 = it->ptS;
		ptTemp.z = 0.0;
		ptTemp2.z = 0.0;
		if(ptTemp.distanceTo(pt1) < 0.001 || ptTemp2.distanceTo(pt1) < 0.001)
		{
			vt2 = it->ptE - it->ptS;
			vt2.z = 0.0;
			if (vt1.isParallelTo(vt2, tol))
			{
				dPipeEle = it->ptS.z;
				bRet = true;
				break;
			}
		}
	}
	return bRet;
}

void UnfoldInstallAdjustElevation::AdjustEleBetweenPts( const AcGePoint3d &ptCur, const AcGePoint3d &ptPre, double dFeedEle, double dPipeEle )
{
	AcGePoint3d ptS, ptE;
	AcDbObjectId idWall = AcDbObjectId::kNull;
	if (IsCorner(ptPre) && !IsPointKw(ptPre)) // 转角位置并且转角点不具有Point_KW类型
	{
		ptS = ptCur;
		ptE = ptPre;
		ptS.z = dFeedEle;
		ptE.z = dFeedEle;
		CreateLine(ptS, ptE, ePipe);
		ptS = ptPre;
		ptE = ptPre;
		ptS.z = dFeedEle;
		ptE.z = dPipeEle;
		CreateLine(ptS, ptE, eKWPipe);
		AddPointElevation(ptCur, dFeedEle);
		AddPointElevation(ptPre, dFeedEle);
		AddPointElevation(ptPre, dPipeEle);
	}
	else if (IsExistPerpendicularWall(ptCur, ptPre, idWall)) // 两点穿过墙体，在墙边上变高
	{
		AcGePoint3d ptTemp;
		if (!GetAdjustPoint(ptCur, ptPre, idWall, ptTemp)) // 得到变高点
		{
			ptTemp = ptCur;
		}
		
		ptS = ptCur;
		ptS.z = dFeedEle;
		ptTemp.z = dFeedEle;
		CreateLine(ptS, ptTemp, ePipe);
		ptE = ptTemp;
		ptE.z = dPipeEle;
		CreateLine(ptTemp, ptE, eKWPipe);
		ptS = ptTemp;
		ptE = ptPre;
		ptS.z = dPipeEle;
		ptE.z = dPipeEle;
		CreateLine(ptS, ptE, ePipe);
		AddPointElevation(ptCur, dFeedEle);
		AddPointElevation(ptTemp, dFeedEle);
		AddPointElevation(ptTemp, dPipeEle);
		AddPointElevation(ptPre, dPipeEle);
	}
	else // 取两点中点变高
	{
		AcGePoint3d ptMid;
		ptMid.x = (ptCur.x + ptPre.x) / 2;
		ptMid.y = (ptCur.y + ptPre.y) / 2;
		ptMid.z = 0.0;
		
		ptS = ptCur;
		ptS.z = dFeedEle;
		ptMid.z = dFeedEle;
		CreateLine(ptS, ptMid, ePipe);
		ptE = ptMid;
		ptE.z = dPipeEle;
		CreateLine(ptMid, ptE, eKWPipe);
		ptS = ptMid;
		ptE = ptPre;
		ptS.z = dPipeEle;
		ptE.z = dPipeEle;
		CreateLine(ptS, ptE, ePipe);
		AddPointElevation(ptCur, dFeedEle);
		AddPointElevation(ptMid, dFeedEle);
		AddPointElevation(ptMid, dPipeEle);
		AddPointElevation(ptPre, dPipeEle);
	}	
}

void UnfoldInstallAdjustElevation::AdjustEleBetweenPts(const AcGePoint3d &ptCur, const AcGePoint3d &ptPre, double dPipeEle)
{
	// 获取当前节点
	LinkNode *pCurNode = GetLinkNode(ptCur);
	if (pCurNode == NULL)
	{
		AfxMessageBox(_T("恭喜你发现了错误，哈哈！"));
		return;
	}

	// 确定当前点标高值
	double dCurEle = 0.0;
	// 不存在端点与ptCur重合且与ptPre共线已变高管线
	if (!FindParallelLine(ptCur, ptPre, dCurEle)) 
	{
		// 获得ptCur点目前已确定的标高值
		std::set<double> setEle;
		GetPointElevation(ptCur, setEle);
		// 取标高最小值
		dCurEle = *setEle.begin();
 	}

	AcGePoint3d ptS, ptE;
	AcDbObjectId idWall = AcDbObjectId::kNull;
	if (IsCorner(ptPre) && !IsPointKw(ptPre)) // 转角位置且转角点不能具有Point_KW类型
	{
		ptS = ptCur;
		ptE = ptPre;
		ptS.z = dCurEle;
		ptE.z = dCurEle;
		CreateLine(ptS, ptE, ePipe);
		// 更新点的连接
		UpdateNodeLink(ptPre, dCurEle);
		UpdateNodeLink(ptPre, dPipeEle);
		AddPointElevation(ptCur, dCurEle);
		AddPointElevation(ptPre, dCurEle);
	}
	else if (IsExistPerpendicularWall(ptCur, ptPre, idWall)) // 两点穿过墙体，在墙边上变高
	{
		AcGePoint3d ptTemp;
		if (GetAdjustPoint(ptCur, ptPre, idWall, ptTemp)) // 得到变高点
		{
			ptS = ptCur;
			ptS.z = dCurEle;
			ptTemp.z = dCurEle;
			CreateLine(ptS, ptTemp, ePipe);
			ptE = ptTemp;
			ptE.z = dPipeEle;
			CreateLine(ptTemp, ptE, eKWPipe);
			ptS = ptTemp;
			ptE = ptPre;
			ptS.z = dPipeEle;
			ptE.z = dPipeEle;
			CreateLine(ptS, ptE, ePipe);
			AddPointElevation(ptCur, dCurEle);
			AddPointElevation(ptTemp, dCurEle);
			AddPointElevation(ptTemp, dPipeEle);
			AddPointElevation(ptPre, dPipeEle);
		}
		else // 无法获得标高点，在父节点处变高
		{
			ptS = ptCur;
			ptE = ptPre;
			ptS.z = dPipeEle;
			ptE.z = dPipeEle;
			CreateLine(ptS, ptE, ePipe);
			// 更新点的连接
			UpdateNodeLink(ptCur, dCurEle);
	    	UpdateNodeLink(ptCur, dPipeEle);

			AddPointElevation(ptCur, dPipeEle);
			AddPointElevation(ptPre, dPipeEle);
		}
	}
	else // 取两点中点变高
	{
		AcGePoint3d ptMid;
		ptMid.x = (ptCur.x + ptPre.x) / 2;
		ptMid.y = (ptCur.y + ptPre.y) / 2;
		ptMid.z = 0.0;
		
		ptS = ptCur;
		ptS.z = dCurEle;
		ptMid.z = dCurEle;
		CreateLine(ptS, ptMid, ePipe);
		ptE = ptMid;
		ptE.z = dPipeEle;
		CreateLine(ptMid, ptE, eKWPipe);
		ptS = ptMid;
		ptE = ptPre;
		ptS.z = dPipeEle;
		ptE.z = dPipeEle;
		CreateLine(ptS, ptE, ePipe);

		AddPointElevation(ptCur, dCurEle);
		AddPointElevation(ptMid, dCurEle);
		AddPointElevation(ptMid, dPipeEle);
		AddPointElevation(ptPre, dPipeEle);
	}
}

void UnfoldInstallAdjustElevation::UpdateNodeLink( const AcGePoint3d &pt, double dEle )
{
	// 获得pt点已确定的标高值
	std::set<double> setEle;
	GetPointElevation(pt, setEle);
	if (setEle.empty())
	{
		return;
	}

	double dMinEle = *setEle.begin();
	double dMaxEle = *setEle.rbegin();
	if (setEle.size() == 1) // pt点只确定了一个标高值
	{
		AcGePoint3d ptS = pt;
		AcGePoint3d ptE = pt;
		ptS.z = dEle;
		ptE.z = dMinEle;
		CreateLine(ptS, ptE, eKWPipe);
		AddPointElevation(pt, dEle);
	}
	else if (dEle < dMinEle + 0.001)
	{
		AcGePoint3d ptS = pt;
		AcGePoint3d ptE = pt;
		ptS.z = dMinEle;
		ptE.z = dEle;
		CreateLine(ptS, ptE, eKWPipe);
		AddPointElevation(pt, dEle);
	}
	else if (dEle > dMaxEle + 0.001)
	{
		AcGePoint3d ptS = pt;
		AcGePoint3d ptE = pt;
		ptS.z = dMaxEle;
		ptE.z = dEle;
		CreateLine(ptS, ptE, eKWPipe);
		AddPointElevation(pt, dEle);
	}
}

void UnfoldInstallAdjustElevation::DrawPipe()
{
	// 获取管线信息
	CString sPipeLayer = GetPipeLayer(m_sysPipeType);
	CString sVPipeLayer = GetVPipeLayer(m_sysPipeType);
	InitLayer(sPipeLayer);
	InitLayer(sVPipeLayer);
	int iPipeIdx = GetPipeLayerIdxByName(sPipeLayer);
	CString sLineType = GetPipeWireLayLineType(sPipeLayer);
	CString sMaterial = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
	CString sDnType = GetDnByMat(sMaterial); 
	double dPipeDn = 20;
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idFeedPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		dPipeDn = pPipe->GetDnDiameter(); 
		pPipe->close();
	}

	CString sLineType2 = GetLayerLineType(sPipeLayer);
	AcGePoint3d ptS, ptE;
	std::vector<LineInfo>::iterator it;
	for (it = m_vecLineInfo.begin(); it != m_vecLineInfo.end(); it++)
	{
		ptS = it->ptS;
		ptE = it->ptE;
		if (ptS.distanceTo(ptE) < 0.001) // 可能存在重合点
		{
			continue;
		}

		TDbPipe *pPipe = new TDbPipe();
		int iPipeIdx = GetPipeLayerIdxByName(sPipeLayer);
		pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
		if (it->type == eKWPipe)//设置立管显示半径
		{
			if(g_bPipeDouble[iPipeIdx])
			{
				pPipe->SetRadiusIn(g_nPipeRadius[iPipeIdx] / 2);
			}
			else
			{
				if(!g_bStandPipeArc)//传统扣弯
					pPipe->SetRadiusIn(-2);
			}
		}
		pPipe->SetStartPoint(ptS);
		pPipe->SetEndPoint(ptE);
		pPipe->SetFlowDir(TPipeSys::kFromStart);
		if(sLineType2.Find(_T("TG")) > -1)
		{
			XLine line(asDblArray(ptS), asDblArray(ptE));
			double nAng = line.Direction();
			if(nAng > PI/2 && nAng < (PI/2*3 + 0.001))
			{
				pPipe->SetStartPoint(ptE);
				pPipe->SetEndPoint(ptS);
				pPipe->SetFlowDir(TPipeSys::kFromEnd);
			}
		}
		pPipe->SetDnDiameter(dPipeDn);
		pPipe->setLayer(sPipeLayer);
		pPipe->SetSysType(GetPipeSysByLayer(sPipeLayer));
		pPipe->setColor(AcCmColor()); //随层
		pPipe->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
		pPipe->setLinetype(sLineType);  
		pPipe->setLineWeight(AcDb::kLnWtByLayer);
		pPipe->SetMaterial(g_iPipeMaterial[iPipeIdx]);
		pPipe->SetLabel(sDnType);
		AddToCurrentSpace(pPipe, Adesk::kTrue);
	}

	InsertSanitaryEquip();
}

CString UnfoldInstallAdjustElevation::GetPipeLayer(TPipeSys::SysType sys)
{
	CString sLayer;
    if(sys == TPipeSys::kFeedWater) 
        sLayer = LAY_PIPE_FEED;
	else if (sys == TPipeSys::kFeedWater2)
		sLayer = LAY_PIPE_FEED2;
	else if (sys == TPipeSys::kFeedWater3)
		sLayer = LAY_PIPE_FEED3;
    else if(sys == TPipeSys::kHeatFeedWater) 
        sLayer = LAY_PIPE_HEADFEED;
	else if(sys == TPipeSys::kHeatFeedWater2) 
        sLayer = LAY_PIPE_HEADFEED2;
	else if(sys == TPipeSys::kHeatFeedWater3) 
        sLayer = LAY_PIPE_HEADFEED3;
    else if(sys == TPipeSys::kHeatBackWater) 
        sLayer = LAY_PIPE_HEADBACK;
	else if(sys == TPipeSys::kHeatBackWater2) 
        sLayer = LAY_PIPE_HEADBACK2;
	else if(sys == TPipeSys::kHeatBackWater3) 
        sLayer = LAY_PIPE_HEADBACK3;
    else if(sys == TPipeSys::kDirtWater)
        sLayer = LAY_PIPE_DIRT;
    else if(sys == TPipeSys::kUselessWater)
        sLayer = LAY_PIPE_USELESS;
    else if(sys == TPipeSys::kRainWater)
        sLayer = LAY_PIPE_RAIN;
    else if(sys == TPipeSys::kUsedWater) 
        sLayer = LAY_PIPE_USED;
	else if(sys == TPipeSys::kUsedWater2) 
        sLayer = LAY_PIPE_USED2;
	else if(sys == TPipeSys::kUsedWater3) 
        sLayer = LAY_PIPE_USED3;
    else if(sys == TPipeSys::kFireFighting) 
        sLayer = LAY_PIPE_FIRE;
	else if(sys == TPipeSys::kFireFighting2) 
        sLayer = LAY_PIPE_FIRE2;
	else if(sys == TPipeSys::kFireFighting3) 
        sLayer = LAY_PIPE_FIRE3;
    else if(sys == TPipeSys::kSprinkle) 
        sLayer = LAY_PIPE_SPRINKLE;
	else if(sys == TPipeSys::kSprinkle2) 
        sLayer = LAY_PIPE_SPRINKLE2;
	else if(sys == TPipeSys::kSprinkle3) 
        sLayer = LAY_PIPE_SPRINKLE3;
    else if(sys == TPipeSys::kCoagulate)
        sLayer = LAY_PIPE_COAGULATE;
    else if(sys == TPipeSys::kDrink)
        sLayer = LAY_PIPE_DRINK;
    else if(sys == TPipeSys::kPressDirt)
        sLayer = LAY_PIPE_PRESSDIRT;
    else if(sys == TPipeSys::kPressUseless)
        sLayer = LAY_PIPE_PRESSUSELESS;
    else if(sys == TPipeSys::kPressRain)
        sLayer = LAY_PIPE_PRESSRAIN;
    else if(sys == TPipeSys::kCivilFeed)
        sLayer = LAY_PIPE_USER1;
    else if(sys == TPipeSys::kCycleFeed)
        sLayer = LAY_PIPE_USER2;
    else if(sys == TPipeSys::kOther)
        sLayer = LAY_PIPE_OTHER;
	else if (sys == TPipeSys::kUser3)  
		sLayer = LAY_PIPE_USER3;
	else if (sys == TPipeSys::kUser4)  
		sLayer = LAY_PIPE_USER4;
	else if (sys == TPipeSys::kUser5)  
		sLayer = LAY_PIPE_USER5;
	else if (sys == TPipeSys::kUser6)  
		sLayer = LAY_PIPE_USER6;
	else if (sys == TPipeSys::kUser7)  
		sLayer = LAY_PIPE_USER7;
	else if (sys == TPipeSys::kUser8)  
		sLayer = LAY_PIPE_USER8;
	return sLayer;
}

CString UnfoldInstallAdjustElevation::GetVPipeLayer(TPipeSys::SysType sys)
{
	CString sLayer;
    if(sys == TPipeSys::kFeedWater) 
        sLayer = LAY_VPIPE_FEED;
	else if (sys == TPipeSys::kFeedWater2)
		sLayer = LAY_VPIPE_FEED2;
	else if (sys == TPipeSys::kFeedWater3)
		sLayer = LAY_VPIPE_FEED3;
    else if(sys == TPipeSys::kHeatFeedWater) 
        sLayer = LAY_VPIPE_HEADFEED;
	else if(sys == TPipeSys::kHeatFeedWater2) 
        sLayer = LAY_VPIPE_HEADFEED2;
	else if(sys == TPipeSys::kHeatFeedWater3) 
        sLayer = LAY_VPIPE_HEADFEED3;
    else if(sys == TPipeSys::kHeatBackWater) 
        sLayer = LAY_VPIPE_HEADBACK;
	else if(sys == TPipeSys::kHeatBackWater2) 
        sLayer = LAY_VPIPE_HEADBACK2;
	else if(sys == TPipeSys::kHeatBackWater3) 
        sLayer = LAY_VPIPE_HEADBACK3;
    else if(sys == TPipeSys::kDirtWater)
        sLayer = LAY_VPIPE_DIRT;
    else if(sys == TPipeSys::kUselessWater)
        sLayer = LAY_VPIPE_USELESS;
    else if(sys == TPipeSys::kRainWater)
        sLayer = LAY_VPIPE_RAIN;
    else if(sys == TPipeSys::kUsedWater) 
        sLayer = LAY_VPIPE_USED;
	else if(sys == TPipeSys::kUsedWater2) 
        sLayer = LAY_VPIPE_USED2;
	else if(sys == TPipeSys::kUsedWater3) 
        sLayer = LAY_VPIPE_USED3;
    else if(sys == TPipeSys::kFireFighting) 
        sLayer = LAY_VPIPE_FIRE;
	else if(sys == TPipeSys::kFireFighting2) 
        sLayer = LAY_VPIPE_FIRE2;
	else if(sys == TPipeSys::kFireFighting3) 
        sLayer = LAY_VPIPE_FIRE3;
    else if(sys == TPipeSys::kSprinkle) 
        sLayer = LAY_VPIPE_SPRINKLE;
	else if(sys == TPipeSys::kSprinkle2) 
        sLayer = LAY_VPIPE_SPRINKLE2;
	else if(sys == TPipeSys::kSprinkle3) 
        sLayer = LAY_VPIPE_SPRINKLE3;
    else if(sys == TPipeSys::kCoagulate)
        sLayer = LAY_VPIPE_COAGULATE;
    else if(sys == TPipeSys::kDrink)
        sLayer = LAY_VPIPE_DRINK;
    else if(sys == TPipeSys::kPressDirt)
        sLayer = LAY_VPIPE_PRESSDIRT;
    else if(sys == TPipeSys::kPressUseless)
        sLayer = LAY_VPIPE_PRESSUSELESS;
    else if(sys == TPipeSys::kPressRain)
        sLayer = LAY_VPIPE_PRESSRAIN;
    else if(sys == TPipeSys::kCivilFeed)
        sLayer = LAY_VPIPE_USER1;
    else if(sys == TPipeSys::kCycleFeed)
        sLayer = LAY_VPIPE_USER2;
    else if(sys == TPipeSys::kOther)
        sLayer = LAY_VPIPE_OTHER;
	else if (sys == TPipeSys::kUser3)  
		sLayer = LAY_VPIPE_USER3;
	else if (sys == TPipeSys::kUser4)  
		sLayer = LAY_VPIPE_USER4;
	else if (sys == TPipeSys::kUser5)  
		sLayer = LAY_VPIPE_USER5;
	else if (sys == TPipeSys::kUser6)  
		sLayer = LAY_VPIPE_USER6;
	else if (sys == TPipeSys::kUser7)  
		sLayer = LAY_VPIPE_USER7;
	else if (sys == TPipeSys::kUser8)  
		sLayer = LAY_VPIPE_USER8;
	return sLayer;
}

void UnfoldInstallAdjustElevation::ModifySanitaryPt( const AcGePoint3d &ptSan )
{
	AcGePoint3d ptTemp = ptSan;
	std::map<AcDbObjectId,AcGePoint3d>::iterator it;
	for (it = m_mapSanPt.begin(); it != m_mapSanPt.end(); it++)
	{
		ptTemp.z = it->second.z;
		if (ptTemp.distanceTo(it->second) < 0.001)
		{
			it->second.z = ptSan.z;
			break;
		}
	}
}

void UnfoldInstallAdjustElevation::InsertSanitaryEquip()
{
	std::map<AcDbObjectId,AcGePoint3d>::iterator it;
	for (it = m_mapSanPt.begin(); it != m_mapSanPt.end(); it++)
	{
		DrawFeedEquip(it->first, it->second);
	}
}

extern bool GetSanitaryDriection(Entity ent, double &dSanitaryDriec);
void UnfoldInstallAdjustElevation::DrawFeedEquip(const AcDbObjectId &idSan, const AcGePoint3d &ptSan)
{
	ads_name name;
	acdbGetAdsName(name, idSan);
	Entity ent(name);
	
	CString sDwbName, sHotElev, sFeedElev, sBlk, sSysBlk;
	double dEle = 0.0, dRadius = 0.0, dDang = 0.0, dBigQ = 0.0;
	XPoint pt;
	int nType = 0;
	if (m_sysPipeType == TPipeSys::kHeatFeedWater 
		|| m_sysPipeType == TPipeSys::kHeatFeedWater2
		|| m_sysPipeType == TPipeSys::kHeatFeedWater3)
	{
		nType = 1;
	}
	else if (m_sysPipeType == TPipeSys::kFeedWater 
		|| m_sysPipeType == TPipeSys::kFeedWater2
		|| m_sysPipeType == TPipeSys::kFeedWater3) // 给水
	{
		nType = 0;
	}
	else if (m_sysPipeType == TPipeSys::kUsedWater 
		|| m_sysPipeType == TPipeSys::kUsedWater2
		|| m_sysPipeType == TPipeSys::kUsedWater3) //  中水
	{
		nType = 0;
	}
	
	double dAngle = 0.0;
	// zxl 2012.12.11 modify 获取洁具数据源
	int nDataSourceType = GetSanitaryDataSourceType(ent);
	if (nDataSourceType == 1 || nDataSourceType == 0)
	{
		GetSanitaryInfo(ent, pt, sBlk, sSysBlk, dRadius, dDang, dBigQ, dEle, nType, 
			sDwbName, sFeedElev, sHotElev);
		ent.GetData(50, &dAngle);
		if (GetSanitaryDriection(ent, dAngle))
		{
			dAngle += PI / 2;
		}
	}
	else
	{
		CSanitaryInfo sanInfo;
		XPoint ptFeed, ptHeatFeed, ptDir, ptBlk;
		GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, pt, ptDir);
		sBlk = sanInfo.sFeedSys;
		sSysBlk = sanInfo.sSysBlk1;
		dDang = sanInfo.dDang;
		dBigQ = sanInfo.dRateQ;
		if (nType == 1 || nType == 0)
		{
			pt = ptSan;
			pt.z = ptFeed.z * 1000;
		}
		
		AcDbObjectId Id = NULL;
		acdbGetObjectId(Id, ent);
		AcDbBlockReference *pBlkRef = NULL;
		acdbOpenObject(pBlkRef, Id, AcDb::kForRead);
		if(!pBlkRef)
			return;
		ptBlk = pBlkRef->position();
		pBlkRef->close();
		dAngle = GetEntDriection(ptBlk, ptDir);
		dAngle += PI / 2;
	}
	
	// 加载图块
	LoadTkBlock(sBlk);
	LoadTkBlock(sSysBlk);
	
	TDbEquipment *pEquip = new TDbEquipment;
	pEquip->SetBlock2d(GetBlkIdByName(sBlk));
	pEquip->SetDang(dDang);
	pEquip->SetSpare(dBigQ);
	pEquip->SetLocation(ptSan);
	pEquip->SetHidePipe(FALSE);
	pEquip->SetAngle(dAngle);
	if(_tcsicmp(sSysBlk, _T("twtsys(00000322)")) == 0){
		if(g_bBlk3D){
			CString csDwb = g_csDwbPath + _T("TwtSys");
			XString xsTmp6;
			if(LoadDwbBlock(csDwb, _T("00000364"), xsTmp6) != RTNORM)//3d水龙头
				return;
			pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
		}
	}         
	else if(_tcsicmp(sSysBlk, _T("twtsys(00000005)")) == 0){
		if(g_bBlk3D){
			CString csDwb = g_csDwbPath + _T("TwtSys");
			XString xsTmp6;
			if(LoadDwbBlock(csDwb, _T("00000416"), xsTmp6) != RTNORM)//3d水龙头
				return;
			pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
		}
	}
	else if(_tcsicmp(sSysBlk, _T("twtsys(00000352)")) == 0 || _tcsicmp(sSysBlk, _T("twtsys(00000014)")) == 0){//小便器自闭式冲洗阀
		if(g_bBlk3D){
			CString csDwb = g_csDwbPath + _T("TwtSys");
			XString xsTmp7;
			if(LoadDwbBlock(csDwb, _T("00000368"), xsTmp7) != RTNORM)//3d自闭式冲洗阀
				return;
			pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
		}
	}
	else if(g_bBlk3D && _tcsicmp(sSysBlk, _T("twtsys(00000293)")) == 0){     //大便器自闭式冲洗阀
		CString csDwb = g_csDwbPath + _T("TwtSys");
		XString xsTmp7;
		if(LoadDwbBlock(csDwb, _T("00000369"), xsTmp7) != RTNORM)//3d自闭式冲洗阀
			return;
		pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
	}
	if (_tcsicmp(sBlk, _T("$TWTSYS$00000519")) == 0)// 给水圆比例 zxl 2012.04.16 add
	{
		pEquip->SetScale(g_nFeedCircleScale);
	}
	
	pEquip->SetSysBlock((const TCHAR*)sSysBlk);
	pEquip->setLayer(InitLayer(LAY_EQ_FEED));
	pEquip->setColor(AcCmColor()); //随层
	AddToCurrentSpace(pEquip, Adesk::kTrue);
	
}

double UnfoldInstallAdjustElevation::GetParentNodeEle( const AcGePoint3d &ptCur )
{
	double dEle = 0.0;
	LinkNode *pNode = GetLinkNode(ptCur);
	if(pNode == NULL)
	{
		return dEle;
	}

	AcGePoint3d ptPre = pNode->ptCur;
	pNode = pNode->pPreNode;
	while(pNode != NULL)
	{
		if (IsAdjustPointEle(pNode->ptCur))
		{
			// 不存在端点与ptCur重合且与ptPre共线已变高管线
			if (!FindParallelLine(pNode->ptCur, ptPre, dEle)) 
			{
				// 获得ptCur点目前已确定的标高值
				std::set<double> setEle;
				GetPointElevation(ptCur, setEle);
				// 取标高最小值
				dEle = *setEle.begin();
 			}
			break;
		}
		ptPre = pNode->ptCur;
		pNode = pNode->pPreNode;
	}
	return dEle;
}