#include "StdAfx.h"
#include "ConcealInstallSanitarySys.h"

#define OFFSET_TIME 4  // 管线偏移次数

ConcealInstallSanitarySys::ConcealInstallSanitarySys()
{
	m_dVPipeEle = DocGetMeterUnitDraw() ? 2.6 : 2600;
}

void ConcealInstallSanitarySys::AutoLinkSanitary( const SanitarySysData &data )
{
	m_dPipeDn = GetPipeDn(data.id);
	m_sysPipe = data.type;
	m_idPipe = data.id;
	InitWallEnt();
	// 独立洁具
	if (IsSingleSanitary(data))
	{
		LinkSingleSanitary(data);
		return;
	}

	// 将洁具按距离给水点远近排序
	SanitarySysData sanData = data;
	std::vector<SanitaryNode> &vecSanNode = sanData.vecSanitaryNode;
	Sort(vecSanNode, sanData.pt);
	// 按洁具点距给水点远近连接洁具
	LinkSanitary(sanData);

} 

bool ConcealInstallSanitarySys::IsSingleSanitary( const SanitarySysData &data )
{
	return false;
}

void ConcealInstallSanitarySys::LinkSingleSanitary( const SanitarySysData &data )
{
	
}

void ConcealInstallSanitarySys::LinkSanitary(const SanitarySysData &data)
{
	// 获得最远洁具给水点 洁具id
	std::vector<SanitaryNode> vecNode = data.vecSanitaryNode;
	std::vector<SanitaryNode>::iterator it = vecNode.begin();
	AcGePoint3d ptSan = it->pt;
	AcDbObjectId idSan = it->idSanitary;
	vecNode.erase(it);
	// 确定X轴Y轴
	ComfirmXAxisYAxis(data.id);

	bool bSuccess = true;
	if (IsVertivalPipe(data.id)) // 给水管是立管
	{
		// 给水管为立管时，设置给水点高度
		m_ptFeed = data.pt;
		m_ptFeed.z = m_dVPipeEle;
		bSuccess = SelectMainPipeFromVPipe(m_ptFeed, ptSan, data.id, idSan);
	} 
	else // 给水管是非立管
	{
		m_ptFeed = data.pt;
		bSuccess = SelectMainPipeFromPipe(data.pt, ptSan, data.id, idSan);
	}

	if (!bSuccess)
	{
		return;
	}

	// 按距离远近依次连接洁具
	it = vecNode.begin();
	while(it != vecNode.end())
	{
		LinkSanitary(it->pt, it->idSanitary);
		it++;
	}

	// 生成管线
	CreatePipe();
	// 添加附件
	InsertFeedEquip();
}

void ConcealInstallSanitarySys::LinkSanitary( const AcGePoint3d &pt, const AcDbObjectId &idSan )
{
	// 通过延长管线直接连接洁具
	if (LinkSanitaryByExtendedPipe(pt, idSan))
	{
		return;
	}

	// 洁具直接连接最近的管线
	LinkDate data;
	data.ptSan = pt;
	data.idSan = idSan;
	data.nTransformTime = 0;
	data.bInWall = false;
	ModifyLinkSanPt(data);
	if (GetLinkData(data))
	{
		LinkDate data1;
		data1.ptSan = pt;
		data1.idSan = idSan;
		data1.nTransformTime = 1;
		data1.bInWall = false;
    	ModifyLinkSanPt(data1);
		if (GetLinkData(data1)) 
		{
			// 通过比较直接连接和一次变换连接的管线长度取近者连接
			if (data.dLinkLen < data1.dLinkLen) 
			{
				LinkSanitary2Pipe(data);
			} 
			else
			{
				LinkSanitary2Pipe(data1);
			} 
		} 
		else // 直接连接洁具与管线
		{
			LinkSanitary2Pipe(data);
		}
		return;
	}

	// 变换一次连接洁具
	LinkDate data1;
	data1.ptSan = pt;
	data1.idSan = idSan;
	data1.nTransformTime = 1;
	data1.bInWall = false;
	ModifyLinkSanPt(data1);
	if (GetLinkData(data1)) 
	{
		LinkSanitary2Pipe(data1);
		return;
	}

	// 变换两次连接洁具
	LinkDate data2;
	data2.ptSan = pt;
	data2.idSan = idSan;
	data2.nTransformTime = 2;
	data2.bInWall = false;
	ModifyLinkSanPt(data2);
	if (GetLinkData(data2)) 
	{
		LinkSanitary2Pipe(data2);
		return;
	}
	acutPrintf(_T("\n洁具不能连接！"));
}

void ConcealInstallSanitarySys::LinkSanitary( const AcGePoint3d &ptSan, const AcGePoint3d &ptFeed, const AcDbObjectId &idSan, PipeType type, bool bInSanPtWall, const AcGePoint3d &ptWall )
{
	if (IsSanitaryPtEleSamePipe(idSan)) // 洁具给水点标高随支管标高
	{
		if (bInSanPtWall)
		{
			AcGePoint3d ptPrj = ptWall;
			if (ptPrj.distanceTo(ptSan) > 0.001) // 洁具点在墙外
			{
				// 转换为真正的洁具点和墙体投影点
				AcGePoint3d ptSanTemp = ptWall;
				ptSanTemp.z = ptFeed.z;
				CreateVirtualPipe(ptFeed, ptSanTemp, type);
		        m_mapSan.insert(std::make_pair(idSan, ptSanTemp));
			}
			else // 洁具点在墙内
			{
				AcGePoint3d ptTemp = ptSan;
				ptTemp.z = ptFeed.z;
				CreateVirtualPipe(ptFeed, ptTemp, type);
		        m_mapSan.insert(std::make_pair(idSan, ptTemp));
			}
		}
		else
		{
			AcGePoint3d ptTemp = ptSan;
			ptTemp.z = ptFeed.z;
			CreateVirtualPipe(ptFeed, ptTemp, type);
		    m_mapSan.insert(std::make_pair(idSan, ptTemp));
		}
	} 
	else // 指定给水点标高
	{
		// 暗装时，得到给水点到最近墙上的投影点
		if (bInSanPtWall)
		{
			AcGePoint3d ptPrj = ptWall;
			// 转换为真正的洁具点和墙体投影点
			ptPrj = ptSan;
			AcGePoint3d ptSanTemp = ptWall;
		
			ptPrj.z = ptFeed.z;
			CreateVirtualPipe(ptFeed, ptPrj, type);
			// 扣弯
			AcGePoint3d pt = ptPrj;
			pt.z = GetSanitaryPtEle(idSan); // 给水点标高  
			CreateVirtualPipe(ptPrj, pt, eVertival);

			// 连接洁具
			ptSanTemp.z = pt.z;
			ptPrj.z = pt.z;
		    CreateVirtualPipe(ptPrj, ptSanTemp, eSmallPipe);
			m_mapSan.insert(std::make_pair(idSan, ptSanTemp));	
		}
		else // 找不到墙体时直接连接
		{
			AcGePoint3d ptSanTemp = ptSan;
			ptSanTemp.z = ptFeed.z;
			CreateVirtualPipe(ptFeed, ptSanTemp, type);
			AcGePoint3d ptTemp = ptSan;
			ptTemp.z = GetSanitaryPtEle(idSan);
			CreateVirtualPipe(ptSanTemp, ptTemp, eVertival);
			m_mapSan.insert(std::make_pair(idSan, ptTemp));
		}
	}	
}

bool ConcealInstallSanitarySys::LinkSanitaryByExtendedPipe( const AcGePoint3d &ptSan, const AcDbObjectId &idSan )
{
	// 获得所有可被延长的管线
	std::vector<PipeData>::iterator it;
	AcGePoint3d ptTemp = ptSan, ptPrj;
	AcDbLine *pLine = NULL;
	PipeType type;
	for(it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
	{
		pLine = it->pLine;
		if (pLine == NULL)
		{
			continue;
		}

		type = it->type;
		if (type != eMainPipe && type != eBranch 
			&& type != eSmallPipe && type != eBranch2)
		{
			continue;
		}

		ptTemp.z = pLine->startPoint().z;
		if (pLine->getClosestPointTo(ptTemp, ptPrj, Adesk::kTrue) == Acad::eOk)
		{
			if (ptTemp.distanceTo(ptPrj) > 0.001) // 不在直线内或其延长线上
			{
				continue;
			}

			// 洁具点标高
			double dSanEle = 0.0;
			if (IsSanitaryPtEleSamePipe(idSan)) // 随支管
			{
				dSanEle = pLine->startPoint().z;
			}
			else // 指定标高
			{
				dSanEle = GetSanitaryPtEle(idSan); 
			}

			// 延长小支管连接洁具时，扣弯需要产生在墙体内
			if (type == eSmallPipe) 
			{
				//当洁具点在墙外时，需安装洁具
				AcGePoint3d ptWall;
				AcGeVector3d vtDir;
				if (GetSanitaryDir(vtDir, idSan) && GetPtInWall(ptWall, ptTemp, vtDir) && ptWall.distanceTo(ptTemp) > 0.001)
				{
					ptWall.z = pLine->startPoint().z;
					AcGePoint3d ptWallPrj;
					if (pLine->getClosestPointTo(ptWall, ptWallPrj, Adesk::kTrue) == Acad::eOk
						&& ptWall.distanceTo(ptWallPrj) < 0.001)
					{
						// 修改管线使之延伸到洁具点
						ExtendLine(pLine, ptWallPrj);
						// 连接洁具
						ptWall.z = dSanEle;
						CreateVirtualPipe(ptWallPrj, ptWall, eVertival);
						ptTemp = ptSan;
						ptTemp.z = dSanEle;
						CreateVirtualPipe(ptWall, ptTemp, eSmallPipe);
						m_mapSan.insert(std::make_pair(idSan, ptTemp));   
						return true;     
					} 
				}
			} 

			// 修改管线使之延伸到洁具点
			ExtendLine(pLine, ptPrj);
			// 连接洁具
			ptTemp = ptSan;
			ptTemp.z = dSanEle;
			LinkSanitary(ptTemp, ptPrj, idSan, eSmallPipe, false, AcGePoint3d());
			return true;
		}
	}
	return false;
}

bool ConcealInstallSanitarySys::PipeParallelXorYAxis( const AcDbObjectId &idPipe )
{
	AcGeVector3d vtDir;
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		vtDir = pPipe->StartPoint() - pPipe->EndPoint();
		vtDir.z = 0.0;
		pPipe->close();
	}
	else
	{
		return false;
	}
	
	if (vtDir.isParallelTo(m_vtXAxis) || vtDir.isParallelTo(m_vtYAxis))
	{
		return true;
	}
	return false;
}

void ConcealInstallSanitarySys::Sort( std::vector<SanitaryNode> &data, const AcGePoint3d &pt  )
{
	// 计算洁具点与给水点在XOY平面内的距离
	std::map<double, SanitaryNode> mapDist;
	std::vector<SanitaryNode>::iterator it;
	AcGePoint3d pt1 = pt, pt2;
	pt1.z = 0.0;
	for (it = data.begin(); it != data.end(); it++)
	{
		pt2 = it->pt;
		pt2.z = 0.0;
		mapDist.insert(std::make_pair(pt1.distanceTo(pt2), *it));
	}

	// 按由大到小排序
	data.clear();
	std::map<double,SanitaryNode>::reverse_iterator itR;
	for (itR = mapDist.rbegin(); itR != mapDist.rend(); itR++)
	{
		data.push_back(itR->second);
	}
}

void ConcealInstallSanitarySys::SetFeedPointEle( double dEle )
{
	m_dVPipeEle = dEle;
	if (!DocGetCurMeterUnitDraw())
	{
		m_dVPipeEle *= 1000;
	}
}

bool ConcealInstallSanitarySys::SelectMainPipeFromVPipe( const AcGePoint3d &ptWater, const AcGePoint3d &ptSan, const AcDbObjectId &idPipe, const AcDbObjectId &idSan )
{
	// 确定主干管位置
	LinkDate data;
	data.ptLink = ptWater;
	data.ptSan = ptSan;
	data.idSan = idSan;
	data.bInWall = false;
	ModifyLinkSanPt(data);
	if (!ConfirmMianPipePosFromVPipe(data, idPipe))
	{
		return false;
	}
	// 连接主干管 
	return LinkMainPipe(data);
}

bool ConcealInstallSanitarySys::SelectMainPipeFromPipe( const AcGePoint3d &ptWater, const AcGePoint3d &ptSan, const AcDbObjectId &idPipe, const AcDbObjectId &idSan )
{
	// 给水管方向
	AcGeVector3d vtPipeDir = m_vtXAxis;
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		vtPipeDir = pPipe->StartPoint() - pPipe->EndPoint();
		vtPipeDir.z = 0.0;
		vtPipeDir.normalize();
		pPipe->close();
	}

	LinkDate data;
	data.ptLink = ptWater;
	data.ptSan = ptSan;
	data.idSan = idSan;
	data.bInWall = false;
	ModifyLinkSanPt(data);
	if (!ConfirmMianPipePosFromPipe(data, vtPipeDir))
	{
		return false;
	}

	// 根据主干管铺设点调整给水点位置使之在给水管流入点
	AcGePoint3d ptWaterNew = ptWater;
	pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		AcGeVector3d vtPipeDir = pPipe->StartPoint() - pPipe->EndPoint();
		vtPipeDir.z = 0.0;

		AcGeVector3d vtDir = data.vecPts[0] - ptWater;
		vtDir.z = 0;
		if (vtDir.isCodirectionalTo(vtPipeDir, m_tolVec))
		{
			ptWaterNew = pPipe->EndPoint();
		}
		else
		{
			ptWaterNew = pPipe->StartPoint();
		}
		pPipe->close();
	}
	
	// 连接主干管 
	data.ptLink = ptWaterNew;
	return LinkMainPipe(data);
}

bool ConcealInstallSanitarySys::GetPipe( AcGePoint3d &ptS, AcGePoint3d &ptE, const AcGeVector3d &vtDir )
{
	// 获得最近的墙体
	AcGePoint3d pt1 = ptS, pt2 = ptE;
	AcGeVector3d vtWall = pt1 - pt2;
	vtWall.z = 0.0;
	AcDbLine line;
	double dWallThick = 0.0; 
	if (!GetNearestWall(pt2, vtWall, line, dWallThick))
	{
		line.setStartPoint(ptS);
		line.setEndPoint(ptE);
		dWallThick = 0.0;
	}

	for(int i = 0; i < OFFSET_TIME; i++)
	{
		// 检查是否与其他系统碰撞
		if (!IsConflicting(pt1, pt2, m_dDistPipe2Pipe))
		{
			ptS = pt1;
			ptE = pt2;
			break;
		}
		// 将点移动到距墙m_dDistPipe2Wall * (i + 1)处
		MovePipe(pt1, line, vtDir, dWallThick * 0.5 + m_dDistPipe2Wall * (i + 1));
		MovePipe(pt2, line, vtDir, dWallThick * 0.5 + m_dDistPipe2Wall * (i + 1));
	}

	return true;
}

bool ConcealInstallSanitarySys::GetPtInWall( AcGePoint3d &ptWall, const AcGePoint3d &ptSan, const AcGeVector3d &vtDir )
{
	// 找到与vtDir垂直的墙
	AcGeVector3d vt = vtDir;
	vt.z = 0.0;
	vt.normalize();
	AcGeVector3d vtWall;
	std::vector<std::pair<XCurveSegment, XCurveSegment> > vecWall;
	std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it;
	for (it = m_vecWallSide.begin(); it != m_vecWallSide.end(); it++)
	{
		if (it->first.GetCurveType() == CURVE_LINE)
		{
			vtWall = it->first.StartPoint() - it->first.EndPoint();
			vtWall.z = 0.0;
			if (vt.isPerpendicularTo(vtWall, m_tolVec))
			{
				vecWall.push_back(*it);
			}
		}
	}

	// 找到距离ptSan最近的墙体
	XCurveSegment segNear, segFar;
	if (!GetWallSide(ptSan, vecWall, segNear, segFar))
	{
		acutPrintf(_T("\n未找到墙体！"));
		return false;
	}
	
	XPoly2D poly;
	GetWallOutLine(poly, segNear, segFar);
	poly.SetElevation(0.0);
	AcGePoint3d pt = ptSan;
	pt.z = 0.0;
	if (((pt & poly) == PR_EDGE)
		|| ((pt & poly) == PR_INSIDE)) // 点在墙内
	{
		ptWall = ptSan;
		return true;
	}
	else // 点在墙外
	{
		AcGePoint3d ptS, ptE;
		ptS = segNear.StartPoint();
		ptE = segNear.EndPoint();
		ptS.z = 0.0;
		ptE.z = 0.0;
		AcDbLine lineNear(ptS, ptE);
		ptS = segFar.StartPoint();
		ptE = segFar.EndPoint();
		ptS.z = 0.0;
		ptE.z = 0.0;
		AcDbLine lineFar(ptS, ptE);
		AcGePoint3d pt = ptSan, ptPrj;
		pt.z = 0.0;
		if ((lineNear.getClosestPointTo(pt, ptPrj, Adesk::kTrue) == Acad::eOk))
		{
			AcGeVector3d vt = ptPrj - pt;
			vt.z = 0.0;
			vt.normalize();
			double dVPipeRadius = GetVPipeDrawRadius();
			ptPrj += vt * dVPipeRadius;
			ptWall = ptPrj;
			return true;
		}
	}
	return false;
}

void ConcealInstallSanitarySys::CreateVirtualPipe( const AcGePoint3d &ptS, const AcGePoint3d &ptE, const PipeType &type)
{
	// 点重合直接返回
	if (ptS.distanceTo(ptE) < 0.001) 
	{
		return;
	}

	AcGeVector3d vtDir = ptS - ptE;
	vtDir.z = 0.0;
	PipeDir dir = GetPipeDir(vtDir);

	AcDbLine *pNewLine = new AcDbLine();
	pNewLine->setStartPoint(ptS);
	pNewLine->setEndPoint(ptE);
	PipeData node;
	node.pLine = pNewLine;
	node.nId = m_nId++;
	node.drection = dir;
    node.type = type;
	m_vecPipeData.push_back(node);
}

bool ConcealInstallSanitarySys::ConfirmMianPipePosFromVPipe( LinkDate &data, const AcDbObjectId &idPipe )
{

	// 从给水点沿m_vtXAxis后m_vtYAxis方向铺设管线
	LinkDate dataX = data;
	bool bXAxis = ConfirmMianPipePosFromPipe(dataX, m_vtXAxis);
	// 从给水点沿m_vtYAxis后m_vtXAxis方向铺设管线
	LinkDate dataY = data;
	bool bYAxis = ConfirmMianPipePosFromPipe(dataY, m_vtYAxis);
	if (bXAxis && bYAxis) // 两方向均可
	{
		AcGePoint3d ptWater = dataX.ptLink, ptSanX, ptX, ptSanY, ptY;
		if (dataX.nTransformTime == 0)
		{
			ptX = dataX.vecPts[0];
			ptSanX = dataX.ptSan;
		}
		else
		{
			ptX = dataX.vecPts[0];
			ptSanX = dataX.vecPts[1];
		}

		if (dataY.nTransformTime == 0)
		{
			ptY = dataY.vecPts[0];
			ptSanY = dataY.ptSan;
		}
		else
		{
			ptY = dataY.vecPts[0];
			ptSanY = dataY.vecPts[1];
		}

		int nNumVPipeX = PassVertivalPipeNumByLine(ptWater, ptX); // 穿过立管个数
		int nNumVPipeY = PassVertivalPipeNumByLine(ptWater, ptY);
		if ((nNumVPipeX == 0 && nNumVPipeY == 0) || (nNumVPipeX > 0 && nNumVPipeY > 0)) // 都穿过立管或都不穿过立管
		{
			// 以经过门窗少为准
			double dWidth = 0.0;
			int nNumDoorX = PassWallNumByLine(ptX, ptSanX, dWidth); // 挨门窗个数
			int nNumDoorY = PassWallNumByLine(ptY, ptSanY, dWidth);
			if (nNumDoorX <= nNumDoorY) // 以穿过门窗少为准
			{
				data = dataX;
			}
			else
			{
				data = dataY;
			}
		}
		else if (nNumVPipeX == 0)// 以不穿过立管为准
		{
			data = dataX;
		}
		else if (nNumVPipeY == 0)// 以不穿过立管为准
		{
			data = dataY;
		}		
	}
	else if (bXAxis && !bYAxis)
	{
		data = dataX;
	}
	else if (!bXAxis && bYAxis)
	{
		data = dataY;
	}
	else
	{
		return false;
	}
	return true;	
}

bool ConcealInstallSanitarySys::ConfirmMianPipePosFromPipe( LinkDate &data, const AcGeVector3d &vtPipeDir)
{
	AcGePoint3d ptSan = data.ptSan;   // 洁具点
	AcGePoint3d ptFeed = data.ptLink; // 供水点
	AcDbObjectId idSan = data.idSan;  
	// 根据水管方向确定连接方向
	AcGeVector3d vtLinkDir1, vtLinkDir2;
	if (vtPipeDir.isParallelTo(m_vtXAxis, m_tolVec))
	{
		vtLinkDir1 = m_vtXAxis;
		vtLinkDir2 = m_vtYAxis;
	}
	else if (vtPipeDir.isParallelTo(m_vtYAxis, m_tolVec))
	{
		vtLinkDir1 = m_vtYAxis;
		vtLinkDir2 = m_vtXAxis;
	}
	else 
	{
		return false;
	}

	// 先按m_vtXAxis后m_vtYAxis方向铺设管线时，管线交点 
	AcDbLine lineX(ptFeed, ptFeed + vtLinkDir1);
	AcDbLine lineY(ptSan, ptSan + vtLinkDir2);
	AcGePoint3dArray ptArr;
	lineX.intersectWith(&lineY, AcDb::kExtendBoth, AcGePlane::kXYPlane, ptArr);
	if (ptArr.length() != 1)
	{
		return false;
	}
	AcGePoint3d ptX = ptArr[0];
	ptX.z = ptFeed.z;
//	if (!IsPipe(idSan)) // 洁具 zxl 2013.11.11 del
	{	
		if (!LayMainPipe(ptSan, ptX, m_dDistPipe2Pipe)) // 直接连接洁具连接线发生碰撞
		{ 
			// 偏移连接线
			AcGeVector3d vtDir;
			if (!GetSanitaryDir(vtDir, idSan))
			{
				acutPrintf(_T("\n无法获取洁具方向！"));
				return false;
			}

			AcGeVector3d vtOffset;
			if (vtDir.isParallelTo(vtLinkDir1, m_tolVec))
			{
				vtOffset = vtDir;
			} 
			else if (vtDir.isPerpendicularTo(vtLinkDir1, m_tolVec))
			{
				if (!GetSanitaryOffsetDir(vtOffset, ptSan, idSan))
				{
					vtOffset = ptFeed - ptX;
					vtOffset.z = 0.0;
					vtOffset.normalize();
				}
			}
			else // 偏移方向需要与m_vtXAxis或m_vtYAxis平行
			{
				return false;
			}

			// 转换一次
			AcGePoint3d ptSan1 = ptSan;
			if (OffsetMainPipe(ptSan1, ptX, m_dDistPipe2Pipe, m_dDistPipe2Wall, vtOffset, OFFSET_TIME))
			{
				if (LayMainPipe(ptSan, ptSan1, m_dDistPipe2Pipe)) // 无碰撞
				{
					data.nTransformTime = 1;     
					data.vecPts.push_back(ptX);
					ptSan1.z = ptFeed.z;
					data.vecPts.push_back(ptSan1);
				}
				else 
				{   
					// 转换两次
					AcGeVector3d vtOffset2 = ptX - ptSan1;
					vtOffset2.z = 0.0;
					vtOffset2.normalize();
					if (vtOffset2.isParallelTo(vtDir, m_tolVec))
					{
						vtOffset2 = vtDir;
					}

					AcGePoint3d ptSan2 = ptSan;
					if (OffsetMainPipe(ptSan2, ptSan1, m_dDistPipe2Pipe, m_dDistPipe2Wall, vtOffset2, OFFSET_TIME))
					{
						if (LayMainPipe(ptSan, ptSan2, m_dDistPipe2Pipe))
						{
							data.nTransformTime = 2;     
							data.vecPts.push_back(ptX);
							ptSan1.z = ptFeed.z;
							data.vecPts.push_back(ptSan1);
							ptSan2.z = ptFeed.z;
							data.vecPts.push_back(ptSan2);
						}
						else // 找不到合适位置连接洁具
						{
							return false;
						}
					}
					else // 找不到合适位置连接洁具
					{
						return false;
					}
				}
			}
			else // 找不到合适位置连接洁具
			{
				return false;
			}
								
		}
		else // 直接连接洁具
		{
			data.nTransformTime = 0;  // 无需转换
			data.vecPts.push_back(ptX);
		}
	}

	return true;
}

bool ConcealInstallSanitarySys::LayMainPipe( const AcGePoint3d &ptS, const AcGePoint3d &ptE, double dDist )
{
	AcDbLine line(ptS, ptE);
	if ((!PassParallelWall(ptS, ptE))             // 没有穿过平行墙体
		&& !IsPassOtherSanitarySysPt(ptS, ptE)    // 没有穿过其他系统洁具点
		&& !IsCollidePipe(&line, dDist))	      // 没有与其他系统平行管线发生碰撞
	{
		return true;
	}
	return false;
}

bool ConcealInstallSanitarySys::LinkMainPipe( LinkDate &data )
{
	// 洁具实际上是管线 zxl 2013.11.11 del
// 	if (IsPipe(data.idSan)) 
// 	{
// 	//	return LinkPipe(ptWater, ptS, ptE);
// 		return false;
// 	}

	int nTransformTime = data.nTransformTime;
	PipeType type;
	AcGePoint3d ptFeed;
	switch(nTransformTime)
	{
	case 0:
		{
			AcGePoint3d ptTemp = data.ptSan;
			ptTemp.z = data.ptLink.z;
			AcGePoint3d pt1 = data.ptLink, pt2 = data.vecPts[0];
			ModifyMainPipePt(pt1, pt2);
			CreateVirtualPipe(pt1, pt2, eMainPipe);
			type = eMainPipe;
			ptFeed = data.vecPts[0];
			break;
		}
	case 1:
		{
			AcGePoint3d ptTemp = data.ptSan;
			ptTemp.z = data.ptLink.z;
			AcGePoint3d pt1 = data.ptLink, pt2 = data.vecPts[0];
			ModifyMainPipePt(pt1, pt2);
			CreateVirtualPipe(pt1, pt2, eMainPipe);
			CreateVirtualPipe(data.vecPts[0], data.vecPts[1], eMainPipe);
			type = eSmallPipe;
			ptFeed = data.vecPts[1];
			break;
		}
	case 2:
		{
			AcGePoint3d ptTemp = data.ptSan;
			ptTemp.z = data.ptLink.z;
			AcGePoint3d pt1 = data.ptLink, pt2 = data.vecPts[0];
			ModifyMainPipePt(pt1, pt2);
			CreateVirtualPipe(pt1, pt2, eMainPipe);
			CreateVirtualPipe(data.vecPts[0], data.vecPts[1], eMainPipe);
			CreateVirtualPipe(data.vecPts[1], data.vecPts[2], eBranch);
			type = eSmallPipe;
			ptFeed = data.vecPts[2];
			break;
		}
	default:
		return false;
	}

	// 连接洁具
	AcGePoint3d ptSan = data.ptSan;
	AcDbObjectId idSan = data.idSan;
	LinkSanitary(ptSan, ptFeed, idSan, type, data.bInWall, data.ptInWall);
	return true;
}

bool ConcealInstallSanitarySys::OffsetMainPipe( AcGePoint3d &ptS, AcGePoint3d &ptE, double dCollideDist, double dOffsetDist, const AcGeVector3d &vtOffset, int nOffsetTime )
{
	AcDbLine line;
	double dWallThick = 0.0;
	AcGeVector3d vtWall = ptS - ptE;
	vtWall.z = 0.0;
	if (!GetNearestWall(ptS, vtWall, line, dWallThick))
	{
		line.setStartPoint(ptS);
		line.setEndPoint(ptE);
		dWallThick = 0.0;
	}
	
	bool bRet = false;
	AcGePoint3d pt1 = ptS, pt2 = ptE;
	for (int j = 0; j < nOffsetTime; j++)
	{
		MovePipe(pt1, line, vtOffset, dWallThick * 0.5 + dOffsetDist * (j + 1));
		MovePipe(pt2, line, vtOffset, dWallThick * 0.5 + dOffsetDist * (j + 1));
		if (LayMainPipe(pt1, pt2, dCollideDist))
		{
			ptS = pt1;
			ptE = pt2;
			bRet = true;
			break;
		}
	}
	return bRet;	
}

void ConcealInstallSanitarySys::ComfirmXAxisYAxis( const AcDbObjectId &idPipe )
{
	// 给水管为立管时，连接洁具时方向
	m_vtXAxis = AcGeVector3d::kXAxis;
	m_vtYAxis = AcGeVector3d::kYAxis;
	m_vtXAxis.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis);
	m_vtYAxis.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis);
	// 非立管时，以管线方向和其垂涎方向为x轴y轴
	if (!IsVertivalPipe(idPipe)) 
	{
		return;
		AcGeVector3d vt = AcGeVector3d::kIdentity;
		TDbPipe *pPipe = NULL;
		acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
		if (pPipe != NULL)
		{
			vt = pPipe->StartPoint() - pPipe->EndPoint();
			vt.z = 0.0;
			pPipe->close();
		}
		// 管线垂直方向
		AcGeVector3d vt2 = vt;
		vt2.rotateBy(PI / 2, AcGeVector3d::kZAxis);
		
		// 以与世界坐标系x轴夹角小的胃X轴方向
		if (vt != AcGeVector3d::kIdentity)
		{
			AcGeVector3d vtX = AcGeVector3d::kXAxis;
			double dAngle1 = vtX.angleTo(vt);
			double dAngle2 = vtX.angleTo(vt2);

			if (dAngle2 > dAngle1)
			{
				m_vtXAxis = vt;
				m_vtYAxis = vt2;
			}
			else
			{
				m_vtXAxis = vt2;
				m_vtYAxis = vt;
			}
		}
	}
}


void ConcealInstallSanitarySys::CreatePipe()
{
	// 获得给水点
	AcGePoint3d ptFeed;
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		if (pPipe->IsVertical())
		{
			ptFeed = pPipe->StartPoint();
		}
		else
		{
			if (pPipe->GetFlowDir() == TPipeSys::kFromStart)
			{
				ptFeed = pPipe->StartPoint();
			}
			else
			{
				ptFeed = pPipe->EndPoint();
			}
		}
		pPipe->close();
	}

	std::vector<PipeData>::iterator it;
	CString sLayer = GetPipeLayer(m_sysPipe);
	CString sVPipeLayer = GetVPipeLayer(m_sysPipe);
	InitPipeLayer(sLayer);
	InitPipeLayer(sVPipeLayer);
	int iPipeIdx = GetPipeLayerIdxByName(sLayer);
	CString sLineType = GetPipeWireLayLineType(sLayer);
	CString sMaterial = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
	CString sDnType = GetDnByMat(sMaterial); 
	CString sLineType2 = GetLayerLineType(sLayer);
	for (it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
	{
		AcDbLine *pline = (*it).pLine;
		// 供水点在管线中间的管线序切断分别设置流向
		if (PipePassFeedPt(pline, ptFeed, sLayer))
		{
			continue;
		}

		TDbPipe *pPipe = new TDbPipe();
		pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
		if (it->type == eVertival)//设置立管显示半径
		{
			if(g_bPipeDouble[iPipeIdx])
			{
				pPipe->SetRadiusIn(g_nPipeRadius[iPipeIdx] / 2);
			}
			else
			{
				if(!g_bStandPipeArc)//传统扣弯
					pPipe->SetRadiusIn(-2);
			}
		}
		pPipe->SetStartPoint(pline->startPoint());
		pPipe->SetEndPoint(pline->endPoint());
		pPipe->SetFlowDir(TPipeSys::kFromStart);
		if(sLineType2.Find(_T("TG")) > -1)
		{
			XLine lineTemp(asDblArray(pline->startPoint()), asDblArray(pline->endPoint()));
			double nAng = lineTemp.Direction();
			if(nAng > PI/2 && nAng < (PI/2*3 + 0.001))
			{
				pPipe->SetStartPoint(pline->endPoint());
				pPipe->SetEndPoint(pline->startPoint());
				pPipe->SetFlowDir(TPipeSys::kFromEnd);
			}
		}
		pPipe->SetDnDiameter(m_dPipeDn);
		pPipe->setLayer(sLayer);
		pPipe->SetSysType(GetPipeSysByLayer(sLayer));
		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);
	}
	// 更新给水管
	ModifyFeedPipe();
}

SanitarySys::PipeDir ConcealInstallSanitarySys::GetPipeDir( const AcGeVector3d &vtDir )
{
	PipeDir dir = eNone;
	if (vtDir.isParallelTo(m_vtXAxis))
	{
		dir = eParallelX;
	}
	else if (vtDir.isParallelTo(m_vtYAxis))
	{
		dir = eParallelY;
	}
	else
	{
		dir = eOther;
	}
	return dir;
}

void ConcealInstallSanitarySys::ModifyFeedPipe()
{
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idPipe, AcDb::kForWrite);
	if (pPipe != NULL)
	{
		if (pPipe->IsVertical()) 
		{
			AcDbLine line(pPipe->StartPoint(), pPipe->EndPoint());
			AcGePoint3d pt;
			if (line.getClosestPointTo(m_ptFeed, pt, Adesk::kTrue) == Acad::eOk)
			{
				AcGePoint3d ptS = pPipe->StartPoint();
				AcGePoint3d ptE = pPipe->EndPoint();
				double dDistS = ptS.distanceTo(pt);
				double dDistE = ptE.distanceTo(pt);
				double dDist = ptS.distanceTo(ptE);
				if (fabs(dDist - dDistE - dDistS) > 0.001) // 点在管线延长线上
				{
					if (dDistS < dDistE)
					{
						pPipe->SetStartPoint(pt);
					} 
					else
					{
						pPipe->SetEndPoint(pt);
					}
				}
			}
		} 
		else
		{
			pPipe->erase();
		}
		pPipe->close();
	}
}

bool ConcealInstallSanitarySys::IsPipe( const AcDbObjectId idEnt )
{
	ads_name name;
	acdbGetAdsName(name, idEnt);
	Entity ent(name);
	if (ent.Is(_T("ATS_PIPE")))
	{
		return true;
	}
	return false;
}

bool ConcealInstallSanitarySys::LinkPipe( const AcGePoint3d &ptWater, const AcGePoint3d &ptS, const AcGePoint3d &ptE )
{
	CreateVirtualPipe(ptWater, ptS, eMainPipe);
	CreateVirtualPipe(ptS, ptE, eMainPipe);
	return true;
}

double ConcealInstallSanitarySys::GetVPipeDrawRadius()
{
	double dRadius = 0.5 * DocGetPScale();
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		dRadius = pPipe->GetRadius() * DocGetPScale();
		pPipe->close();
	}
	return dRadius;
}

void ConcealInstallSanitarySys::GetPtToLineDist( std::multimap<double, std::pair<AcDbLine*, AcGePoint3d> > &mapDist, const AcGePoint3d &pt, const AcGeVector3d &vtDir, PipeType type )
{
	std::vector<PipeData>::iterator it;
	AcGeVector3d vtTemp;
	AcGePoint3d ptPrj, ptTemp = pt, ptS, ptE;
	AcDbLine *pLine = NULL;
	AcDbLine line;
	for (it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
	{
		pLine = it->pLine;
		if (pLine == NULL || it->type != type)
		{
			continue;
		}

		vtTemp = pLine->startPoint() - pLine->endPoint();
		vtTemp.z = 0.0;
		if (vtTemp.isParallelTo(vtDir, m_tolVec)) 
		{
			ptS = pLine->startPoint();
			ptE = pLine->endPoint();
			ptS.z = 0.0;
			ptE.z = 0.0;
			line.setStartPoint(ptS);
			line.setEndPoint(ptE);
			if (line.getClosestPointTo(ptTemp, ptPrj, Adesk::kTrue) == Acad::eOk)
			{
				double dDist = ptTemp.distanceTo(ptPrj);
				ptPrj.z = pLine->startPoint().z;
				mapDist.insert(std::make_pair(dDist, std::make_pair(pLine, ptPrj)));
			}
		}
	}
}

void ConcealInstallSanitarySys::ExtendLine( AcDbLine *pLine, const AcGePoint3d &pt )
{
	ASSERT(pLine != NULL);
	AcGePoint3d ptS = pLine->startPoint();
	AcGePoint3d ptE = pLine->endPoint();
	double dDistS = ptS.distanceTo(pt);
	double dDistE = ptE.distanceTo(pt);
	double dDist = ptS.distanceTo(ptE);
	double dLen = dDistS + dDistE;
	if (fabs(dLen - dDist) > 0.001 && dLen > dDist) // 在延长线上
	{
		if (dDistS < dDistE)
		{
			pLine->setStartPoint(pt);
		} 
		else
		{
			pLine->setEndPoint(pt);
		}
	}
}

bool ConcealInstallSanitarySys::OffsetLine( AcGePoint3d &ptS, AcGePoint3d &ptE, double dCollideDist, const AcGeVector3d &vtOffset, int nOffsetTime)
{
	AcDbLine line;
	double dWallThick = 0.0;
	AcGeVector3d vtWall = ptS - ptE;
	vtWall.z = 0.0;
	if (!GetNearestWall(ptS, vtWall, line, dWallThick))
	{
		line.setStartPoint(ptS);
		line.setEndPoint(ptE);
		dWallThick = 0.0;
	}
	
	bool bRet = false;
	AcGePoint3d pt1 = ptS, pt2 = ptE;
	for (int j = 0; j < nOffsetTime; j++)
	{
		MovePipe(pt1, line, vtOffset, dWallThick * 0.5 + m_dDistPipe2Wall * (j + 1));
		MovePipe(pt2, line, vtOffset, dWallThick * 0.5 + m_dDistPipe2Wall * (j + 1));
		if (!IsConflicting(pt1, pt2, dCollideDist))
		{
			ptS = pt1;
			ptE = pt2;
			bRet = true;
			break;
		}
	}
	return bRet;
}

void ConcealInstallSanitarySys::GetOffsetDir( AcGeVector3d &vtOffset, const AcGePoint3d &ptSan, const AcGeVector3d &vtSanitaryDir, const AcGeVector3d &vtLinkedPipe, const AcDbObjectId &idSan )
{
	if (vtSanitaryDir.isParallelTo(vtLinkedPipe, m_tolVec)) // 洁具方向与洁具连接的管线方向平行
	{
		if (!GetSanitaryOffsetDir(vtOffset, ptSan, idSan)) // 给水点相对另一个给水点的方向
		{
			vtOffset = vtLinkedPipe;
			vtOffset.rotateBy(PI / 2, AcGeVector3d::kZAxis);
		}
	}
	else if (vtSanitaryDir.isPerpendicularTo(vtLinkedPipe, m_tolVec))
	{
		vtOffset = vtSanitaryDir;
	}
	else 
	{
		vtOffset = vtLinkedPipe;
		vtOffset.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	}

	vtOffset.z = 0.0;
	vtOffset.normalize();

	// 偏移方向有可能需与m_vtXAxis或m_vtYAxis平行
	std::map<double, AcGeVector3d> mapDir;
	double dAngle = vtOffset.angleTo(m_vtYAxis);
	mapDir.insert(std::make_pair(dAngle, m_vtYAxis));
	dAngle = vtOffset.angleTo(-m_vtYAxis);
	mapDir.insert(std::make_pair(dAngle, -m_vtYAxis));
	dAngle = vtOffset.angleTo(m_vtXAxis);
	mapDir.insert(std::make_pair(dAngle, m_vtXAxis));
	dAngle = vtOffset.angleTo(-m_vtXAxis);
	mapDir.insert(std::make_pair(dAngle, -m_vtXAxis));
	vtOffset = mapDir.begin()->second;
}

//////////////////////////////////////////////////////////////////////////
void ConcealInstallSanitarySys::DrawSanitaryDir( const AcGePoint3d &pt, const AcGeVector3d &vtDir )
{
	AcGeVector3d vt = vtDir;
	vt.normalize();
	XPoint ptE = pt + vt * 500;
	AcGeVector3d vt1 = vt;
	vt1.rotateBy(PI/2, AcGeVector3d::kZAxis);

	XPoint pt1 = ptE - vt * 50 + vt1 * 50;
	XPoint pt2 = ptE - vt * 50 - vt1 * 50;
	XLine line1(asDblArray(pt), ptE);
	line1.Make();
	XLine line2(ptE, pt1);
	line2.Make();
	XLine line3(ptE, pt2);
	line3.Make();
}

bool ConcealInstallSanitarySys::GetLinkData( LinkDate &data )
{
	// 连接洁具时可参考的四个方向的管线
	AcGeVector3d vtLinkDir1 = m_vtXAxis;
	AcGeVector3d vtLinkDir2 = m_vtXAxis;
	AcGeVector3d vtLinkDir3 = m_vtXAxis;
	AcGeVector3d vtLinkDir4 = m_vtXAxis;
	vtLinkDir2.rotateBy(PI * 0.5, AcGeVector3d::kZAxis);
	vtLinkDir3.rotateBy(PI, AcGeVector3d::kZAxis);
	vtLinkDir4.rotateBy(PI * 1.5, AcGeVector3d::kZAxis);
	
	AcDbObjectId idSan = data.idSan;
	AcGePoint3d ptSan = data.ptSan;

	// 洁具方向
	AcGeVector3d vtSanitaryDir;
	GetSanitaryDir(vtSanitaryDir, idSan);
	
	// 在四个方向连接洁具
	AcDbLine *pLineTemp = NULL;
	double dDist = 0.0;
	AcGePoint3d ptLinkTemp, ptCornerTemp;
	std::multimap<double, LinkDate> mapLinkDist;
	AcGeVector3d vtOffset;  // 偏移方向
	GetOffsetDir(vtOffset, ptSan, vtSanitaryDir, vtLinkDir1, idSan);
	LinkDate DataTemp1 = data;
	if (GetLinkData(DataTemp1, vtLinkDir1, m_vtYAxis, vtOffset))
	{
		mapLinkDist.insert(std::make_pair(DataTemp1.dLinkLen, DataTemp1));
	}
	
	LinkDate DataTemp2 = data;
	GetOffsetDir(vtOffset, ptSan, vtSanitaryDir, vtLinkDir2, idSan);
	if (GetLinkData(DataTemp2, vtLinkDir2, m_vtXAxis, vtOffset))
	{
		mapLinkDist.insert(std::make_pair(DataTemp2.dLinkLen, DataTemp2));
	}

	LinkDate DataTemp3 = data;
	GetOffsetDir(vtOffset, ptSan, vtSanitaryDir, vtLinkDir3, idSan);
	if (GetLinkData(DataTemp3, vtLinkDir3, m_vtYAxis, vtOffset))
	{
		mapLinkDist.insert(std::make_pair(DataTemp3.dLinkLen, DataTemp3));
	}

	LinkDate DataTemp4 = data;
	GetOffsetDir(vtOffset, ptSan, vtSanitaryDir, vtLinkDir4, idSan);
	if (GetLinkData(DataTemp4, vtLinkDir4, m_vtXAxis, vtOffset))
	{
		mapLinkDist.insert(std::make_pair(DataTemp4.dLinkLen, DataTemp4));
	}
	
	// 找到连接线最短的路径
	std::multimap<double, LinkDate>::iterator it;
	it = mapLinkDist.begin();
	if (it != mapLinkDist.end())
	{
		data = (*it).second;
		return true;
	}
	return false;
}	

bool ConcealInstallSanitarySys::GetLinkData( LinkDate &data, const AcGeVector3d &vtLink, const AcGeVector3d &vtPipe, const AcGeVector3d &vtOffset )
{
	// 获得点pt到所有与vtLine平行的直线的距离
	AcGePoint3d ptSan = data.ptSan;
	std::multimap<double, std::pair<AcDbLine*, AcGePoint3d> > mapData;
	GetPtToLineDist(mapData, ptSan, vtPipe, eMainPipe);
	GetPtToLineDist(mapData, ptSan, vtPipe, eBranch);
	GetPtToLineDist(mapData, ptSan, vtPipe, eBranch2);
	// 找出与vtDir同向的直线
	std::multimap<double, std::pair<AcDbLine*, AcGePoint3d> > mapNew;
	std::multimap<double, std::pair<AcDbLine*, AcGePoint3d> >::iterator it;
	AcGeVector3d vtTemp;
	for (it = mapData.begin(); it != mapData.end(); it++)
	{
		vtTemp = ((*it).second).second - ptSan;
		vtTemp.z = 0.0;
		vtTemp.normalize();
		if (vtTemp.isCodirectionalTo(vtLink, m_tolVec)) // 与连接方向同向
		{
			mapNew.insert(*it);
		}
	}
	
	// 获得同向最近的直线
	bool bRet = false;
	it = mapNew.begin();
	if (it != mapNew.end())
	{
		ptSan.z = (*it).second.second.z;
		int nTransfromTime = data.nTransformTime;
		switch(nTransfromTime)
		{
		case 0:
			{
				/*
												 *
												 *	
					ptSan*********************** ptLink
												 *
												 *			
					洁具连接管线示意图，ptSan为洁具点
				*/
				if (!IsConflicting(ptSan, ((*it).second).second, m_dDistPipe2Pipe))
				{
					data.pLine = ((*it).second).first;
					data.ptLink = ((*it).second).second;
					if (!data.bInWall) // 洁具点在墙内
					{
						data.dLinkLen = (*it).first;
					} 
					else // 在墙外
					{
						data.dLinkLen = (data.ptInWall).distanceTo(((*it).second).second);
					}
					bRet = true;
				}
				break;
			}
		case 1:
			{
				/*
												 *
												 *	
					ptConer*********************** ptLink
					*							 *
					*							 *			
					*
					ptSan
					洁具连接管线示意图，ptSan为洁具点
				*/
				AcGePoint3d pt1 = (*it).second.second, pt2 = ptSan;
				AcGeVector3d vtMove = vtOffset;
				if (OffsetLine(pt1, pt2, m_dDistPipe2Wall, vtMove, OFFSET_TIME))
				{
					if (!IsConflicting(pt2, ptSan, m_dDistPipe2Pipe))
					{
						data.pLine = ((*it).second).first;
						data.ptLink = pt1;
						data.vecPts.push_back(pt2);
						if (!data.bInWall)
						{
							data.dLinkLen = (*it).first + GetDist(ptSan, pt2);
						} 
						else
						{
							data.dLinkLen = (*it).first + GetDist(data.ptInWall, pt2);
						}
						bRet = true;
					}
				}
				break;
			}
		case 2:
			{
				/*
														 *
														 *	
							ptCorner1*********************** ptLink
							*							 *
							*							 *
							*			
				ptSan*******ptCorner2
							
					洁具连接管线示意图，ptSan为洁具点
				*/
				AcGePoint3d pt1 = (*it).second.second, pt2 = ptSan;
				AcGeVector3d vtMove = vtOffset;
				if (OffsetLine(pt1, pt2, m_dDistPipe2Wall, vtMove, OFFSET_TIME))
				{
					AcGeVector3d vtMove2 = pt1 - pt2;
					vtMove2.z = 0.0;
					vtMove2.normalize();
					AcGePoint3d pt3 = ptSan, pt4 = pt2;
					if (IsConflicting(pt3, pt4, m_dDistPipe2Pipe))
					{
						if (OffsetLine(pt3, pt4, m_dDistPipe2Wall, vtMove2, OFFSET_TIME) && !IsConflicting(ptSan, pt3, m_dDistPipe2Pipe))
						{
							data.pLine = ((*it).second).first;
							data.ptLink = pt1;
							data.dLinkLen = (*it).first + GetDist(pt3, pt4);
							data.vecPts.push_back(pt4);
							data.vecPts.push_back(pt3);
							bRet = true;
						}
					}
				}
				break;
			}
		}
	}
	return bRet;
}

void ConcealInstallSanitarySys::LinkSanitary2Pipe( const LinkDate &data )
{
	AcGePoint3d ptFeed;
	PipeType type;
	switch(data.nTransformTime)
	{
	case 0:
		{
			ExtendLine(data.pLine, data.ptLink);
			ptFeed = data.ptLink;
			type = eSmallPipe;
			break;
		}
	case 1:
		{
			if (data.vecPts.size() == 1)
			{
				ExtendLine(data.pLine, data.ptLink);
				CreateVirtualPipe(data.ptLink, data.vecPts[0], eBranch);
				ptFeed = data.vecPts[0];
				type = eSmallPipe;
			}
			break;
		}
	case 2:
		{
			if (data.vecPts.size() == 2)
			{
				ExtendLine(data.pLine, data.ptLink);
				CreateVirtualPipe(data.ptLink, data.vecPts[0], eBranch);
				CreateVirtualPipe(data.vecPts[0], data.vecPts[1], eBranch);
				ptFeed = data.vecPts[1];
				type = eSmallPipe;
			}
			break;
		}
	default:
		return;
	}

	if (IsPipe(data.idSan))
	{
		AcGePoint3d ptSan = data.ptSan;
		ptSan.z = ptFeed.z;
		CreateVirtualPipe(ptFeed, ptSan, eMainPipe);
	}
	else
	{
	     LinkSanitary(data.ptSan, ptFeed, data.idSan, type, data.bInWall, data.ptInWall);
	}
}

double ConcealInstallSanitarySys::GetDist( const AcGePoint3d &pt1, const AcGePoint3d &pt2 )
{
	AcGePoint3d ptS = pt1, ptE = pt2;
	ptS.z = 0.0;
	ptE.z = 0.0;
	return ptS.distanceTo(ptE);
}

void ConcealInstallSanitarySys::ModifyLinkSanPt(LinkDate &data)
{
	// 当洁具点在墙外时，以洁具点暗装时到墙体的投影点为虚拟洁具点进行连接
	AcGeVector3d vtDir;
	GetSanitaryDir(vtDir, data.idSan);
	AcGePoint3d ptSan = data.ptSan, ptWall;
	if (GetPtInWall(ptWall, ptSan, vtDir) && ptSan.distanceTo(ptWall) > 0.001)
	{
		data.ptSan = ptWall; // 将洁具点到墙体的投影点当做待连接洁具点
		data.ptInWall = ptSan;
		data.bInWall = true;
	}
}

bool ConcealInstallSanitarySys::PipePassFeedPt( AcDbLine *pLine, const AcGePoint3d &ptFeed, const CString &sLayer)
{
	AcGePoint3d ptTemp = ptFeed;
	AcGePoint3d ptS = pLine->startPoint();
	AcGePoint3d ptE = pLine->endPoint();
	ptTemp.z = ptS.z;
	// 供水点在线的端点处
	if (ptS.distanceTo(ptTemp) < 0.001 || ptE.distanceTo(ptTemp) < 0.001)
	{
		return false;
	}

	// 供水点在线内
	double dLen = ptS.distanceTo(ptE);
	double dDist = ptS.distanceTo(ptTemp) + ptE.distanceTo(ptTemp);
	if (fabs(dDist - dLen) < 0.001)
	{
		int iPipeIdx = GetPipeLayerIdxByName(sLayer);
		CString sLineType = GetPipeWireLayLineType(sLayer);
		CString sMaterial = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
		CString sDnType = GetDnByMat(sMaterial); 
    	CString sLineType2 = GetLayerLineType(sLayer);

		TDbPipe *pPipe = new TDbPipe();
		pPipe->SetStartPoint(ptTemp);
		pPipe->SetEndPoint(ptS);
		pPipe->SetFlowDir(TPipeSys::kFromStart);
		if(sLineType2.Find(_T("TG")) > -1)
		{
			XLine line(asDblArray(ptTemp), asDblArray(ptS));
			double nAng = line.Direction();
			if(nAng > PI/2 && nAng < (PI/2*3 + 0.001))
			{
				pPipe->SetStartPoint(ptS);
				pPipe->SetEndPoint(ptTemp);
				pPipe->SetFlowDir(TPipeSys::kFromEnd);
			}
		}
		pPipe->SetDnDiameter(m_dPipeDn);
		pPipe->setLayer(sLayer);
		pPipe->SetSysType(GetPipeSysByLayer(sLayer));
		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);

		TDbPipe *pPipe2 = new TDbPipe();
		pPipe2->SetStartPoint(ptTemp);
		pPipe2->SetEndPoint(ptE);
		pPipe2->SetFlowDir(TPipeSys::kFromStart);
		if(sLineType2.Find(_T("TG")) > -1)
		{
			XLine line(asDblArray(ptTemp), asDblArray(ptE));
			double nAng = line.Direction();
			if(nAng > PI/2 && nAng < (PI/2*3 + 0.001))
			{
				pPipe2->SetStartPoint(ptE);
				pPipe2->SetEndPoint(ptTemp);
				pPipe2->SetFlowDir(TPipeSys::kFromEnd);
			}
		}
		pPipe2->SetDnDiameter(m_dPipeDn);
		pPipe2->setLayer(sLayer);
		pPipe2->SetSysType(GetPipeSysByLayer(sLayer));
		pPipe2->setColor(AcCmColor()); //随层
		pPipe2->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
		pPipe2->setLinetype(sLineType);  
		pPipe2->setLineWeight(AcDb::kLnWtByLayer);
		pPipe2->SetMaterial(g_iPipeMaterial[iPipeIdx]);
		pPipe2->SetLabel(sDnType);
		AddToCurrentSpace(pPipe2, Adesk::kTrue);
		return true;
	}
	// 供水点不在线上
	return false;
}

void ConcealInstallSanitarySys::ModifyMainPipePt( AcGePoint3d &ptS, AcGePoint3d &ptE )
{
	TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, m_idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		if (!pPipe->IsVertical())
		{
			AcGePoint3d pt1 = pPipe->StartPoint();
			AcGePoint3d pt2 = pPipe->EndPoint();
			AcGeVector3d vt1 = pt1 - pt2;
			AcGeVector3d vt2 = ptS - ptE;
			AcGeTol tol;
			tol.setEqualVector(0.001);
			if (vt2.isParallelTo(vt1, tol))
			{
				if (ptS.distanceTo(pt1) < 0.001)
				{
					if (ptS.distanceTo(ptE) < pt1.distanceTo(pt2))
					{
						ptE = pt2;
					} 
				} 
				else if (ptS.distanceTo(pt2) < 0.001)
				{
					if (ptS.distanceTo(ptE) < pt1.distanceTo(pt2))
					{
						ptE = pt1;
					} 
				}
			}
		}
		pPipe->close();
	}
}

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