// TDbDuctNode.cpp: implementation of the TDbDuctNode class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TDbDuctNode.h"

#include "GlobalFunction.h"
#include "PipeTools.h"
#include "DbDuct.h"

ACRX_DXF_DEFINE_MEMBERS(ATSDuctNode, ATSPipeNode, AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent, 1, ATS_DUCTNODE,
						"ATS_DUCTNODE图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbDuctNode);

// sg modify
// const Adesk::UInt8 TDbDuctNode::g_nVersion = 1; // 7.5
const Adesk::UInt8 TDbDuctNode::g_nVersion = 2; // 7.6



///////////////////////////Construction/Destruction////////////////////////////
TDbDuctNode::TDbDuctNode():
m_nMain(0), m_nSysDrawMod(2), m_nDrawMod(0), m_dDrawParam(1), m_dDrawParam2(1),
m_bMuffler(FALSE), m_nMufflerMod(0), m_bShowDLYP(FALSE), m_nDLYPNum(3),
m_nDLYPType(0), m_nXMWNum(1), m_bValue(FALSE), m_nSpare(0), m_dSpare(0.0),
m_nAlign(4), m_dFlangeDis(100), m_dFlangeThick(50)
{
	m_visibility = TPipeSys::kVisible; // 所有风管节点都应该是可见的

	m_nType = kStem;             // 连接件类型
	m_nLinkType = kSingleFlange; // 连接方式
	m_lstDuctIFace.Reset();      // 风管尺寸
}

TDbDuctNode::~TDbDuctNode()
{
}

void TDbDuctNode::SetLinkType(const Adesk::UInt8 nLinkMod) // 法兰连接类型
{
	assertWriteEnabled();
	m_nLinkType = (TDbDuctNode::FlangeLinkType)nLinkMod;
}

BOOL TDbDuctNode::Is(const CString &csType) const // 判断节点是否是指定的类型
{
	CString trueType = _T("Stem");
	DuctNodeType nType = GetNodeType();
	if (nType == kStem) // 一般堵头
	{
		trueType = _T("Stem");
	}
	else if (nType == kElbow) // 弯头
	{
		trueType = _T("Elbow");
	}
	else if (nType == kKouElbow) // 扣弯
	{
		trueType = _T("KouElbow");
	}
	else if (nType == kYiZiElbow) // 乙字弯头
	{
		trueType = _T("YiZiElbow");
	}
	else if (nType == kTapered) // 变径
	{
		trueType = _T("Tapered");
	}
	else if (nType == kTianYuanDiFang) // 天圆地方
	{
		trueType = _T("TianYuanDiFang");
	}
	else if (nType == kFlange) // 法兰
	{
		trueType = _T("Flange");
	}
	else if (nType == k3Corner) // 三通
	{
		trueType = _T("3Corner");
	}
	else if (nType == k4Corner) // 四通
	{
		trueType = _T("4Corner");
	}
	else if (nType == kSoft) // 软接口
	{
		trueType = _T("Soft");
	}
	else if (nType == kOther) // 其他
	{
		trueType = _T("Other");
	}
	else if (nType == kTaoDong) // 掏洞三通
	{
		trueType = _T("TaoDong");
	}
	return trueType==csType;
}



/////////有关与管线之间连接点(m_lstInterface中的m_ptLocation)的相关函数////////
int TDbDuctNode::FindIdInLink(AcDbObjectId linkId) const // 查找指定ID
{
	int nLen = GetInterfaceNum();
	for (int i = 0; i < nLen; i++)
	{
		const AcDbObjectId &id = GetIPipe(i);
		if (id == linkId)
		{
			return i;
		}
	}
	return -1; // 找不到
}

// 获取所有连接的管线ID
void TDbDuctNode::GetAllLinkDucts(DList<AcDbObjectId> &ductIds) const
{
	int nLen = GetInterfaceNum();
	for (int i = 0; i < nLen; i++)
	{
		const AcDbObjectId &id = GetIPipe(i);
		ductIds.Append(new AcDbObjectId(id));
	}
}

AcDbIntArray TDbDuctNode::GetAllTypes() const // 获取所有的连接类型
{
	AcDbIntArray types;
	int nLen = GetDuctIFaceNum();
	for (int i = 0; i < nLen; i++)
	{
		int nType = GetIType(i);
		types.append(nType);
	}
	return types;
}



////////////////////////有关m_lstDuctIFace的相关函数///////////////////////////
BOOL TDbDuctNode::HasNullIFace(AcDbIntArray &ifaces) const // 节点中是否有空接口
{
	if (!ifaces.isEmpty()) // 首先清空
	{
		ifaces.removeSubArray(0, ifaces.logicalLength()-1);
	}

	int nLen = GetDuctIFaceNum();
	for (int i = 0; i < nLen; i++)
	{
		int nType = GetIType(i);
		if (nType == 1) // 空接口1，原来连接的是管线
		{
			ifaces.append(i);
		}
		else if (nType == 2) // 空接口2，原来连接的是节点
		{
			const AcDbObjectId &idNode = GetIPipe(i);
			if (idNode.isErased() || idNode.isNull()) // 连接的节点被删除
			{
				ifaces.append(i);
			}
		}
	}
	return TRUE;
}



////////////////////////////Override TDbPipeNode///////////////////////////////
// 判断节点是否可以连接管段，nPos: 0--start; 1--end
BOOL TDbDuctNode::CanLinkSide(const AcDbObjectId &idPipe, int nPos) const
{
	BOOL bRet(FALSE);
	OPENOBJ_BEGIN(idPipe, AcDb::kForRead, TDbDuct, pDuct);
	if (pDuct != NULL)
	{
		XPoint ptLoc = GetLocation();
		const XPoint &ptRef = nPos?pDuct->EndPoint():pDuct->StartPoint();
		if (ptRef.Distance(ptLoc) < PS_SNAP) // 与位置点一致
		{
			return TRUE;
		}

		int nLen = GetInterfaceNum();
		for (int i=0; i<nLen; i++)
		{
			const XPoint &ptLink = GetILocation(i);
			if (ptRef.Distance(ptLink) < PS_SNAP) // 与接口点一致
			{
				bRet = TRUE;
				break;
			}
		}
	}
	OPENOBJ_END();
	return bRet;
}

void TDbDuctNode::RemoveInterface(TPipeSys::SysType st) // 删除两种接口
{
	assertWriteEnabled();
	int nCount = GetInterfaceNum();
	for (int i=0; i<nCount; i++)
	{
		TPipeInterface &iFace = *m_lstInterface[i];
		if (iFace.m_sysType == st)
		{
			m_lstInterface.Remove();
			m_lstDuctIFace.Remove(i);
			i--;
		}
	}
}

void TDbDuctNode::RemoveInterface(const AcDbObjectId &idPipe)
{
	assertWriteEnabled();
	int nCount = GetInterfaceNum();
	for (int i=0; i<nCount; i++)
	{
		TPipeInterface &iFace = *m_lstInterface[i];
		if (idPipe == (AcDbObjectId)iFace.m_idPipe)
		{
			m_lstInterface.Remove();
			m_lstDuctIFace.Remove(i);
			break;
		}
	}
}

// 转轴侧坐标
XPoint TransformPoint(const XPoint& point, double angle, const XPoint& basePoint)
{
	XPoint pt = point - basePoint;
	XPoint ptN(pt.x + cos(angle) * pt.y, pt.z + sin(angle) * pt.y, point.z);
	return ptN;
}	

// 注：打断、合并时替换，不考虑特殊情况，管线正常接连，ID都不为空，接口为0
//     空接口引出、空接口与其他连接时替换，ID都不为空，接口由1变为0或2
//     删除掏洞主管时替换，删除接口，不替换
//     生系统图时替换：1）连接件直接相连或空接口，新ID为空，调整向量，接口类型不变
//                     2）掏洞接口，不删除接口，类型不变
void TDbDuctNode::ReplaceInterface(const AcDbObjectId &idOld,
								   const AcDbObjectId &idNew) // 替换两种接口
{
	assertWriteEnabled();
	int nIndex = FindIdInLink(idOld);
	if (nIndex == -1) // 找不到
	{
		return;
	}

	int nType = GetIType(nIndex); // 接管类型
	if ((nType==3) && (m_nSysDrawMod!=4)) // 非系统图的掏洞节点
	{
		RemoveInterface(idOld); // 断开连接，删除接口
		return;
	}
	SetIPipe(nIndex, idNew); // 其他情况，一律替换ID
	
	if ((m_nSysDrawMod==4) && (idNew.isNull() || idNew.isErased())) // 系统图，空接口
	{
		XPoint ptLink = GetILocation(nIndex);
		XVector3D vec = GetIDirection(nIndex);
		vec.Normalize();
		vec.Scale(200);
		XPoint ptVec = ptLink + vec; // 旧

		XPoint ptChange1 = ::TransformPoint(ptVec, PI/4, XPoint()), // 注：角度暂时写死
			ptChange2 = ::TransformPoint(ptLink, PI/4, XPoint());
		vec = ptChange1 - ptChange2;
		vec.Normalize();
		SetIDirection(nIndex, vec); // 重新设置连接方向
		return;
	}

	if (nType == 1) // 空接口，新连接的是节点
	{
		OPENOBJ_BEGIN(idNew, AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode != NULL)
		{
			SetIType(nIndex, 2);
			return;
		}
		OPENOBJ_END();
	}

	SetIType(nIndex, 0); // 其他情况均为接新管线，接口类型应为0
	OPENOBJ_BEGIN(idNew, AcDb::kForRead, TDbDuct, pDuct);
	if (pDuct != NULL)
	{
		SetIDrawType(nIndex, pDuct->GetSysDrawMod());
		SetIDQSide(nIndex, pDuct->GetDQSide());
		SetIDQType(nIndex, pDuct->GetDuiQi());
		
		XPoint pt = ::GetNearPt(m_ptLocation, pDuct->GetStartPoint(), pDuct->GetEndPoint());
		SetILocation(nIndex, pt);
		TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
		XVector3D vt = pDuct->GetDirection(pt, nSide); // 向量
		if (nSide == TPipeSys::kEndPt) // 终点
		{
			SetIFlowDir(nIndex, TPipeSys::kInlet);
			SetIEle(nIndex, pDuct->GetElevationAt(1));
		}
		else // 起点
		{
			SetIFlowDir(nIndex, TPipeSys::kOutlet);
			SetIEle(nIndex, pDuct->GetElevationAt(0)); // 标高
		}
		SetIDirection(nIndex, vt);

		if (pDuct->IsVertical())
		{
			SetIVDAngle(nIndex, pDuct->GetVDAngle());
		}
	}
	OPENOBJ_END();
}

// 更新接口，注：同时更新m_lstInterface和m_lstDuctIFace，只处理连接管线的正常情况
void TDbDuctNode::UpdateInterface(TPipeSys::SysType st, const XPoint &ptAt,
								  const DList<AcDbObjectId> &ids,
								  const AcDbIntArray &types)
{
	assertWriteEnabled();
	int nCount1 = ids.Length(),
		nCount2 = types.logicalLength();
	if (nCount1 != nCount2) // 1、先判断链表数量是否正确
	{
		return;
	}

 	int i(0);
	DList<AcDbObjectId> lstDuct; // 2、存储需要新生成的接口
	for (i=0; i<nCount1; i++)
	{
		lstDuct.Append(new AcDbObjectId(ids[i]));
	}
	AcDbIntArray aryTypes; // 存储新生成的连接类型
	for (i=0; i<nCount2; i++)
	{
		aryTypes.append(types[i]);
	}

	nCount1 = lstDuct.Length();
	nCount2 = types.logicalLength();
	if (nCount1 != nCount2) // 3、再次判断链表数量是否正确
	{
		return;
	}

 	m_ptLocation = ptAt; // 4、更新节点位置

	int nLen = GetInterfaceNum(); // 5、更新或者删除老的接口
	for (i=0; i<nLen; i++)
	{
		TPipeInterface &iFace = *m_lstInterface[i]; // 旧
		for (int j=0; j<lstDuct.Length(); j++)
		{
			if (iFace.m_idPipe == *lstDuct[j]) // 新
			{
				int nType = aryTypes[j];
				SetIType(i, nType); // 先修改类型，再删除
				lstDuct.Remove();
				aryTypes.removeAt(j);
				if ((nType == 1) || (nType == 2)) // 空接口或者接节点，暂不更新
				{
					break;
				}
				
				// 判断是否符合几何条件,或更新接口
				OPENOBJ_BEGIN(iFace.m_idPipe, AcDb::kForRead, TDbDuct, pDuct);
				if (pDuct == NULL)
				{
					break;
				}

				iFace.m_sysType = st; // 系统类型
				
				XPoint ptLink;
				if (nType == 0) // 两边连接的节点
				{
					ptLink = ::GetNearPt(ptAt, pDuct->GetStartPoint(), pDuct->GetEndPoint());
				}
				else // 掏洞节点，nType=3
				{
					pDuct->ProjectToMe(ptAt, ptLink); // 注：暂时将其投影到中心线上
				}
				iFace.m_ptLocation = ptLink;
				
				TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
				iFace.m_vtLocation = pDuct->GetDirection(ptLink, nSide); // 向量
				if (nSide == TPipeSys::kEndPt) // 终点
				{
					iFace.m_flowDir = TPipeSys::kInlet;
					SetIEle(i, pDuct->GetElevationAt(1)); // 标高
				}
				else // 起点，掏洞节点的连接方向取连接点的切线方向
				{
					iFace.m_flowDir = TPipeSys::kOutlet;
					SetIEle(i, pDuct->GetElevationAt(0));
				}
				
				SetISection(i, pDuct->GetSectionType());
				SetIDrawType(i, pDuct->GetSysDrawMod());
				SetIWidth(i, pDuct->GetWidth());
				SetIHeight(i, pDuct->GetHeight());
				SetIFlDist(i, pDuct->GetFlChuTou());
				SetIFlThick(i, pDuct->GetFlThick());
				SetIDQSide(i, pDuct->GetDQSide());
				SetIDQType(i, pDuct->GetDuiQi());
				if (pDuct->IsVertical())
				{
					SetIVDAngle(i, pDuct->GetVDAngle());
				}
				OPENOBJ_END();
				break;
			}
		}
	}

	nLen = lstDuct.Length();
	nCount2 = aryTypes.logicalLength();
	if (nLen != nCount2) // 6、再次判断链表数量是否正确
	{
		return;
	}

	for (i=0; i<nLen; i++) // 7、生成新接口
	{
		AcDbObjectId &id = *lstDuct[i];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuct, pDuct);
		if (pDuct == NULL)
		{
			continue;
		}

		TPipeInterface iFace;
		iFace.m_sysType = st;
		iFace.m_faceType = TPipeInterface::kNodeLocation;
		iFace.m_idPipe = id;
		
		double dEle(0);
		TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
		XPoint ptNear = ::GetNearPt(ptAt, pDuct->GetStartPoint(), pDuct->GetEndPoint());
		iFace.m_ptLocation = ptNear;                             // 连接位置
		iFace.m_vtLocation = pDuct->GetDirection(ptNear, nSide); // 向量
		if (nSide == TPipeSys::kEndPt) // 终点
		{
			dEle = pDuct->GetElevationAt(1);
			iFace.m_flowDir = TPipeSys::kInlet; // 进口
		}
		else // 起点
		{
			dEle = pDuct->GetElevationAt(0);
			iFace.m_flowDir = TPipeSys::kOutlet; // 出口
		}
		AddInterface(iFace);
		
		TDuctIFaceMakeup iFaceMakeUp;
		iFaceMakeUp.m_nType = aryTypes[i];        // 接管类型
		iFaceMakeUp.m_dWidth = pDuct->GetWidth(); // 管线的几何属性
		iFaceMakeUp.m_dHeight = pDuct->GetHeight();
		iFaceMakeUp.m_nDrawType = (Adesk::UInt8)pDuct->GetSysDrawMod();
		iFaceMakeUp.m_nSection = pDuct->GetSectionType();
		iFaceMakeUp.m_dFlDist = pDuct->GetFlChuTou();
		iFaceMakeUp.m_dFlThick = pDuct->GetFlThick();
		iFaceMakeUp.m_dEle = dEle;
		iFaceMakeUp.m_nDQSide = pDuct->GetDQSide();
		iFaceMakeUp.m_nDQType = pDuct->GetDuiQi();
		if (pDuct->IsVertical())
		{
			iFaceMakeUp.m_dVDAngle = pDuct->GetVDAngle();
		}
		AddDuctIFace(iFaceMakeUp);
		OPENOBJ_END();
	}
}

// 节点是否遮挡管线
BOOL TDbDuctNode::IsHidePipe() const
{
	BOOL bRet1 = GetInterfaceNum()<2, // 一般堵头不遮挡
		bRet2 = (m_nType==kTaoDong) && (m_nDrawMod==13), // 掏洞样式13不遮挡
		bRet3 = (m_nSysDrawMod==1) || (m_nSysDrawMod==4), // 单线、系统图不遮挡
		// 焊接连接、单线法兰不遮挡
		bRet4 = (m_nLinkType==kSingleFlange) || (m_nLinkType==kSingleLine);
	return !(bRet1 || bRet2 || bRet3 || bRet4);
}



//////////////////////////////Renew TDbPipeNode////////////////////////////////
// 获取节点连接的立管在接口链表中的索引号
AcDbIntArray TDbDuctNode::GetVerPipeIndex() const
{
	AcDbIntArray indexArray;
	int nLen = GetInterfaceNum();
	for (int i=0; i<nLen; i++)
	{
		const XVector3D vt = GetIDirection(i);
		if (fabs(vt.x)<1.0E-6 && fabs(vt.y)<1.0E-6)
		{
			indexArray.append(i);
		}
	}
	return indexArray;
}



/////////////////////////////Override TDbEntity////////////////////////////////
void TDbDuctNode::CopyPropertiesFrom(AcDbEntity* pSrc, unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbPipeNode::CopyPropertiesFrom(pSrc, gMatchFlag);
	TDbDuctNode *pNode = TDbDuctNode::cast(pSrc);
	if (pNode != NULL)
	{
		m_nType = pNode->m_nType;
		m_ptLocation = pNode->m_ptLocation;
		m_nMain = pNode->m_nMain;
		m_nSysDrawMod = pNode->m_nSysDrawMod;
		m_nDrawMod = pNode->m_nDrawMod;
		m_dDrawParam = pNode->m_dDrawParam;
		m_dDrawParam2 = pNode->m_dDrawParam2;
		m_nLinkType = pNode->m_nLinkType;
		m_bShowDLYP = pNode->m_bShowDLYP;
		m_nDLYPType = pNode->m_nDLYPType;
		m_nDLYPNum = pNode->m_nDLYPNum;
		m_bMuffler = pNode->m_bMuffler;
		m_nMufflerMod = pNode->m_nMufflerMod;
		m_bValue = pNode->m_bValue;
		m_nXMWNum = pNode->m_nXMWNum;
	}
}

Acad::ErrorStatus TDbDuctNode::subGetClassID(CLSID* pClsid) const
{
	return Acad::eOk;
}

// 取动态属性显示数据
void TDbDuctNode::GetTips(DList<TObjInfoUnit> &info) const
{
	CString csType = _T("堵头");
	CStringArray csDrawMods;
	if (m_nType==kElbow || m_nType==kKouElbow)
	{
		csType = (m_nType==kKouElbow)?_T("变高弯头"):_T("弯头");
		csDrawMods.Add(_T("内外弧线"));
		csDrawMods.Add(_T("内斜线"));
		csDrawMods.Add(_T("内弧线"));
		csDrawMods.Add(_T("内外直角线"));
		csDrawMods.Add(_T("虾米弯"));
	}
	else if (m_nType == kYiZiElbow)
	{
		csType = _T("乙字弯");
		csDrawMods.Add(_T("双弧"));
		csDrawMods.Add(_T("斜接"));
		csDrawMods.Add(_T("角接"));
	}
	else if (m_nType==kTapered || m_nType==kTianYuanDiFang)
	{
		csType = (m_nType==kTianYuanDiFang)?_T("天圆地方"):_T("变径");
		csDrawMods.Add(_T("宽度决定"));
		csDrawMods.Add(_T("角度决定"));
		csDrawMods.Add(_T("用户输入"));
	}
	else if (m_nType==k3Corner || m_nType==kTaoDong)
	{
		csType = (m_nType==kTaoDong)?_T("三通"):_T("插管三通");
		csDrawMods.Add(_T("普通三通"));
		csDrawMods.Add(_T("直角三通"));
		csDrawMods.Add(_T("圆角三通"));
		csDrawMods.Add(_T("承插三通"));
		csDrawMods.Add(_T("Y型三通"));
		csDrawMods.Add(_T("T型三通"));
		csDrawMods.Add(_T("平行三通"));
		csDrawMods.Add(_T("圆管三通"));
		csDrawMods.Add(_T("圆管三通"));
		csDrawMods.Add(_T("斜插三通"));
		csDrawMods.Add(_T("斜插三通"));
		csDrawMods.Add(_T("叉形三通"));
		csDrawMods.Add(_T("圆管三通"));
	}
	else if (m_nType == k4Corner)
	{
		csType = _T("四通");
		csDrawMods.Add(_T("圆角四通"));
		csDrawMods.Add(_T("直角四通"));
		csDrawMods.Add(_T("承插四通"));
		csDrawMods.Add(_T("交叉四通"));
		csDrawMods.Add(_T("普通四通"));
		csDrawMods.Add(_T("直角四通"));
		csDrawMods.Add(_T("圆管四通"));
		csDrawMods.Add(_T("圆管四通"));
	}
	else if (m_nType == kFlange)
	{
		csType = _T("法兰");
	}
	else if (m_nType == kOther)
	{
		csType = _T("未知连接件");
	}
	else if (m_nType == kSoft)
	{
		csType = _T("软接口");
	}
	
	CStringArray csFls;
	csFls.Add(_T("单线法兰"));
	csFls.Add(_T("双线法兰"));
	csFls.Add(_T("三线法兰"));
	csFls.Add(_T("双竖线"));
	csFls.Add(_T("焊接"));
	
	info.Append(new TObjInfoUnit(_T("连接件类型"), csType));
	info.Append(new TObjInfoUnit(_T("连接件位置"), Point3d2Str(m_ptLocation)));
	info.Append(new TObjInfoUnit(_T("连接方式"), csFls[m_nLinkType]));
	info.Append(new TObjInfoUnit(_T("接口数量"), Dist2Str(GetInterfaceNum())));
	if (m_nType==kOther || m_nType==kStem || m_nType==kSoft || m_nType==kTaoDong
		|| m_nType==kFlange)
	{
		return; // 没有其他内容需要显示
	}

	if (m_nType==kTianYuanDiFang || m_nType==kTapered)
	{
		info.Append(new TObjInfoUnit(_T("长度计算法"), csDrawMods[m_nDrawMod]));
		if (m_nDrawMod == 1)
		{
			info.Append(new TObjInfoUnit(_T("角度"), XString(_T("%.1f度"),
				Rad2Degree(m_dDrawParam))));
		}
		else if (m_nDrawMod == 2)
		{
			info.Append(new TObjInfoUnit(_T("固定长度"), Dist2Str(m_dDrawParam2)));
		}
		return;
	}

	info.Append(new TObjInfoUnit(_T("绘制样式"), csDrawMods[m_nDrawMod]));
	if (m_nType==kYiZiElbow)
	{
		info.Append(new TObjInfoUnit(_T("角度"), XString(_T("%.1f度"),
			Rad2Degree(m_dDrawParam))));
		if (m_nDrawMod == 1) // 斜接
		{
			info.Append(new TObjInfoUnit(_T("曲率半径"), Dist2Str(m_dDrawParam2)));
		}
		return;
	}

	info.Append(new TObjInfoUnit(_T("曲率半径"), Dist2Str(m_dDrawParam)));
	if (m_nType == kElbow)
	{
		CString csMuffler = m_bMuffler?_T("是"):_T("否");
		info.Append(new TObjInfoUnit(_T("消声弯头"), csMuffler));
		if (m_bMuffler)
		{
			CStringArray csMufflers;
			csMufflers.Add(_T("样式一"));
			csMufflers.Add(_T("样式二"));
			csMufflers.Add(_T("样式三"));
			info.Append(new TObjInfoUnit(_T("消声弯头样式"),
				csMufflers[m_nMufflerMod]));
		}
		
		CString csShowDLYP = m_bShowDLYP?_T("是"):_T("否");
		info.Append(new TObjInfoUnit(_T("显示导流片"), csShowDLYP));
		if (m_bShowDLYP)
		{
			info.Append(new TObjInfoUnit(_T("导流片类型"), _T("单层")));
			info.Append(new TObjInfoUnit(_T("导流片数量"), Dist2Str(m_nDLYPNum)));
		}
		return;
	}
	
	if ((m_nType==k3Corner) && (m_nDrawMod==9 || m_nDrawMod==10	|| m_nDrawMod==11))
	{
		info.Append(new TObjInfoUnit(_T("角度"), XString(_T("%.0f度"),
			Rad2Degree(m_dDrawParam2))));
	}
	if ((m_nType==k4Corner) && (m_nDrawMod==7))
	{
		info.Append(new TObjInfoUnit(_T("角度"), XString(_T("%.0f度"),
			Rad2Degree(m_dDrawParam2))));
	}
}

Acad::ErrorStatus TDbDuctNode::GetGripText(int idx, CString &cs) const
{
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	if (IsVisible() && (idx == 0))
	{
		cs = _T("移动风管节点");
	}
	return Acad::eOk;
}



////////////////////////////////存储数据////////////////////////////////////////////
Acad::ErrorStatus TDbDuctNode::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipeNode::dwgInFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}
	
	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if (nVer > g_nVersion) // Version is too new
	{
		return Acad::eMakeMeProxy;
	}

	Adesk::UInt8 nTmpNum;
	pFiler->readItem(&nTmpNum);
	m_nType = (TDbDuctNode::DuctNodeType)nTmpNum;
	pFiler->readItem((AcGePoint3d*)&m_ptLocation);
	pFiler->readItem(&m_nMain);
	pFiler->readItem(&m_nSysDrawMod);
	pFiler->readItem(&m_nAlign);
	pFiler->readItem(&m_nDrawMod);
	pFiler->readItem(&m_dDrawParam);
	pFiler->readItem(&m_dDrawParam2);
	pFiler->readItem(&nTmpNum);
	m_nLinkType = (TDbDuctNode::FlangeLinkType)nTmpNum;
	pFiler->readItem(&m_dFlangeDis);
	pFiler->readItem(&m_dFlangeThick);
	//pFiler->readItem(&m_bMuffler);
	FilerRead(pFiler, m_bMuffler);
	pFiler->readItem(&m_nMufflerMod);
	//pFiler->readItem(&m_bShowDLYP);
	FilerRead(pFiler, m_bShowDLYP);
	pFiler->readItem(&m_nDLYPNum);

	m_lstDuctIFace.Reset();
    Adesk::UInt16 nNum = 0;
	pFiler->readItem(&nNum);
	for (Adesk::UInt16 i=0; i<nNum; i++)
	{
		TDuctIFaceMakeup *pDuctIFace = new TDuctIFaceMakeup;
		m_lstDuctIFace.Append(pDuctIFace);
		es = pDuctIFace->DwgInFields(pFiler);
		if (es != Acad::eOk)
			return es;
	}

    pFiler->readItem(&m_idDoteLayer);
    pFiler->readItem(&m_idFlangeLayer);

	if (nVer > 1) // 7.6
	{
		pFiler->readItem(&m_nDLYPType);
		pFiler->readItem(&m_nXMWNum);
		//pFiler->readItem(&m_bValue);
		FilerRead(pFiler, m_bValue);
		pFiler->readItem(&m_nSpare);
		pFiler->readItem(&m_dSpare);
		ReadString(pFiler, m_szSpare);
	}
	else // 7.5
	{
		m_nDLYPType = 0;
		m_nXMWNum = 1;
		m_bValue = FALSE;
		m_nSpare = 0;
		m_dSpare = 0.0;
		m_szSpare = _T("");

		if ((m_nType==k3Corner) && (m_nDrawMod==6))
		{
			m_nDrawMod = 7; // 针对7.5图的读取，做的修改
		}

		for (int j=0; j<nNum; j++)
		{
			SetIFlDist(j, m_dFlangeDis);
			SetIFlThick(j, m_dFlangeThick);
		}
	}
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDuctNode::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbPipeNode::dwgOutFields(pFiler);
	if (es != Acad::eOk)
		return es;
	
	pFiler->writeItem(g_nVersion);
	pFiler->writeItem((Adesk::UInt8)m_nType);
	pFiler->writeItem((const AcGePoint3d &)m_ptLocation);
	pFiler->writeItem(m_nMain);
	pFiler->writeItem(m_nSysDrawMod);
	pFiler->writeItem(m_nAlign);
	pFiler->writeItem(m_nDrawMod);
	pFiler->writeItem(m_dDrawParam);
	pFiler->writeItem(m_dDrawParam2);
	pFiler->writeItem((Adesk::UInt8)m_nLinkType);
	pFiler->writeItem(m_dFlangeDis);
	pFiler->writeItem(m_dFlangeThick);
	//pFiler->writeItem(m_bMuffler);
	FilerWrite(pFiler, m_bMuffler);
	pFiler->writeItem(m_nMufflerMod);
	//pFiler->writeItem(m_bShowDLYP);
	FilerWrite(pFiler, m_bShowDLYP);
	pFiler->writeItem(m_nDLYPNum);

	Adesk::UInt16 nCount = (Adesk::UInt16)m_lstDuctIFace.Length();
	pFiler->writeItem(nCount);
	BOOL bValid = objectId().isValid();
	for (Adesk::UInt16 i=0; i<nCount; i++)
	{
		m_lstDuctIFace[i].DwgOutFields(pFiler, bValid);
	}

	pFiler->writeItem(m_idDoteLayer);
    pFiler->writeItem(m_idFlangeLayer);

	
	if (g_nSaveTArchVer > 6)
	{
		pFiler->writeItem(m_nDLYPType);
		pFiler->writeItem(m_nXMWNum);
		//pFiler->writeItem(m_bValue);
		FilerWrite(pFiler, m_bValue);
		pFiler->writeItem(m_nSpare);
		pFiler->writeItem(m_dSpare);
		pFiler->writeItem((const TCHAR *)m_szSpare);
	}
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDuctNode::dxfInFields(AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipeNode::dxfInFields(pFiler);
	if (es != Acad::eOk)
		return es;
	
	if (!pFiler->atSubclassData(_T("TDbDuctNode")))
		return Acad::eBadDxfSequence;
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDuctNode::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	Acad::ErrorStatus es = TDbPipeNode::dxfOutFields(pFiler);
	assert(es == Acad::eOk);
	
	es = pFiler->writeItem(AcDb::kDxfSubclass, _T("TDbDuctNode"));
	assert(es == Acad::eOk);
	return es;
}

// 如果是节点被复制，强制将全部接口的类型设置为1
Acad::ErrorStatus TDbDuctNode::subDeepClone(AcDbObject *pOwner, AcDbObject *&pClonedObject,
										 AcDbIdMapping &idMap,
										 Adesk::Boolean isPrimary) const
{
    Acad::ErrorStatus es = TDbEntity::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
    if (es != Acad::eOk)
	{
        return es;
	}

	TDbDuctNode* pNewNode = TDbDuctNode::cast(pClonedObject);
	if (pNewNode != NULL)
	{
		int nLen = pNewNode->GetInterfaceNum();
		for (int i=0; i<nLen; i++)
		{
			pNewNode->SetIType(i, 1);
		}
	}
    return Acad::eOk;
}


/////////////////////////////////拾取有关////////////////////////////////////////
Acad::ErrorStatus
TDbDuctNode::subGetOsnapPoints(AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark,
							const AcGePoint3d &ptPick, const AcGePoint3d &lastPoint,
							const AcGeMatrix3d &viewXform,
							AcGePoint3dArray &snapPoints, AcDbIntArray &geomIds) const
{
	assertReadEnabled();
	if (osnapMode==AcDb::kOsModeIns || osnapMode==AcDb::kOsModeNode)
	{
		snapPoints.append(m_ptLocation);
	}
	
	Acad::ErrorStatus es = TDbPipeNode::subGetOsnapPoints(osnapMode, gsSelectionMark,
		ptPick,	lastPoint, viewXform, snapPoints, geomIds);
	return es;
}

Acad::ErrorStatus TDbDuctNode::subGetGripPoints(AcGePoint3dArray &gripPoints,
											 AcDbIntArray &osnapModes,
											 AcDbIntArray &geomIds) const
{
	assertReadEnabled();
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	if (IsVisible())
	{
		GetGSPoints(gripPoints);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::subGetStretchPoints(AcGePoint3dArray &stretchPoints) const
{
	assertReadEnabled();
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	if (IsVisible())
	{
		GetGSPoints(stretchPoints);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::GetGSPoints(AcGePoint3dArray &stretchPoints) const
{
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	stretchPoints.append(m_ptLocation);
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::subMoveGripPointsAt(const AcDbIntArray &indices,
												const AcGeVector3d &offset)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	if (IsVisible())
	{
		es = MoveGSPointsAt(indices, offset);
	}
	
	if (objectId().isValid())
	{
		int nLen = GetInterfaceNum();
		for (int i=0; i<nLen; i++)
		{
			SetIType(i, 1);
		}
	}
	return es;
}

Acad::ErrorStatus TDbDuctNode::subMoveStretchPointsAt(const AcDbIntArray &indices,
												   const AcGeVector3d &offset)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	if (IsVisible())
	{
		es = MoveGSPointsAt(indices, offset);
	}
	return es;
}

Acad::ErrorStatus TDbDuctNode::MoveGSPointsAt(const AcDbIntArray &indices,
											  const AcGeVector3d &offset)
{
	if (m_nType == TDbDuctNode::kStem)
	{
		return Acad::eOk;
	}

	AcGeMatrix3d mat;
	mat.setToTranslation(offset);
	Acad::ErrorStatus es = subTransformBy(mat);
	return es;
}


///////////////////////////////Override AcDbEntity///////////////////////////////
Acad::ErrorStatus TDbDuctNode::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipeNode::subTransformBy(xform);
	m_ptLocation.TransformBy(xform);

    if (!!objectId())
	{
        XString &sCmd = GetCurDocData()->m_sCurCommand;
		if (_tcsicmp(sCmd, _T("MOVE")) == 0)
		{
			int nLen = GetInterfaceNum();
			for (int i=0; i<nLen; i++)
			{
				SetIType(i, 1);
			}
		}
    }
	return es;
}

Acad::ErrorStatus TDbDuctNode::GetExtents(XPoint &ptLow, XPoint &ptUp) const
{
	Acad::ErrorStatus es = TDbPipeNode::GetExtents(ptLow, ptUp);
	if (es == Acad::eOk)
	{
		if (ptLow==XPoint() && ptUp==XPoint())
		{
			ptLow = m_ptLocation;
			ptUp = m_ptLocation;
		}
		else
		{
			ptLow = Min(ptLow, m_ptLocation);
			ptUp = Max(ptUp, m_ptLocation);
		}
	}
	return es;
}




///////////////////////////////////二维绘制/////////////////////////////////////
Acad::ErrorStatus TDbDuctNode::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	int nLen1 = GetInterfaceNum(),
		nLen2 = GetDuctIFaceNum();
	if (nLen1 != nLen2)
	{
		return Acad::eInvalidInput;
	}

	Acad::ErrorStatus es = Acad::eOk;
	if (m_nSysDrawMod == 4) // 系统图
	{
		es = ExplodeOrDrawSys(dc);
		return es;
	}

	BOOL bTYDF = m_nType==kTianYuanDiFang;
	switch(m_nType)
	{
	case kElbow:		  // 弯头
		es = DrawElbow2D(dc);
		break;
	case kKouElbow:       // 扣弯
		es = DrawKElbow2D(dc);
		break;
	case kTapered:        // 变径
	case kTianYuanDiFang: // 天圆地方
		es = DrawTapered2D(dc, bTYDF);
	    break;
	case kYiZiElbow:      // 乙字弯
		es = DrawYZElbow2D(dc);
	    break;
	case k3Corner:        // 三通
		es = Draw3Corner2D(dc);
		break;
	case kTaoDong:        // 掏洞三通
		es = DrawTaoDong2D(dc);
	    break;
	case k4Corner:        // 四通
		es = Draw4Corner2D(dc);
	    break;
	}
	
	if (es == Acad::eOk)
	{
		es = DrawFL2D(dc); // 法兰
	}
	return es;
}


////////////////////////////二维辅助绘制/////////////////////////////
// 绘制节点中心线seg，先切换图层，然后绘制
void TDbDuctNode::DrawMidSegs(XExplodeDraw &dc, const DList<XCurveSegment> &segs) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId(), // 先保存，旧图层ID
		idLineTypeOld = dc.GetLineTypeId();    // 旧线型ID
	AcDbObjectId idLayer = m_idDoteLayer;
	if (idLayer.isValid()) // 再创建，新图层ID
	{
		dc.SetLayer(idLayer);
	}
	dc.SetColorLayer(colorIndex(), idLayer);
	
	AcDbObjectId idLineType;
	OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pRec);
	if (pRec != NULL)
	{
		idLineType = pRec->linetypeObjectId();
		dc.SetLineType(idLineType);
	}
	OPENOBJ_END();

	int nLen = segs.Length();
	for (int i=0; i<nLen; i++)
	{
		dc << segs[i]; // 接着绘制
	}
	dc.SetLayer(idLayerOld); // 最后修改回原图层、线型
	dc.SetColorLayer(colorIndex(), idLayerOld);
	dc.SetLineType(idLineTypeOld);
}

// 绘制节点中需要分粗、细两种画法的seg
void TDbDuctNode::Draw2DSegs(XExplodeDraw &dc, const DList<XCurveSegment> &segs) const
{
	double dDuct1Weight(0);
	OPENOBJ_BEGIN(GetIPipe(0), AcDb::kForRead, TDbDuct, pDuct);
	if (pDuct != NULL)
	{
		dDuct1Weight = pDuct->GetDuctWeight();
	}
	OPENOBJ_END();
	
	int nLen = segs.Length();
	double dWeight = GetPScale() * dDuct1Weight;
	for (int i=0; i<nLen; i++)
	{
		XCurveSegment seg = segs[i];
		if (g_bPipeWeight)
		{
			DrawWeight(dc, dWeight, seg, colorIndex(), linetypeScale());
		}
		else
		{
			dc << seg;
		}
	}
}

// 绘制节点中细线seg
void TDbDuctNode::DrawXiSegs(XExplodeDraw &dc, const DList<XCurveSegment> &segs) const
{
	int nLen = segs.Length();
	for (int i=0; i<nLen; i++)
	{
		dc << segs[i];
	}
}

// 绘制法兰层seg
void TDbDuctNode::DrawFLSegs(XExplodeDraw &dc, const DList<XCurveSegment> &segs) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId(), // 先保存，旧图层ID
		idLineTypeOld = dc.GetLineTypeId(),    // 旧线型ID
		idLayer = m_idFlangeLayer;
	if (idLayer.isValid()) // 再创建，新图层ID
	{
		dc.SetLayer(idLayer);
	}
	dc.SetColorLayer(colorIndex(), idLayer);

	AcDbObjectId idLineType;
	OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pRec);
	if (pRec != NULL)
	{
		idLineType = pRec->linetypeObjectId();
		dc.SetLineType(idLineType);
	}
	OPENOBJ_END();

	int nLen = segs.Length();
	for (int i=0; i<nLen; i++)
	{
		dc << segs[i]; // 接着绘制
	}
	dc.SetLayer(idLayerOld); // 最后修改回原图层、线型
	dc.SetColorLayer(colorIndex(), idLayerOld);
}


////////////////////////二维辅助绘制构造Segs//////////////////////////
void TDbDuctNode::BuildSegs1(XPoint pt1, XPoint pt2, // 两点一线
							 DList<XCurveSegment> &segs) const
{
	XCurveSegment seg;
	seg = XLine(pt1, pt2, LS_FINITE);
	segs.Append(new XCurveSegment(seg));
}

void TDbDuctNode::BuildSegs2(XPoint pt1, XPoint ptInt, XPoint pt2, // 三点两线
							 DList<XCurveSegment> &segs) const
{
	XCurveSegment seg;
	seg = XLine(pt1, ptInt, LS_FINITE);
	segs.Append(new XCurveSegment(seg));
	seg = XLine(ptInt, pt2, LS_FINITE);
	segs.Append(new XCurveSegment(seg));
}

void TDbDuctNode::BuildSegs6(XPoint pt1, XPoint pt2, XPoint pt3, XPoint pt4,
							 DList<XCurveSegment> &segs) const // 四点三线
{
	XCurveSegment seg;
	seg = XLine(pt1, pt2, LS_FINITE);
	segs.Append(new XCurveSegment(seg));
	seg = XLine(pt2, pt3, LS_FINITE);
	segs.Append(new XCurveSegment(seg));
	seg = XLine(pt3, pt4, LS_FINITE);
	segs.Append(new XCurveSegment(seg));
}

void TDbDuctNode::BuildSegs3(const XLine &line, DList<XCurveSegment> &segs) const // 线
{
	XCurveSegment seg;
	seg = line;
	segs.Append(new XCurveSegment(seg));
}

void TDbDuctNode::BuildSegs4(XArc &arc, DList<XCurveSegment> &segs) const // 弧
{
	XCurveSegment seg;
	seg = arc;
	segs.Append(new XCurveSegment(seg));
}

void TDbDuctNode::BuildSegs5(XCircle &circle, DList<XCurveSegment> &segs) const // 圆
{
	XCurveSegment seg;
	seg = circle;
	segs.Append(new XCurveSegment(seg));
}


////////////////////////////公共绘制算法//////////////////////////////
// 类似不带消声的“内斜线”弯头中的内线，特点为两端为50长度短线
// 注：弯头中nSide是0，三/四通中nSide是1
BOOL TDbDuctNode::DrawLine(DList<XCurveSegment> &lstSeg, XLine l1,
						   XLine l2, int nSide) const
{
	XPoint ptInt, ptTmp1, ptTmp2;
	if (l1.Intersection(&l2, ptInt) != 1)
	{
		return FALSE;
	}
	
	XVector3D vt1 = ptInt - l1.EndPoint(),
		vt2 = ptInt - l2.EndPoint();
	vt1.Normalize();
	vt2.Normalize();
	vt1.Scale(50);
	vt2.Scale(50);

	XPoint ptStart1 = (nSide==0)?l1.StartPoint():l1.EndPoint(),
		ptStart2 = (nSide==0)?l2.StartPoint():l2.EndPoint();
	ptTmp1 = ptStart1 + vt1;
	ptTmp2 = ptStart2 + vt2;
	BuildSegs6(ptStart1, ptTmp1, ptTmp2, ptStart2, lstSeg);
	return TRUE;
}

// 注：以较短距离的80%为长度，绘制相切弧
BOOL TDbDuctNode::DrawArc(DList<XCurveSegment> &lstSeg, XPoint ptCorner1,
						  XPoint ptCorner2, XPoint pt1, XPoint pt2, BOOL bIsBig) const
{
	XPoint ptTmp1, ptTmp2, ptInt, ptCen;
	double dAngle1 = ads_angle(XPoint(), XVector3D(ptCorner1-pt1)),
		dAngle2 = ads_angle(XPoint(), XVector3D(ptCorner2-pt2));
	ads_polar(pt1, dAngle1+PI/2, 800, ptTmp1);
	ads_polar(pt2, dAngle2+PI/2, 800, ptTmp2);
	
	XLine lineTmp1(ptTmp1, pt1, LS_INFINITE),
		lineTmp2(ptTmp2, pt2, LS_INFINITE);
	if (!lineTmp1.Intersection(&lineTmp2, ptInt))
	{
		return FALSE;
	}
	
	XPoint ptNear = ::GetNearPt(ptInt, pt1, pt2);
	double dScale = bIsBig?0.8:0.2,
		dDist = ptInt.Distance(ptNear) * dScale; // 注：取较短距离的0.8
	::AT_cal_fillet(pt1, ptInt, pt2, dDist, ptTmp1, ptCen, ptTmp2, FALSE);
	
	BOOL bSwitch(TRUE);
	XArc arc = ::GetRightArc(ptTmp1, ptCen, ptTmp2, bSwitch); // 选择优弧
	BuildSegs4(arc, lstSeg);
	BuildSegs1(pt1, ptTmp1, lstSeg);
	BuildSegs1(ptTmp2, pt2, lstSeg);
	return TRUE;
}

// 注：两端以50长度短线与弧线连接，类似弯头
BOOL TDbDuctNode::DrawArc2(DList<XCurveSegment> &lstSeg, int nIFace1, int nIFace2,
						   XPoint pt1, XPoint pt2, BOOL bMidLine, double dNum) const
{
	XVector3D vt1 = GetIDirection(nIFace1),
		vt2 = GetIDirection(nIFace2);
	vt1.Normalize();
	vt2.Normalize();
	vt1.Scale(-dNum);
	vt2.Scale(-dNum);

	XPoint pt3 = pt1 + vt1,
		pt4 = pt2 + vt2;
	BuildSegs1(pt1, pt3, lstSeg); // 50长度短线
	BuildSegs1(pt2, pt4, lstSeg);

	XPoint ptInt;
	XLine line1(pt1, pt3, LS_INFINITE),
		line2(pt2, pt4, LS_INFINITE);
	if (!line1.Intersection(&line2, ptInt)) // 交点
	{
		return FALSE;
	}

	XPoint ptCen, ptTmp1, ptTmp2, ptMid;
	double dDist = ptInt.Distance(pt4); // 获取圆心
	::AT_cal_fillet(pt3, ptInt, pt4, dDist, ptTmp1,	ptCen, ptTmp2, FALSE);

	XArc arc;
	BOOL bSwitch(TRUE);

	if (bMidLine) // 中心线
	{
		arc = ::GetRightArc(ptTmp1, ptCen, ptTmp2, bSwitch);
		if (bSwitch) // 获取优弧
		{
			arc.SetAngleByPoints(pt3, pt4);
		}
		else
		{
			arc.SetAngleByPoints(pt4, pt3);
		}
	}
	else // 不是中心线
	{
		arc = ::GetRightArc(pt3, ptCen, pt4, bSwitch);
		arc.MidPoint(ptMid);
		double dWidth1 = GetIWidth(nIFace1),
			dWidth2 = GetIWidth(nIFace2);
		if (fabs(dWidth1 - dWidth2) > 0.001) // 管线宽度不一样
		{
			arc.MidPoint(ptMid);
			if (bSwitch)
			{
				arc = XArc(pt3, ptMid, pt4);
			}
			else
			{
				arc = XArc(pt4, ptMid, pt3);
			}
		}
	}
	BuildSegs4(arc, lstSeg);
	return TRUE;
}

// 注：三通样式9、10、11，四通样式7，斜接乙字弯中的弯头弧线画法
XPoint TDbDuctNode::GetArcPts(XPoint ptStart, double dWide, double dDirection,
							  XPoint ptRef, DList<XCurveSegment> &segs,
							  double &dNewAng) const
{
	XPoint ptS50, ptEnd, ptE50, ptCen, ptMid;
	ads_polar(ptStart, dDirection, -50, ptS50); // 获取第二点
	BuildSegs1(ptStart, ptS50, segs);
	
	ads_polar(ptStart, dDirection, -15*dWide, ptE50);
	XCurveSegment seg(ptStart, ptE50, 0, LS_FINITE);
	seg.ProjectToMe(ptRef, ptEnd);
	XVector3D vtCen = ptRef - ptEnd; // 将参考点向线上做投影，确定圆心方向
	vtCen.Normalize();
	
	BOOL bYZElbow = GetNodeType()==kYiZiElbow;
	double dAngle = (m_nDrawMod!=11)?(PI/2-m_dDrawParam2):PI/3, // 弯头角度
		dRadius = dWide*m_dDrawParam + 50; // 旧的半径，考虑了曲率
	dAngle = bYZElbow?m_dDrawParam:dAngle;
	dRadius = bYZElbow?dWide:dRadius;
	vtCen.Scale(dRadius);
	ptCen = ptStart + vtCen; // 旧的圆心位置
	
	double dSAng = ads_angle(XPoint(), XVector3D(ptStart-ptCen)); // 起点角度
	dSAng = CT_std_angle(dSAng);
	double dEAng = CT_std_angle(dSAng+dAngle),
		dEAng2 = CT_std_angle(dSAng-dAngle);
	ads_polar(ptCen, dEAng, dRadius, ptEnd);
	ads_polar(ptCen, dEAng2, dRadius, ptE50);
	ptEnd = ::GetNearPt(ptRef, ptEnd, ptE50);            // 终点坐标
	dEAng = ads_angle(XPoint(), XVector3D(ptEnd-ptCen)); // 终点角度
	dEAng = CT_std_angle(dEAng);
	
	Midpoint(ptStart, ptEnd, ptMid);
	vtCen = ptMid - ptCen; // 两个圆心之间的方向
	vtCen.Normalize();
    double dLen = 50/(sin(dAngle*0.5)); // 两个圆心之间的距离
	vtCen.Scale(dLen);
	ptCen = ptCen + vtCen; // 新的圆心
	dRadius = ptCen.Distance(ptS50);
	ads_polar(ptCen, dEAng, dRadius, ptE50);
	BuildSegs1(ptE50, ptEnd, segs);
	dNewAng = ads_angle(XPoint(), XVector3D(ptEnd-ptE50));
	
	BOOL bSwitch(FALSE);
	XArc arc = ::GetRightArc(ptS50, ptCen, ptE50, bSwitch); // 选择优弧
	BuildSegs4(arc, segs);
	return ptEnd;
}

BOOL TDbDuctNode::DrawFlange(DList<XCurveSegment> &segs, XPoint pt, // 注：2D绘制法兰
							 double dAngle, double dFlDia, double dFlThick) const
{
	pt.z = 0;
	XPoint pt1, pt2; // 上下两点
	ads_polar(pt, dAngle+PI/2, dFlDia/2, pt1);
	ads_polar(pt, dAngle-PI/2, dFlDia/2, pt2);
	if (m_nLinkType==kSingleLine || m_nLinkType==kSingleFlange)
	{
		BuildSegs1(pt1, pt2, segs); // 单线法兰、焊接
		return TRUE;
	}

	if (m_nLinkType == kTrebleFlange) // 三线法兰
	{
		BuildSegs1(pt1, pt2, segs);
	}
	
	XPoint ptTmp, pt3, pt4;
	ads_polar(pt, dAngle, dFlThick/2, ptTmp);
	ads_polar(ptTmp, dAngle+PI/2, dFlDia/2, pt1); // 四个角点
	ads_polar(ptTmp, dAngle-PI/2, dFlDia/2, pt2);
	ads_polar(pt1, dAngle, -dFlThick, pt3);
	ads_polar(pt2, dAngle, -dFlThick, pt4);
	if (m_nLinkType==kBothFlange || m_nLinkType==kTrebleFlange)
	{
		BuildSegs2(pt1, pt2, pt4, segs); // 双线法兰、三线法兰
		BuildSegs2(pt4, pt3, pt1, segs);
	}
	else if (m_nLinkType == kBothLine) // 双竖线
	{
		BuildSegs1(pt1, pt2, segs);
		BuildSegs1(pt3, pt4, segs);
	}
	return TRUE;
}


//////////////////////////////辅助绘制////////////////////////////////
XPoint TDbDuctNode::GetZeroPt() const // 将m_ptLocation的Z坐标置为0
{
	XPoint ptLoc;
	Spoint(ptLoc, m_ptLocation.x, m_ptLocation.y, 0);
	return ptLoc;
}

// 获取法兰遮挡后与管线连接的点位置
// bSys：是否是系统图；bIs3D：是否为3D；b50Len：是否为50长度；bZero：是否自动将Z坐标归0
void TDbDuctNode::GetPtsIFace(XPointList &pts, BOOL bSys, BOOL bIs3D,
							  BOOL b50Len, BOOL bZero, double dNum) const
{
	pts.Reset();
	int nLen = GetInterfaceNum();
	for (int i=0; i<nLen; i++)
	{
		XPoint pt = GetILocation(i); // 连接点
		AcGeVector3d vec = GetIDirection(i).AsAcGeVector3d();
		vec.normalize(); // 连接方向
		
		double dThick(0.0);
		if (!bSys)
		{
			dThick = GetIFlThick(i)*0.5; // 法兰厚度
			if (!IsHidePipe()) // 法兰是否遮挡节点
			{
				dThick = bIs3D?2.0:0.0;
			}
		}
		
		if (m_nType==k3Corner && fabs(vec.x)<1.0E-6 && fabs(vec.y)<1.0E-6)
		{
			pt = pt + XVector3D(vec*dThick); // 三通中的立管接口
		}
		else // 其他情况
		{
			dThick = (b50Len?dNum:0.0) + dThick;
			pt = pt - XVector3D(vec*dThick);
		}
		
		if (bZero) // 将Z坐标归0
		{
			pt.z = 0;
		}
		pts.Append(new XPoint(pt));
	}
}

// 获取各支管编号，注：逆时针排序
AcDbIntArray TDbDuctNode::GetBranchNums(int nMain) const
{
	DList<AcDbObjectId> ids;
	GetAllLinkDucts(ids);
	AcDbIntArray types = GetAllTypes();
	return ::GetCornerBranchNums(objectId(), m_ptLocation, ids, types, nMain);
}

// 获取m_ptLocation向各管线中线的投影，用于处理偏心
void TDbDuctNode::GetTrueMidPts(XPointList &pts) const
{
	DList<AcDbObjectId> ids;
	GetAllLinkDucts(ids);
	AcDbIntArray types = GetAllTypes();
	pts.Reset();
	::GetDuctTrueMidPts(objectId(), m_ptLocation, ids, types, pts);
	
	int nLen = pts.Length();
	for (int i=0; i<nLen; i++)
	{
		pts[i]->z = 0;
	}
}



/////////////////////////////系统图绘制///////////////////////////////
XCurveSegment GetArcSeg1(XPoint pt1, XPoint ptCen, XPoint pt2,
						 double dWidth1, double dWidth2);
XCurveSegment GetArcSeg2(XPoint pt1, XPoint ptInt, XPoint pt2,
						 double dRadius, double dWidth1, double dWidth2);
XCurveSegment GetArcSeg3(XPoint ptStart, XPoint ptCen, XPoint &ptEnd, double dRadius,
						 double dAngle, const AcGeVector3d &vecNormal,
						 const AcGeVector3d &vecRef);
Acad::ErrorStatus TDbDuctNode::ExplodeOrDrawSys(XExplodeDraw &dc) const
{
	if (m_nSysDrawMod != 4) // 必须是系统图
	{
		return Acad::eInvalidInput;
	}
	
	Acad::ErrorStatus es = Acad::eOk;
	switch(m_nType)
	{
	case kElbow:		  // 弯头
	case kKouElbow:       // 扣弯
		es = DrawSysElbow(dc);
		break;
	case kTapered:        // 变径
		es = DrawSysTapered(dc);
		break;
	case kTianYuanDiFang: // 天圆地方
		es = DrawSysTYDF(dc);
		break;
	case kYiZiElbow:      // 乙字弯
		es = DrawSysYZElbow(dc);
		break;
	case k3Corner:        // 三通
		es = DrawSys3T(dc);
		break;
	case kTaoDong:        // 掏洞三通
		es = DrawSysTD(dc);
		break;
	case k4Corner:        // 四通
		es = DrawSys4T(dc);
		break;
	}
	return es; // 直接返回，不绘制法兰
}

Acad::ErrorStatus TDbDuctNode::DrawSysElbow(XExplodeDraw &dc) const // 弯头
{
	XPointList pts;
	GetPtsIFace(pts, TRUE, FALSE, FALSE, TRUE);
	if (pts.Length() != 2) // 1、获取与管线相连点，考虑了法兰遮挡
	{
		return Acad::eInvalidInput;
	}
	
	DList<XCurveSegment> segs; // 2、绘制
	XPoint ptLoc = GetZeroPt(),
		ptCen, ptTmp1, ptTmp2;
	double dDist = ptLoc.Distance(*pts[1]) * 0.25; // 只取实际曲率的1/4，其他补直线
	::AT_cal_fillet(*pts[0], ptLoc, *pts[1], dDist, ptTmp1, ptCen, ptTmp2, FALSE);
	
	BOOL bSwitch(TRUE);
	XArc arc = ::GetRightArc(ptTmp1, ptCen, ptTmp2, bSwitch); // 选择优弧
	BuildSegs4(arc, segs);
	BuildSegs1(*pts[0], ptTmp1, segs);
	BuildSegs1(ptTmp2, *pts[1], segs);
	Draw2DSegs(dc, segs);
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::DrawSysTapered(XExplodeDraw &dc) const // 变径
{
	XPointList pts;
	GetPtsIFace(pts, TRUE, FALSE, FALSE, TRUE);
	if (pts.Length() != 2) // 1、获取与管线相连点，考虑了法兰遮挡
	{
		return Acad::eInvalidInput;
	}
	
	double dDist = pts[0]->Distance(*pts[1]),
		dDraw = (dDist > 300-1.0E-5)?(dDist/6.0):dDist;
	dDraw = (dDist > 600-1.0E-5)?(dDist/3.0):dDraw; // 2、确定绘制长度

	double dWidth1 = GetIWidth(0), // 管线尺寸
		dWidth2 = GetIWidth(1),
		dHigh1 = GetIHeight(0),
		dHigh2 = GetIHeight(1);
	int nBig(0);
	double dTmp1 = fabs(dWidth1 - dWidth2),
		dTmp2 = fabs(dHigh1 - dHigh2);
	if (dTmp1 > dTmp2 - 1.0E-5) // 宽度变化
	{
		nBig = dWidth1>dWidth2-1.0E-5?0:1; // 2、获取较大管径编号
	}
	else // 高度变化
	{
		nBig = dHigh1>dHigh2-1.0E-5?0:1;
	}

	int nSmall = 1 - nBig;
	DList<XCurveSegment> lstSeg;
	double dAng = GetIAngle(nBig);
	XPoint ptTmp1, ptTmp2, pt1, pt2, pt3, pt4;
	ads_polar(*pts[nBig], dAng, -dDraw, ptTmp1);
	ads_polar(*pts[nSmall], dAng, dDraw, ptTmp2);
	BuildSegs1(*pts[nBig], ptTmp1, lstSeg); // 3、补充绘制
	BuildSegs1(*pts[nSmall], ptTmp2, lstSeg);

	ads_polar(ptTmp1, dAng-PI/4*3, 150, pt1);
	ads_polar(ptTmp1, dAng+PI/4, 150, pt2);
	ads_polar(ptTmp2, dAng-PI/4*3, 100, pt3);
	ads_polar(ptTmp2, dAng+PI/4, 100, pt4);
	BuildSegs1(pt1, pt3, lstSeg); // 4、绘制上下线
	BuildSegs1(pt2, pt4, lstSeg);

	ads_polar(ptTmp1, dAng-PI/4*3, 180, pt1);
	ads_polar(ptTmp1, dAng+PI/4, 180, pt2);
	ads_polar(ptTmp2, dAng-PI/4*3, 130, pt3);
	ads_polar(ptTmp2, dAng+PI/4, 130, pt4);
	BuildSegs1(pt1, pt2, lstSeg); // 5、绘制类法兰线
	BuildSegs1(pt3, pt4, lstSeg);
	Draw2DSegs(dc, lstSeg);
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::DrawSysTYDF(XExplodeDraw &dc) const // 天圆地方
{
	XPointList pts;
	GetPtsIFace(pts, TRUE, FALSE, FALSE, TRUE);
	if (pts.Length() != 2) // 1、获取与管线相连点，考虑了法兰遮挡
	{
		return Acad::eInvalidInput;
	}

	double dDist = pts[0]->Distance(*pts[1]),
		dDraw = (dDist > 300-1.0E-5)?(dDist/6.0):dDist;
	dDraw = (dDist>600-1.0E-5)?(dDist/3.0):dDraw; // 2、确定绘制长度
	
	int nRect = (GetISection(0)==0)?0:1, // 3、获取方管编号
		nCircle = 1- nRect;
	
	double dAng = GetIAngle(nRect);
	DList<XCurveSegment> lstSeg;
	XPoint ptTmp1, ptTmp2, pt1, pt2, pt3, pt4;
	ads_polar(*pts[nRect], dAng, -dDraw, ptTmp1);
	ads_polar(*pts[nCircle], dAng, dDraw, ptTmp2);
	BuildSegs1(*pts[nRect], ptTmp1, lstSeg); // 4、补充绘制
	BuildSegs1(*pts[nCircle], ptTmp2, lstSeg);

	ads_polar(ptTmp1, dAng-PI/4*3, 150, pt1);
	ads_polar(ptTmp1, dAng+PI/4, 150, pt2);
	ads_polar(ptTmp2, dAng-PI/4*3, 110, pt3);
	ads_polar(ptTmp2, dAng+PI/4, 110, pt4);
	BuildSegs2(pt1, ptTmp2, pt2, lstSeg); // 5、绘制上下线
	BuildSegs1(pt3, pt4, lstSeg);
	
	ads_polar(ptTmp1, dAng-PI/4*3, 180, pt1);
	ads_polar(ptTmp1, dAng+PI/4, 180, pt2);
	BuildSegs1(pt1, pt2, lstSeg); // 6、绘制类法兰线
	Draw2DSegs(dc, lstSeg);
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::DrawSysYZElbow(XExplodeDraw &dc) const // 乙字弯
{
	XPointList pts;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, FALSE);
	if (pts.Length() != 2) // 1、获取与管线相连点，注：考虑法兰遮挡节点
	{
		return Acad::eInvalidInput;
	}
	
	XPoint pt1 = *pts[0], // 2、获取绘制信息
		pt2 = *pts[1];
	DList<XCurveSegment> segs;
	BOOL bSameEle = fabs(pt1.z-pt2.z)<1.0E-5; // 3、判断连接管线是否标高相同
	if (!bSameEle || (m_nDrawMod == 2))       // 角接或不同标高
	{
		BuildSegs1(pt1, pt2, segs);
		Draw2DSegs(dc, segs);
		return Acad::eOk;
	}
	
	XVector3D vt1 = GetIDirection(0),
		vt2 = GetIDirection(1), // 4、获取中线圆心方向
		vtMid1(vt1), vtMid2(vt2);
	XCurveSegment seg1(pt1, XPoint(pt1+vt1), 0, LS_INFINITE),
		seg2(pt2, XPoint(pt2+vt2), 0, LS_INFINITE);
	XPoint ptPro1, ptPro2;
	seg2.ProjectToMe(pt1, ptPro1);
	seg1.ProjectToMe(pt2, ptPro2);
	vtMid1 = ptPro1 - pt1;
	vtMid2 = ptPro2 - pt2;
	
	double dDist1 = GetIWidth(0), // 管线宽度
		dDist2 = GetIWidth(1),
		dDistM = (dDist1+dDist2)/2.0;
	double dLen = pt1.Distance(pt2),                 // 斜边长度
		dRadius1 = (dLen*0.25)/sin(m_dDrawParam2/2), // 中线圆半径
		dRadius2 = dRadius1;
	if (m_nDrawMod == 1) // 斜接
	{
		dRadius1 = dDist1 * m_dDrawParam2;
		dRadius2 = dDist2 * m_dDrawParam2;
	}
	
	vtMid1.Normalize();
	vtMid2.Normalize();
	vtMid1.Scale(dRadius1);
	vtMid2.Scale(dRadius2);
	XPoint ptCen1 = pt1 + vtMid1, // 5、获取圆心点
		ptCen2 = pt2 + vtMid2;
	pt1.z = pt2.z = ptCen1.z = ptCen2.z = 0;
	XPoint ptLoc = GetZeroPt();
	
	XCurveSegment seg;
	XPoint ptTmp1, ptTmp2, ptTmp3, ptTmp4;
	DList<XCurveSegment> midSegs; // 7、绘制中线
	if (0 == m_nDrawMod) // 双弧
	{
		seg = ::GetArcSeg1(pt1, ptCen1, ptLoc, dDist1, dDistM);
		midSegs.Append(new XCurveSegment(seg));
		seg = ::GetArcSeg1(pt2, ptCen2, ptLoc, dDist2, dDistM);
		midSegs.Append(new XCurveSegment(seg));
	}
	else if (1 == m_nDrawMod) // 斜接
	{
		seg = ::GetArcSeg3(pt1, ptCen1, ptTmp1, dRadius1, m_dDrawParam,
			AcGeVector3d::kZAxis, vt1.AsAcGeVector3d());
		midSegs.Append(new XCurveSegment(seg));
		seg = ::GetArcSeg3(pt2, ptCen2, ptTmp2, dRadius2, m_dDrawParam,
			AcGeVector3d::kZAxis, vt2.AsAcGeVector3d());
		midSegs.Append(new XCurveSegment(seg));
		BuildSegs1(ptTmp1, ptTmp2, midSegs);
	}	
	Draw2DSegs(dc, midSegs);
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::DrawSys3T(XExplodeDraw &dc) const // 三通
{
	XPointList pt0s;
	GetPtsIFace(pt0s, FALSE, FALSE, FALSE, TRUE);
	if (pt0s.Length() != 3)
	{
		return Acad::eInvalidInput; // 1、获取法兰遮挡后与管线相连点
	}
	
	XPoint ptLoc = GetZeroPt();
	DList<XCurveSegment> lstSeg;
	for (int i=0; i<3; i++)
	{
		BuildSegs1(GetZeroPt(), *pt0s[i], lstSeg);
	}
	Draw2DSegs(dc, lstSeg); // 2、绘制
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::DrawSysTD(XExplodeDraw &dc) const // 掏洞
{
	XPointList pt0s;
	GetPtsIFace(pt0s, FALSE, FALSE, FALSE, TRUE);
	if (pt0s.Length() != 2)
	{
		return Acad::eInvalidInput; // 1、获取法兰遮挡后与管线相连点
	}
	
	int nBranch = 1 - m_nMain;
	DList<XCurveSegment> lstSeg;
	BuildSegs1(GetZeroPt(), *pt0s[nBranch], lstSeg);
	Draw2DSegs(dc, lstSeg); // 2、绘制
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuctNode::DrawSys4T(XExplodeDraw &dc) const // 四通
{
	XPointList pt0s;
	GetPtsIFace(pt0s, FALSE, FALSE, FALSE, TRUE);
	if (pt0s.Length() != 4)
	{
		return Acad::eInvalidInput; // 1、获取法兰遮挡后与管线相连点
	}
	
	XPoint ptLoc = GetZeroPt();
	DList<XCurveSegment> lstSeg;
	for (int i=0; i<4; i++)
	{
		BuildSegs1(ptLoc, *pt0s[i], lstSeg);
	}
	Draw2DSegs(dc, lstSeg); // 2、绘制
	return Acad::eOk;
}



////////////////////////////////法兰//////////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawFL2D(XExplodeDraw &dc) const
{
	BOOL bNoDraw1 = (m_nSysDrawMod==1) || (m_nSysDrawMod==4), // 单线、系统图
		bNoDraw2 = (m_nDrawMod==13) && (m_nType==kTaoDong);   // 样式13的掏洞
	if (bNoDraw1 || bNoDraw2) // 1、首先判断出不绘制的条件
	{
		return Acad::eOk;
	}

	XCurveSegment seg;
	DList<XCurveSegment> segs;
	XPoint ptLoc = GetZeroPt(); // 2、将所有的点投影到XOY平面上
	int nLen = GetInterfaceNum();
	for (int i=0; i<nLen; i++)  // 3、一个个接口的绘制法兰
	{
		const AcDbObjectId &id = GetIPipe(i); // ①获取连接的风管属性
		double dAng = GetIAngle(i),    // 法向
			dDuctDia = GetIWidth(i),   // 管径
			dDuctHigh = GetIHeight(i); // 高度
		double dFlDia(dDuctDia);       // 法兰直径

		XVector3D vt = GetIDirection(i); // ②判断是水平管还是立管
		BOOL bVertical = (fabs(vt.x)<1.0E-6) && (fabs(vt.y)<1.0E-6);

		XPoint pt1, pt2, pt3, pt4, ptTmp; // ③根据连接的不同类型，绘制不同样式的法兰
		if (bVertical) // 立管
		{
			if (m_nType==kStem || m_nType==k3Corner) // 堵头、三通
			{
				continue; // 不绘制
			}

			if (m_nType==kTapered || m_nType==kTianYuanDiFang) // 变径、天圆地方
			{
				dFlDia += 2*GetIFlDist(i);
				if (GetISection(i) == 1) // 圆
				{
					XCircle cirIn(ptLoc, dFlDia/2);
					BuildSegs5(cirIn, segs);
					continue;
				}
				
				XPoly2D poly(1);
				::GetSquare(ptLoc, GetIVDAngle(i), dFlDia, dDuctHigh+2*GetIFlDist(i),
					&poly, NULL);
				for (int j=0; j<poly.TotalSegments(); j++)
				{
					poly.Nth(j, seg);
					segs.Append(new XCurveSegment(seg));
				}
				continue;
			}

			if (m_nType == kKouElbow) // 扣弯
			{
				int nOther = i==0?1:0; // 水平管标号
				BOOL bHasLowElbow(FALSE);
				double dHDAngle = GetIVDAngle(nOther),
					dVDAngle = GetIAngle(i);
				OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuct, pDuct);
				if (pDuct != NULL)
				{
					bHasLowElbow = pDuct->IsUpPipesOk();
					dVDAngle = pDuct->GetVDAngle(); // 立管绘制角度
					XVector3D openDirVt;
					pDuct->GetVerOpenDir(openDirVt);
					dHDAngle = ads_angle(XPoint(), openDirVt); // 开口方向
				}
				OPENOBJ_END();

				XPoint ptOnVDuct = GetILocation(i),
					ptOnHDuct = GetILocation(nOther);
				if (ptOnVDuct.z < (ptOnHDuct.z-1.0E-6)) // 下弯头
				{
					ptOnHDuct.z = ptOnVDuct.z = 0;
					double dUpWidth = GetIWidth(nOther);
					if (fabs(dDuctHigh) < 1.0E-6) // 圆
					{
						XArc tmpArc;
						XPointList ptLst;
						GetYKEFlPts(dHDAngle, dDuctDia, ptOnHDuct, dUpWidth,
							tmpArc, GetIFlDist(i), ptLst);
						if (ptLst.Length() != 5)
						{
							break;
						}
						XArc arc(*ptLst[0], *ptLst[2], *ptLst[4]);
						BuildSegs4(arc, segs);
						continue;
					}
					
					XPointList ptLst;
					GetFKEFlPts(dHDAngle, dVDAngle,	ptOnHDuct, dUpWidth,
						i, ptLst); // 立管法兰边框点
					for (int j=0; j<ptLst.Length()-1; j++)
					{
						BuildSegs1(*ptLst[j], *ptLst[j+1], segs);
					}
				}
				else if (ptOnVDuct.z>(ptOnHDuct.z+1.0E-6) && !bHasLowElbow) // 上弯头
				{
					ptOnHDuct.z = ptOnVDuct.z = 0;
					if (fabs(dDuctHigh) < 1.0E-6) // 圆
					{
						XCircle circle(ptLoc, dDuctDia/2+GetIFlDist(i));
						BuildSegs5(circle, segs);
						continue;
					}

					double dAngle = CT_std_angle(dVDAngle - dHDAngle),
						dTmpDia(dDuctDia), dTmpHigh(dDuctHigh);
					if (fabs(dAngle)<0.0001 || fabs(dAngle-PI)<0.0001)
					{
						dTmpDia = dDuctHigh;
						dTmpHigh = dDuctDia;
					}
					
					ads_polar(ptLoc, dHDAngle, dTmpHigh/2+GetIFlDist(i), ptTmp);
					ads_polar(ptTmp, dHDAngle+PI/2, dTmpDia/2+GetIFlDist(i), pt1);
					ads_polar(ptTmp, dHDAngle-PI/2, dTmpDia/2+GetIFlDist(i), pt2);
					ads_polar(pt2, dHDAngle, -dTmpHigh-2*GetIFlDist(i), pt3);
					ads_polar(pt1, dHDAngle, -dTmpHigh-2*GetIFlDist(i), pt4);
					BuildSegs2(pt1, pt2, pt3, segs);
					BuildSegs2(pt3, pt4, pt1, segs);
				}
			}
			continue;
		}

		if ((m_nType==kTaoDong) && (i==m_nMain)) // 插管三通，主风管上无法兰
		{
			continue;
		}

		if (m_nType == kStem) // 堵头
		{
			ads_polar(ptLoc, dAng+PI/2, dFlDia/2, pt1);
			ads_polar(ptLoc, dAng-PI/2, dFlDia/2, pt2);
			BuildSegs1(pt1, pt2, segs); // 水平管两端按焊接绘制
			continue;
		}

		dFlDia += 2*GetIFlDist(i);
		XPoint ptFlange = GetILocation(i);
		DrawFlange(segs, ptFlange, dAng, dFlDia, GetIFlThick(i));
	}

	DrawFLSegs(dc, segs);
	return Acad::eOk;
}



////////////////////////////弯头////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawElbow2D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 2) // 1、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}

	double dRightDist = 50 + (m_dDrawParam-0.5)*GetIWidth(1);
	if (dRightDist < -1.0E-5)
	{
		return Acad::eInvalidInput;
	}
	else if (dRightDist < 50-1.0E-5)
	{
		dRightDist *= 0.2;
	}
	else
	{
		dRightDist = 50;
	}

	XPointList pts, pt50s;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, TRUE);  // 法兰遮挡后的连接点
	GetPtsIFace(pt50s, FALSE, FALSE, TRUE, TRUE, dRightDist); // 增加50以后的点
	if ((pts.Length()!=2) || (pt50s.Length()!=2)) // 2、获取与管线相连点
	{
		return Acad::eInvalidInput;
	}

	if (m_nSysDrawMod != 3) // 3、除双线图外，绘制中心线
	{
		XPoint ptLoc = GetZeroPt(); // 将绘制标高变为0
		DList<XCurveSegment> midSegs;
		if ((m_nDrawMod == 1) || (m_nDrawMod == 3)) // 内斜线、内外直线
		{
			BuildSegs2(*pts[0], ptLoc, *pts[1], midSegs); // 绘制直线
		}
		else if ((m_nDrawMod == 0) || (m_nDrawMod == 2)) // 双弧线、内外弧线
		{
			if (m_bMuffler && (m_nMufflerMod==2) && (m_nDrawMod==2) &&
				(m_nSysDrawMod==2))
			{
				; // 内外弧中的第三种消声弯头，不绘制中心线
			}
			else // 其他情况下
			{
 				DrawArc2(midSegs, 0, 1, *pts[0], *pts[1], TRUE, dRightDist); // 绘制弧线
			}
		}
		else // 虾米弯
		{
			XPointList ptsMid;
			DrawXMSegs(midSegs, *pts[0], *pts[1], ptsMid, dRightDist);
		}

		if (m_nSysDrawMod == 1)
		{
			DrawXiSegs(dc, midSegs); // (2)单线图，细线绘制
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs); // (3)三线图，切换中心线图层、线型绘制
	}

	int k(0);
	DList<XLine> lLst; // 4、储存临时用到的线，共8根
	for (k=0; k<2; k++)
	{
		double dTmp1 = GetIWidth(k)/2.0,
			dTmp2 = dTmp1 + GetIFlDist(k)*0.8;
		if ((m_nMufflerMod == 2) && (m_nDrawMod == 2)) // 中广电消声样式
		{
			dTmp2 = dTmp1 + GetIFlDist(k);
		}
		XLine lTmp = XLine(*pts[k], *pt50s[k], LS_INFINITE).Offset(dTmp2);
		lLst.Append(new XLine(lTmp));
		lTmp = XLine(*pts[k], *pt50s[k], LS_INFINITE).Offset(dTmp1);
		lLst.Append(new XLine(lTmp));
		lTmp = XLine(*pts[k], *pt50s[k], LS_INFINITE).Offset(-dTmp1);
		lLst.Append(new XLine(lTmp));
		lTmp = XLine(*pts[k], *pt50s[k], LS_INFINITE).Offset(-dTmp2);
		lLst.Append(new XLine(lTmp));
	}
	if (lLst.Length() != 8)
	{
		return Acad::eInvalidInput;
	}

	XPoint ptInt1, ptInt2, ptInt3, ptInt4; // 5、获取内外弧线的顶点、半径
	if (!lLst[1]->Intersection(lLst[6], ptInt1) ||
		!lLst[2]->Intersection(lLst[5], ptInt2))
	{
		return Acad::eInvalidInput;
	}

	double dDist1 = ptInt1.Distance(lLst[6]->EndPoint()), // 内外弧线半径
		dDist2 = ptInt2.Distance(lLst[5]->EndPoint());
	double dWide1 = GetIWidth(0), // 管线宽度
		dWide2 = GetIWidth(1);

	// 6、根据样式，绘制弯头上下线，首先不考虑消声，都按实线处理
	DList<XCurveSegment> lstSeg; // 实线
	if (m_nDrawMod == 0) // 内外曲线样式
	{
 		DrawArc2(lstSeg, 0, 1, lLst[1]->GetStartPoint(), lLst[6]->GetStartPoint(), FALSE, dRightDist);
 		DrawArc2(lstSeg, 0, 1, lLst[2]->GetStartPoint(), lLst[5]->GetStartPoint(), FALSE, dRightDist);
	}
	else if (m_nDrawMod == 3) // 内外直线样式
	{
		BuildSegs2(lLst[1]->GetStartPoint(), ptInt1, lLst[6]->GetStartPoint(), lstSeg);
		BuildSegs2(lLst[2]->GetStartPoint(), ptInt2, lLst[5]->GetStartPoint(), lstSeg);
	}
	else if (m_nDrawMod == 4) // 虾米弯样式
	{
		XPointList pts1, pts2; // 节线点
		DrawXMSegs(lstSeg, lLst[1]->GetStartPoint(), lLst[6]->GetStartPoint(), pts1, dRightDist);
		DrawXMSegs(lstSeg, lLst[2]->GetStartPoint(), lLst[5]->GetStartPoint(), pts2, dRightDist);
		if ((pts1.Length()!=m_nXMWNum) || (pts2.Length()!=m_nXMWNum))
		{
			return Acad::eInvalidInput;
		}

		for (k=0; k<m_nXMWNum; k++)
		{
			BuildSegs1(*pts1[k], *pts2[k], lstSeg);
		}
	}
	else if (m_nDrawMod == 1) // 内斜线样式
	{
		if (dDist1 > (dDist2 + 1.0E-6)) // 注：保证外侧是直线，1、6为外侧
		{
			BuildSegs2(lLst[1]->GetStartPoint(), ptInt1, lLst[6]->GetStartPoint(), lstSeg);
			BuildSegs6(lLst[2]->GetStartPoint(), lLst[2]->GetEndPoint(), lLst[5]->GetEndPoint(),
				lLst[5]->GetStartPoint(), lstSeg);
		}
		else // 2、5为外侧
		{
			BuildSegs2(lLst[2]->GetStartPoint(), ptInt2, lLst[5]->GetStartPoint(), lstSeg);
			BuildSegs6(lLst[1]->GetStartPoint(), lLst[1]->GetEndPoint(), lLst[6]->GetEndPoint(),
				lLst[6]->GetStartPoint(), lstSeg);
		}
	}
	else // 内弧线样式
	{
		if (dDist1 > (dDist2 + 1.0E-6)) // 注：保证外侧是直线，1、6为外侧
		{
			BuildSegs2(lLst[1]->GetStartPoint(), ptInt1, lLst[6]->GetStartPoint(), lstSeg);
			DrawArc2(lstSeg, 0, 1, lLst[2]->GetStartPoint(), lLst[5]->GetStartPoint(), FALSE, dRightDist);
		}
		else // 2、5为外侧
		{
			BuildSegs2(lLst[2]->GetStartPoint(), ptInt2, lLst[5]->GetStartPoint(), lstSeg);
			DrawArc2(lstSeg, 0, 1, lLst[1]->GetStartPoint(), lLst[6]->GetStartPoint(), FALSE, dRightDist);
		}
	}

	XCurveSegment seg;
	if (m_bMuffler && (m_nDrawMod!=4)) // 7、绘制消声弯头，虾米弯没有消声
	{
		DList<XCurveSegment> lstDashSeg; // 虚线
		for (k=0; k<lstSeg.Length(); k++)
		{
			seg = *lstSeg[k--];
			lstDashSeg.Append(new XCurveSegment(seg)); // (1)将实现转为虚线
			lstSeg.Remove();
		}

		if (!lLst[0]->Intersection(lLst[7], ptInt3) ||
			!lLst[3]->Intersection(lLst[4], ptInt4)) // 消声内外弧线顶点
		{
			return Acad::eInvalidInput;
		}

		XPoint ptTmp1, ptTmp2, ptTmp3, ptTmp4, ptTmp5;
		double dDist3 = ptInt3.Distance(lLst[7]->EndPoint()), // 消声内外弧线半径
			dDist4 = ptInt4.Distance(lLst[4]->EndPoint());
		// (2)绘制新实线部分
		if (m_nDrawMod == 0) // 内外曲线样式
		{
			DrawArc2(lstSeg, 0, 1, lLst[0]->GetStartPoint(), lLst[7]->GetStartPoint(), FALSE, dRightDist);
			DrawArc2(lstSeg, 0, 1, lLst[3]->GetStartPoint(), lLst[4]->GetStartPoint(), FALSE, dRightDist);
		}
		else if (m_nDrawMod == 3) // 内外直线样式
		{
			BuildSegs2(lLst[0]->GetStartPoint(), ptInt3, lLst[7]->GetStartPoint(), lstSeg);
			BuildSegs2(lLst[3]->GetStartPoint(), ptInt4, lLst[4]->GetStartPoint(), lstSeg);
		}
		else if (m_nDrawMod == 1) // 内斜线样式，消声样式1
		{
			if (dDist3 > (dDist4 + 1.0E-6)) // 注：保证外侧是直线，0、7为外侧
			{
				BuildSegs2(lLst[0]->GetStartPoint(), ptInt3, lLst[7]->GetStartPoint(), lstSeg);
				BuildSegs1(lLst[3]->GetStartPoint(), lLst[4]->GetStartPoint(), lstSeg);
			}
			else // 3、4为外侧
			{
				BuildSegs2(lLst[3]->GetStartPoint(), ptInt4, lLst[4]->GetStartPoint(), lstSeg);
				BuildSegs1(lLst[0]->GetStartPoint(), lLst[7]->GetStartPoint(), lstSeg);
			}
			
			if (m_nMufflerMod == 0) // 消声样式1
			{
				lstDashSeg.Reset(); // 清空全部虚线
				if (dDist3 > (dDist4 + 1.0E-6)) // 0、7为外侧
				{
					BuildSegs2(lLst[1]->GetStartPoint(), ptInt1, lLst[6]->GetStartPoint(), lstDashSeg);
					BuildSegs1(lLst[2]->GetStartPoint(), lLst[5]->GetStartPoint(), lstDashSeg);
				}
				else // 3、4为外侧
				{
					BuildSegs2(lLst[2]->GetStartPoint(), ptInt2, lLst[5]->GetStartPoint(), lstDashSeg);
					BuildSegs1(lLst[1]->GetStartPoint(), lLst[6]->GetStartPoint(), lstDashSeg);
				}
			}
		}
		else // 内弧线样式
		{
			if (m_nMufflerMod != 2) // 原有消声样式
			{
				if (dDist3 > (dDist4 + 1.0E-6)) // 注：保证外侧是直线，0、7为外侧
				{
					BuildSegs2(lLst[0]->GetStartPoint(), ptInt3, lLst[7]->GetStartPoint(), lstSeg);
					DrawArc2(lstSeg, 0, 1, lLst[3]->GetStartPoint(), lLst[4]->GetStartPoint(), FALSE, dRightDist);
				}
				else // 3、4为外侧
				{
					BuildSegs2(lLst[3]->GetStartPoint(), ptInt4, lLst[4]->GetStartPoint(), lstSeg);
					DrawArc2(lstSeg, 0, 1, lLst[0]->GetStartPoint(), lLst[7]->GetStartPoint(), FALSE, dRightDist);
				}
			}
			else  // 中广电消声样式，m_nMufflerMod==2
			{
				lstDashSeg.Reset(); // 无虚线
				BuildSegs3(*lLst[1], lstSeg);
				BuildSegs3(*lLst[2], lstSeg);
				BuildSegs3(*lLst[5], lstSeg);
				BuildSegs3(*lLst[6], lstSeg);
				BuildSegs1(lLst[0]->EndPoint(), lLst[3]->EndPoint(), lstSeg);
				BuildSegs1(lLst[4]->EndPoint(), lLst[7]->EndPoint(), lstSeg);

				if (dDist3 > (dDist4 + 1.0E-6)) // 注：保证外侧是直线，0、7为外侧
				{
					BuildSegs2(lLst[0]->EndPoint(), ptInt3, lLst[7]->EndPoint(), lstSeg);
					seg = ::GetArcSeg2(lLst[3]->EndPoint(), ptInt4, lLst[4]->EndPoint(),
						dDist4, dWide1, dWide2);
					lstSeg.Append(new XCurveSegment(seg)); // 先画弧线
					
					XArc arc = seg.GetArc();
					ptTmp5 = arc.GetCenterPt(); // 获取圆心
					XLine lTmp1 = XLine(ptInt3, ptTmp5, LS_FINITE).Offset(50),
						lTmp2 = XLine(ptInt3, ptTmp5, LS_FINITE).Offset(-50);

					XLine lineTmp1(lLst[0]->GetStartPoint(), ptInt3);
					lTmp2.Intersection(&lineTmp1, ptTmp1);
					lTmp2.Intersection(&arc, ptTmp3, ptTmp5);
					XLine lineTmp2(lLst[7]->GetStartPoint(), ptInt3);
					lTmp1.Intersection(&lineTmp2, ptTmp2);
					lTmp2.Intersection(&arc, ptTmp4, ptTmp5);
				}
				else // 3、4为外侧
				{
					BuildSegs2(lLst[3]->EndPoint(), ptInt4, lLst[4]->EndPoint(), lstSeg);
					seg = ::GetArcSeg2(lLst[0]->EndPoint(), ptInt3, lLst[7]->EndPoint(),
						dDist3, dWide1, dWide2);
					lstSeg.Append(new XCurveSegment(seg));
					
					XArc arc = seg.GetArc();
					ptTmp5 = arc.GetCenterPt(); // 获取圆心
					XLine lTmp1 = XLine(ptInt4, ptTmp5, LS_FINITE).Offset(50),
						lTmp2 = XLine(ptInt4, ptTmp5, LS_FINITE).Offset(-50);


					XLine lineTmp1(lLst[3]->GetStartPoint(), ptInt4);
					lTmp1.Intersection(&lineTmp1, ptTmp1);
					lTmp1.Intersection(&arc, ptTmp3, ptTmp5);
					XLine lineTmp2(lLst[4]->GetStartPoint(), ptInt4);
					lTmp2.Intersection(&lineTmp2, ptTmp2);
					lTmp2.Intersection(&arc, ptTmp4, ptTmp5);
				}
				BuildSegs1(ptTmp1, ptTmp3, lstSeg);
				BuildSegs1(ptTmp2, ptTmp4, lstSeg);
			}
		}

		if ((m_nMufflerMod==1) && (m_nDrawMod!=0)) // (3)另一种绘制样式
		{
			lstDashSeg.Reset();
			double dAng1 = GetIAngle(0), // 管线法向
				dAng2 = GetIAngle(1);
			if (dDist3 > (dDist4 + 1.0E-6)) // 注：保证外侧是直线，0、7为外侧
			{
				ads_polar(lLst[1]->GetStartPoint(), dAng1-PI/2, dWide1/3.0, ptTmp1);
				ads_polar(ptTmp1, dAng1, -dDist2*1.3, ptTmp2);
				ads_polar(lLst[7]->GetStartPoint(), dAng2, -dDist3/3.0, ptTmp3);
				ads_polar(ptTmp3, dAng2+PI/2, dWide2*0.7, ptTmp4);
			}
			else
			{
				ads_polar(lLst[2]->GetStartPoint(), dAng1+PI/2, dWide1/3.0, ptTmp1);
				ads_polar(ptTmp1, dAng1, -dDist1*1.3, ptTmp2);
				ads_polar(lLst[4]->GetStartPoint(), dAng2, -dDist4/3.0, ptTmp3);
				ads_polar(ptTmp3, dAng2-PI/2, dWide2*0.7, ptTmp4);
			}
			BuildSegs1(ptTmp2, ptTmp1, lstSeg);
			BuildSegs1(ptTmp4, ptTmp3, lstSeg);
		}
		
		AcDbObjectId idLineTypeOld = dc.GetLineTypeId(),
			idDashType = InitLineType(_T("DASH"), database());
		if (idDashType.isValid())
		{
			dc.SetLineType(idDashType);
		}
		
		for (int i=0; i<lstDashSeg.Length(); i++)
		{
			dc << *lstDashSeg[i]; // 绘制虚线
		}
		dc.SetLineType(idLineTypeOld);
	}
	
	if (m_bShowDLYP) // 8、显示导流叶片
	{
		DList<XCurveSegment> lstDLYPSeg;
		if (!DrawDLYPSegs(lstDLYPSeg, *pt50s[0], *pt50s[1]))
		{
			return Acad::eInvalidInput;
		}
		DrawXiSegs(dc, lstDLYPSeg);
	}

	Draw2DSegs(dc, lstSeg); // 9、绘制实线
    return Acad::eOk;
}

// 获取虾米弯点的位置及弧段
BOOL TDbDuctNode::DrawXMSegs(DList<XCurveSegment> &lstSeg, XPoint ptStart,
							 XPoint ptEnd, XPointList &pts, double dNum) const
{
	XPoint pt1, pt2, ptCen, ptTmp1, ptTmp2;
	double dAng1 = GetIAngle(0), // 管线法向
		dAng2 = GetIAngle(1);
	double dAngle = CT_acute_angle(dAng1 - dAng2); // 两法兰线的夹角
	ads_polar(ptStart, dAng1, -dNum, pt1);
	ads_polar(ptEnd, dAng2, -dNum, pt2);
	BuildSegs1(ptStart, pt1, lstSeg); // 50长度的短线
	BuildSegs1(ptEnd, pt2, lstSeg);

	ads_polar(pt1, dAng1-PI/2, 500, ptTmp1);
	ads_polar(pt2, dAng2-PI/2, 500, ptTmp2);

	XLine lineTmp(ptTmp2, pt2,LS_INFINITE);
	if (!XLine(ptTmp1, pt1, LS_INFINITE).Intersection(&lineTmp, ptCen)) // 获取弧心
	{
		return FALSE;
	}

	XCurveSegment seg;
	double dWidth1 = GetIWidth(0), // 管径
		dWidth2 = GetIWidth(1);
	seg = ::GetArcSeg1(pt1, ptCen, pt2, dWidth1, dWidth2);
	if (!seg.Is(CURVE_ARC))
	{
		return FALSE;
	}
	
	XArc arc = seg.GetArc();
	ptCen = arc.GetCenterPt();          // 获取圆心
	double dRadius = arc.GetRadius(); // 半径
	dAng1 = arc.GetStarAngle();      // 起点角度
	arc.SetAngleByPoints(pt1, pt2);     // 起、止点

	dAngle = (PI - dAngle)/m_nXMWNum;
	for (int i = 0; i <= m_nXMWNum; i++)
	{
		if ((i == 0) || (i == m_nXMWNum))
		{
			dAng1 += dAngle/2.0; // 端节角度
			if (i == 0)
			{
				ptTmp1 = pt1;
			}
		}
		else
		{
			dAng1 += dAngle; // 中节角度
		}

		ads_polar(ptCen, dAng1, dRadius, ptTmp2);
		if (i != m_nXMWNum)
		{
			pts.Append(new XPoint(ptTmp2));
		}
		BuildSegs1(ptTmp1, ptTmp2, lstSeg);
		ptTmp1 = ptTmp2;
	}
	return TRUE;
}

// 获取导流叶片的位置点
void TDbDuctNode::GetDLYPPts(XPoint ptStart, XPoint ptEnd, XPointList &pts) const
{
	double dD = 5.0, // 公差
		dDist = ptStart.Distance(ptEnd); // 等差数列和
	int nCount = m_nDLYPNum + 1; // 项数
	double dA1 = dDist/nCount - (nCount-1)*dD*0.5; // 首项

	pts.Reset();
	XPoint ptTmp(ptEnd);
	XVector3D vt = ptStart - ptEnd;
	for (int i=1; i<nCount; i++)
	{
		double dAn = dA1 + (i-1)*dD; // 通项公式
		vt.Normalize();
		vt.Scale(dAn);
		ptTmp = ptTmp + vt;
		pts.Append(new XPoint(ptTmp));
	}
}

// 导流叶片的绘制算法，注：8.0以前仅绘制“单层”导流叶片
BOOL TDbDuctNode::DrawDLYPSegs(DList<XCurveSegment> &lstSeg, XPoint ptStart,
							   XPoint ptEnd) const
{
	double dAng1 = GetIAngle(0), // 管线法向
		dAng2 = GetIAngle(1),
		dAngle = CT_acute_angle(dAng1 - dAng2); // 两法兰线的夹角
	double dWidth1 = GetIWidth(0), // 管线宽度
		dWidth2 = GetIWidth(1);
	XPoint pt1, pt2, pt3, pt4, ptInt;
	ads_polar(ptStart, dAng1-PI/2, dWidth1/2, pt1); // 上下线的起止点
	ads_polar(ptStart, dAng1+PI/2, dWidth1/2, pt2);
	ads_polar(ptEnd, dAng2-PI/2, dWidth2/2, pt3);
	ads_polar(ptEnd, dAng2+PI/2, dWidth2/2, pt4);

	XPointList ptLst1, ptLst2; // 导流叶片完整时的起、止点
	double dDist1 = pt1.Distance(pt4),
		dDist2 = pt2.Distance(pt3);
	if (dDist1 > dDist2 - 1.0E-5) // 注：保证点的方向正确，由外向内
	{
		GetDLYPPts(pt1, pt2, ptLst1); // 获取导流叶片的位置点
		GetDLYPPts(pt4, pt3, ptLst2);
	}
	else
	{
		GetDLYPPts(pt2, pt1, ptLst1);
		GetDLYPPts(pt3, pt4, ptLst2);
	}
	if (ptLst1.Length()!=m_nDLYPNum || ptLst2.Length()!=m_nDLYPNum)
	{
		return FALSE;
	}
	
	XCurveSegment seg;
	double dLen(0);     // 导流叶片长度，取决于最内侧的导流叶片长度
	BOOL bBreak(FALSE); // 是否绘制正确
	for (int i=0; i<m_nDLYPNum; i++)
	{
		ads_polar(*ptLst1[i], dAng1, -dWidth1, pt1);
		ads_polar(*ptLst2[i], dAng2, -dWidth2, pt2);
		XLine lineTmp(*ptLst2[i],	pt2, LS_INFINITE);
		if (!XLine(*ptLst1[i], pt1, LS_INFINITE).Intersection(&lineTmp, ptInt))
		{
			bBreak = TRUE;
			break;
		}

		double dDist = ptInt.Distance(*ptLst2[i]);
		seg = ::GetArcSeg2(*ptLst1[i], ptInt, *ptLst2[i], dDist, dWidth1, dWidth2);
		if (!seg.Is(CURVE_ARC))
		{
			bBreak = TRUE;
			break;
		}
		
		XArc arc = seg.GetArc();
		double dRadius = arc.GetRadius(); // 半径
		if (i == 0) // 角度
		{
			dAngle = (PI - dAngle)*1.0/3.0; // Ang1
		}
		else
		{
			dAngle = dLen/dRadius; // AngN
		}
		
		double dMidAngle = arc.MidAngle(), // 弧段中点角度
			dTmpAng1 = dMidAngle + dAngle*0.5,
			dTmpAng2 = dMidAngle - dAngle*0.5;
		XPoint ptCen = arc.GetCenterPt(); // 圆心
		ads_polar(ptCen, dTmpAng1, dRadius, pt3);
		ads_polar(ptCen, dTmpAng2, dRadius, pt4);
		arc.SetAngleByPoints(pt4, pt3);
		if (i == 0)
		{
			dLen = arc.GetLength();
		}
		BuildSegs4(arc, lstSeg);
	}
	return !bBreak;
}


////////////////////////////扣弯////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawKElbow2D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 2) // 1、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}

	AcDbIntArray indexArray = GetVerPipeIndex();
	int nLen = indexArray.logicalLength(); // 2、获取连接的立管数量
	if (nLen != 1)
	{
		return Acad::eInvalidInput;
	}

	int nVNum = indexArray[0], // 3、获取立管、水平管索引号
		nHNum = 1-nVNum;
	XPoint ptStart = GetILocation(nHNum), // 绘制点；注：指定非立管连接点为绘制起点
		ptEnd = GetILocation(nVNum);
	double dAngle1 = GetIAngle(nHNum); // 非立管法向
	ads_polar(ptStart, dAngle1, -GetIFlThick(nHNum)/2, ptStart); // 仅改变绘制的长度
		
	XPoint ptNodeLoc = GetZeroPt(),
		ptVDTmp(ptNodeLoc); // 扣弯中线的端点
	XCurveSegment seg;
	DList<XCurveSegment> lstSeg; // 4、绘制上、下弯头线
	if (ptStart.z > ptEnd.z) // 下弯头
	{
		ptStart.z = ptEnd.z = 0;
		XPoint ptVDuct1, ptVDuct2;
		double dVDWidth = GetIWidth(nVNum), // 立管宽度
			dVDHigh = GetIHeight(nVNum);
		if (fabs(dVDHigh) < 1.0E-6) // 圆
		{
			ads_polar(ptNodeLoc, dAngle1, -dVDWidth/2, ptVDTmp);
			ads_polar(ptNodeLoc, dAngle1+PI/2, dVDWidth/2, ptVDuct1);
			ads_polar(ptNodeLoc, dAngle1-PI/2, dVDWidth/2, ptVDuct2);
			XArc arc(ptVDuct1, ptVDTmp, ptVDuct2);
			BuildSegs4(arc, lstSeg);
		}
		else // 矩形
		{
			double dAngle2 = GetIVDAngle(nVNum),
				dAng = CT_acute_angle(dAngle1 - dAngle2);
			if (fabs(dAng-PI/2) < 1.0E-6)
			{
				TchPrivate::Exchange(dVDWidth, dVDHigh);
			}
			ads_polar(ptNodeLoc, dAngle1, -dVDWidth/2, ptVDTmp);
			ads_polar(ptVDTmp, dAngle1+PI/2, dVDHigh/2, ptVDuct1);
			ads_polar(ptVDTmp, dAngle1-PI/2, dVDHigh/2, ptVDuct2);
			BuildSegs1(ptVDuct1, ptVDuct2, lstSeg);
		}
		
		XPoint pt1, pt2;
		ads_polar(ptStart, dAngle1+PI/2, GetIWidth(nHNum)/2, pt1);
		ads_polar(ptStart, dAngle1-PI/2, GetIWidth(nHNum)/2, pt2);
		BuildSegs1(pt1, ptVDuct1, lstSeg);
		BuildSegs1(pt2, ptVDuct2, lstSeg);
	}
	else // 上弯头
	{
		ptStart.z = ptEnd.z = 0;
		BOOL bHasLowElbow(FALSE);
		OPENOBJ_BEGIN(GetIPipe(nVNum), AcDb::kForRead, TDbDuct, pDuct);
		if (pDuct != NULL)
		{
			bHasLowElbow = pDuct->IsUpPipesOk();
		}
		OPENOBJ_END();
		
		BOOL bIsOk(TRUE);
		if (!bHasLowElbow) // 无下弯头
		{
			bIsOk = DrawUpKElbow2D1(lstSeg, nVNum, nHNum, ptStart, ptVDTmp);
		}
		else // 有下弯头
		{
			bIsOk = DrawUpKElbow2D2(lstSeg, nVNum, ptStart, ptVDTmp);
		}
		if (!bIsOk)
		{
			return Acad::eInvalidInput;
		}
	}

	if (m_nSysDrawMod != 3) // 5、除双线外，绘制中心线
	{
		DList<XCurveSegment> midSegs;
		BuildSegs1(ptStart, ptVDTmp, midSegs);
		if ((m_nSysDrawMod==1) || (m_nSysDrawMod==4))
		{
			DrawXiSegs(dc, midSegs);
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs);
	}
	Draw2DSegs(dc, lstSeg);
	return Acad::eOk;
}

// 无下弯的上弯头
BOOL TDbDuctNode::DrawUpKElbow2D1(DList<XCurveSegment> &segs, int nVNum,
									int nHNum, XPoint ptStart,
									XPoint &ptVDTmp, BOOL bIs3T) const
{
	XPoint ptLoc = GetZeroPt(),
		ptSpare(ptStart);
	ptSpare.z = 0;
	
	double dVDAngle = GetIVDAngle(nVNum), // 立管角度
		dLowAngle = GetIAngle(nHNum);     // 非立管法向
	double dWidth = GetIWidth(nHNum),     // 非立管宽度
		dVDWidth = GetIWidth(nVNum),      // 立管宽度
		dVDHigh = GetIHeight(nVNum);      // 立管高度
	XPoint pt1, pt2, pt3, pt4, ptInt1, ptInt2, ptTmp;
	ads_polar(ptSpare, dLowAngle+PI/2, dWidth/2, pt1);
	ads_polar(ptSpare, dLowAngle-PI/2, dWidth/2, pt2);

	XLine tmpLine(ptLoc, ptSpare, LS_INFINITE);
	XLine lowL1 = tmpLine.Offset(-dWidth/2), // 非立管管线边线
		lowL2 = tmpLine.Offset(dWidth/2);

	double dFlangeDis = bIs3T?0:GetIFlDist(nVNum);
	if (fabs(dVDHigh) < 1.0E-6) // 圆
	{
		ads_polar(pt1, dLowAngle, -dWidth, pt3);
		ads_polar(pt2, dLowAngle, -dWidth, pt4);

		XCircle circle(ptLoc, dVDWidth/2+dFlangeDis);
		if (lowL1.Intersection(&circle, ptInt1, ptTmp))
			ptInt1 = ::GetNearPt(pt1, ptInt1, ptTmp); // 取较近的交点
		else
			ptInt1 = ::GetTangentPt2(circle, pt1, pt3); // 取切点
		
		ptTmp = XPoint();
		if (lowL2.Intersection(&circle, ptInt2, ptTmp))
			ptInt2 = ::GetNearPt(pt2, ptInt2, ptTmp);
		else
			ptInt2 = ::GetTangentPt2(circle, pt2, pt4);
		if (ptInt1==XPoint() || ptInt2==XPoint())
			return FALSE;

		ptTmp = XPoint();
		XLine lineTmp(ptLoc, ptSpare);
		if (circle.Intersection(&lineTmp, ptVDTmp, ptTmp))
			ptVDTmp = ::GetNearPt(ptLoc, ptVDTmp, ptTmp);
		else
			return FALSE;

		if (bIs3T) // 注：防止立管都被删除时，绘制错误
		{
			BuildSegs5(circle, segs);
		}

	}
	else // 矩形
	{
		double dAngle = CT_std_angle(dVDAngle - dLowAngle);
		if (fabs(dAngle)<1.0E-3 || fabs(dAngle-PI)<1.0E-3)
		{
			TchPrivate::Exchange(dVDWidth, dVDHigh);
		}

		XPoint ptVDuct1, ptVDuct2;
		ads_polar(ptLoc, dLowAngle, dVDHigh/2+dFlangeDis, ptVDTmp);
		ads_polar(ptVDTmp, dLowAngle+PI/2, dVDWidth/2+dFlangeDis, ptVDuct1);
		ads_polar(ptVDTmp, dLowAngle-PI/2, dVDWidth/2+dFlangeDis, ptVDuct2);

		XLine line(ptVDuct1, ptVDuct2, LS_FINITE);
		if (!line.Intersection(&lowL1, ptInt1))
		{
			ptInt1 = ptVDuct1;
		}
		if (!line.Intersection(&lowL2, ptInt2))
		{
			ptInt2 = ptVDuct2;
		}
		if (ptInt1==XPoint() || ptInt2==XPoint())
		{
			return FALSE;
		}
		
		if (!line.Intersection(&tmpLine, ptVDTmp))
		{
			Midpoint(ptInt1, ptInt2, ptVDTmp);
		}

		if (bIs3T) // 注：防止立管都被删除时，绘制错误
		{
			ads_polar(ptVDuct1, dLowAngle, -dVDHigh, ptVDuct1);
			ads_polar(ptVDuct2, dLowAngle, -dVDHigh, ptVDuct2);
			BuildSegs6(ptInt1, ptVDuct1, ptVDuct2, ptInt2, segs);
		}
	}
	BuildSegs1(ptInt1, pt1, segs);
	BuildSegs1(ptInt2, pt2, segs);
	return TRUE;
}

// 矩形截面立管下扣弯法兰
void TDbDuctNode::GetFKEFlPts(double dUpAng, double dVDAng,
							  XPoint upNodePt, double dUpWide,
							  int nVDtNum, XPointList &pts) const
{
	double dVDWidth = GetIWidth(nVDtNum), // 立管尺寸
		dVDHigh = GetIHeight(nVDtNum),
		dFlDis = GetIFlDist(nVDtNum);     // 立管上的法兰尺寸
	double dAng = CT_acute_angle(dUpAng - dVDAng); // 夹角
	if (fabs(dAng-PI/2) > 1.0E-3)
	{
		TchPrivate::Exchange(dVDWidth, dVDHigh);
	}

	XPoint ptLoc = GetZeroPt(),
		ptVF1, ptVF2, ptVF3, ptVF4, ptTmp; // 立管法兰边框点(逆时针顺序)
	ads_polar(ptLoc, dUpAng, -(dVDHigh/2+dFlDis), ptTmp);
	ads_polar(ptTmp, dUpAng+PI/2, dVDWidth/2+dFlDis, ptVF2);
	ads_polar(ptTmp, dUpAng-PI/2, dVDWidth/2+dFlDis, ptVF3);
	ads_polar(ptVF2, dUpAng, dVDHigh+2*dFlDis, ptVF1);
	ads_polar(ptVF3, dUpAng, dVDHigh+2*dFlDis, ptVF4);
	
	XPoint ptV1, ptV2; // 立管边框点(逆时针顺序)
	ads_polar(ptTmp, dUpAng, dFlDis, ptTmp);
	ads_polar(ptTmp, dUpAng+PI/2, dVDWidth/2, ptV1);
	ads_polar(ptTmp, dUpAng-PI/2, dVDWidth/2, ptV2);
	
	XPoint upSparePt(upNodePt), ptUp1, ptUp2, ptInt1, ptInt2;
	upSparePt.z = 0;
	ads_polar(upSparePt, dUpAng+PI/2, dUpWide/2, ptUp1); // 上节点非立管边线点
	ads_polar(upSparePt, dUpAng-PI/2, dUpWide/2, ptUp2);

	pts.Reset();
	XLine line1(ptV1, ptUp1, LS_FINITE),
		line2(ptVF1, ptVF4, LS_FINITE),
		line3(ptVF2, ptVF1, LS_FINITE);
	if (!line1.Intersection(&line2, ptInt1))
	{
		if (line1.Intersection(&line3, ptInt1))
			pts.Append(new XPoint(ptInt1));
	}
	else
	{
		pts.Append(new XPoint(ptInt1));
		pts.Append(new XPoint(ptVF1));
	}

	pts.Append(new XPoint(ptVF2));
	pts.Append(new XPoint(ptVF3));
	line1.SetPoints(ptV2, ptUp2);
	if (!line1.Intersection(&line2, ptInt2))
	{
		line3.SetPoints(ptVF3, ptVF4);
		if (line1.Intersection(&line3, ptInt2))
			pts.Append(new XPoint(ptInt2));
	}
	else
	{
		pts.Append(new XPoint(ptVF4));
		pts.Append(new XPoint(ptInt2));
	}
}

// 圆截面立管下扣弯法兰
void TDbDuctNode::GetYKEFlPts(double dUpAng, double dVDWidth,
							  XPoint upNodePt, double dUpWidth,
							  XArc &tmpArc, double dVDFlDist, XPointList &pts) const
{
	XPoint ptNodeLoc = GetZeroPt(),
		upSparePt(upNodePt);
	upSparePt.z = 0;
	
	XPoint ptV1, ptV2; // 立管边框点(逆时针顺序)
	ads_polar(ptNodeLoc, dUpAng+PI/2, dVDWidth/2, ptV1);
	ads_polar(ptNodeLoc, dUpAng-PI/2, dVDWidth/2, ptV2);
//	tmpArc.center = ptNodeLoc;
	tmpArc.SetCenterPt(ptNodeLoc);
	tmpArc.SetAngleByPoints(ptV2, ptV1);
	tmpArc.SetRadius(ptNodeLoc.Distance(ptV1));

	XPoint ptVF1, ptVF2, // 立管法兰边框点(逆时针顺序)
		ptMid; // 圆弧中点
	ads_polar(ptNodeLoc, dUpAng, -(dVDWidth/2+dVDFlDist), ptMid);
	ads_polar(ptNodeLoc, dUpAng+PI/2, dVDWidth/2+dVDFlDist, ptVF1);
	ads_polar(ptNodeLoc, dUpAng-PI/2, dVDWidth/2+dVDFlDist, ptVF2);
	
	XPoint ptTmp1, ptTmp2, ptInt1, ptInt2, ptTmp;
	ads_polar(upSparePt, dUpAng+PI/2, dUpWidth/2, ptTmp1); // 上节点非立管管线边线点
	ads_polar(upSparePt, dUpAng-PI/2, dUpWidth/2, ptTmp2);
	XLine UpNodeSideL1(ptV1, ptTmp1, LS_FINITE), // 上节点非立管管线边线点
		UpNodeSideL2(ptV2, ptTmp2, LS_FINITE);
	
	pts.Reset();
	XCircle circle(ptNodeLoc, dVDWidth/2+dVDFlDist);
	if (UpNodeSideL1.Intersection(&circle, ptInt1, ptTmp)) {
		ptInt1 = ::GetNearPt(ptTmp1, ptInt1, ptTmp);
		pts.Append(new XPoint(ptInt1));
	}
	pts.Append(new XPoint(ptVF1));
	pts.Append(new XPoint(ptMid));
	pts.Append(new XPoint(ptVF2));
	if (UpNodeSideL2.Intersection(&circle, ptInt2, ptTmp)) {
		ptInt2 = ::GetNearPt(ptTmp2, ptInt2, ptTmp);
		pts.Append(new XPoint(ptInt2));
	}
}

// 有下弯头的上弯头
BOOL TDbDuctNode::DrawUpKElbow2D2(DList<XCurveSegment> &segs, int nVNum,
								  XPoint ptStart, XPoint &ptVDTmp) const
{
	XPointList pts; // 立管上节点所连接的非立管，管线信息
	DList<XVector3D> vts;
	AcGeDoubleArray widths;
	int nType(-1);  // 立管上节点类型：0--下扣弯，1--连2根立管的三通，2--连1根立管的三通
	OPENOBJ_BEGIN(GetIPipe(nVNum), AcDb::kForRead, TDbDuct, pDuct);
	if (pDuct==NULL || !pDuct->IsVertical())
	{
		return FALSE;
	}

	pDuct->GetUpPipesPt(pts);
	widths = pDuct->GetUpPipesWidth();
	pDuct->GetUpPipesVec(vts);
	int nNumber = pts.Length();
	if ((widths.logicalLength()!=nNumber) || (vts.Length()!=nNumber))
	{
		return FALSE; // 数量一定是相等的
	}

	AcDbObjectId upNodeId = pDuct->GetVerUpNode(); // 上节点
	OPENOBJ_BEGIN(upNodeId, AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		if (!(pNode->Is(_T("KouElbow")) || pNode->Is(_T("3Corner")) || (nNumber!=0)))
		{
			return TRUE; // 上节点不遮挡“上弯头”，nType = -1
		}

		nType = (pNode->Is(_T("3Corner")))?(3-nNumber):0; // 判断上节点类型
		if (nNumber == 3)
		{
			return FALSE;
		}
	}
	OPENOBJ_END();
	OPENOBJ_END();

	int nHNum = 1 - nVNum; // 水平管标号
	double dWide = GetIWidth(nHNum), // 本节点非立管管线宽度
		dLowAngle = GetIAngle(nHNum); // 管线方向
	double dVDWide = GetIWidth(nVNum), // 立管尺寸
		dVDFlDist = GetIFlDist(nVNum), // 立管法兰出头长度
		dVDHigh = GetIHeight(nVNum),
		dVDAngle = GetIVDAngle(nVNum); // 立管角度
	XPoint ptLoc = GetZeroPt(),	ptSpare(ptStart), pt1, pt2;
	ptSpare.z = 0;
	ads_polar(ptSpare, dLowAngle+PI/2, dWide/2, pt1); // 本节点非立管管线边线点
	ads_polar(ptSpare, dLowAngle-PI/2, dWide/2, pt2);

	XLine tmpLine(ptLoc, ptSpare, LS_INFINITE);
	XLine lowL1 = tmpLine.Offset(-dWide/2), // 本节点非立管管线边线
		lowL2 = tmpLine.Offset(dWide/2);

	XCurveSegment seg;
	XPoint ptInt1, ptInt2, ptTmp; // 临时点
	if (nType == 0) // 扣弯
	{
		double dUpAngle = ads_angle(XPoint(), *vts[0]), // 开口方向
			dAng = CT_std_angle(dUpAngle - dLowAngle);  // 夹角
		if (fabs(dVDHigh) < 1.0E-6) // 圆
		{
			XArc tmpArc;
			XPointList ptLst;
			GetYKEFlPts(dUpAngle, dVDWide, *pts[0], widths[0],
				tmpArc, dVDFlDist, ptLst);
			if (ptLst.Length() != 5)
				return FALSE;
			
			XArc arc(*ptLst[0], *ptLst[2], *ptLst[4]); // 立管法兰边框
			if (lowL1.Intersection(&arc, ptInt1, ptTmp))
				ptInt1 = ::GetNearPt(pt1, ptInt1, ptTmp); // 取一个较近的交点
			if (lowL2.Intersection(&arc, ptInt2, ptTmp))
				ptInt2 = ::GetNearPt(pt2, ptInt2, ptTmp);
			
			XPoint ptMid;
			tmpArc.MidPoint(ptMid);
			XCircle circle(ptLoc, dVDWide/2+dVDFlDist);
			if (dAng>1.0E-6 && dAng<(PI/2+1.0E-6))
			{
				if (ptInt2 == XPoint())
				{
					ptInt2 = ::GetTangentPt1(arc, pt2, *ptLst[2]);
					if (ptInt2 == XPoint())
						ptInt2 = *ptLst[2];
				}
				
				if (dAng>1.0E-6 && dAng<(PI/2-1.0E-6))
					ads_polar(pt1, dLowAngle, -100, ptInt1);
				else if (fabs(dAng-PI/2)<1.0E-6 && ptInt1==XPoint())
				{
					ptInt1 = ::GetTangentPt1(tmpArc, pt1, ptMid);
					if (ptInt1 == XPoint())
						ptInt1 = ptMid;
					XLine lineTmp(pt1, ptInt1, LS_INFINITE);
					if (!circle.Intersection(&lineTmp, ptInt1, ptTmp))
						return FALSE;
					ptInt1 = ::GetNearPt(pt1, ptInt1, ptTmp);
				}
			}
			else if (dAng>(PI/2+1.0E-6) && dAng<(1.5*PI-1.0E-6))
			{
				ptTmp = *ptLst[1];
				if (dAng > (PI+1.0E-6))
					ptTmp = *ptLst[0];
				if (ptInt2 == XPoint())
				{
					ptInt2 = ::GetTangentPt1(arc, pt2, ptTmp);
					if (ptInt2 == XPoint())
						ptInt2 = ptTmp;
				}
				
				ptTmp = *ptLst[3];
				if (dAng > (PI+1.0E-6))
					ptTmp = *ptLst[2];
				if (ptInt1 == XPoint())
				{
					ptInt1 = ::GetTangentPt1(arc, pt1, ptTmp);
					if (ptInt1 == XPoint())
						ptInt1 = ptTmp;
				}
			}
			else if (dAng>(PI*1.5-1.0E-6) && dAng<(2*PI-1.0E-6))
			{
				if (dAng>(PI*1.5+1.0E-6) && dAng<(2*PI-1.0E-6))
					ads_polar(pt2, dLowAngle, -100, ptInt2);
				else if (fabs(dAng-PI*1.5)<0.001 && ptInt2==XPoint())
				{
					ptInt2 = ::GetTangentPt1(tmpArc, pt2, ptMid);
					if (ptInt2 == XPoint())
						ptInt2 = ptMid;
					
					XLine lineTmp1(pt2, ptInt2, LS_INFINITE);
					if (!circle.Intersection(&lineTmp1, ptInt2, ptTmp))
						return FALSE;
					ptInt2 = ::GetNearPt(pt2, ptInt2, ptTmp);
				}
				
				if (ptInt1 == XPoint())
				{
					ptInt1 = ::GetTangentPt1(arc, pt1, *ptLst[2]);
					if (ptInt1 == XPoint())
						ptInt1 = *ptLst[2];
				}
			}
			
			ads_polar(ptSpare, dLowAngle, -dWide, ptTmp);
			XLine line(ptTmp, ptSpare, LS_INFINITE);
			if (line.Intersection(&arc, ptVDTmp, ptTmp))
				ptVDTmp = ::GetNearPt(pt1, ptVDTmp, ptTmp);
			else
			{
				line.SetPoints(ptSpare, ptLoc);
				if (line.Intersection(&arc, ptVDTmp, ptTmp))
					ptVDTmp = ::GetNearPt(pt1, ptVDTmp, ptTmp);
				else
					return FALSE;
			}
		}
		else
		{
			XPointList flangePts;
			GetFKEFlPts(dUpAngle, dVDAngle, *pts[0], widths[0],
				nVNum, flangePts); // 立管法兰边框点
			int nPtCount = flangePts.Length();
			if (nPtCount!=4 && nPtCount!=6)
			{
				return FALSE;
			}
			
			int n1 = nPtCount==4?0:1, // 注：角标与立管法兰对应，在链表中的号
				n2 = nPtCount==4?1:2,
				n3 = nPtCount==4?2:3,
				n4 = nPtCount==4?3:4;
			if (fabs(dAng-PI*0.5)<1.0E-6 || fabs(dAng-PI)<1.0E-6 ||
				fabs(dAng-PI*1.5)<1.0E-6)
			{
				XLine line(*flangePts[n2], *flangePts[n3], LS_FINITE);
				if (fabs(dAng-PI*0.5) < 1.0E-6)
					line.SetPoints(*flangePts[n3], *flangePts[n4]);
				else if (fabs(dAng-PI*1.5)<1.0E-6)
					line.SetPoints(*flangePts[n1], *flangePts[n2]);
				
				if (!lowL1.Intersection(&line, ptInt1))
					ptInt1 = line.EndPoint();
				if (!lowL2.Intersection(&line, ptInt2))
					ptInt2 = line.StartPoint();
				ptVDTmp = line.MidPoint();
			}
			else if ((dAng>(PI/2+1.0E-6)&&dAng<(PI-1.0E-6)) ||
				(dAng>(PI+1.0E-6)&&dAng<(1.5*PI-1.0E-6))) // 钝角
			{
				XLine line1(*flangePts[n2], *flangePts[n3], LS_FINITE),
					line2(*flangePts[n2], *flangePts[n1], LS_FINITE);
				if (dAng>(PI/2+1.0E-6) && dAng<(PI-1.0E-6))
					line2.SetPoints(*flangePts[n3], *flangePts[n4]);
				
				if (!lowL1.Intersection(&line1, ptInt1))
				{
					if (dAng>(PI/2+1.0E-6) && dAng<(PI-1.0E-6))
					{
						if (!lowL1.Intersection(&line2, ptInt1))
							ptInt1 = line2.EndPoint();
					}
					else
						ptInt1 = line1.EndPoint();
				}
				if (!lowL2.Intersection(&line1, ptInt2))
				{
					if (dAng>(PI/2+1.0E-6) && dAng<(PI-1.0E-6))
						ptInt2 = line1.StartPoint();
					else
					{
						if (!lowL2.Intersection(&line2, ptInt2))
							ptInt2 = line2.EndPoint();
					}
				}
				
				ads_polar(ptSpare, dLowAngle, -dWide, ptTmp);
				XLine line3(ptSpare, ptTmp, LS_INFINITE);
				if (!line3.Intersection(&line1, ptVDTmp))
				{
					if (!line3.Intersection(&line2, ptVDTmp))
						return FALSE;
				}
			}
			else if (dAng>1.0E-6 && dAng<(PI/2+1.0E-6)) // 锐角
			{
				XLine line(*flangePts[n3], *flangePts[n4], LS_FINITE);
				if (!lowL2.Intersection(&line, ptInt2))
					ptInt2 = *flangePts[n3];
				ads_polar(pt1, dLowAngle, -100, ptInt1);
				ads_polar(ptStart, dLowAngle, -100, ptVDTmp);
			}
			else if (dAng>(PI*1.5-1.0E-6) && dAng<(2*PI-1.0E-6)) // 锐角
			{
				XLine line(*flangePts[n1], *flangePts[n2], LS_FINITE);
				if (!lowL1.Intersection(&line, ptInt1))
					ptInt1 = *flangePts[n2];
				ads_polar(pt2, dLowAngle, -100, ptInt2);
				ads_polar(ptSpare, dLowAngle, -100, ptVDTmp);
			}
		}
		BuildSegs1(ptInt1, pt1, segs);
		BuildSegs1(ptInt2, pt2, segs);
		return TRUE;
	}
	
	if (nType == 1) // 连2根立管的三通
	{
		if (fabs(dVDHigh) < 1.0E-6) // 圆
		{
			XPoint pt3, pt4;
			ads_polar(pt1, dLowAngle, -dWide, pt3);
			ads_polar(pt2, dLowAngle, -dWide, pt4);
			XCircle circle(ptLoc, dVDWide/2);
			if (circle.Intersection(&lowL1, ptInt1, ptTmp) != 0)
				ptInt1 = ::GetNearPt(pt1, ptInt1, ptTmp);
			else {
				ptInt1 = ::GetTangentPt2(circle, pt1, pt3);
				if (ptInt1 == XPoint())
					ads_polar(pt1, dLowAngle, -200, ptInt1);
			}

			if (circle.Intersection(&lowL2, ptInt2, ptTmp) != 0)
				ptInt2 = ::GetNearPt(pt2, ptInt2, ptTmp);
			else {
				ptInt2 = ::GetTangentPt2(circle, pt2, pt4);
				if (ptInt2 == XPoint())
					ads_polar(pt2, dLowAngle, -200, ptInt2);
			}

			if (circle.Intersection(&tmpLine, ptVDTmp, ptTmp) == 0)
				return FALSE;
			ptVDTmp = ::GetNearPt(ptSpare, ptVDTmp, ptTmp);
		}
		else
		{
			double dAng = CT_std_angle(dLowAngle - dVDAngle); // 夹角
			if (fabs(dAng) < 1.0E-6)
			{
				ads_polar(ptLoc, dVDAngle, dVDWide/2, ptTmp);
				ads_polar(ptTmp, dVDAngle+PI/2, dVDHigh/2, ptInt1);
				ads_polar(ptTmp, dVDAngle-PI/2, dVDHigh/2, ptInt2);
				ptVDTmp = ptTmp;
			}
			else if (fabs(dAng-PI) < 1.0E-6)
			{
				ads_polar(ptLoc, dVDAngle, -dVDWide/2, ptTmp);
				ads_polar(ptTmp, dVDAngle+PI/2, dVDHigh/2, ptInt2);
				ads_polar(ptTmp, dVDAngle-PI/2, dVDHigh/2, ptInt1);
				ptVDTmp = ptTmp;
			}
			else if (fabs(dAng-PI*0.5)<1.0E-6 || fabs(dAng-PI*1.5)<1.0E-6)
			{
				ads_polar(ptLoc, dLowAngle, dVDHigh/2, ptTmp);
				ads_polar(ptTmp, dLowAngle+PI/2, dVDWide/2, ptInt1);
				ads_polar(ptTmp, dLowAngle-PI/2, dVDWide/2, ptInt2);
				ptVDTmp = ptTmp;
			}
			else
			{
				ads_polar(pt1, dLowAngle, -200, ptInt1);
				ads_polar(pt2, dLowAngle, -200, ptInt2);
				ads_polar(ptSpare, dLowAngle, -200, ptVDTmp);
			}
		}
		BuildSegs1(ptInt1, pt1, segs);
		BuildSegs1(ptInt2, pt2, segs);
		return TRUE;
	}
	
	// 连1根立管的三通
	double dOpenAng = ads_angle(XPoint(), *vts[0]); // 管线方向
	double dAng = CT_std_angle(dLowAngle - dOpenAng); // 夹角
	if (fabs(dAng-PI*0.5)<1.0E-6 || fabs(dAng-PI*1.5)<1.0E-6)
	{
		XPoint ptTmp1, ptTmp2, ptTmp3, ptTmp4; // 下节点非立管管线边线点
		ads_polar(*pts[0], dOpenAng+PI/2, widths[0]/2, ptTmp1);
		ads_polar(*pts[0], dOpenAng-PI/2, widths[0]/2, ptTmp3);
		ads_polar(*pts[1], dOpenAng+PI/2, widths[1]/2, ptTmp2);
		ads_polar(*pts[1], dOpenAng-PI/2, widths[1]/2, ptTmp4);
		ptTmp1 = ::GetNearPt(ptSpare, ptTmp1, ptTmp3);
		ptTmp2 = ::GetNearPt(ptSpare, ptTmp2, ptTmp4);
		XLine tmpLine1(ptTmp1, ptTmp2, LS_INFINITE);
		tmpLine1.Intersection(&lowL1, ptInt1);
		tmpLine1.Intersection(&lowL2, ptInt2);
		tmpLine1.Intersection(&tmpLine, ptVDTmp);
		BuildSegs1(ptInt1, pt1, segs);
		BuildSegs1(ptInt2, pt2, segs);
	}
	else
	{
		ptVDTmp = ptLoc;
	}
	return TRUE;
}


/////////////////////////变径、天圆地方/////////////////////
Acad::ErrorStatus TDbDuctNode::DrawTapered2D(XExplodeDraw &dc, BOOL bIsTYDF) const
{
	if (GetInterfaceNum() != 2) // 1、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}
	
	XPointList pts;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, TRUE);
	if (pts.Length() != 2) // 2、获取与管线相连点，考虑了法兰遮挡
	{
		return Acad::eInvalidInput;
	}
	
	if (m_nSysDrawMod != 3) // 3、绘制中线
	{
		DList<XCurveSegment> midSegs;
		BuildSegs1(*pts[0], *pts[1], midSegs);
		if (m_nSysDrawMod == 1) // 单线图
		{
			DrawXiSegs(dc, midSegs);
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs); // 三线图
	}

	// 4、获取绘制信息
	double dWidth1 = GetIWidth(0), // 管线尺寸
		dWidth2 = GetIWidth(1),
		dHigh1 = GetIHeight(0),
		dHigh2 = GetIHeight(1);
	XVector3D vt1 = GetIDirection(0),
		vt2 = GetIDirection(1);
	BOOL bIsVDuct1(FALSE), bIsVDuct2(FALSE),
		bCircle1 = GetISection(0)==1, // 1接口是否为圆管
		bCircle2 = GetISection(1)==1; // 2接口是否为圆管
	if (fabs(vt1.x)<1.0E-6 && fabs(vt1.y)<1.0E-6) // 1接口接立管
	{
		bIsVDuct1 = TRUE;
	}
	if (fabs(vt2.x)<1.0E-6 && fabs(vt2.y)<1.0E-6) // 2接口接立管
	{
		bIsVDuct2 = TRUE;
	}

	XCurveSegment seg;
	DList<XCurveSegment> lstSeg; // 5、绘制上下线
	if (bIsVDuct1 && bIsVDuct2)
	{
		if (bCircle1)
		{
			XCircle circle(*pts[0], dWidth1/2);
			BuildSegs5(circle, lstSeg);
		}
		else
		{
			XPoly2D rect(1);
			::GetSquare(*pts[0], GetIVDAngle(0), dWidth1, dHigh1, &rect, NULL);
			if (rect.Length() != 4)
			{
				return Acad::eInvalidInput;
			}

			rect.AppendNode(*rect[0]);
			for (int j=0; j<4; j++)
			{
				BuildSegs1(*rect[j], *rect[j+1], lstSeg);
			}
		}

		if (bCircle2)
		{
			XCircle circle(*pts[1], dWidth2/2);
			BuildSegs5(circle, lstSeg);
		}
		else
		{
			XPoly2D rect(1);
			::GetSquare(*pts[1], GetIVDAngle(1), dWidth2, dHigh2, &rect, NULL);
			if (rect.Length() != 4)
			{
				return Acad::eInvalidInput;
			}

			rect.AppendNode(*rect[0]);
			for (int j=0; j<4; j++)
			{
				BuildSegs1(*rect[j], *rect[j+1], lstSeg);
			}
		}
	}
	else
	{
		XPoint pt1, pt2, pt3, pt4;
		double dAng = GetIAngle(0);
		ads_polar(*pts[0], dAng-PI/2, dWidth1/2, pt1);
		ads_polar(*pts[0], dAng+PI/2, dWidth1/2, pt2);
		ads_polar(*pts[1], dAng-PI/2, dWidth2/2, pt3);
		ads_polar(*pts[1], dAng+PI/2, dWidth2/2, pt4);
		BuildSegs1(pt1, pt3, lstSeg);
		BuildSegs1(pt2, pt4, lstSeg);
		
		if (bIsTYDF && bCircle1)
		{
			BuildSegs2(pt3, *pts[0], pt4, lstSeg);
		}
		else if (bIsTYDF && bCircle2)
		{
			BuildSegs2(pt1, *pts[1], pt2, lstSeg);
		}
	}
	Draw2DSegs(dc, lstSeg);
	return Acad::eOk;
}


///////////////////////////乙字弯///////////////////////////
void GetNewPts(XPoint &pt1, XPoint &pt2, double dLen)
{
	XVector3D vt = pt1 - pt2;
	vt.Normalize();
	vt.Scale(dLen);
	pt1 = pt1 + vt;
	vt.Scale(-1);
	pt2 = pt2 + vt;
	return;
}

Acad::ErrorStatus TDbDuctNode::DrawYZElbow2D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 2) // 1、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}

	XPointList pts;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, FALSE);
	if (pts.Length() != 2) // 2、获取与管线相连点，注：考虑法兰遮挡节点
	{
		return Acad::eInvalidInput;
	}

	XPoint pt1 = *pts[0],
		pt2 = *pts[1];
	BOOL bSameEle = (fabs(pt1.z-pt2.z)<1.0E-5); // 3、判断连接管线是否标高相同
	pt1.z = pt2.z = 0;

	double dAng1 = GetIAngle(0), // 方向
		dAng2 = GetIAngle(1);
	double dDist1 = GetIWidth(0), // 管线宽度
		dDist2 = GetIWidth(1);
	double dThick1 = GetIFlThick(0), // 法兰厚度
		dThick2 = GetIFlThick(1);
	double dFlDia1 = dDist1 + 2*GetIFlDist(0), // 法兰直径
		dFlDia2 = dDist2 + 2*GetIFlDist(1);

	XPoint p1, p2, p3, p4;
	XPoint ptTmp1, ptTmp2, ptTmp3, ptTmp4;
	DList<XCurveSegment> lstSeg; // 绘制边线
	if (bSameEle && (m_nDrawMod == 2)) // 4、角接样式
	{
		ads_polar(pt1, dAng1, -(dDist1-dThick1), p1); // 按照从左到右的顺序排列
		ads_polar(pt1, dAng1, -dDist1, p2);
		ads_polar(pt2, dAng2, -dDist2, p3);
		ads_polar(pt2, dAng2, -(dDist2-dThick2), p4);

		if (m_nSysDrawMod != 3) // 绘制中心线
		{
			DList<XCurveSegment> midSegs;
			BuildSegs1(pt1, p1, midSegs);
			BuildSegs1(p2, p3, midSegs);
			BuildSegs1(pt2, p4, midSegs);
			
			if (m_nSysDrawMod == 1) // 单线图
			{
				DrawXiSegs(dc, midSegs);
				return Acad::eOk;
			}
			DrawMidSegs(dc, midSegs); // 三线图
		}
		
		Midpoint(p1, p2, ptTmp1); // 中间法兰位置点
		Midpoint(p3, p4, ptTmp2);
		DrawFlange(lstSeg, ptTmp1, dAng1, dFlDia1, dThick1);
		DrawFlange(lstSeg, ptTmp2, dAng2, dFlDia2, dThick2);
		DrawFLSegs(dc, lstSeg); // 绘制法兰

		lstSeg.Reset();
		dDist1 *= 0.5;
		dDist2 *= 0.5;
		BuildSegs3(XLine(pt1, p1, LS_FINITE).Offset(dDist1), lstSeg);
		BuildSegs3(XLine(pt1, p1, LS_FINITE).Offset(-dDist1), lstSeg);
		BuildSegs3(XLine(pt2, p4, LS_FINITE).Offset(dDist2), lstSeg);
		BuildSegs3(XLine(pt2, p4, LS_FINITE).Offset(-dDist2), lstSeg);

		ads_polar(p2, dAng1+PI/2, dDist1, ptTmp1);
		ads_polar(p2, dAng1-PI/2, dDist1, ptTmp2);
		ads_polar(p3, dAng2+PI/2, dDist2, ptTmp3);
		ads_polar(p3, dAng2-PI/2, dDist2, ptTmp4);
		BuildSegs1(ptTmp1, ptTmp4, lstSeg);
		BuildSegs1(ptTmp2, ptTmp3, lstSeg);
		Draw2DSegs(dc, lstSeg); // 绘制边线
		return Acad::eOk;
	}

	double dLen = pt1.Distance(pt2); // 斜边长度
	ads_polar(pt1, dAng1+PI/2, dDist1/2, p1);
	ads_polar(pt1, dAng1-PI/2, dDist1/2, p2);
	ads_polar(pt2, dAng2+PI/2, dDist2/2, p3);
	ads_polar(pt2, dAng2-PI/2, dDist2/2, p4);

	if (!bSameEle) // 5、标高不等下，乙字弯画法由中广电提供
	{
		if (m_nSysDrawMod != 3) // 绘制中心线
		{
			DList<XCurveSegment> midSegs;
			BuildSegs1(pt1, pt2, midSegs);
			
			if (m_nSysDrawMod == 1) // 单线图
			{
				DrawXiSegs(dc, midSegs);
				return Acad::eOk;
			}
			DrawMidSegs(dc, midSegs); // 三线图
		}

		BuildSegs1(p1, p4, lstSeg);
		BuildSegs1(p2, p3, lstSeg);
		Draw2DSegs(dc, lstSeg); // 绘制边线
		
		double dEle1 = pts[0]->z, // 标高
			dEle2 = pts[1]->z;
		dAng1 = CT_std_angle(dAng1); // 将角度调整到0到2PI范围内
		dAng2 = CT_std_angle(dAng2);
		double dAngle = dAng1 - dAng2;
		if (((dEle1>dEle2)&&(dAngle>1.0E-5)) || ((dEle1<dEle2)&&(dAngle<1.0E-5)))
		{
			ads_polar(p2, dAng1+PI/2, dDist1/8, ptTmp1); // 2-->4
			ads_polar(p4, dAng2+PI/2, dDist2/8, ptTmp3);
		}
		else // 1-->3
		{
			ads_polar(p1, dAng1-PI/2, dDist1/8, ptTmp1);
			ads_polar(p3, dAng2-PI/2, dDist2/8, ptTmp3);
		}
		
		ads_polar(ptTmp1, dAng1, -dLen*0.05, ptTmp1);
		ads_polar(ptTmp1, dAng1, -dLen*0.15, ptTmp2);
		ads_polar(ptTmp3, dAng2, -dLen*0.05, ptTmp3);
		ads_polar(ptTmp3, dAng2, -dLen*0.15, ptTmp4);
		
		lstSeg.Reset();
		BuildSegs6(ptTmp1, ptTmp2, ptTmp4, ptTmp3, lstSeg);
		DrawFLSegs(dc, lstSeg); // 绘制
		return Acad::eOk;
	}
	
	XVector3D vt1 = GetIDirection(0),
		vt2 = GetIDirection(1);
	XVector3D vtMid1(vt1), vtMid2(vt2); // 6、获取中线圆心方向
	XCurveSegment seg1(pt1, XPoint(pt1+vt1), 0, LS_INFINITE),
		seg2(pt2, XPoint(pt2+vt2), 0, LS_INFINITE);
	XPoint ptPro1, ptPro2;
	seg2.ProjectToMe(pt1, ptPro1);
	seg1.ProjectToMe(pt2, ptPro2);
	vtMid1 = ptPro1 - pt1;
	vtMid2 = ptPro2 - pt2;

	double dDistM = (dDist1+dDist2)/2.0;
	double dRadius1 = (dLen*0.25)/sin(m_dDrawParam/2), // 中线圆半径
		dRadius2 = dRadius1;
	if (m_nDrawMod == 1) // 斜接样式
	{
		dRadius1 = dDist1*m_dDrawParam2 - (dThick1*0.5)/tan(m_dDrawParam/2);
		dRadius2 = dDist2*m_dDrawParam2 - (dThick2*0.5)/tan(m_dDrawParam/2);
	}

	vtMid1.Normalize();
	vtMid2.Normalize();
	vtMid1.Scale(dRadius1);
	vtMid2.Scale(dRadius2);
	XPoint ptCen1 = pt1 + vtMid1, // 7、获取圆心点
		ptCen2 = pt2 + vtMid2;
	ptCen1.z = ptCen2.z = 0;
	XPoint ptLoc = GetZeroPt();
	
	XCurveSegment seg;
	double dNewAng1(0), dNewAng2(0);
	if (m_nSysDrawMod != 3) // 8、绘制中心线
	{
		DList<XCurveSegment> midSegs;
		if (m_nDrawMod == 1) // 斜接样式
		{
			ptTmp1 = GetArcPts(pt1, dRadius1, dAng1, pt2, midSegs, dNewAng1);
			ptTmp2 = GetArcPts(pt2, dRadius2, dAng2, pt1, midSegs, dNewAng2);
			ads_polar(ptTmp1, dNewAng1, dThick1, ptTmp3);
			ads_polar(ptTmp2, dNewAng2, dThick2, ptTmp4);
			BuildSegs1(ptTmp3, ptTmp4, midSegs);
		}
		else // 双弧样式
		{
			seg = ::GetArcSeg1(pt1, ptCen1, ptLoc, dDist1, dDistM);
			midSegs.Append(new XCurveSegment(seg));
			seg = ::GetArcSeg1(pt2, ptCen2, ptLoc, dDist2, dDistM);
			midSegs.Append(new XCurveSegment(seg));
		}
		
		if (m_nSysDrawMod == 1) // 单线图
		{
			DrawXiSegs(dc, midSegs);
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs); // 三线图
	}

	XPoint ptNear1 = ::GetNearPt(ptCen1, p1, p2),
		ptNear2 = ::GetNearPt(ptCen2, p3, p4),
		ptFar1 = ::GetFarPt(ptCen1, p1, p2),
		ptFar2 = ::GetFarPt(ptCen2, p3, p4);
	if (m_nDrawMod == 1) // 斜接样式
	{
		DList<XCurveSegment> segs;
		ptTmp1 = GetArcPts(pt1, dRadius1, dAng1, pt2, segs, dNewAng1);
		ptTmp2 = GetArcPts(pt2, dRadius2, dAng2, pt1, segs, dNewAng2);
		ads_polar(ptTmp1, dNewAng1, dThick1*0.5, ptTmp3); // 中间法兰位置点
		ads_polar(ptTmp2, dNewAng2, dThick2*0.5, ptTmp4);
		DrawFlange(lstSeg, ptTmp3, dNewAng1, dFlDia1, dThick1);
		DrawFlange(lstSeg, ptTmp4, dNewAng2, dFlDia2, dThick2);
		DrawFLSegs(dc, lstSeg); // 绘制法兰

		lstSeg.Reset();
		pt2.Mirror(ptCen2, ptTmp3);
		ptTmp1 = GetArcPts(ptNear1, (dRadius1-dDist1*0.5), dAng1, ptTmp3, lstSeg, dNewAng1);
		ptTmp2 = GetArcPts(ptFar2, (dRadius2+dDist2*0.5), dAng2, pt1, lstSeg, dNewAng2);
		ads_polar(ptTmp1, dNewAng1, dThick1, ptTmp3);
		ads_polar(ptTmp2, dNewAng2, dThick2, ptTmp4);
		BuildSegs1(ptTmp3, ptTmp4, lstSeg);

		pt1.Mirror(ptCen1, ptTmp3);
		ptTmp1 = GetArcPts(ptFar1, (dRadius1+dDist1*0.5), dAng1, pt2, lstSeg, dNewAng1);
		ptTmp2 = GetArcPts(ptNear2, (dRadius2-dDist2*0.5), dAng2, ptTmp3, lstSeg, dNewAng2);
		ads_polar(ptTmp1, dNewAng1, dThick1, ptTmp3);
		ads_polar(ptTmp2, dNewAng2, dThick2, ptTmp4);
		BuildSegs1(ptTmp3, ptTmp4, lstSeg);
		Draw2DSegs(dc, lstSeg); // 绘制边线
		return Acad::eOk;
	}

	vtMid1 = ptCen1 - ptLoc;
	vtMid2 = ptCen2 - ptLoc;
	vtMid1.Normalize();
	vtMid2.Normalize();
	vtMid1.Scale(dDistM/2);
	vtMid2.Scale(dDistM/2);
	XPoint pt5 = ptLoc + vtMid1,
		pt6 = ptLoc + vtMid2;
	
	seg = ::GetArcSeg1(ptNear1, ptCen1, pt5, dDist1, dDistM);
	lstSeg.Append(new XCurveSegment(seg));
	seg = ::GetArcSeg1(ptFar1, ptCen1, pt6, dDist1, dDistM);
	lstSeg.Append(new XCurveSegment(seg));
	seg = ::GetArcSeg1(ptNear2, ptCen2, pt6, dDist2, dDistM);
	lstSeg.Append(new XCurveSegment(seg));
	seg = ::GetArcSeg1(ptFar2, ptCen2, pt5, dDist2, dDistM);
	lstSeg.Append(new XCurveSegment(seg));
	Draw2DSegs(dc, lstSeg); // 绘制边线
	return Acad::eOk;
}


////////////////////////////掏洞////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawTaoDong2D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 2) // 1、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}

	XPointList pts;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, TRUE); // 法兰遮挡后的连接点
	if (pts.Length() != 2) // 2、获取与管线相连点
	{
		return Acad::eInvalidInput;
	}

	int nB = 1 - m_nMain;   // 支管
	DList<XCurveSegment> midSegs, lstSeg;
	if (m_nSysDrawMod != 3) // 3、除双线图外，绘制中心线
	{
		XPoint ptLoc = GetZeroPt(); // 将绘制标高变为0
		BuildSegs1(*pts[nB], ptLoc, midSegs);
		if (m_nSysDrawMod == 1)
		{
			DrawXiSegs(dc, midSegs); // 单线图，细线绘制
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs); // 三线图，切换中心线图层、线型绘制
	}

	if (m_nDrawMod == 13) // 4、样式13只绘制中心线
	{
		return Acad::eOk;
	}
	
	XPoint ptM(*pts[m_nMain]), ptM2;
	ads_polar(ptM, GetIAngle(m_nMain), -10000, ptM2);
	XCurveSegment mSeg(ptM, ptM2, 0, LS_INFINITE); // 主管中心线

	XPoint ptB(*pts[nB]), ptB1(*pts[nB]), ptB2, ptBTmp;
	mSeg.ProjectToMe(ptB, ptBTmp);
	XVector3D vtTmp = ptB - ptBTmp;
	vtTmp.Normalize();
	vtTmp.Scale(GetIWidth(m_nMain)*0.5);
	ptM = ptM + vtTmp;
	ptM2 = ptM2 + vtTmp;
	mSeg.SetPoints(ptM, ptM2); // 与支管连接的主管侧壁

	double dBAngle = GetIAngle(nB);
	ads_polar(ptB, dBAngle, 10000, ptBTmp);
	XCurveSegment bSeg(ptB, ptBTmp, 0, LS_INFINITE); // 插管中心线
	bSeg.ProjectToMe(ptM2, ptBTmp);
	vtTmp = ptM2 - ptBTmp;
	vtTmp.Normalize();
	vtTmp.Scale(GetIWidth(nB)*0.5);
	ptB1 = ptB + vtTmp;
	ptB.Mirror(ptB1, ptB2);
	ptBTmp = ptBTmp + vtTmp;
	bSeg.SetPoints(ptB1, ptBTmp); // 与主管侧壁组成小弧的支管侧壁

	XPoint ptInt, ptTmp, ptTmp1, ptTmp2, ptCen;
	if (!mSeg.Intersection(bSeg, ptInt, ptTmp))
	{
		return Acad::eInvalidInput;
	}

	BOOL bSwitch(TRUE); // 大、小弧的优、劣是一致的
	double dDist = ptInt.Distance(ptB1)*0.8;
	::AT_cal_fillet(ptM2, ptInt, ptB1, dDist, ptTmp1, ptCen, ptTmp2, FALSE);
	BuildSegs1(ptTmp2, ptB1, lstSeg);
	XArc smallArc = ::GetRightArc(ptTmp1, ptCen, ptTmp2, bSwitch); // 选择优弧
	BuildSegs4(smallArc, lstSeg); // 小弧

	ads_polar(ptB2, dBAngle, -dDist*0.25, ptTmp1); // ptTmp1为大弧起点
	XLine tmpL1(ptB2, ptTmp1, LS_INFINITE);
	if (!mSeg.Intersection(tmpL1, ptTmp, ptTmp2)) // ptTmp为与主管侧壁交点
	{
		return Acad::eInvalidInput;
	}
	
	if (m_nDrawMod == 14) // 大弧线连接
	{
		dDist = ptCen.Distance(ptTmp1); // 大弧半径
		XLine tmpL2(ptInt, ptTmp, LS_FINITE);
		XCircle circle(ptCen, dDist);
		if (!circle.Intersection(&tmpL2, ptTmp2, ptBTmp)) // 没有交点
		{
			BuildSegs1(ptB2, ptTmp, lstSeg); // 改用直线连接
		}
		else // 有交点则用弧线连接
		{
			BuildSegs1(ptB2, ptTmp1, lstSeg);
			XArc bigArc = ::GetRightArc(ptTmp2, ptCen, ptTmp1, bSwitch); // 选择优弧
			BuildSegs4(bigArc, lstSeg); // 小弧
		}
	}
	else // 直线
	{
		BuildSegs1(ptB2, ptTmp, lstSeg);
	}
	Draw2DSegs(dc, lstSeg); // 绘制实线
    return Acad::eOk;
}


////////////////////////////三通////////////////////////////
Acad::ErrorStatus TDbDuctNode::Draw3Corner2D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 3) // 1 、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}
	
	XPointList pts, pt0s;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, FALSE);
	GetPtsIFace(pt0s, FALSE, FALSE, FALSE, TRUE);
	if ((pts.Length() != 3) || (pt0s.Length() != 3))
	{
		return Acad::eInvalidInput; // 2、获取法兰遮挡后与管线相连点
	}

	DList<AcDbObjectId> linkIds;
	GetAllLinkDucts(linkIds);
	AcGeIntArray types = GetAllTypes();

	int nVDuct1(-1), nVDuct2(-1); // 3、判断是否有立管
	::Get3TVDuctNums(objectId(), linkIds, types, nVDuct1, nVDuct2);

	int nDrawMod(m_nDrawMod); // 绘制样式，会自动调整
	if (m_nSysDrawMod != 3)   // 4、除双线外，绘制中心线
	{
		BOOL bFlag(TRUE);
		DList<XCurveSegment> midSegs;		
		if ((nVDuct1 == -1) && (nVDuct2 == 1)) // 不带立管，根据绘制样式绘制
		{
			bFlag = FALSE;
			int nO1(-1), nO2(-1), nTmp(5); // 获取支管标号
			::GetAnotherPipe(m_nMain, nO1, nO2, nTmp);

			double dTmpAng(0);
			XPoint ptNew1, ptNew2, ptTmp(*pt0s[m_nMain]);
			switch(m_nDrawMod)
			{
			case 6: // 平行型
				BuildSegs2(*pt0s[nO2], ptTmp, *pt0s[nO1], midSegs);
				break;
			case 9:
			case 10: // 斜插型
				{
					nTmp = ::IsParallel(GetIDirection(m_nMain),
						GetIDirection(nO1))?nO2:nO1; // 获取不平行管线
					AcGeVector3d vtM = GetIDirection(m_nMain).AsAcGeVector3d()*(-1),
						vtT = GetIDirection(nTmp).AsAcGeVector3d();
					double dCurrent = vtM.angleTo(vtT);
					if ((dCurrent<PI*4/9-1.0E-5) || (dCurrent>PI*11/18+1.0E-5))
					{
						bFlag = TRUE;
						nDrawMod = 7; // 不满足样式9/10的要求，自动修改绘制样式
					}
					else // 按照样式9或10绘制
					{
						ptNew1 = GetArcPts(*pt0s[nTmp], GetIWidth(nTmp), // 法兰点
							GetIAngle(nTmp), ptTmp, midSegs, dTmpAng);
						nTmp = nTmp==nO1?nO2:nO1; // 与主风管平行
						BuildSegs2(ptNew1, ptTmp, *pt0s[nTmp], midSegs);
					}
				}
				break;
			case 11: // 叉型
				ptNew1 = GetArcPts(*pt0s[nO1], GetIWidth(nO1), GetIAngle(nO1),
					ptTmp, midSegs, dTmpAng); // 法兰点1
				ptNew2 = GetArcPts(*pt0s[nO2], GetIWidth(nO2), GetIAngle(nO2),
					ptTmp, midSegs, dTmpAng); // 法兰点2
				BuildSegs2(ptNew2, ptTmp, ptNew1, midSegs);
				break;
			case 12:
				ptNew1 = GetYTopPt(ptTmp);
				Midpoint(ptNew1, ptTmp, ptNew2);
				BuildSegs1(ptTmp, ptNew1, midSegs);
				BuildSegs2(*pt0s[nO1], ptNew2, *pt0s[nO2], midSegs);
				break;
			default: // 其他
				bFlag = TRUE;
				break;
			}
		}

		if (bFlag) // 除特殊样式外，其他都按标准样式绘制中心线
		{
			XPoint ptLoc = GetZeroPt();
			for (int i=0; i<3; i++)
			{
				BuildSegs1(ptLoc, *pt0s[i], midSegs);
			}
		}
		
		if (m_nSysDrawMod == 1)
		{
			DrawXiSegs(dc, midSegs); // 单线图
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs); // 三线图
	}

	DList<XCurveSegment> lstSeg;
	if ((nVDuct1>-1) && (nVDuct2>-1)) // 5、连接了两根立管
	{
		int nHDuct(0), nTmp(5); // 获取水平管编号
		::GetAnotherPipe(nVDuct1, nVDuct2, nHDuct, nTmp);

		XPoint ptVDTmp;
		nTmp = (pts[nVDuct1]->z>(pts[nVDuct2]->z+1.0E-6))?nVDuct1:nVDuct2;
		if (DrawUpKElbow2D1(lstSeg, nTmp, nHDuct, *pts[nHDuct], ptVDTmp, TRUE))
		{
			Draw2DSegs(dc, lstSeg); // 按照无下弯头的上弯头绘制
			return Acad::eOk;
		}
		return Acad::eInvalidInput;
	}

	if (nVDuct1 > -1) // 6、连接了一根立管
	{
		int nHDuct1(-1), nHDuct2(-1), nTmp(5);
		::GetAnotherPipe(nVDuct1, nHDuct1, nHDuct2, nTmp); // 获取水平管编号

		XPoint pt1, pt2, pt3, pt4, pt5, pt6;
		double dAng1 = GetIAngle(nHDuct1),
			dAng2 = GetIAngle(nHDuct2);
		ads_polar(*pt0s[nHDuct1], dAng1+PI/2, GetIWidth(nHDuct1)/2, pt1);
		ads_polar(*pt0s[nHDuct1], dAng1-PI/2, GetIWidth(nHDuct1)/2, pt2);
		ads_polar(*pt0s[nHDuct2], dAng2+PI/2, GetIWidth(nHDuct2)/2, pt3);
		ads_polar(*pt0s[nHDuct2], dAng2-PI/2, GetIWidth(nHDuct2)/2, pt4);

		XVector3D vtOpen;
		double dUpDuctWidth(0);
		BOOL bHasLowElbow(FALSE);
		OPENOBJ_BEGIN(GetIPipe(nVDuct1), AcDb::kForRead, TDbDuct, pDuct);
		if (pDuct != NULL)
		{
			AcDbObjectId upNodeId = pDuct->GetVerUpNode(); // 立管上节点
			if (upNodeId != objectId())
			{
				bHasLowElbow = pDuct->IsUpPipesOk();
				if (bHasLowElbow)
				{
					pDuct->GetVerOpenDir(vtOpen);
					AcGeDoubleArray tmpWidths = pDuct->GetUpPipesWidth();
					dUpDuctWidth = tmpWidths[0];
				}
			}
		}
		OPENOBJ_END();
		
		if (bHasLowElbow && fabs(dAng1-dAng2)<(PI+1.0E-6)) // 有下弯头，且平行
		{
			AcGeVector3d vecOpen = vtOpen.AsAcGeVector3d(),
				vecHDuct1 = GetIDirection(nHDuct1).AsAcGeVector3d();
			double dAngle = vecHDuct1.angleTo(vecOpen, AcGeVector3d::kZAxis),
				dDist = (pt1.Distance(pt4)-dUpDuctWidth)*0.5;
			if (dAngle>(PI+1.0E-6) && dAngle<(2*PI-1.0E-6))
			{
				ads_polar(pt2, dAng1, -dDist, pt5);
				ads_polar(pt3, dAng2, -dDist, pt6);
				BuildSegs1(pt2, pt5, lstSeg);
				BuildSegs1(pt3, pt6, lstSeg);
				BuildSegs1(pt1, pt4, lstSeg);
			}
			else
			{
				ads_polar(pt1, dAng1, -dDist, pt5);
				ads_polar(pt4, dAng2, -dDist, pt6);
				BuildSegs1(pt2, pt3, lstSeg);
				BuildSegs1(pt1, pt5, lstSeg);
				BuildSegs1(pt6, pt4, lstSeg);
			}
		}
		else
		{
			BuildSegs1(pt1, pt4, lstSeg);
			BuildSegs1(pt2, pt3, lstSeg);
		}
		Draw2DSegs(dc, lstSeg); // 绘制
		return Acad::eOk;
	}

	XPointList lstMids;
	GetTrueMidPts(lstMids);
	AcDbIntArray branchs = GetBranchNums(m_nMain); // 7、获取支管编号和位置点偏移
	if (branchs.logicalLength()!=2 || lstMids.Length()!=3)
	{
		return Acad::eInvalidInput;
	}

	AcDbIntArray idxs(branchs);
	idxs.insertAt(0, m_nMain);

	XPointList ptLst;
	DList<XLine> lstLine;
	for (int j=0; j<idxs.logicalLength(); j++) // 8、计算其他需要的点和线
	{
		int nTmp = idxs[j];
		XLine line(LS_FINITE); // 注：线与点的角标是对应的
		line = XLine(*lstMids[nTmp], *pt0s[nTmp]).Offset(-GetIWidth(nTmp)/2);
		ptLst.Append(new XPoint(line.EndPoint()));
		lstLine.Append(new XLine(line));
		line = XLine(*lstMids[nTmp], *pt0s[nTmp]).Offset(GetIWidth(nTmp)/2);
		ptLst.Append(new XPoint(line.EndPoint()));
		lstLine.Append(new XLine(line));
	}
	if (lstLine.Length()!=6 || ptLst.Length()!=6)
	{
		return Acad::eInvalidInput;
	}
	
	BOOL bIsOk(TRUE);
	DList<XCurveSegment> flSegs;
	switch(nDrawMod) { // 9、根据连接管线的不同情况，绘制不同的样式
	case 0: // 普通三通
	case 1: // 直角三通
		bIsOk = DrawRandom3T(lstSeg, ptLst, lstLine, branchs[1]);
		break;
	case 2: // 圆角三通
		bIsOk = DrawCAngle3T(pt0s, lstSeg, ptLst, branchs[1]);
		break;
	case 3: // 承插三通
		bIsOk = DrawInsert3T(lstSeg, ptLst, lstLine, branchs[1]);
		break;
	case 4: // Y型三通
	case 5: // T型三通
		bIsOk = DrawY3T(pt0s, lstSeg, ptLst, branchs[1]);
		break;
	case 6: // 平行三通
		bIsOk = DrawParall3T(pt0s, lstSeg, ptLst, branchs[1]);
		break;
	case 7: // 圆管三通
	case 8:
		bIsOk = DrawCircle3T(lstSeg, ptLst, lstLine, branchs[1]);
		break;
	case 9: // 斜插三通
	case 10:
		bIsOk = DrawXieInsert3T(pt0s, lstSeg, ptLst, branchs[1], flSegs);
		break;
	case 11: // 叉型三通
		bIsOk = DrawAcross3T(pt0s, lstSeg, ptLst, branchs[1], flSegs);
		break;
	case 12: // 样式12三通
		bIsOk = Draw12Mod3T(pt0s, lstSeg, ptLst, branchs[1]);
		break;
	}

	if (!bIsOk)
	{
		return Acad::eInvalidInput;
	}
	Draw2DSegs(dc, lstSeg); // 10、绘制
	DrawFLSegs(dc, flSegs);
	return Acad::eOk;
}

// 绘制3D调节阀，注：目前只在样式0到2中可以绘制
BOOL TDbDuctNode::DrawValve(XPoint pt, int nB, DList<XCurveSegment> &segs) const
{
	if (!m_bValue)
	{
		return TRUE;
	}
	
	XPoint ptRet;
	double dAngMain = GetIAngle(m_nMain), // 主风方向
		dAngB = GetIAngle(nB);
	double dDist = GetIWidth(nB) * 0.7;
	ads_polar(pt, dAngMain, dDist, ptRet);
	ads_polar(ptRet, dAngB, -dDist, ptRet);
	BuildSegs1(pt, ptRet, segs);
	return TRUE;
}

// 普通三通、直角三通
BOOL TDbDuctNode::DrawRandom3T(DList<XCurveSegment> &segs, const XPointList &pts,
							   const DList<XLine> &llst, int nB2) const
{
	XPoint ptInt;
	if (!llst[5].Intersection(&llst[2], ptInt))
	{
		return FALSE;
	}
	BuildSegs2(pts[5], ptInt, pts[2], segs);

	int nB1(-1), nTmp1(nB2), nTmp2(5);
	::GetAnotherPipe(m_nMain, nTmp1, nB1, nTmp2);
	XVector3D vt1 = GetIDirection(m_nMain),
		vt2 = GetIDirection(nB2);
	if (::IsParallel(vt1, vt2) != 0) // 平行或相反
	{
		DrawValve(ptInt, nB1, segs);
		BuildSegs1(pts[1], pts[4], segs);
		if (m_nDrawMod == 0) // 普通三通
		{
			if (!llst[0].Intersection(&llst[3], ptInt))
			{
				return FALSE;
			}
			BuildSegs2(pts[0], ptInt, pts[3], segs);
			return TRUE;
		}
		return DrawLine(segs, llst[0], llst[3], 1);
	}

	XVector3D vt3 = GetIDirection(nB1);
	if (::IsParallel(vt1, vt3) != 0) // 平行或相反
	{
		DrawValve(ptInt, nB2, segs);
		BuildSegs1(pts[0], pts[3], segs);
		if (m_nDrawMod == 1) // 直角三通
		{
			return DrawLine(segs, llst[1], llst[4], 1);
		}
	}
	else // 都不平行，交于一点的情况，不绘制调节阀
	{
		if (m_nDrawMod == 1) // 直角三通
		{
			BuildSegs1(pts[1], pts[4], segs);
			return DrawLine(segs, llst[0], llst[3], 1);
		}
		llst[3].Intersection(&llst[0], ptInt);
		BuildSegs2(pts[0], ptInt, pts[3], segs);
	}
	
	if (!llst[1].Intersection(&llst[4], ptInt))
	{
		return FALSE;
	}
	BuildSegs2(pts[1], ptInt, pts[4], segs);
	return TRUE;
}

// 圆角三通
BOOL TDbDuctNode::DrawCAngle3T(const XPointList &pts, DList<XCurveSegment> &segs,
							   const XPointList &ptLst, int nB2) const
{
	int nB1(-1), n(5);
	::GetAnotherPipe(m_nMain, nB2, nB1, n);
	XVector3D vt1 = GetIDirection(m_nMain),
		vt2 = GetIDirection(nB2);
	int nTmp = (::IsParallel(vt1, vt2)!=0)?nB1:nB2; // 与主管不平行管线
	n = (nTmp==nB1)?0:1; // 选择nums中的第几组
	int nB = (n==0)?nB2:nB1; // 与主管平行
	double dTmp = (n==0)?(-PI/2):(PI/2);
	
	int nums[2][6] = {{1, 4, 0, 3, 2, 5}, {0, 3, 1, 4, 5, 2}}; // 统一代码使用
	BuildSegs1(ptLst[nums[n][0]], ptLst[nums[n][1]], segs);
	if (!DrawArc(segs, pts[m_nMain], pts[nTmp], ptLst[nums[n][2]], ptLst[nums[n][3]]))
	{
		return FALSE;
	}

	XPoint ptCen, ptInt1, ptInt2, ptTmp, ptNear;
	XLine line1(ptLst[nums[n][0]], ptLst[nums[n][2]], LS_INFINITE),
		line2(ptLst[nums[n][4]], ptLst[nums[n][3]], LS_INFINITE);
	if (!line1.Intersection(&line2, ptCen))
	{
		return FALSE;
	}

	BOOL bSwitch(FALSE);
	double dAngMain = GetIAngle(m_nMain); // 管线法向
	double dRadius = ptLst[nums[n][4]].Distance(ptCen),
		dDist = ptLst[nums[n][2]].Distance(ptLst[nums[n][5]]);
	ads_polar(ptCen, dAngMain+dTmp, dRadius, ptTmp);
	XArc arc = ::GetRightArc(ptTmp, ptCen, ptLst[nums[n][4]], bSwitch); // 选择优弧
	
	ads_polar(ptLst[nums[n][5]], GetIAngle(nB), -dDist, ptTmp);
	XLine lineTmp(ptTmp, ptLst[nums[n][5]], LS_FINITE);
	if (!arc.Intersection(&lineTmp, ptInt1, ptInt2))
	{
		ads_polar(ptLst[nums[n][4]], GetIAngle(nTmp), -dDist, ptTmp);
		XLine lineTmp(ptLst[nums[n][4]], ptTmp);
		if (!lineTmp.Intersection(&lineTmp, ptNear))
		{
			return FALSE;
		}
		ads_polar(ptNear, GetIAngle(nB), -100, ptNear);
		BuildSegs1(ptNear, ptLst[nums[n][4]], segs);
	}
	else
	{
		ptNear = ::GetNearPt(ptLst[nums[n][5]], ptInt1, ptInt2);
		if (bSwitch)
		{
			arc.SetAngleByPoints(ptNear, ptLst[nums[n][4]]);
		}
		else
		{
			arc.SetAngleByPoints(ptLst[nums[n][4]], ptNear);
		}
		BuildSegs4(arc, segs);
	}
	BuildSegs1(ptNear, ptLst[nums[n][5]], segs);
	DrawValve(ptNear, nTmp, segs);
	return TRUE;
}

// 承插三通
BOOL TDbDuctNode::DrawInsert3T(DList<XCurveSegment> &segs, const XPointList &pts,
							   const DList<XLine> &llst, int nB2) const
{
	int nB1(-1), n(5);
	::GetAnotherPipe(m_nMain, nB2, nB1, n);
	XVector3D vt1 = GetIDirection(m_nMain),
		vt2 = GetIDirection(nB2);
	int nTmp = (::IsParallel(vt1, vt2)!=0)?nB1:nB2;
	n = (nTmp==nB1)?0:1;
	
	int nums[2][6] = {{1, 4, 0, 3, 5, 2}, {0, 3, 1, 4, 2, 5}}; // 统一代码使用
	BuildSegs1(pts[nums[n][0]], pts[nums[n][1]], segs);
	if (!DrawLine(segs, llst[nums[n][2]], llst[nums[n][3]], 1))
	{
		return FALSE;
	}
	
	XPoint ptInt1, ptInt2;
	ads_polar(pts[nums[n][2]], GetIAngle(m_nMain), -50, ptInt1);
	BuildSegs1(ptInt1, pts[nums[n][4]], segs);
	XLine line(ptInt1, pts[nums[n][4]], LS_INFINITE);
	if (!llst[nums[n][5]].Intersection(&line, ptInt2))
	{
		return FALSE;
	}
	BuildSegs1(pts[nums[n][5]], ptInt2, segs);
	return TRUE;
}

// 获取Y型、15样式三通中，顶点位置
XPoint TDbDuctNode::GetYTopPt(XPoint ptOld) const
{
	XPointList pt0s;
	GetPtsIFace(pt0s, FALSE, FALSE, FALSE, TRUE);
	if (pt0s.Length() != 3)
	{
		return XPoint();
	}
	
	int nNum1(-1), nNum2(-1), nTmp(5);
	XPoint ptTmp1, ptTmp2, ptTmp3, ptInt1, ptInt2;
	::GetAnotherPipe(m_nMain, nNum1, nNum2, nTmp);
	ads_polar(ptOld, GetIAngle(m_nMain), -1000, ptTmp1);
	ads_polar(*pt0s[nNum1], GetIAngle(nNum1), -1000, ptTmp2);
	ads_polar(*pt0s[nNum2], GetIAngle(nNum2), -1000, ptTmp3);
	XLine l1(ptOld, ptTmp1, LS_INFINITE),
		l2(*pt0s[nNum1], ptTmp2, LS_INFINITE),
		l3(*pt0s[nNum2], ptTmp3, LS_INFINITE);
	if (!l1.Intersection(&l2, ptInt1) || !l1.Intersection(&l3, ptInt2))
	{
		return XPoint();
	}
	
	ads_polar(ptInt1, GetIAngle(m_nMain), -0.25*GetIWidth(nNum1), ptInt1);
	ads_polar(ptInt2, GetIAngle(m_nMain), -0.25*GetIWidth(nNum2), ptInt2);
	ptTmp1 = ::GetNearPt(ptOld, ptInt1, ptInt2);
	return ptTmp1;
}

 // Y型、T型三通
BOOL TDbDuctNode::DrawY3T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
						  const XPointList &ptLst, int nB2) const
{
	int nB1(-1), n(5);
	::GetAnotherPipe(m_nMain, nB2, nB1, n);
	if (!DrawArc(lstSeg, pts[m_nMain], pts[nB1], ptLst[0], ptLst[3]))
	{
		return FALSE; // 绘制两小圆弧
	}
	if (!DrawArc(lstSeg, pts[m_nMain], pts[nB2], ptLst[1], ptLst[4]))
	{
		return FALSE;
	}

	if (m_nDrawMod == 5) // T型三通
	{
		BuildSegs1(ptLst[5], ptLst[2], lstSeg);
		return TRUE;
	}

	XPoint ptOffset; // 偏移后，主风管中线位置
	double dAngMain = GetIAngle(m_nMain), // 主风管法向
		dWidthM = GetIWidth(m_nMain), // 管线宽度
		dWidth1 = GetIWidth(nB1),
		dWidth2 = GetIWidth(nB2);
	double dScale = dWidth2/(dWidth1+dWidth2); // 注：按支管管径比例偏移主风管中线
	ads_polar(ptLst[1], dAngMain+PI/2, dWidthM*dScale, ptOffset);
	XPoint ptYInt = GetYTopPt(ptOffset); // Y型中，两大弧交点

	XPoint ptMid1, ptMid2, ptCen1, ptCen2, ptTmp;
	Midpoint(ptYInt, ptLst[5], ptMid1); // 中点
	Midpoint(ptYInt, ptLst[2], ptMid2);
	
	XVector3D vtTmp = ptLst[5] - ptYInt;
	double dAngle = ads_angle(XPoint(), vtTmp);
	ads_polar(ptMid1, dAngle+PI/2, dWidth1, ptTmp);
	XLine line1(ptTmp, ptMid1, LS_INFINITE),
		line2(ptLst[5], ptLst[4], LS_INFINITE);
	if (!line1.Intersection(&line2, ptCen1))
	{
		return FALSE;
	}
	
	vtTmp = ptLst[2] - ptYInt;
	dAngle = ads_angle(XPoint(), vtTmp);
	ads_polar(ptMid2, dAngle-PI/2, dWidth2, ptTmp);
	line1.SetPoints(ptTmp, ptMid2);
	line2.SetPoints(ptLst[2], ptLst[3]);
	if (!line1.Intersection(&line2, ptCen2))
	{
		return FALSE;
	}
	
	BOOL bSwitch(TRUE);
	XArc arc = ::GetRightArc(ptLst[5], ptCen1, ptYInt, bSwitch);
	BuildSegs4(arc, lstSeg);
	arc = ::GetRightArc(ptLst[2], ptCen2, ptYInt, bSwitch);
	BuildSegs4(arc, lstSeg);
	return TRUE;
}

// 第12种样式三通
BOOL TDbDuctNode::Draw12Mod3T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
							  const XPointList &ptLst, int nB2) const
{
	int nB1(-1), nTmp(5);
	::GetAnotherPipe(m_nMain, nB2, nB1, nTmp);

	XPointList newPts;
	for (int i=0; i<6; i++)
	{
		nTmp = (i<2)?m_nMain:nB1;
		nTmp = (i<4)?nTmp:nB2;
		XPoint ptTmp;
		ads_polar(ptLst[i], GetIAngle(nTmp), -100, ptTmp);
		BuildSegs1(ptLst[i], ptTmp, lstSeg);
		newPts.Append(new XPoint(ptTmp));
	}
	if (newPts.Length() != 6)
	{
		return FALSE;
	}

	XPoint ptYInt = GetYTopPt(pts[m_nMain]); // Y型顶点
	BuildSegs6(*newPts[2], *newPts[3], *newPts[0], *newPts[1], lstSeg);
	BuildSegs2(*newPts[1], *newPts[4], *newPts[5], lstSeg);
	BuildSegs2(*newPts[2], ptYInt, *newPts[5], lstSeg);
	return TRUE;
}

// 圆管三通
BOOL TDbDuctNode::DrawCircle3T(DList<XCurveSegment> &lstSeg, const XPointList &ptLst,
							   const DList<XLine> &llst, int nB2) const
{
	int nP1(0), nP2(0);
	BOOL bParal(FALSE); // 不含有平行管线
	for (int i=0; i<3&&!bParal; i++)
	{
		for (int j=i+1; j<3; j++)
		{
			if (::IsParallel(GetIDirection(i), GetIDirection(j)) != 0)
			{
				nP1 = i;
				nP2 = j;
				bParal = TRUE; // 平行
				break;
			}
		}
	}

	nP1 = bParal?nP1:m_nMain;
	nP2 = bParal?nP2:nB2;
	int nOther(-1), nTmp(5); // 找到不平行管线
	::GetAnotherPipe(nP1, nP2, nOther, nTmp);

	XPoint ptInt1, ptInt2, ptMid;
	if (nOther == m_nMain) // 圆管Y型
	{
		XLine l(ptLst[4], ptLst[3], LS_FINITE);
		if (!llst[1].Intersection(&l, ptInt1) || !llst[0].Intersection(&l, ptInt2))
		{
			return FALSE;
		}
		BuildSegs1(ptLst[5], ptLst[2], lstSeg);
		BuildSegs2(ptLst[1], ptInt1, ptLst[4], lstSeg);
		BuildSegs2(ptLst[0], ptInt2, ptLst[3], lstSeg);
	}
	else // 圆管普通型
	{
		if (nOther == nB2)
		{
			XLine l(ptLst[2], ptLst[1], LS_FINITE);
			if (!llst[5].Intersection(&l, ptInt1) || !llst[4].Intersection(&l, ptInt2))
			{
				return FALSE;
			}
			BuildSegs1(ptLst[3], ptLst[0], lstSeg);
			BuildSegs2(ptLst[2], ptInt1, ptLst[5], lstSeg);
			BuildSegs2(ptLst[1], ptInt2, ptLst[4], lstSeg);
		}
		else // 包含不含有平行管线的情况
		{
			XLine l(ptLst[0], ptLst[5], LS_FINITE);
			if (!llst[3].Intersection(&l, ptInt1) || !llst[2].Intersection(&l, ptInt2))
			{
				return FALSE;
			}
			BuildSegs1(ptLst[1], ptLst[4], lstSeg);
			BuildSegs2(ptLst[3], ptInt1, ptLst[0], lstSeg);
			BuildSegs2(ptLst[2], ptInt2, ptLst[5], lstSeg);
		}
	}

	if (m_nDrawMod == 8) // 相等的情况，样式8
	{
		XPoint ptLoc = GetZeroPt();
		BuildSegs2(ptInt2, ptLoc, ptInt1, lstSeg);
		return TRUE;
	}

	double dMin = min(GetIWidth(nP1), GetIWidth(nP2)) * 0.125, // 管径较小的
		dAngle = ads_angle(XPoint(), XVector3D(ptInt1-ptInt2));
	Midpoint(ptInt1, ptInt2, ptMid);
	ads_polar(ptMid, dAngle-PI/2, dMin, ptMid); // 弧中点
	
	XArc arc(ptInt1, ptMid, ptInt2); // 相贯线
	BuildSegs4(arc, lstSeg);
	return TRUE;
}

// 平行三通
BOOL TDbDuctNode::DrawParall3T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
							   const XPointList &ptLst, int nB2) const
{
	int nB1(-1), nTmp(5); // 找到支管标号
	::GetAnotherPipe(m_nMain, nB2, nB1, nTmp);
	BuildSegs1(ptLst[0], ptLst[3], lstSeg);
	BuildSegs1(ptLst[1], ptLst[4], lstSeg);

	XPoint ptTmp;
	ads_polar(pts[m_nMain], GetIAngle(m_nMain)+PI/2, 1000, ptTmp);
	XCurveSegment seg(pts[m_nMain], ptTmp, 0, LS_FINITE);
	seg.ProjectToMe(pts[nB1], ptTmp);
	double dDist = pts[nB1].Distance(ptTmp) * 0.35;
	ads_polar(pts[m_nMain], GetIAngle(m_nMain), -dDist, ptTmp);
	BuildSegs2(ptLst[2], ptTmp, ptLst[5], lstSeg);
	return TRUE;
}

// 斜插三通
BOOL TDbDuctNode::DrawXieInsert3T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
								  const XPointList &ptLst, int nB2,
								  DList<XCurveSegment> &flSegs) const
{
	int nB1(-1), nTmp(5), m(5), n(0), nOther(0); // 找到支管标号
	::GetAnotherPipe(m_nMain, nB2, nB1, nTmp);
	nTmp = ::IsParallel(GetIDirection(m_nMain), GetIDirection(nB1))?nB2:nB1;
	nOther = (nTmp==nB1)?nB2:nB1; // nOther与主管平行
	m = (nTmp==nB1)?2:5; // nTmp为不平行管线，统一角标
	n = (nTmp==nB1)?3:4;

	double dRate(m_dDrawParam), dTmpAng(0); // 曲率半径
	XPoint ptNew1 = GetArcPts(ptLst[m], GetIWidth(nTmp)*(dRate+0.5)/dRate,
		GetIAngle(nTmp), pts[m_nMain], lstSeg, dTmpAng); // 大弧，绘制
	XPoint ptNew2 = GetArcPts(ptLst[n], GetIWidth(nTmp)*(dRate-0.5)/dRate,
		GetIAngle(nTmp), pts[m_nMain], lstSeg, dTmpAng); // 小弧，绘制

	XPoint ptTmp1(ptNew1), ptTmp2(ptNew2);
	::GetNewPts(ptTmp1, ptTmp2, GetIFlDist(nTmp));
	BuildSegs1(ptTmp1, ptTmp2, flSegs); // 法兰绘制

	DList<XCurveSegment> segs;
	XPoint ptInt1(pts[m_nMain]), ptInt2(pts[nOther]), ptMid,
		ptLoc = GetZeroPt();
	XCurveSegment segTmp(ptInt1, ptInt2, 0, LS_FINITE);
	segTmp.ProjectToMe(ptLoc, ptMid);
	BOOL bFlag = (ptMid&segTmp)==PR_INSIDE;

	XPoint ptNew = GetArcPts(pts[nTmp], GetIWidth(nTmp), GetIAngle(nTmp),
		ptInt1, segs, dTmpAng); // 中心线，不绘制
	XLine mirrorLine(ptInt1, ptNew, LS_INFINITE);
	if (nOther == nB2) // 主管与支2平行
	{
		m = bFlag?5:4; // 和0对应
		n = bFlag?4:5; // 和1对应
		BuildSegs1(ptLst[1], ptLst[n], lstSeg);
		XLine l(ptLst[0], ptLst[m], LS_INFINITE);
		if (m_nDrawMod == 10)
		{
			BuildSegs1(ptLst[0], ptNew2, lstSeg);
			XLine line(ptLst[0], ptNew2, LS_INFINITE);
			XLine retL = ::GetMirrorLine(line, mirrorLine);
			if (!retL.Intersection(&l, ptInt1))
			{
				return FALSE;
			}
			BuildSegs2(pts[m_nMain], ptInt1, ptLst[m], lstSeg);
			BuildSegs1(ptInt1, ptNew1, lstSeg);
			return TRUE;
		}

		ads_polar(ptNew, dTmpAng, 5*GetIWidth(m_nMain), ptInt1);
		mirrorLine.SetPoints(ptInt1, ptNew);
		XLine line1 = mirrorLine.Offset(-GetIWidth(nB1)*0.5),
			line2 = mirrorLine.Offset(GetIWidth(nB1)*0.5);
		if (!l.Intersection(&line1, ptInt2) || !l.Intersection(&line2, ptInt1))
		{
			return FALSE;
		}
		BuildSegs2(ptLst[0], ptInt1, ptNew2, lstSeg);
		BuildSegs2(ptLst[m], ptInt2, ptNew1, lstSeg);
	}
	else // 主管与支1平行
	{
		m = bFlag?3:2; // 和0对应
		n = bFlag?2:3; // 和1对应
		BuildSegs1(ptLst[0], ptLst[m], lstSeg);
		XLine l(ptLst[n], ptLst[1], LS_INFINITE);
		if (m_nDrawMod == 10)
		{
			BuildSegs1(ptLst[1], ptNew2, lstSeg);
			XLine line(ptLst[1], ptNew2, LS_INFINITE);
			XLine retL = ::GetMirrorLine(line, mirrorLine);
			if (!retL.Intersection(&l, ptInt1))
			{
				return FALSE;
			}
			BuildSegs2(pts[m_nMain], ptInt1, ptLst[n], lstSeg);
			BuildSegs1(ptInt1, ptNew1, lstSeg);
			return TRUE;
		}
		
		ads_polar(ptNew, dTmpAng, 5*GetIWidth(m_nMain), ptInt1);
		mirrorLine.SetPoints(ptInt1, ptNew);
		XLine line1 = mirrorLine.Offset(-GetIWidth(nB1)*0.5),
			line2 = mirrorLine.Offset(GetIWidth(nB1)*0.5);
		if (!l.Intersection(&line1, ptInt2) || !l.Intersection(&line2, ptInt1))
		{
			return FALSE;
		}
		BuildSegs2(ptLst[1], ptInt2, ptNew2, lstSeg);
		BuildSegs2(ptLst[n], ptInt1, ptNew1, lstSeg);
	}
	
	m = (nTmp==nB1)?nB2:nB1;
	double dMin = GetIWidth(m) * 0.125, // 管径较小的
		dAngle = ads_angle(XPoint(), XVector3D(ptInt1-ptInt2));
	Midpoint(ptInt1, ptInt2, ptLoc);
	ads_polar(ptLoc, dAngle-PI/2, dMin, ptLoc); // 弧中点
	
	XArc arc(ptInt1, ptLoc, ptInt2); // 相贯线
	BuildSegs4(arc, lstSeg);
	return TRUE;
}

// 叉型三通
BOOL TDbDuctNode::DrawAcross3T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
							   const XPointList &ptLst, int nB2,
							   DList<XCurveSegment> &flSegs) const
{
	int nB1(-1), nTmp(5); // 找到支管标号
	::GetAnotherPipe(m_nMain, nB2, nB1, nTmp);

	double dScale1 = (m_dDrawParam-0.5)/m_dDrawParam,
		dScale2 = (m_dDrawParam+0.5)/m_dDrawParam, dTmpAng(0);
	XPoint pt2 = GetArcPts(ptLst[2], GetIWidth(nB1)*dScale2, GetIAngle(nB1),
		pts[m_nMain], lstSeg, dTmpAng); // 大弧
	XPoint pt3 = GetArcPts(ptLst[3], GetIWidth(nB1)*dScale1, GetIAngle(nB1),
		pts[m_nMain], lstSeg, dTmpAng); // 小弧
	XPoint pt5 = GetArcPts(ptLst[5], GetIWidth(nB2)*dScale2, GetIAngle(nB2),
		pts[m_nMain], lstSeg, dTmpAng); // 大弧
	XPoint pt4 = GetArcPts(ptLst[4], GetIWidth(nB2)*dScale1, GetIAngle(nB2),
		pts[m_nMain], lstSeg, dTmpAng);	// 小弧
	BuildSegs1(pt3, ptLst[0], lstSeg);
	BuildSegs1(pt4, ptLst[1], lstSeg);

	DList<XCurveSegment> segs; // 不绘制
	XPoint ptMid1 = GetArcPts(pts[nB1], GetIWidth(nB1), GetIAngle(nB1),
		pts[m_nMain], segs, dTmpAng);
	XPoint ptMid2 = GetArcPts(pts[nB2], GetIWidth(nB2), GetIAngle(nB2),
		pts[m_nMain], segs, dTmpAng);
	
	XLine line(pt3, ptLst[0], LS_INFINITE),
		mirrorLine(pts[m_nMain], ptMid1, LS_INFINITE);
	XLine retL1 = ::GetMirrorLine(line, mirrorLine); // 获取镜像后的线

	line.SetPoints(pt4, ptLst[1]);
	mirrorLine.SetPoints(pts[m_nMain], ptMid2);
	XLine retL2 = ::GetMirrorLine(line, mirrorLine);

	ads_polar(pts[m_nMain], GetIAngle(m_nMain), 1000, ptMid1);
	line.SetPoints(pts[m_nMain], ptMid1);
	if (!line.Intersection(&retL1, ptMid1) || !line.Intersection(&retL2, ptMid2))
	{
		return FALSE;
	}
	BuildSegs1(pt2, ptMid1, lstSeg);
	BuildSegs1(pt5, ptMid2, lstSeg);
	ptMid1 = ::GetFarPt(pts[m_nMain], ptMid1, ptMid2);
	BuildSegs1(ptMid1, pts[m_nMain], lstSeg);

	GetNewPts(pt2, pt3, GetIFlDist(nB1));
	GetNewPts(pt5, pt4, GetIFlDist(nB2));
	BuildSegs1(pt2, pt3, flSegs); // 用来画法兰
	BuildSegs1(pt4, pt5, flSegs);
	return TRUE;
}


////////////////////////////四通////////////////////////////
Acad::ErrorStatus TDbDuctNode::Draw4Corner2D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 4) // 1、保证所有的链表不越界
	{
		return Acad::eInvalidInput;
	}

	XPointList pts;
	GetPtsIFace(pts, FALSE, FALSE, FALSE, TRUE); // 2、法兰遮挡后的管线连接点
	if (pts.Length() != 4)
	{
		return Acad::eInvalidInput;
	}
	
	XPointList midPts;
	GetTrueMidPts(midPts); // 3、获取支管编号和中心点偏移
	AcDbIntArray aryBs = GetBranchNums(m_nMain);
	if (aryBs.logicalLength()!=3 || midPts.Length()!=4)
	{
		return Acad::eInvalidInput;
	}

	if (m_nSysDrawMod != 3) // 4、除双线外，绘制中心线
	{
		XPoint ptLoc = GetZeroPt(); // 修正Z坐标为0
		DList<XCurveSegment> midSegs;
		switch(m_nDrawMod)
		{
		case 6: // 圆管四通，不带弯头
			{
				AcGeVector3d vtMain = GetIDirection(m_nMain).AsAcGeVector3d(),
					vtB1 = GetIDirection(aryBs[0]).AsAcGeVector3d(),
					vtB3 = GetIDirection(aryBs[2]).AsAcGeVector3d();
				if (vtMain.isPerpendicularTo(vtB1)==Adesk::kTrue || // 主管与支1垂直
					vtMain.isPerpendicularTo(vtB3)==Adesk::kTrue || // 主管与支3垂直
					vtB1.isParallelTo(vtB3)==Adesk::kTrue)          // 支1与支3平行
				{
					for (int i=0; i<4; i++)
					{
						BuildSegs1(ptLoc, *pts[i], midSegs);
					}
				}
				else // 不垂直，且两支管不平行
				{
					BuildSegs1(*pts[m_nMain], *pts[aryBs[1]], midSegs);
					BuildSegs2(*pts[aryBs[0]], *pts[m_nMain], *pts[aryBs[2]], midSegs);
				}
			}
			break;
		case 7: // 圆管四通，带弯头
			{
				double dTmpAng(0);
				XPoint ptNew1 = GetArcPts(*pts[aryBs[0]], GetIWidth(aryBs[0]),
					GetIAngle(aryBs[0]), *pts[m_nMain], midSegs, dTmpAng);
				XPoint ptNew2 = GetArcPts(*pts[aryBs[2]], GetIWidth(aryBs[2]),
					GetIAngle(aryBs[2]), *pts[m_nMain], midSegs, dTmpAng);
				BuildSegs1(*pts[m_nMain], *pts[aryBs[1]], midSegs);
				BuildSegs2(ptNew1, *pts[m_nMain], ptNew2, midSegs);
			}
			break;
		default: // 方管四通
			for (int i=0; i<4; i++)
			{
				BuildSegs1(ptLoc, *pts[i], midSegs);
			}
			break;
		}
		
		if (m_nSysDrawMod == 1)
		{
			DrawXiSegs(dc, midSegs); // 单线图，细线绘制
			return Acad::eOk;
		}
		DrawMidSegs(dc, midSegs); // 三线图，切换中心线图层、线型绘制
	}
	
	AcDbIntArray idxs(aryBs);
	idxs.insertAt(0, m_nMain);

	XPointList ptLst; // 5、计算其他需要的点和线
	DList<XLine> lstLine;
	for (int j=0; j<idxs.logicalLength(); j++)
	{
		int nTmp = idxs[j];
		XLine line(LS_FINITE); // 注：线与点的角标是对应的
		line = XLine(*midPts[nTmp], *pts[nTmp]).Offset(-GetIWidth(nTmp)/2);
		ptLst.Append(new XPoint(line.EndPoint()));
		lstLine.Append(new XLine(line));
		line = XLine(*midPts[nTmp], *pts[nTmp]).Offset(GetIWidth(nTmp)/2);
		ptLst.Append(new XPoint(line.EndPoint()));
		lstLine.Append(new XLine(line));
	}
	if (lstLine.Length()!=8 || ptLst.Length()!=8)
	{
		return Acad::eInvalidInput;
	}
		
	BOOL bIsOk(TRUE);
	DList<XCurveSegment> lstSeg; // 6、绘制四通其他线
	DList<XCurveSegment> flSegs;
	switch(m_nDrawMod) {
	case 0: // 圆角四通
		bIsOk = DrawRound4T(pts, lstSeg, ptLst, lstLine, aryBs[0], aryBs[2]);
		break;
	case 1: // 直角四通
	case 3: // 交叉四通
	case 5:
		bIsOk = DrawCAngle4T(lstSeg, ptLst, lstLine, aryBs[0], aryBs[2]);
		break;
	case 2: // 承插四通
		bIsOk = DrawInsert4T(lstSeg, ptLst, lstLine, aryBs[0], aryBs[2]);
		break;
	case 4: // 通用四通
		bIsOk = DrawRandom4T(lstSeg, ptLst, lstLine);
		break;
	case 6: // 圆管四通
	case 7:
		bIsOk = DrawCircle4T(pts, lstSeg, ptLst, aryBs[0], aryBs[2], flSegs);
		break;
	}
	
	if (!bIsOk)
	{
		return Acad::eInvalidInput;
	}
	Draw2DSegs(dc, lstSeg); // 7、绘制
	DrawFLSegs(dc, flSegs);
	return Acad::eOk;
}

// 圆角四通
BOOL TDbDuctNode::DrawRound4T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
							  const XPointList &ptLst, const DList<XLine> &llst,
							  int nB1, int nB3) const
{
	BOOL bOk1 = DrawArc(lstSeg, pts[m_nMain], pts[nB1], ptLst[0], ptLst[3]),
		bOk2 = DrawArc(lstSeg, pts[m_nMain], pts[nB3], ptLst[1], ptLst[6]);
	if (!(bOk1 && bOk2)) // 绘制内弧
	{
		return FALSE;
	}
	
	double dAng1 = GetIAngle(m_nMain), // 法向
		dAng2 = GetIAngle(nB1),
		dAng3 = GetIAngle(nB3);
	XPoint ptArc1, ptArc2, ptArc3, ptArc4, ptCen1, ptCen2, ptInt, ptTmp;
	ads_polar(ptLst[2], dAng2, -50, ptArc1);
	ads_polar(ptLst[7], dAng3, -50, ptArc2);
	BuildSegs1(ptArc1, ptLst[2], lstSeg);
	BuildSegs1(ptArc2, ptLst[7], lstSeg);

	double dRadius1 = GetIWidth(nB1) * (2*m_dDrawParam+1) * 0.5, // 外弧半径
		dRadius2 = GetIWidth(nB3) * (2*m_dDrawParam+1) * 0.5;
	ads_polar(ptArc1, dAng2-PI/2, dRadius1, ptCen1); // 外弧圆心
	ads_polar(ptArc2, dAng3+PI/2, dRadius2, ptCen2);
	ads_polar(ptCen1, dAng1-PI/2, dRadius1, ptArc3);
	ads_polar(ptCen2, dAng1+PI/2, dRadius2, ptArc4);
	
	XLine line1 = llst[5],
		line2 = llst[4];
	XPoint ptRes1 = line1.NearPoint(ptLst[0]), // 相当于投影
		ptRes2 = line2.NearPoint(ptLst[1]);
	line1.SetPoints(ptLst[5], ptRes1);
	line2.SetPoints(ptLst[4], ptRes2);

	int nB2(-1);
	::GetAnotherPipe(m_nMain, nB1, nB3, nB2);

	BOOL bSwitch(FALSE);
	XArc arc = ::GetRightArc(ptArc1, ptCen1, ptArc3, bSwitch); // 选择优弧
	if (arc.Intersection(&line1, ptInt, ptTmp))
	{
		BuildSegs1(ptInt, ptLst[5], lstSeg);
		if (bSwitch)
		{
			TchPrivate::Exchange(ptInt, ptArc1);
		}
		arc.SetAngleByPoints(ptInt, ptArc1);
		BuildSegs4(arc, lstSeg);
	}
	else
	{
		if (!DrawArc(lstSeg, pts[nB2], pts[nB1], ptLst[5], ptLst[2], FALSE))
		{
			return FALSE;
		}
	}
	
	arc = ::GetRightArc(ptArc2, ptCen2, ptArc4, bSwitch); // 选择优弧
	if (arc.Intersection(&line2, ptInt, ptTmp))
	{
		BuildSegs1(ptInt, ptLst[4], lstSeg);
		if (bSwitch)
		{
			TchPrivate::Exchange(ptArc2, ptInt);
		}
		arc.SetAngleByPoints(ptInt, ptArc2);
		BuildSegs4(arc, lstSeg);
	}
	else
	{
		if (!DrawArc(lstSeg, pts[nB2], pts[nB3], ptLst[4], ptLst[7], FALSE))
		{
			return FALSE;
		}
	}
	return TRUE;
}

// 直角、交叉四通
BOOL TDbDuctNode::DrawCAngle4T(DList<XCurveSegment> &lstSeg, const XPointList &ptLst,
							   const DList<XLine> &llst, int nB1, int nB3) const
{
	BOOL bOk1 = DrawLine(lstSeg, llst[0], llst[3], 1),
		bOk2 = DrawLine(lstSeg, llst[1], llst[6], 1);
	if (!(bOk1 && bOk2))
	{
		return FALSE;
	}
	if (m_nDrawMod == 3) // 交叉四通
	{
		int nB2(-1);
		::GetAnotherPipe(m_nMain, nB1, nB3, nB2);
		bOk1 = DrawLine(lstSeg, llst[5], llst[2], 1);
		bOk2 = DrawLine(lstSeg, llst[4], llst[7], 1);
		return (bOk1 && bOk2);
	}

	XPoint ptInt1, ptInt2;
	if (!llst[2].Intersection(&llst[5], ptInt1) || !llst[4].Intersection(&llst[7], ptInt2))
	{
		return FALSE;
	}
	if (m_nDrawMod == 5)
	{
		BuildSegs2(ptLst[2], ptInt1, ptLst[5], lstSeg);
		BuildSegs2(ptLst[4], ptInt2, ptLst[7], lstSeg);
		return TRUE;
	}

	XPoint pt1, pt2, pt3, pt4;
	ads_polar(ptLst[2], GetIAngle(nB1), -50, pt1);
	ads_polar(ptInt1, GetIAngle(m_nMain), 50, pt2);
	ads_polar(ptLst[7], GetIAngle(nB3), -50, pt3);
	ads_polar(ptInt2, GetIAngle(m_nMain), 50, pt4);
	BuildSegs6(ptLst[2], pt1, pt2, ptLst[5], lstSeg);
	BuildSegs6(ptLst[7], pt3, pt4, ptLst[4], lstSeg);
	return TRUE;
}

// 承插四通
BOOL TDbDuctNode::DrawInsert4T(DList<XCurveSegment> &lstSeg, const XPointList &ptLst,
							   const DList<XLine> &llst, int nB1, int nB3) const
{
	BOOL bOk1 = DrawLine(lstSeg, llst[0], llst[3], 1),
		bOk2 = DrawLine(lstSeg, llst[1], llst[6], 1);
	if (!(bOk1 && bOk2))
	{
		return FALSE;
	}
	
	int nB2(-1);
	::GetAnotherPipe(m_nMain, nB1, nB3, nB2);
	XPoint ptInt1, ptInt2, pt1, pt2, pt3, pt4;
	ads_polar(ptLst[0], GetIAngle(m_nMain), -50, pt1);
	ads_polar(ptLst[1], GetIAngle(m_nMain), -50, pt2);
	ads_polar(ptLst[5], GetIAngle(nB2), -50, pt3);
	ads_polar(ptLst[4], GetIAngle(nB2), -50, pt4);

	XLine l1(pt1, pt3, LS_FINITE),
		l2(pt2, pt4, LS_FINITE);
	if (!l1.Intersection(&llst[2], ptInt1) || !l2.Intersection(&llst[7], ptInt2))
	{
		return FALSE;
	}
	BuildSegs2(ptLst[5], pt3, pt1, lstSeg);
	BuildSegs1(ptInt1, ptLst[2], lstSeg);
	BuildSegs2(ptLst[4], pt4, pt2, lstSeg);
	BuildSegs1(ptInt2, ptLst[7], lstSeg);
	return TRUE;
}

// 通用四通
BOOL TDbDuctNode::DrawRandom4T(DList<XCurveSegment> &lstSeg, const XPointList &ptLst,
							   const DList<XLine> &llst) const
{
	XPoint p1, p2, p3, p4;
	if (!llst[0].Intersection(&llst[3], p1) || !llst[2].Intersection(&llst[5], p2) ||
		!llst[4].Intersection(&llst[7], p3) || !llst[6].Intersection(&llst[1], p4))
	{
		return FALSE;
	}
	BuildSegs2(ptLst[0], p1, ptLst[3], lstSeg);
	BuildSegs2(ptLst[2], p2, ptLst[5], lstSeg);
	BuildSegs2(ptLst[4], p3, ptLst[7], lstSeg);
	BuildSegs2(ptLst[6], p4, ptLst[1], lstSeg);
	return TRUE;
}

// 圆管四通
BOOL TDbDuctNode::DrawCircle4T(const XPointList &pts, DList<XCurveSegment> &lstSeg,
							   const XPointList &ptLst, int nB1, int nB3,
							   DList<XCurveSegment> &flSegs) const
{
	int nB2(-1);
	::GetAnotherPipe(m_nMain, nB1, nB3, nB2); // 获取支管2的标号

	BOOL bFlag(TRUE); // 标志位置点是否在连接件内部
	double dWide1 = GetIWidth(nB1),	dWide2 = GetIWidth(nB3),
		dAng1 = GetIAngle(nB1),	dAng3 = GetIAngle(nB3);
	XPoint ptLoc = pts[m_nMain],        // 中心点修正
		ptB1(pts[nB1]), ptB3(pts[nB3]); // 连接点
	XPoint p2(ptLst[2]), p3(ptLst[3]), p6(ptLst[6]), p7(ptLst[7]);
	if (m_nDrawMod == 7) // 绘制弯头
	{
		double d1 = (m_dDrawParam-0.5)/m_dDrawParam, // 小弧修正
			d2 = (m_dDrawParam+0.5)/m_dDrawParam;    // 大弧修正
		p2 = GetArcPts(p2, dWide1*d2, GetIAngle(nB1), ptLoc, lstSeg, dAng1); // 大
		p3 = GetArcPts(p3, dWide1*d1, GetIAngle(nB1), ptLoc, lstSeg, dAng1); // 小
		p6 = GetArcPts(p6, dWide2*d1, GetIAngle(nB3), ptLoc, lstSeg, dAng3); // 大
		p7 = GetArcPts(p7, dWide2*d2, GetIAngle(nB3), ptLoc, lstSeg, dAng3); // 小

		XPoint ptTmp1(p2), ptTmp2(p3);
		::GetNewPts(ptTmp1, ptTmp2, GetIFlDist(nB1));
		BuildSegs1(ptTmp1, ptTmp2, flSegs); // 法兰绘制
		ptTmp1 = p6;
		ptTmp2 = p7;
		::GetNewPts(ptTmp1, ptTmp2, GetIFlDist(nB3));
		BuildSegs1(ptTmp1, ptTmp2, flSegs);

		DList<XCurveSegment> segs; // 不绘制
		ptB1 = GetArcPts(ptB1, dWide1, GetIAngle(nB1), ptLoc, segs, dAng1);
		ptB3 = GetArcPts(ptB3, dWide2, GetIAngle(nB3), ptLoc, segs, dAng3);

		ptTmp2 = pts[nB2];
		XCurveSegment segTmp(ptLoc, ptTmp2, 0, LS_FINITE);
		ptLoc = GetZeroPt();
		segTmp.ProjectToMe(ptLoc, ptTmp1);
		bFlag = (ptTmp1&segTmp)==PR_INSIDE;
	}

	double dTmp = (m_nDrawMod==7)?1:-1;
	int m = bFlag?5:4; // 和0对应
	XPoint ptInt1, ptInt2;
	ads_polar(ptB1, dAng1, 5*dTmp*GetIWidth(m_nMain), ptInt1);
	XLine tmpL1(ptLst[0], ptLst[m], LS_INFINITE),
		tmpL2(ptInt1, ptB1, LS_INFINITE);
	XLine l1 = tmpL2.Offset(-GetIWidth(nB1)*0.5),
		l2 = tmpL2.Offset(GetIWidth(nB1)*0.5);
	if (!tmpL1.Intersection(&l1, ptInt2) || !tmpL1.Intersection(&l2, ptInt1))
	{
		return FALSE;
	}
	BuildSegs2(ptLst[0], ptInt1, p3, lstSeg);
	BuildSegs2(ptLst[m], ptInt2, p2, lstSeg);

	m = bFlag?4:5; // 和1对应
	XPoint ptInt3, ptInt4;
	tmpL1.SetPoints(ptLst[1], ptLst[m]);
	ads_polar(ptB3, dAng3, 5*dTmp*GetIWidth(m_nMain), ptInt3);
	tmpL2.SetPoints(ptInt3, ptB3);
	XLine l3 = tmpL2.Offset(-GetIWidth(nB3)*0.5),
		l4 = tmpL2.Offset(GetIWidth(nB3)*0.5);
	if (!tmpL1.Intersection(&l3, ptInt3) || !tmpL1.Intersection(&l4, ptInt4))
	{
		return FALSE;
	}
	BuildSegs2(p6, ptInt3, ptLst[1], lstSeg);
	BuildSegs2(p7, ptInt4, ptLst[m], lstSeg);
	
	double dMin = GetIWidth(nB2) * 0.125; // 管径较小的
	dAng1 = ads_angle(XPoint(), XVector3D(ptInt1-ptInt2));
	dAng3 = ads_angle(XPoint(), XVector3D(ptInt3-ptInt4));
	Midpoint(ptInt1, ptInt2, ptB1);
	Midpoint(ptInt3, ptInt4, ptB3);
	ads_polar(ptB1, dAng1-PI/2, dMin, ptB1); // 弧中点
	ads_polar(ptB3, dAng3+PI/2, dMin, ptB3);
	
	XArc arc1(ptInt1, ptB1, ptInt2), // 相贯线
		arc2(ptInt3, ptB3, ptInt4);
	BuildSegs4(arc1, lstSeg);
	BuildSegs4(arc2, lstSeg);
	return TRUE;
}



///////////////////////////////////三维绘制/////////////////////////////////////
Acad::ErrorStatus TDbDuctNode::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != GetDuctIFaceNum()) // 首先保证连表数量正确
	{
		return Acad::eInvalidInput;
	}

	Acad::ErrorStatus es = Acad::eOk;
 	if (m_nSysDrawMod == 4) // 系统图
	{
		es = ExplodeOrDrawSys(dc);
		return es;
	}

	switch(m_nType)
	{
	case kElbow:		  // 弯头
		es = DrawElbow3D(dc);
		break;
	case kKouElbow:       // 扣弯
		es = DrawKElbow3D(dc);
		break;
	case kTapered:        // 变径
		es = DrawTapered3D(dc);
		break;
	case kTianYuanDiFang: // 天圆地方
		es = DrawTYDF3D(dc);
		break;
	case kYiZiElbow:      // 乙字弯
		es = DrawYZElbow3D(dc);
		break;
	case k3Corner:        // 三通
		es = Draw3T3D(dc);
		break;
	case k4Corner:        // 四通
		es = Draw4T3D(dc);
		break;
	}

	if (es == Acad::eOk)
	{
		es = DrawFL3D(dc); // 法兰
	}
	return es;
}


////////////////////////////法兰////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawFL3D(XExplodeDraw &dc) const
{
	int nLen = GetInterfaceNum();
	if (nLen == 1) // 注：一般堵头时，不绘制
	{
		return Acad::eOk;
	}
	if ((m_nDrawMod==13) && (m_nType==kTaoDong)) // 注：样式13的掏洞不绘制
	{
		return Acad::eOk;
	}
	
	AcDbObjectId idLayerOld = dc.GetLayerId(),
		idDoteLayer = m_idFlangeLayer; // 法兰层
	if (idDoteLayer.isValid())
	{
		dc.SetLayer(idDoteLayer);
	}
	dc.SetColorLayer(colorIndex(), idDoteLayer);

	for (int i=0; i<nLen; i++)
	{
		BOOL bIsVDuct(FALSE);
		XVector3D vtDraw = GetIDirection(i); // 法向
		vtDraw.Normalize();
		if (fabs(vtDraw.x)<1.0E-6 && fabs(vtDraw.y)<1.0E-6)
			bIsVDuct = TRUE; // 判断是否为立管
		
		if (m_nType == k3Corner) // 注：当有两根立管与三通连接时，立管上的法兰不绘制
		{
			int nSum(0);
			for (int j=0; j<3; j++)
			{
				const XVector3D &vt = GetIDirection(j); // 判断有几根立管
				if (fabs(vt.x)<1.0E-6 && fabs(vt.y)<1.0E-6)
					nSum += (2*j+1);
			}
			
			if (bIsVDuct && (nSum==4 || nSum==6 || nSum==8)) // 连接了两根立管
				continue;
		}
		
		double dThick = GetIFlThick(i); // 法兰片厚度
		if (fabs(dThick) < 1.0E-6)
			dThick = 4;
		XPoint ptLink = GetILocation(i); // 连接点位置
		vtDraw.Scale(dThick/2);
		XPoint ptStart = ptLink + vtDraw, // 路径起止点
			ptEnd = ptLink - vtDraw;
					
		double dDia = GetIWidth(i), // 管径或宽度
			dHigh = GetIHeight(i); // 高度
		dDia += 2.0*GetIFlDist(i);
		if (fabs(dHigh) < 1.0E-6) // 圆风管
		{
			DList<X3DFace> lstFaces;
			BOOL bIsOk = ::GetColumn3DFaces(ptStart, dDia/2.0, vtDraw, ptEnd,
				dDia/2.0, vtDraw, lstFaces, g_nSplitNum, 4);
			if (!bIsOk)
				break;

			int nCount = lstFaces.Length();
			for (int k=0; k<nCount; k++)
			{
				X3DFace face = *lstFaces[k];
				dc << face;
			}
		}
		else // 方风管
		{
			dHigh += 2.0*GetIFlDist(i);
			XPointList ductPts1, ductPts2;
			if (bIsVDuct)
			{
				double dVDAngle = GetIVDAngle(i);
				XPoly2D pts1, pts2;
				::GetSquare(ptStart, dVDAngle, dDia, dHigh, &pts1, NULL); // 立管截面
				::GetSquare(ptEnd, dVDAngle, dDia, dHigh, &pts2, NULL);
				if (pts1.Length()!=4 || pts2.Length()!=4)
					break;

				int k(0);
				for (k=0; k<4; k++)
					ductPts1.Append(new XPoint(*pts1[k]));
				for (k=0; k<4; k++)
					ductPts2.Append(new XPoint(*pts2[k]));
			}
			else
			{
				::GetDuctSidePts(ptStart, dDia, dHigh, vtDraw, ductPts1);
				::GetDuctSidePts(ptEnd, dDia, dHigh, vtDraw, ductPts2);
			}
			if (ductPts1.Length()!=4 || ductPts2.Length()!=4)
				break;
			
			dc << ::GetFace1(*ductPts1[0], *ductPts1[1], *ductPts1[2], *ductPts1[3]);
			dc << ::GetFace1(*ductPts2[0], *ductPts2[1], *ductPts2[2], *ductPts2[3]);
			dc << ::GetFace1(*ductPts1[0], *ductPts1[1], *ductPts2[1], *ductPts2[0]);
			dc << ::GetFace1(*ductPts1[3], *ductPts1[2], *ductPts2[2], *ductPts2[3]);
			dc << ::GetFace1(*ductPts1[0], *ductPts1[3], *ductPts2[3], *ductPts2[0]);
			dc << ::GetFace1(*ductPts1[1], *ductPts1[2], *ductPts2[2], *ductPts2[1]);
		}
	}
	
	dc.SetLayer(idLayerOld);
	dc.SetColorLayer(colorIndex(), idLayerOld);
	return Acad::eOk;
}


////////////////////////////弯头////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawElbow3D(XExplodeDraw &dc) const
{
	if ((GetInterfaceNum()!=2) || (GetDuctIFaceNum()!=2))
		return Acad::eInvalidInput; // 保证链表不越界

	XPointList lstBasePts;
	GetPtsIFace(lstBasePts, FALSE, TRUE, FALSE, FALSE);
	if (lstBasePts.Length() != 2) // 获取与管线相连点，考虑了法兰遮挡节点
		return Acad::eInvalidInput;

	XPoint ptStart = *lstBasePts[0], // 与管线相连点
		ptEnd = *lstBasePts[1];
	XVector3D vt1 = GetIDirection(0), // 管线法向
		vt2 = GetIDirection(1);
	double dWidth1 = GetIWidth(0), // 管线宽度
		dWidth2 = GetIWidth(1),
		dHigh1 = GetIHeight(0),
		dHigh2 = GetIHeight(1);
	if (m_bMuffler) // 消声弯头
	{
		dWidth1 += GetIFlDist(0)*1.6;
		dWidth2 += GetIFlDist(1)*1.6;
	}
	
	XPoint ptLoc(m_ptLocation);
	if (fabs(dHigh1)<1.0E-6 && fabs(dHigh2)<1.0E-6 && m_nDrawMod==0) // 圆管内外弧线
	{
		XPointList pts;
		::GetTHSplitPts(ptStart, ptEnd, vt1, vt2, g_nSplitNum, pts, 0, ptLoc);
		int nLen = pts.Length(), i(0);
		if (nLen != g_nSplitNum+2)
			return Acad::eInvalidInput;
		
		DList<X3DFace> lstFaces;
		XPoint ptTmp1(*pts[1]), ptTmp2(*pts[g_nSplitNum]);
		BOOL bIsOk1 = ::GetColumn3DFaces(*pts[0], dWidth1/2, vt1, ptTmp1, dWidth1/2,
			vt1, lstFaces, g_nSplitNum, 4, FALSE, FALSE, FALSE, FALSE);
		BOOL bIsOk2 = ::GetColumn3DFaces(ptTmp2, dWidth2/2, vt2, *pts[g_nSplitNum+1],
			dWidth2/2, vt2, lstFaces, g_nSplitNum, 4, FALSE, FALSE, FALSE, FALSE);
		if (!bIsOk1 || !bIsOk2)
			return Acad::eInvalidInput;
		
		double dChange = (dWidth2-dWidth1)/(g_nSplitNum-1);
		AcGeCircArc3d arc(ptTmp1, *pts[g_nSplitNum/2], ptTmp2);
		for (i=1; i<g_nSplitNum; i++)
		{
			AcGeLine3d tangentL1, tangentL2;
			if (arc.tangent(pts[i]->AsAcGePoint3d(), tangentL1)==Adesk::kFalse ||
				arc.tangent(pts[i+1]->AsAcGePoint3d(), tangentL2)==Adesk::kFalse)
				return Acad::eInvalidInput;

			AcGeVector3d vtTmp1 = tangentL1.direction(),
				vtTmp2 = tangentL2.direction();
			double dNum1 = dWidth1 + dChange*(i-1),
				dNum2 = dWidth1 + dChange*i;
			BOOL bIsOk = ::GetColumn3DFaces(*pts[i], dNum1/2.0, XVector3D(vtTmp1),
				*pts[i+1], dNum2/2.0, XVector3D(vtTmp2), lstFaces, g_nSplitNum, 4,
				FALSE, FALSE, FALSE, FALSE);
			if (!bIsOk)
				break;
		}
		
		nLen = lstFaces.Length();
		for (i=0; i<nLen; i++)
			dc << *lstFaces[i];
		return Acad::eOk;
	}


	if (fabs(dHigh1) < 1.0E-6) // 注：不分方圆，一率按方管处理
		dHigh1 = dWidth1;
	if (fabs(dHigh2) < 1.0E-6)
		dHigh2 = dWidth2;
	XPointList lPts1, lPts2;
	::GetDuctSidePts(ptStart, dWidth1, dHigh1, vt1, lPts1);
	::GetDuctSidePts(ptEnd, dWidth2, dHigh2, vt2, lPts2);
	if (lPts1.Length()!=4 || lPts2.Length()!=4) // 管线连接处的截面四个角点
		return Acad::eInvalidInput;

	int nExSplit(1), nInSplit(1), nType(0); // 连接件边线分割份数
	BOOL bExShow(TRUE), bInShow(TRUE);      // 是否显示边线
	if (m_nDrawMod == 0) // 内外弧线
	{
		nExSplit = nInSplit = g_nSplitNum;
		bExShow = bInShow = FALSE;
	}
	else if (m_nDrawMod == 1) // 内斜线
	{
		nInSplit = m_bMuffler?0:2;
	}
	else if (m_nDrawMod == 2) // 内弧线
	{
		nInSplit = g_nSplitNum;
		bInShow = FALSE;
	}
	else if (m_nDrawMod == 4) // 虾米弯头
	{
		nInSplit = nExSplit = m_nXMWNum;
		nType = 3;
	}


	XPointList pts1, pts2, // 分别为内上、下线
		pts3, pts4;		   // 分别为外上、下线
	double dDist1 = lPts1[0]->Distance(*lPts2[1]),
		dDist2 = lPts1[1]->Distance(*lPts2[0]);
	if (dDist1 > (dDist2+1.0e-6)) // 判断内外
	{
		::GetTHSplitPts(*lPts1[1], *lPts2[0], vt1, vt2, nInSplit, pts1, nType, ptLoc);
		::GetTHSplitPts(*lPts1[2], *lPts2[3], vt1, vt2, nInSplit, pts2, nType, ptLoc);
		::GetTHSplitPts(*lPts1[0], *lPts2[1], vt1, vt2, nExSplit, pts3, nType, ptLoc);
		::GetTHSplitPts(*lPts1[3], *lPts2[2], vt1, vt2, nExSplit, pts4, nType, ptLoc);
	}
	else
	{
		::GetTHSplitPts(*lPts1[0], *lPts2[1], vt1, vt2, nInSplit, pts1, nType, ptLoc);
		::GetTHSplitPts(*lPts1[3], *lPts2[2], vt1, vt2, nInSplit, pts2, nType, ptLoc);
		::GetTHSplitPts(*lPts1[1], *lPts2[0], vt1, vt2, nExSplit, pts3, nType, ptLoc);
		::GetTHSplitPts(*lPts1[2], *lPts2[3], vt1, vt2, nExSplit, pts4, nType, ptLoc);
	}
	int nLen1 = pts1.Length(), // 获取分割点
		nLen2 = pts2.Length(),
		nLen3 = pts3.Length(),
		nLen4 = pts4.Length();
	if (nLen1!=nLen2 || nLen1!=nInSplit+2 || nLen3!=nLen4 || nLen3!=nExSplit+2)
		return Acad::eInvalidInput;

	
	int m(0), n(0);
	for (m=0; m<nLen1-1; m++) // 绘制内、外面
	{
		if (m == 0) // 内
			dc << ::GetFace1(*pts1[m], *pts2[m], *pts2[m+1], *pts1[m+1],
			TRUE, TRUE, bInShow);
		else if (m == nLen1-2)
			dc << ::GetFace1(*pts1[m], *pts2[m], *pts2[m+1], *pts1[m+1], bInShow);
		else
			dc << ::GetFace1(*pts1[m], *pts2[m], *pts2[m+1], *pts1[m+1],
			bInShow, TRUE, bInShow);
	}

	for (n=0; n<nLen3-1; n++)
	{
		if (n == 0) // 外
			dc << ::GetFace1(*pts3[n], *pts4[n], *pts4[n+1], *pts3[n+1],
			TRUE, TRUE, bExShow);
		else if (n == nLen3-2)
			dc << ::GetFace1(*pts3[n], *pts4[n], *pts4[n+1], *pts3[n+1], bExShow);
		else
			dc << ::GetFace1(*pts3[n], *pts4[n], *pts4[n+1], *pts3[n+1],
			bExShow, TRUE, bExShow);
	}


	// 绘制上下面
	if (m_nDrawMod == 0) // 内外弧线
	{
		if (nLen1 != nLen3) // = g_nSplitNum+2
		{
			return Acad::eInvalidInput;
		}

		for (m=0; m<nLen1-1; m++)
		{
			BOOL bShow1 = (m==nLen1-2),
				bShow2 = (m==0);
			dc << ::GetFace2(*pts1[m], *pts1[m+1], *pts3[m+1], TRUE, bShow1);
			dc << ::GetFace2(*pts2[m], *pts2[m+1], *pts4[m+1], TRUE, bShow1);
			dc << ::GetFace2(*pts1[m], *pts3[m], *pts3[m+1], bShow2, TRUE);
			dc << ::GetFace2(*pts2[m], *pts4[m], *pts4[m+1], bShow2, TRUE);
		}
		return Acad::eOk;
	}

	if (m_nDrawMod == 4) // 虾米弯
	{
		if (nLen1 != nLen3) // = m_nXMWNum+2
		{
			return Acad::eInvalidInput;
		}

		for (m=0; m<nLen1-1; m++)
		{
			dc << ::GetFace1(*pts1[m], *pts1[m+1], *pts3[m+1], *pts3[m]);
			dc << ::GetFace1(*pts2[m], *pts2[m+1], *pts4[m+1], *pts4[m]);
		}
		return Acad::eOk;
	}
	
	if (m_nDrawMod == 3) // 内外直线
	{
		if (nLen1 != nLen3) // = 3
		{
			return Acad::eInvalidInput;
		}

		dc << ::GetFace1(*pts1[1], *pts3[1], *pts3[0], *pts1[0], FALSE);
		dc << ::GetFace1(*pts1[1], *pts3[1], *pts3[2], *pts1[2], FALSE);

		dc << ::GetFace1(*pts2[1], *pts4[1], *pts4[0], *pts2[0], FALSE);
		dc << ::GetFace1(*pts2[1], *pts4[1], *pts4[2], *pts2[2], FALSE);
		return Acad::eOk;
	}

	if (m_nDrawMod==1 && !m_bMuffler) // 不带消声的内外直线
	{
		dc << ::GetFace1(*pts1[1], *pts3[1], *pts3[0], *pts1[0], FALSE);
		dc << ::GetFace1(*pts1[2], *pts3[1], *pts3[2], *pts1[3], FALSE);
		dc << ::GetFace2(*pts1[1], *pts1[2], *pts3[1], TRUE);
		dc << ::GetFace1(*pts2[1], *pts4[1], *pts4[0], *pts2[0], FALSE);
		dc << ::GetFace1(*pts2[2], *pts4[1], *pts4[2], *pts2[3], FALSE);
		dc << ::GetFace2(*pts2[1], *pts2[2], *pts4[1], TRUE);
		return Acad::eOk;
	}

	dc << ::GetFace2(*pts1[0], *pts3[0], *pts3[1], TRUE, TRUE);
	dc << ::GetFace2(*pts1[nLen1-1], *pts3[2], *pts3[1], TRUE, TRUE);
	dc << ::GetFace2(*pts2[0], *pts4[0], *pts4[1], TRUE, TRUE);
	dc << ::GetFace2(*pts2[nLen1-1], *pts4[2], *pts4[1], TRUE, TRUE);
	
	if (m_nDrawMod == 1) // 带消声的内外直线
	{
		dc << ::GetFace2(*pts1[0], *pts1[1], *pts3[1], TRUE);
		dc << ::GetFace2(*pts2[0], *pts2[1], *pts4[1], TRUE);
		return Acad::eOk;
	}
	
	for (m=0; m<nLen1-1; m++) // 内弧线
	{
		dc << ::GetFace2(*pts1[m], *pts1[m+1], *pts3[1], TRUE);
		dc << ::GetFace2(*pts2[m], *pts2[m+1], *pts4[1], TRUE);
	}
	return Acad::eOk;
}


//////////////////////////变高弯头//////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawKElbow3D(XExplodeDraw &dc) const
{
	if ((GetInterfaceNum()!=2) || (GetDuctIFaceNum()!=2))
		return Acad::eInvalidInput; // 保证链表不越界

	XPointList lstBasePts;
	GetPtsIFace(lstBasePts, FALSE, TRUE, FALSE, FALSE);
	if (lstBasePts.Length() != 2) // 1、获取与管线相连点，注：考虑法兰遮挡节点
		return Acad::eInvalidInput;

	XVector3D vt1 = GetIDirection(0), // 管线法向
		vt2 = GetIDirection(1);
	int nVDuct(0);
	if (fabs(vt2.x)<1.0E-6 && fabs(vt2.y)<1.0E-6) // 2、判断立管编号
		nVDuct = 1;
	int nHDuct = 1 - nVDuct; // 水平管编号

	vt1 = GetIDirection(nHDuct); // 3、获取管线信息
	vt2 = GetIDirection(nVDuct);
	XPoint pt1 = *lstBasePts[nHDuct], // 与管线相连点
		pt2 = *lstBasePts[nVDuct];
	double dWidth1 = GetIWidth(nHDuct), // 管线宽度
		dWidth2 = GetIWidth(nVDuct),
		dHigh1 = GetIHeight(nHDuct),
		dHigh2 = GetIHeight(nVDuct);

	// 4、圆管的内外弧线
	XPoint ptLoc(m_ptLocation);
	if (fabs(dHigh1)<1.0E-6 && fabs(dHigh2)<1.0E-6 && m_nDrawMod==0)
	{
		XPointList pts;
		::GetTHSplitPts(pt1, pt2, vt1, vt2, g_nSplitNum, pts); // 路径
		int nLen = pts.Length(), i(0);
		if (nLen != g_nSplitNum+2)
			return Acad::eInvalidInput;
		
		DList<X3DFace> lstFaces;
		XPoint ptTmp1(*pts[1]), ptTmp2(*pts[g_nSplitNum]);
		AcGeCircArc3d arc(ptTmp1, *pts[g_nSplitNum/2], ptTmp2);
		double dChange = (dWidth2-dWidth1)/(nLen-1);
		for (i=1; i<g_nSplitNum; i++)
		{
			AcGeLine3d tangentL1, tangentL2;
			if (arc.tangent(pts[i]->AsAcGePoint3d(), tangentL1)==Adesk::kFalse ||
				arc.tangent(pts[i+1]->AsAcGePoint3d(), tangentL2)==Adesk::kFalse)
				return Acad::eInvalidInput;
			
			AcGeVector3d vtTmp1 = tangentL1.direction(),
				vtTmp2 = tangentL2.direction();
			double dNum1 = dWidth1 + dChange*i,
				dNum2 = dWidth1 + dChange*(i+1);

			BOOL bIsOk(TRUE);
			if (i != g_nSplitNum-1)
			{
				bIsOk = ::GetColumn3DFaces(*pts[i], dNum1/2.0, XVector3D(vtTmp1),
					*pts[i+1], dNum2/2.0, XVector3D(vtTmp2), lstFaces, g_nSplitNum,
					4, FALSE, FALSE, FALSE, FALSE);
			}
			else // 注：在立管与水平管连接处，需要特殊处理一下向量关系
			{
				bIsOk = ::GetColumn3DFaces(*pts[i], dNum1/2.0, XVector3D(vtTmp1),
					*pts[i+1], dNum2/2.0, XVector3D(vtTmp1), lstFaces, g_nSplitNum,
					4, FALSE, FALSE, FALSE, FALSE);
			}

			if (!bIsOk)
				break;
		}
		
		AcGeVector3d vtSpare1 = vt1.AsAcGeVector3d(),
			vtSpare2 = vt2.AsAcGeVector3d();
		ptTmp1 = ptTmp1 - XVector3D(vtSpare1.normalize());
		ptTmp2 = ptTmp2 - XVector3D(vtSpare2.normalize());
		BOOL bIsOk1 = ::GetColumn3DFaces(pt1, dWidth1/2, vt1, ptTmp1, dWidth1/2,
			vt1, lstFaces, g_nSplitNum, 4, FALSE, FALSE, FALSE, FALSE);
		BOOL bIsOk2 = ::GetColumn3DFaces(ptTmp2, dWidth2/2, vt2, pt2, dWidth2/2,
			vt2, lstFaces, g_nSplitNum, 4, FALSE, FALSE, FALSE, FALSE);
		if (!bIsOk1 || !bIsOk2)
			return Acad::eInvalidInput;
		
		nLen = lstFaces.Length();
		for (i=0; i<nLen; i++)
			dc << *lstFaces[i];
		return Acad::eOk;
	}


	if (fabs(dHigh1) < 1.0E-6) // 注：不分方圆，一率按方管处理
		dHigh1 = dWidth1;
	if (fabs(dHigh2) < 1.0E-6)
		dHigh2 = dWidth2;

	// 5、获取管线的边线点
	XPointList pts1;
	::GetDuctSidePts(pt1, dWidth1, dHigh1, vt1, pts1); // 水平管截面
	XPoly2D pts2;
	double dVDAngle = GetIVDAngle(nVDuct); // 立管角度
	::GetSquare(pt2, dVDAngle, dWidth2, dHigh2, &pts2, NULL); // 立管截面
	if (pts1.Length()!=4 || pts2.Length()!=4)
		return Acad::eInvalidInput;

	BOOL bUpKowWan(FALSE);
	if (vt2.z > 1.0E-6) // 6、判断是否是上扣弯
		bUpKowWan = TRUE;

	int nUpSplit(g_nSplitNum), nLowSplit(g_nSplitNum); // 7、获取连接件边线分割份数
	if (bUpKowWan && m_nDrawMod!=0)
	{
		nLowSplit = 1;
		if (m_nDrawMod == 1) // 两条直线
			nUpSplit = 2;
		else if (m_nDrawMod == 3)
			nUpSplit = 1;
	}
	else if (!bUpKowWan && m_nDrawMod!=0)
	{
		nUpSplit = 1;
		if (m_nDrawMod == 1)
			nLowSplit = 2;
		else if (m_nDrawMod == 3)
			nLowSplit = 1;
	}

	double dHDAngle = GetIAngle(nHDuct),
		dAngle = CT_std_angle(dVDAngle-dHDAngle);
	int nIndexNum(0);
	if (bUpKowWan)
	{
		if ((dAngle>-1.0E-6 && dAngle<PI/4-1.0E-6) ||
			(dAngle>PI/4*7+1.0E-6 && dAngle<PI*2-1.0E-6))
			nIndexNum = 2;
		else if (dAngle>PI/4-1.0E-6 && dAngle<PI/4*3+1.0E-6)
			nIndexNum = 3;
		else if (dAngle>PI/4*3+1.0E-6 && dAngle<PI/4*5-1.0E-6)
			nIndexNum = 0;
		else
			nIndexNum = 1;
	}
	else
	{
		if ((dAngle>-1.0E-6 && dAngle<PI/4-1.0E-6) ||
			(dAngle>PI/4*7+1.0E-6 && dAngle<PI*2-1.0E-6))
			nIndexNum = 6;
		else if (dAngle>PI/4-1.0E-6 && dAngle<PI/4*3+1.0E-6)
			nIndexNum = 7;
		else if (dAngle>PI/4*3+1.0E-6 && dAngle<PI/4*5-1.0E-6)
			nIndexNum = 4;
		else
			nIndexNum = 5;
	}

	// 注：pts2中，分别与pts1顺序相连的角标
	int nSerialNum[8][4] = {{2, 3, 0, 1}, {3, 0, 1, 2}, {0, 1, 2, 3}, {1, 2, 3, 0},
	{1, 0, 3, 2}, {2, 1, 0, 3}, {3, 2, 1, 0}, {0, 3, 2, 1}};
	int nNum0 = nSerialNum[nIndexNum][0],
		nNum1 = nSerialNum[nIndexNum][1],
		nNum2 = nSerialNum[nIndexNum][2],
		nNum3 = nSerialNum[nIndexNum][3];

	// 8、分割连接件边线，注：角标与水平管的角点相对应
	XPointList lstPt1, lstPt2, lstPt3, lstPt4;
	::GetTHSplitPts(*pts1[0], *pts2[nNum0], vt1, vt2, nUpSplit, lstPt1);
	::GetTHSplitPts(*pts1[1], *pts2[nNum1], vt1, vt2, nUpSplit, lstPt2);
	::GetTHSplitPts(*pts1[2], *pts2[nNum2], vt1, vt2, nLowSplit, lstPt3);
	::GetTHSplitPts(*pts1[3], *pts2[nNum3], vt1, vt2, nLowSplit, lstPt4);
	int nLen1 = lstPt1.Length(),
		nLen2 = lstPt3.Length();
	if (nLen1!=nUpSplit+2 || lstPt2.Length()!=nLen1 || nLen2!=nLowSplit+2
		|| lstPt4.Length()!=nLen2)
		return Acad::eInvalidInput;
	
	int m(0);
	for (m=0; m<nLen1-1; m++) // 8、绘制上、下面
	{
		BOOL bShow1 = (m==0),
			bShow2 = (m==nLen1-2);
		dc << ::GetFace1(*lstPt1[m], *lstPt2[m], *lstPt2[m+1], *lstPt1[m+1],
			bShow1, TRUE, bShow2);
	}

	for (m=0; m<nLen2-1; m++)
	{
		BOOL bShow1 = (m==0),
			bShow2 = (m==nLen2-2);
		dc << ::GetFace1(*lstPt3[m], *lstPt4[m], *lstPt4[m+1], *lstPt3[m+1],
			bShow1, TRUE, bShow2);
	}


	// 9、绘制内、外面
	if (m_nDrawMod == 0) // 内外弧线
	{
		for (m=0; m<g_nSplitNum+1; m++)
		{
			BOOL bShow1 = (m==0),
				bShow2 = (m==g_nSplitNum);
			dc << ::GetFace2(*lstPt1[m], *lstPt4[m], *lstPt4[m+1], bShow1, TRUE);
			dc << ::GetFace2(*lstPt1[m], *lstPt4[m+1], *lstPt1[m+1], FALSE, bShow2, TRUE);
			dc << ::GetFace2(*lstPt2[m], *lstPt3[m], *lstPt3[m+1], bShow1, TRUE);
			dc << ::GetFace2(*lstPt2[m], *lstPt3[m+1], *lstPt2[m+1], FALSE, bShow2, TRUE);
		}
		return Acad::eOk;
	}

	if (m_nDrawMod == 1) // 内斜线
	{
		dc << ::GetFace1(*lstPt1[1], *lstPt4[1], *lstPt4[0], *lstPt1[0], FALSE);
		dc << ::GetFace1(*lstPt2[1], *lstPt3[1], *lstPt3[0], *lstPt2[0], FALSE);
		if (bUpKowWan)
		{
			dc << ::GetFace2(*lstPt1[1], *lstPt1[2], *lstPt4[1], TRUE);
			dc << ::GetFace1(*lstPt1[2], *lstPt4[1], *lstPt4[2], *lstPt1[3], FALSE);
			dc << ::GetFace2(*lstPt2[1], *lstPt2[2], *lstPt3[1], TRUE);
			dc << ::GetFace1(*lstPt2[2], *lstPt3[1], *lstPt3[2], *lstPt2[3], FALSE);
		}
		else
		{
			dc << ::GetFace2(*lstPt4[1], *lstPt4[2], *lstPt1[1], TRUE);
			dc << ::GetFace1(*lstPt4[2], *lstPt1[1], *lstPt1[2], *lstPt4[3], FALSE);
			dc << ::GetFace2(*lstPt3[1], *lstPt3[2], *lstPt2[1], TRUE);
			dc << ::GetFace1(*lstPt3[2], *lstPt2[1], *lstPt2[2], *lstPt3[3], FALSE);
		}
		return Acad::eOk;
	}

	if (m_nDrawMod == 3) // 内外直角
	{
		dc << ::GetFace1(*lstPt1[1], *lstPt4[1], *lstPt4[0], *lstPt1[0], FALSE);
		dc << ::GetFace1(*lstPt1[1], *lstPt4[1], *lstPt4[2], *lstPt1[2], FALSE);
		dc << ::GetFace1(*lstPt2[1], *lstPt3[1], *lstPt3[0], *lstPt2[0], FALSE);
		dc << ::GetFace1(*lstPt2[1], *lstPt3[1], *lstPt3[2], *lstPt2[2], FALSE);
		return Acad::eOk;
	}

	// 内弧线
	if (bUpKowWan)
	{
		dc << ::GetFace2(*lstPt1[0], *lstPt4[0], *lstPt4[1], TRUE, TRUE);
		dc << ::GetFace2(*lstPt1[g_nSplitNum+1], *lstPt4[2], *lstPt4[1], TRUE, TRUE);
		dc << ::GetFace2(*lstPt2[0], *lstPt3[0], *lstPt3[1], TRUE, TRUE);
		dc << ::GetFace2(*lstPt2[g_nSplitNum+1], *lstPt3[2], *lstPt3[1], TRUE, TRUE);
		for (m=0; m<g_nSplitNum+1; m++)
		{
			dc << ::GetFace2(*lstPt1[m], *lstPt1[m+1], *lstPt4[1], TRUE);
			dc << ::GetFace2(*lstPt2[m], *lstPt2[m+1], *lstPt3[1], TRUE);
		}
	}
	else
	{
		dc << ::GetFace2(*lstPt4[0], *lstPt1[0], *lstPt1[1], TRUE, TRUE);
		dc << ::GetFace2(*lstPt4[g_nSplitNum+1], *lstPt1[2], *lstPt1[1], TRUE, TRUE);
		dc << ::GetFace2(*lstPt3[0], *lstPt2[0], *lstPt2[1], TRUE, TRUE);
		dc << ::GetFace2(*lstPt3[g_nSplitNum+1], *lstPt2[2], *lstPt2[1], TRUE, TRUE);
		for (m=0; m<g_nSplitNum+1; m++)
		{
			dc << ::GetFace2(*lstPt4[m], *lstPt4[m+1], *lstPt1[1], TRUE);
			dc << ::GetFace2(*lstPt3[m], *lstPt3[m+1], *lstPt2[1], TRUE);
		}
	}
	return Acad::eOk;
}


////////////////////////////变径////////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawTapered3D(XExplodeDraw &dc) const
{
	if ((GetInterfaceNum()!=2) || (GetDuctIFaceNum()!=2))
		return Acad::eInvalidInput; // 保证链表不越界
	
	XPointList lstBasePts;
	GetPtsIFace(lstBasePts, FALSE, TRUE, FALSE, FALSE);
	if (lstBasePts.Length() != 2) // 获取与管线相连点，考虑了法兰遮挡节点
		return Acad::eInvalidInput;

	XPoint ptStart = *lstBasePts[0],  // 与管线相连点
		ptEnd = *lstBasePts[1];
	XVector3D vt1 = GetIDirection(0), // 法向
		vt2 = GetIDirection(1);
	double dWidth1 = GetIWidth(0)/2,  // 宽度一半
		dWidth2 = GetIWidth(1)/2;
	double dHigh1 = GetIHeight(0),    // 高度
		dHigh2 = GetIHeight(1);

	BOOL bIsOk(TRUE);
	DList<X3DFace> lstFaces;
	if (fabs(dHigh1)<1.0E-6 && fabs(dHigh2)<1.0E-6) // 两个圆管
	{
		vt2.Scale(-1);
		bIsOk = ::GetColumn3DFaces(ptStart, dWidth1, vt1, ptEnd, dWidth2,
			vt2, lstFaces, g_nSplitNum, 2, FALSE, FALSE);
		if (!bIsOk)
			return Acad::eInvalidInput;
	}
	else // 两个方管
	{
		if (fabs(vt1.x)<1.0E-6 && fabs(vt1.y)<1.0E-6 && fabs(vt2.x)<1.0E-6 &&
			fabs(vt2.y)<1.0E-6) // 两个立管
		{
			XPoly2D pts1, pts2;
			double dVDAngle = GetIVDAngle(0); // 立管角度
			::GetSquare(ptStart, dVDAngle, dWidth1*2, dHigh1, &pts1, NULL);
			::GetSquare(ptEnd, dVDAngle, dWidth2*2, dHigh2, &pts2, NULL); // 立管截面
			if (pts1.Length()!=4 || pts2.Length()!=4)
				return Acad::eInvalidInput;
			
			dc << ::GetFace1(*pts1[0], *pts1[1], *pts2[1], *pts2[0]);
			dc << ::GetFace1(*pts1[1], *pts1[2], *pts2[2], *pts2[1]);
			dc << ::GetFace1(*pts1[2], *pts1[3], *pts2[3], *pts2[2]);
			dc << ::GetFace1(*pts1[3], *pts1[0], *pts2[0], *pts2[3]);
			return Acad::eOk;
		}

		if (!DrawCube3d(ptStart, 0, ptEnd, 1, vt1, lstFaces))
			return Acad::eInvalidInput;
	}
	
	int nCount = lstFaces.Length();
	for (int k=0; k<nCount; k++)
	{
		X3DFace face = *lstFaces[k];
		dc << face;
	}
	return Acad::eOk;
}


//////////////////////////天圆地方//////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawTYDF3D(XExplodeDraw &dc) const
{
	if ((GetInterfaceNum()!=2) || (GetDuctIFaceNum()!=2))
		return Acad::eInvalidInput; // 保证链表不越界
	
	// 获取与管线相连点，考虑法兰遮挡节点
	XPointList ptDrawLst;
	GetPtsIFace(ptDrawLst, FALSE, TRUE, FALSE, FALSE);
	if (ptDrawLst.Length() != 2)
		return Acad::eInvalidInput;
	
	int nCircleNum(0), nRectNum(1); // 管1为圆管，管2为方管
	BOOL bIsCircle = ::IsCircleDuct(objectId(), GetIPipe(0), 0);
	if (!bIsCircle)
	{
		nCircleNum = 1; // 管2为圆管，管1为方管
		nRectNum = 0;
	}
		
	XPointList circlePts1; // 注：与方管顶点连接
	::GetSplitCirclePts(*ptDrawLst[nCircleNum],	GetIWidth(nCircleNum)/2,
		GetIDirection(nCircleNum), g_nSplitNum, circlePts1);	
	XPointList circlePts2; // 注：与方管边连接
	::GetSplitCirclePts(*ptDrawLst[nCircleNum], GetIWidth(nCircleNum)/2,
		GetIDirection(nCircleNum), 4, circlePts2);
	int nLen1 = circlePts1.Length(),
		nLen2 = circlePts2.Length();
	if (nLen1==0 || nLen1!=g_nSplitNum+1 || nLen2==0 || nLen2!=5)
		return Acad::eInvalidInput;
	
	double dWidth = GetIWidth(nRectNum), // 方管尺寸
		dHigh = GetIHeight(nRectNum);
	XVector3D vt1 = GetIDirection(nCircleNum), // 管线法向
		vt2 = GetIDirection(nRectNum);
	if (fabs(vt1.x)<1.0E-6 && fabs(vt1.y)<1.0E-6 && fabs(vt2.x)<1.0E-6 &&
		fabs(vt2.y)<1.0E-6) // 两个立管
	{
		XPoly2D pts;
		double dVDAngle = GetIVDAngle(nRectNum); // 立管角度
		::GetSquare(*ptDrawLst[nRectNum], dVDAngle, dWidth, dHigh, &pts, NULL);
		if (pts.Length() != 4) // 立管截面
			return Acad::eInvalidInput;

		int nIndex(0);
		if (vt1.z > vt2.z+1.0E-6) // 圆管在上
		{
			if (fabs(dVDAngle-PI/2) < 1.0E-6)
				nIndex = 1;
			else if (dVDAngle > PI/2+1.0E-6)
				nIndex = 2;
		}
		else
		{
			if (fabs(dVDAngle-PI/2) < 1.0E-6)
				nIndex = 4;
			else if (dVDAngle > PI/2+1.0E-6)
				nIndex = 5;
			else
				nIndex = 3;
		}
		
		int nSerialNum1[6][4] = {{0, 3, 2, 1}, {1, 0, 3, 2}, {2, 1, 0, 3}, {2, 3, 0, 1},
		{1, 2, 3, 0}, {0, 1, 2, 3}};
		int nNum0 = nSerialNum1[nIndex][0],
			nNum1 = nSerialNum1[nIndex][1],
			nNum2 = nSerialNum1[nIndex][2],
			nNum3 = nSerialNum1[nIndex][3];
		dc << ::GetFace2(*circlePts2[nNum0], *pts[0], *pts[1], TRUE, TRUE, FALSE, TRUE);
		dc << ::GetFace2(*circlePts2[nNum1], *pts[1], *pts[2], TRUE, TRUE, FALSE, TRUE);
		dc << ::GetFace2(*circlePts2[nNum2], *pts[2], *pts[3], TRUE, TRUE, FALSE, TRUE);
		dc << ::GetFace2(*circlePts2[nNum3], *pts[3], *pts[0], TRUE, TRUE, FALSE, TRUE);
		
		int nSerialNum2[6][4] = {{0, 3, 2, 1}, {1, 0, 3, 2}, {2, 1, 0, 3}, {3, 0, 1, 2},
		{0, 1, 2, 3}, {1, 2, 3, 0}};
		AcDbIntArray nSerialNum3;
		for (int j=0; j<4; j++)
		{
			int nNum = nSerialNum2[nIndex][j];
			nSerialNum3.append(nNum);
		}

		int nItemNum = g_nSplitNum/4; // 每份个数
		for (int k=0; k<nLen1-1; k++)
		{
			int nInRectNum = k/nItemNum,
				nNum = nSerialNum3[nInRectNum];
			dc << ::GetFace2(*pts[nNum], *circlePts1[k], *circlePts1[k+1],
				FALSE, TRUE, FALSE, FALSE);
		}
		return Acad::eOk;
	}
	
	XPointList rectPts;
	::GetDuctSidePts(*ptDrawLst[nRectNum], dWidth, dHigh, GetIDirection(nCircleNum),
		rectPts);
	if (rectPts.Length() != 4)
		return Acad::eInvalidInput;
	
	dc << ::GetFace2(*circlePts2[0], *rectPts[0], *rectPts[3], TRUE, TRUE, FALSE, TRUE);
	dc << ::GetFace2(*circlePts2[1], *rectPts[0], *rectPts[1], TRUE, TRUE, FALSE, TRUE);
	dc << ::GetFace2(*circlePts2[2], *rectPts[1], *rectPts[2], TRUE, TRUE, FALSE, TRUE);
	dc << ::GetFace2(*circlePts2[3], *rectPts[2], *rectPts[3], TRUE, TRUE, FALSE, TRUE);
	
	int nItemNum = g_nSplitNum/4; // 每份个数
	for (int k=0; k<nLen1-1; k++)
	{
		int nInRectNum = k/nItemNum;
		dc << ::GetFace2(*rectPts[nInRectNum], *circlePts1[k], *circlePts1[k+1],
			FALSE, TRUE, FALSE, FALSE);
	}
	return Acad::eOk;
}


///////////////////////////乙字弯///////////////////////////
Acad::ErrorStatus TDbDuctNode::DrawYZElbow3D(XExplodeDraw &dc) const
{
	if ((GetInterfaceNum()!=2) || GetDuctIFaceNum()!=2) // 保证链表不越界
		return Acad::eInvalidInput;
	
	XPointList linkPts;
	GetPtsIFace(linkPts, FALSE, TRUE, FALSE, FALSE);
	if (linkPts.Length() != 2)
		return Acad::eInvalidInput; // 1、获取与管线相连点，考虑了法兰遮挡节点
	
	BOOL bSameEle(TRUE);
	XPoint ptStart = *linkPts[0], // 2、获取绘制信息
		ptEnd = *linkPts[1],
		ptLoc; // 注：修正m_ptLocation点标高
	Spoint(ptLoc, m_ptLocation.x, m_ptLocation.y, (ptStart.z+ptEnd.z)/2.0);
	if (fabs(ptStart.z-ptEnd.z) > 1.0E-6)
		bSameEle = FALSE; // 3、判断是等标高乙字弯，或变高乙字弯
	
	XVector3D vtStart = GetIDirection(0), // 向量
		vtEnd = GetIDirection(1);
	double dWStart = GetIWidth(0),  // 宽度
		dWEnd = GetIWidth(1);
	double dHStart = GetIHeight(0), // 高度
		dHEnd = GetIHeight(1);

	
	XPoint ptPro1, ptPro2;
	DList<X3DFace> lstFaces;
	if (m_nDrawMod == 2) // 角接乙字弯
	{
		double dTmp1 = (!bSameEle && fabs(dHStart)>1.0E-6)?dHStart:dWStart,
			dTmp2 = (!bSameEle && fabs(dHEnd)>1.0E-6)?dHEnd:dWEnd;
		vtStart.Normalize();
		vtEnd.Normalize();
		vtStart.Scale(dTmp1);
		vtEnd.Scale(dTmp2);
		ptPro1 = ptStart - vtStart;
		ptPro2 = ptEnd - vtEnd;
		
		BOOL bIsOk1(TRUE), bIsOk2(TRUE), bIsOk3(TRUE);
		if (fabs(dHStart)<1.0E-6 && fabs(dHEnd)<1.0E-6) // 两个圆管
		{
			bIsOk1 = ::GetColumn3DFaces(ptStart, dWStart/2.0, vtStart, ptPro1,
				dWStart/2.0, vtStart, lstFaces, g_nSplitNum, 4, TRUE, FALSE);
			bIsOk2 = ::GetColumn3DFaces(ptEnd, dWEnd/2.0, vtEnd, ptPro2,
				dWEnd/2.0, vtEnd, lstFaces, g_nSplitNum, 4, TRUE, FALSE);
			bIsOk3 = ::GetColumn3DFaces(ptPro1, dWStart/2.0, vtStart, ptPro2,
				dWEnd/2.0, vtStart, lstFaces, g_nSplitNum, 4, TRUE, FALSE);
		}
		else
		{
			bIsOk1 = DrawCube3d(ptStart, 0, ptPro1, 0, vtStart,	lstFaces);
			bIsOk2 = DrawCube3d(ptPro1, 0, ptPro2, 1, vtStart, lstFaces);
			bIsOk3 = DrawCube3d(ptPro2, 1, ptEnd, 1, vtStart, lstFaces);
		}	
		if (!bIsOk1 || !bIsOk2 || !bIsOk3)
		{
			return Acad::eInvalidInput;
		}

		int nCount = lstFaces.Length();
		for (int k=0; k<nCount; k++)
		{
			X3DFace face = *lstFaces[k];
			dc << face;
		}
		return Acad::eOk;
	}
	

	XCurveSegment segStart(ptStart, XPoint(ptStart+vtStart), 0),
		segEnd(ptEnd, XPoint(ptEnd+vtEnd), 0);
	segEnd.ProjectToMe(ptStart, ptPro1);
	segStart.ProjectToMe(ptEnd, ptPro2);

	XVector3D vtMid1 = ptPro1 - ptStart, // 4、获取中线圆心方向
		vtMid2 = ptPro2 - ptEnd;
	vtMid1.Normalize();
	vtMid2.Normalize();	
	
	double dDist = ptStart.Distance(ptEnd), // 斜边长度
		dRadius = dDist/(4*sin(m_dDrawParam/2)), // 中线圆半径
		dRadius1(dWStart*m_dDrawParam2), dRadius2(dWEnd*m_dDrawParam2);
	if (m_nDrawMod == 1) // 斜接乙字弯
	{
		if (!bSameEle && fabs(dHStart)>1.0E-6 && fabs(dHEnd)>1.0E-6)
		{
			dRadius1 = dHStart*m_dDrawParam2; // 不等标高的方管
			dRadius2 = dHEnd*m_dDrawParam2;
		}
		vtMid1.Scale(dRadius1);
		vtMid2.Scale(dRadius2);
	}
	else // 双弧乙字弯
	{
		vtMid1.Scale(dRadius);
		vtMid2.Scale(dRadius);
	}

	XPoint ptSCen = ptStart + vtMid1, // 5、获取圆心点
		ptECen = ptEnd + vtMid2;

	// 6、根据不同绘制样式，来绘制乙字弯
	if (m_nDrawMod == 0) // 双弧乙字弯
	{
		if (!bSameEle) // 不等标高
		{
			vtMid1 = ptSCen - ptLoc;
			vtMid2 = ptECen - ptLoc;
		}
		else // 中间点接口方向
		{
			vtMid1 = XVector3D((ptSCen-ptLoc).AsAcGeVector3d().perpVector());
			vtMid2 = XVector3D((ptECen-ptLoc).AsAcGeVector3d().perpVector());
			if (vtStart.AsAcGeVector3d().dotProduct(vtMid1.AsAcGeVector3d()) > 1.0E-6)
				TchPrivate::Exchange(vtMid1, vtMid2);
		}
		
		double dWMid = (dWStart+dWEnd)/2.0;
		// 7、根据方圆管的不同进行绘制——圆管
		if (fabs(dHStart)<1.0E-6 && fabs(dHEnd)<1.0E-6)
		{
			if (!bSameEle) // 注：当标高不等时，需要修正中间点接口方向
			{
				AcGePlane tmpPlane(ptSCen, (ptStart-ptSCen).AsAcGeVector3d(),
					(ptLoc-ptSCen).AsAcGeVector3d());
				AcGeCircArc3d tmpArc(ptSCen, tmpPlane.normal(), dRadius);
				AcGeLine3d line;
				if (tmpArc.tangent(ptLoc, line)==Adesk::kFalse)
					return Acad::eInvalidInput;
				vtMid1 = XVector3D(line.direction());
				vtMid2 = XVector3D(line.direction()*(-1));
			}

			XPointList path1, path2;
			::GetTHSplitPts(ptStart, ptLoc, vtStart, vtMid1, g_nSplitNum, path1);
			::GetTHSplitPts(ptLoc, ptEnd, vtMid2, vtEnd, g_nSplitNum, path2); // 节点中心线
			if (path1.Length()!=g_nSplitNum+2 || path2.Length()!=g_nSplitNum+2)
				return Acad::eInvalidInput;
			
			XPoint ptTmp1(*path1[1]), ptTmp2(*path1[g_nSplitNum]),
				ptTmp3(*path2[1]), ptTmp4(*path2[g_nSplitNum]);
			AcGeVector3d vtSpare1 = vtStart.AsAcGeVector3d(),
				vtSpare2 = vtMid1.AsAcGeVector3d(),
				vtSpare3 = vtMid2.AsAcGeVector3d(),
				vtSpare4 = vtEnd.AsAcGeVector3d();
			ptTmp1 = ptTmp1 - XVector3D(vtSpare1.normalize()*10);
			ptTmp2 = ptTmp2 + XVector3D(vtSpare1.normalize()*10);
			ptTmp3 = ptTmp3 - XVector3D(vtSpare1.normalize()*10);
			ptTmp4 = ptTmp4 + XVector3D(vtSpare1.normalize()*10);
			
			BOOL bIsOk1 = ::GetColumn3DFaces(*path1[0], dWStart/2, vtStart, ptTmp1, dWStart/2,
				vtStart, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE),
				bIsOk2 = ::GetColumn3DFaces(ptTmp2, dWMid/2, vtMid1, *path1[g_nSplitNum+1],
				dWMid/2, vtMid1, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE);
			BOOL bIsOk3 = ::GetColumn3DFaces(*path2[0], dWMid/2, vtMid2, ptTmp3, dWMid/2,
				vtMid2, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE),
				bIsOk4 = ::GetColumn3DFaces(ptTmp4, dWEnd/2, vtEnd, *path2[g_nSplitNum+1], dWEnd/2,
				vtEnd, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE);
			if (!bIsOk1 || !bIsOk2 || !bIsOk3 || !bIsOk4)
				return Acad::eInvalidInput;
			
			int i(1);
			AcGeCircArc3d arc1(*path1[1], *path1[g_nSplitNum/2], *path1[g_nSplitNum]); // 弧线
			double dChange1 = (dWMid-dWStart)/(g_nSplitNum+1);
			for (i=1; i<g_nSplitNum; i++)
			{
				AcGeLine3d tangentLine1, tangentLine2;
				if (arc1.tangent(path1[i]->AsAcGePoint3d(), tangentLine1)==Adesk::kFalse ||
					arc1.tangent(path1[i+1]->AsAcGePoint3d(), tangentLine2)==Adesk::kFalse)
					return Acad::eInvalidInput;
				
				AcGeVector3d vtTmp1 = tangentLine1.direction(),
					vtTmp2 = tangentLine2.direction();
				double dNum1 = dWStart + dChange1*i,
					dNum2 = dWStart + dChange1*(i+1);
				BOOL bIsOk = ::GetColumn3DFaces(*path1[i], dNum1/2.0, XVector3D(vtTmp1),
					*path1[i+1], dNum2/2.0, XVector3D(vtTmp2), lstFaces, g_nSplitNum, 2,
					FALSE, FALSE, FALSE, FALSE);
				if (!bIsOk)
					return Acad::eInvalidInput;
			}
			
			AcGeCircArc3d arc2(*path2[1], *path2[g_nSplitNum/2], *path2[g_nSplitNum]);
			double dChange2 = (dWEnd-dWMid)/(g_nSplitNum+1);
			for (i=1; i<g_nSplitNum; i++)
			{
				AcGeLine3d tangentLine1, tangentLine2;
				if (arc2.tangent(path2[i]->AsAcGePoint3d(), tangentLine1)==Adesk::kFalse ||
					arc2.tangent(path2[i+1]->AsAcGePoint3d(), tangentLine2)==Adesk::kFalse)
					return Acad::eInvalidInput;
				
				AcGeVector3d vtTmp1 = tangentLine1.direction(),
					vtTmp2 = tangentLine2.direction();
				double dNum1 = dWMid + dChange2*i,
					dNum2 = dWMid + dChange2*(i+1);
				
				BOOL bIsOk = ::GetColumn3DFaces(*path2[i], dNum1/2.0, XVector3D(vtTmp1), *path2[i+1],
					dNum2/2.0, XVector3D(vtTmp2), lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE);
				if (!bIsOk)
					return Acad::eInvalidInput;
			}
			
			int nLen = lstFaces.Length();
			for (i=0; i<nLen; i++)
				dc << *lstFaces[i];
			return Acad::eOk;
		}
		
		double dHMid = (dHStart+dHEnd)/2.0; // 方管
		XPointList pts1, pts2, pts3, pts4;
		::GetDuctSidePts(ptStart, dWStart, dHStart, vtStart, pts1);
		::GetDuctSidePts(ptEnd, dWEnd, dHEnd, vtEnd, pts4);
		if (bSameEle)
		{
			::GetDuctSidePts(ptLoc, dWMid, dHMid, vtMid1, pts2);
			::GetDuctSidePts(ptLoc, dWMid, dHMid, vtMid2, pts3);
		}
		else
		{
			vtMid1.Normalize();
			vtMid1.Scale(dHMid/2.0);
			XPoint ptTmp1(ptLoc+vtMid1), ptTmp2(ptLoc-vtMid1);
			if (ptStart.z > (ptEnd.z+1.0E-6))
				TchPrivate::Exchange(ptTmp1, ptTmp2);
			
			XVector3D vtTmp = *pts1[1] - *pts1[0];
			vtTmp.Normalize();
			vtTmp.Scale(dWMid/2.0);
			
			XPoint pt0 = ptTmp1 + vtTmp,
				pt1 = ptTmp1 - vtTmp,
				pt2 = ptTmp2 - vtTmp,
				pt3 = ptTmp2 + vtTmp;
			pts2.Append(new XPoint(pt0)); // 注：当标高不等时，手动添加中间截面的四个角点
			pts2.Append(new XPoint(pt1));
			pts2.Append(new XPoint(pt2));
			pts2.Append(new XPoint(pt3));
			
			pts3.Append(new XPoint(pt1));
			pts3.Append(new XPoint(pt0));
			pts3.Append(new XPoint(pt3));
			pts3.Append(new XPoint(pt2));
		}
		if (pts1.Length()!=4 || pts2.Length()!=4 || pts3.Length()!=4 || pts4.Length()!=4)
			return Acad::eInvalidInput;
		
		if (!bSameEle) // 注：当标高不等时，需要修正中间点接口方向
		{
			AcGeVector3d vtTmp1 = (*pts2[1]-*pts2[0]).AsAcGeVector3d(),
				vtTmp2 = (*pts2[3]-*pts2[0]).AsAcGeVector3d();
			AcGePlane plane(pts2[0]->AsAcGePoint3d(), vtTmp1, vtTmp2);
			AcGeVector3d vtNormal = plane.normal();
			vtMid1 = XVector3D(vtNormal);
			vtMid2 = XVector3D(vtNormal*(-1));
			if (ptStart.z > (ptEnd.z+1.0E-6))
				TchPrivate::Exchange(vtMid1, vtMid2);
		}

		XPointList lstPt1, lstPt2, lstPt3, lstPt4;
		::GetTHSplitPts(*pts1[0], *pts2[1], vtStart, vtMid1, g_nSplitNum, lstPt1);
		::GetTHSplitPts(*pts1[3], *pts2[2], vtStart, vtMid1, g_nSplitNum, lstPt2);
		::GetTHSplitPts(*pts1[1], *pts2[0], vtStart, vtMid1, g_nSplitNum, lstPt3);
		::GetTHSplitPts(*pts1[2], *pts2[3], vtStart, vtMid1, g_nSplitNum, lstPt4);
		int nLen = lstPt1.Length(), m(0);
		if (nLen!=g_nSplitNum+2 || lstPt2.Length()!=nLen || lstPt3.Length()!=nLen
			|| lstPt4.Length()!=nLen)
			return Acad::eInvalidInput;
		
		for (m=0; m<nLen-1; m++)
		{
			BOOL bShow1(FALSE), bShow2(FALSE);
			if (m == 0)
				bShow1 = TRUE;
			else if (m == nLen-2)
				bShow2 = TRUE;
			
			// 绘制内、外面
			dc << ::GetFace1(*lstPt1[m], *lstPt2[m], *lstPt2[m+1], *lstPt1[m+1], bShow1, TRUE, bShow2);
			dc << ::GetFace1(*lstPt3[m], *lstPt4[m], *lstPt4[m+1], *lstPt3[m+1], bShow1, TRUE, bShow2);
			// 绘制上、下面
			dc << ::GetFace2(*lstPt3[m], *lstPt1[m], *lstPt1[m+1], bShow1, TRUE); // 内
			dc << ::GetFace2(*lstPt4[m], *lstPt2[m], *lstPt2[m+1], bShow1, TRUE);
			dc << ::GetFace2(*lstPt3[m], *lstPt3[m+1], *lstPt1[m+1], TRUE, bShow2); // 外
			dc << ::GetFace2(*lstPt4[m], *lstPt4[m+1], *lstPt2[m+1], TRUE, bShow2);
		}

		XPointList lstPt5, lstPt6, lstPt7, lstPt8;
		::GetTHSplitPts(*pts3[0], *pts4[1], vtMid2, vtEnd, g_nSplitNum, lstPt5);
		::GetTHSplitPts(*pts3[3], *pts4[2], vtMid2, vtEnd, g_nSplitNum, lstPt6);
		::GetTHSplitPts(*pts3[1], *pts4[0], vtMid2, vtEnd, g_nSplitNum, lstPt7);
		::GetTHSplitPts(*pts3[2], *pts4[3], vtMid2, vtEnd, g_nSplitNum, lstPt8);
		nLen = lstPt5.Length();
		if (nLen!=g_nSplitNum+2 || lstPt6.Length()!=nLen || lstPt7.Length()!=nLen
			|| lstPt8.Length()!=nLen)
			return Acad::eInvalidInput;
		
		for (m=0; m<nLen-1; m++)
		{
			BOOL bShow1(FALSE), bShow2(FALSE);
			if (m == 0)
				bShow1 = TRUE;
			else if (m == nLen-2)
				bShow2 = TRUE;
			
			// 绘制内、外面
			dc << ::GetFace1(*lstPt5[m], *lstPt6[m], *lstPt6[m+1], *lstPt5[m+1], bShow1, TRUE, bShow2);
			dc << ::GetFace1(*lstPt7[m], *lstPt8[m], *lstPt8[m+1], *lstPt7[m+1], bShow1, TRUE, bShow2);
			// 绘制上、下面
			dc << ::GetFace2(*lstPt7[m], *lstPt5[m], *lstPt5[m+1], bShow1, TRUE); // 内
			dc << ::GetFace2(*lstPt8[m], *lstPt6[m], *lstPt6[m+1], bShow1, TRUE);
			dc << ::GetFace2(*lstPt7[m], *lstPt7[m+1], *lstPt5[m+1], TRUE, bShow2); // 外
			dc << ::GetFace2(*lstPt8[m], *lstPt8[m+1], *lstPt6[m+1], TRUE, bShow2);
		}
		return Acad::eOk;
	}
	
	// 斜接乙字弯
    AcGePlane plane1(ptStart.AsAcGePoint3d(), vtStart.AsAcGeVector3d(),
		vtMid1.AsAcGeVector3d());
	AcGePlane plane2(ptEnd.AsAcGePoint3d(), vtEnd.AsAcGeVector3d(),
		vtMid2.AsAcGeVector3d());
    AcGeVector3d vtNormal1 = plane1.normal(),
		vtNormal2 = plane2.normal();
	
	XPoint ptSTmp, ptETmp;
	XCurveSegment segTmp1 = ::GetArcSeg3(ptStart, ptSCen, ptSTmp, dRadius1,
		m_dDrawParam, vtNormal1, vtStart);
	XCurveSegment segTmp2 = ::GetArcSeg3(ptEnd, ptECen, ptETmp, dRadius2,
		m_dDrawParam, vtNormal2, vtEnd);
	XVector3D vtSTmp = ptETmp - ptSTmp, // 方向
		vtETmp = ptSTmp - ptETmp;

	if (fabs(dHStart)<1.0E-6 && fabs(dHEnd)<1.0E-6) // 两个圆管
	{
		XPointList sidePts1, sidePts2;
		::GetTHSplitPts(ptStart, ptSTmp, vtStart, vtSTmp, g_nSplitNum, sidePts1);
		::GetTHSplitPts(ptEnd, ptETmp, vtEnd, vtETmp, g_nSplitNum, sidePts2);
		int nLen = sidePts1.Length(), i(0);
		if (nLen!=g_nSplitNum+2 || sidePts2.Length()!=g_nSplitNum+2)
			return Acad::eInvalidInput;
		
		XPoint ptTmp1(*sidePts1[1]), ptTmp2(*sidePts1[g_nSplitNum]),
			ptTmp3(*sidePts2[1]), ptTmp4(*sidePts2[g_nSplitNum]);
		AcGeVector3d vtSpare1 = vtStart.AsAcGeVector3d(),
			vtSpare2 = vtSTmp.AsAcGeVector3d();
		ptTmp1 = ptTmp1 - XVector3D(vtSpare1.normalize()*10);
		ptTmp2 = ptTmp2 - XVector3D(vtSpare2.normalize()*10);
		AcGeVector3d vtSpare3 = vtEnd.AsAcGeVector3d(),
			vtSpare4 = vtETmp.AsAcGeVector3d();
		ptTmp3 = ptTmp3 - XVector3D(vtSpare3.normalize()*10);
		ptTmp4 = ptTmp4 - XVector3D(vtSpare4.normalize()*10);
		
		BOOL bIsOk1 = ::GetColumn3DFaces(*sidePts1[0], dWStart/2, vtStart, ptTmp1, dWStart/2,
			vtStart, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE),
			bIsOk2 = ::GetColumn3DFaces(ptTmp2, dWStart/2, vtSTmp, *sidePts1[g_nSplitNum+1],
			dWStart/2, vtSTmp, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE),
			bIsOk3 = ::GetColumn3DFaces(*sidePts2[0], dWEnd/2, vtEnd, ptTmp3, dWEnd/2, vtEnd,
			lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE),
			bIsOk4 = ::GetColumn3DFaces(ptTmp4, dWEnd/2, vtETmp, *sidePts2[g_nSplitNum+1],
			dWEnd/2, vtETmp, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE);
		if (!bIsOk1 || !bIsOk2 || !bIsOk3 || !bIsOk4)
			return Acad::eInvalidInput;
		

		AcGeCircArc3d arc1(*sidePts1[1], *sidePts1[g_nSplitNum/2], *sidePts1[g_nSplitNum]),
			arc2(*sidePts2[1], *sidePts2[g_nSplitNum/2], *sidePts2[g_nSplitNum]);
		for (i=1; i<g_nSplitNum; i++)
		{
			AcGeLine3d tangentLine1, tangentLine2, tangentLine3, tangentLine4;
			if (arc1.tangent(sidePts1[i]->AsAcGePoint3d(), tangentLine1)==Adesk::kFalse ||
				arc1.tangent(sidePts1[i+1]->AsAcGePoint3d(), tangentLine2)==Adesk::kFalse)
				return Acad::eInvalidInput;
			if (arc2.tangent(sidePts2[i]->AsAcGePoint3d(), tangentLine3)==Adesk::kFalse ||
				arc2.tangent(sidePts2[i+1]->AsAcGePoint3d(), tangentLine4)==Adesk::kFalse)
				return Acad::eInvalidInput;
			
			AcGeVector3d vtTmp1 = tangentLine1.direction(),
				vtTmp2 = tangentLine2.direction(),
				vtTmp3 = tangentLine3.direction(),
				vtTmp4 = tangentLine4.direction();
			BOOL bIsOk1 = ::GetColumn3DFaces(*sidePts1[i], dWStart/2.0, XVector3D(vtTmp1),
				*sidePts1[i+1], dWStart/2.0, XVector3D(vtTmp2), lstFaces, g_nSplitNum, 2,
				FALSE, FALSE, FALSE, FALSE),
				bIsOk2 = ::GetColumn3DFaces(*sidePts2[i], dWEnd/2.0, XVector3D(vtTmp3),
				*sidePts2[i+1], dWEnd/2.0, XVector3D(vtTmp4), lstFaces, g_nSplitNum, 2,
				FALSE, FALSE, FALSE, FALSE);
			if (!bIsOk1 || !bIsOk2)
				break;
		}

		bIsOk1 = ::GetColumn3DFaces(ptSTmp, dWStart/2, vtSTmp, ptETmp, dWEnd/2,
			vtSTmp, lstFaces, g_nSplitNum, 2, FALSE, FALSE, FALSE, FALSE);
		if (!bIsOk1)
			return Acad::eInvalidInput;
		
		nLen = lstFaces.Length();
		for (i=0; i<nLen; i++)
			dc << *lstFaces[i];
		return Acad::eOk;
	}
	else // 两个方管
	{
		XPointList segPts1, segPts2, segPts3, segPts4;
		::GetDuctSidePts(ptStart, dWStart, dHStart, vtStart, segPts1);
		::GetDuctSidePts(ptSTmp, dWStart, dHStart, vtSTmp, segPts2);
		::GetDuctSidePts(ptEnd, dWEnd, dHEnd, vtEnd, segPts3);
		::GetDuctSidePts(ptETmp, dWEnd, dHEnd, vtETmp, segPts4);
		if (segPts1.Length()!=4 || segPts2.Length()!=4 || segPts3.Length()!=4
			|| segPts4.Length()!=4) // 管端截面的四个角点
			return Acad::eInvalidInput;
		
		XPointList pts1, pts2, pts3, pts4, pts5, pts6, pts7, pts8;
		::GetTHSplitPts(*segPts1[1], *segPts2[0], vtStart, vtSTmp, g_nSplitNum, pts1);
		::GetTHSplitPts(*segPts1[2], *segPts2[3], vtStart, vtSTmp, g_nSplitNum, pts2);
		::GetTHSplitPts(*segPts1[0], *segPts2[1], vtStart, vtSTmp, g_nSplitNum, pts3);
		::GetTHSplitPts(*segPts1[3], *segPts2[2], vtStart, vtSTmp, g_nSplitNum, pts4);
		::GetTHSplitPts(*segPts3[1], *segPts4[0], vtEnd, vtETmp, g_nSplitNum, pts5);
		::GetTHSplitPts(*segPts3[2], *segPts4[3], vtEnd, vtETmp, g_nSplitNum, pts6);
		::GetTHSplitPts(*segPts3[0], *segPts4[1], vtEnd, vtETmp, g_nSplitNum, pts7);
		::GetTHSplitPts(*segPts3[3], *segPts4[2], vtEnd, vtETmp, g_nSplitNum, pts8);
		int nLen = pts1.Length();
		if (nLen!=g_nSplitNum+2 || pts2.Length()!=nLen || pts3.Length()!=nLen || pts4.Length()!=nLen
			|| pts5.Length()!=nLen || pts6.Length()!=nLen || pts7.Length()!=nLen || pts8.Length()!=nLen)
			return Acad::eInvalidInput;
		for (int m=0; m<nLen-1; m++)
		{
			BOOL bShow1(FALSE), bShow2(FALSE);
			if (m == 0)
				bShow2 = TRUE;
			else if (m == nLen - 2)
				bShow1 = TRUE;
			
			// 绘制内、外面
			dc << ::GetFace1(*pts1[m], *pts2[m], *pts2[m+1], *pts1[m+1], bShow2, TRUE, bShow1);
			dc << ::GetFace1(*pts3[m], *pts4[m], *pts4[m+1], *pts3[m+1], bShow2, TRUE, bShow1);
			dc << ::GetFace1(*pts5[m], *pts6[m], *pts6[m+1], *pts5[m+1], bShow2, TRUE, bShow1);
			dc << ::GetFace1(*pts7[m], *pts8[m], *pts8[m+1], *pts7[m+1], bShow2, TRUE, bShow1);
			// 绘制上下面
			dc << ::GetFace2(*pts1[m], *pts1[m+1], *pts3[m+1], TRUE, bShow1);
			dc << ::GetFace2(*pts2[m], *pts2[m+1], *pts4[m+1], TRUE, bShow1);
			dc << ::GetFace2(*pts1[m], *pts3[m], *pts3[m+1], bShow2, TRUE);
			dc << ::GetFace2(*pts2[m], *pts4[m], *pts4[m+1], bShow2, TRUE);
			dc << ::GetFace2(*pts5[m], *pts5[m+1], *pts7[m+1], TRUE, bShow1);
			dc << ::GetFace2(*pts6[m], *pts6[m+1], *pts8[m+1], TRUE, bShow1);
			dc << ::GetFace2(*pts5[m], *pts7[m], *pts7[m+1], bShow2, TRUE);
			dc << ::GetFace2(*pts6[m], *pts8[m], *pts8[m+1], bShow2, TRUE);
		}
		
		dc << ::GetFace1(*segPts2[0], *segPts2[1], *segPts4[0], *segPts4[1]);
		dc << ::GetFace1(*segPts2[1], *segPts2[2], *segPts4[3], *segPts4[0]);
		dc << ::GetFace1(*segPts2[2], *segPts2[3], *segPts4[2], *segPts4[3]);
		dc << ::GetFace1(*segPts2[3], *segPts2[0], *segPts4[1], *segPts4[2]);
	}
	return Acad::eOk;
}


////////////////////////////三通////////////////////////////
Acad::ErrorStatus TDbDuctNode::Draw3T3D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 3) // 保证链表不越界
		return Acad::eInvalidInput;
	XPointList lstBasePts;
	GetPtsIFace(lstBasePts, FALSE, TRUE, FALSE, FALSE); // 1、获取与管线相连点，注：考虑法兰遮挡节点
	if (lstBasePts.Length() != 3)
		return Acad::eInvalidInput;
	
	int nSum(0), i(0);
	for (i=0; i<3; i++)
	{
		const XVector3D &vt = GetIDirection(i); // 2、判断有几根立管
		if (fabs(vt.x)<1.0E-6 && fabs(vt.y)<1.0E-6)
			nSum += (2*i+1);
	}
	
	if (nSum == 9) // 连接了三根立管
		return Acad::eInvalidInput;
	int nMain(m_nMain); // 注：临时修正主管编号，方便计算
	if (nSum==4 || nSum==6 || nSum==8) { // 连接了两根立管，nMain为向上的立管
		int nHDuct(0), nVDuct1(-1), nVDuct2(-1), nTmp(5);
		if (nSum == 4) // 获取水平管编号
			nHDuct = 2;
		else if (nSum == 6)
			nHDuct = 1;
		::GetAnotherPipe(nHDuct, nVDuct1, nVDuct2, nTmp); // 获取立管编号

		const XVector3D &vtVDuct = GetIDirection(nVDuct1);
		if (vtVDuct.z > 1.0E-6)
			nMain = nVDuct1;
		else
			nMain = nVDuct2;
	}
	else if (nSum==1 || nSum==3 || nSum==5) { // 连接了一根立管
		int nVDuct(0), nHDuct1(-1), nHDuct2(-1), nTmp(5);
		if (nSum == 3) // 获取立管编号
			nVDuct = 1;
		else if (nSum == 5)
			nVDuct = 2;
		::GetAnotherPipe(nVDuct, nHDuct1, nHDuct2, nTmp);
		nMain = nHDuct1;
	}

	AcDbIntArray branchArray = GetBranchNums(nMain); // 3、获取支管编号
	if (branchArray.logicalLength() != 2)
		return Acad::eInvalidInput;

	const XVector3D &vtM = GetIDirection(nMain);
	const XVector3D &vt1 = GetIDirection(branchArray[0]);
	const XVector3D &vt2 = GetIDirection(branchArray[1]);
	double dWidthM = GetIWidth(nMain),
		dWidth1 = GetIWidth(branchArray[0]),
		dWidth2 = GetIWidth(branchArray[1]),
		dHighM = GetIHeight(nMain),
		dHigh1 = GetIHeight(branchArray[0]),
		dHigh2 = GetIHeight(branchArray[1]);
	BOOL bMDuctIsCircle(FALSE);
	if (fabs(dHighM) < 1.0E-6) { // 注：暂时圆管按照方管处理
		dHighM = dWidthM;
		bMDuctIsCircle = TRUE;
	}
	if (fabs(dHigh1) < 1.0E-6)
		dHigh1 = dWidth1;
	if (fabs(dHigh2) < 1.0E-6)
		dHigh2 = dWidth2;
	XPointList ptsM, pts1, pts2;
	::GetDuctSidePts(*lstBasePts[nMain], dWidthM, dHighM, vtM, ptsM);
	::GetDuctSidePts(*lstBasePts[branchArray[0]], dWidth1, dHigh1, vt1, pts1);
	::GetDuctSidePts(*lstBasePts[branchArray[1]], dWidth2, dHigh2, vt2, pts2);
	if (pts1.Length()!=4 || pts2.Length()!=4 || ptsM.Length()!=4) // 4、获取风管边线点
		return Acad::eInvalidInput;
	
	// 5、根据连接立管数量的不同，绘制不同的样式
	if (nSum==4 || nSum==6 || nSum==8) { // 连接了两根立管
		BOOL bIsBranch2 = ::IsParallel(vtM, vt2);
		int nBranch = bIsBranch2?branchArray[1]:branchArray[0]; // 向下的立管
		double dW = bIsBranch2?dWidth2:dWidth1,
			dH = bIsBranch2?dHigh2:dHigh1;
		double dVDAngle = GetIVDAngle(nMain);
		if (bMDuctIsCircle) { // 立管为圆管
			double dTmpAngle = GetIAngle(nBranch);
			dVDAngle = dTmpAngle + PI/2;
		}

		XPoly2D polyM(1), polyB(1); // 主截面
		::GetSquare(*lstBasePts[nMain], dVDAngle, dWidthM, dHighM, &polyM, NULL);
		::GetSquare(*lstBasePts[nBranch], dVDAngle, dW, dH, &polyB, NULL);
		if (polyM.Length()!=4 || polyB.Length()!=4)
			return Acad::eInvalidInput;
		dc << ::GetFace1(*polyM[0], *polyM[1], *polyB[1], *polyB[0]);
		dc << ::GetFace1(*polyM[1], *polyM[2], *polyB[2], *polyB[1]);
		dc << ::GetFace1(*polyM[2], *polyM[3], *polyB[3], *polyB[2]);
		dc << ::GetFace1(*polyM[3], *polyM[0], *polyB[0], *polyB[3]);

		int nHNum(-1), nAnother(5), nIndex(1);
		::GetAnotherPipe(nMain, nBranch, nHNum, nAnother);
		double dHAngle = GetIAngle(nHNum),
			dAng = CT_std_angle(dHAngle - dVDAngle); // 夹角
		if (fabs(dAng) < 1.0E-6)
			nIndex = 0;
		else if (fabs(dAng-PI*0.5) < 1.0E-6)
			nIndex = 3;
		else if (fabs(dAng-PI) < 1.0E-6)
			nIndex = 2;

		int nSerialNum[4][3] = {{1, 0, 0}, {2, 1, 1}, {3, 2, 2}, {0, 3, 3}};
		int nNum0 = nSerialNum[nIndex][0],
			nNum1 = nSerialNum[nIndex][1],
			nNum2 = nSerialNum[nIndex][2];
		AcGePoint3d ptM1 = polyM[nNum0]->AsAcGePoint3d(),
			ptM2 = polyM[nNum1]->AsAcGePoint3d(),
			ptB1 = polyB[nNum2]->AsAcGePoint3d();
		AcGePlane plane(ptM2, ptM1, ptB1);

		XPointList tmpPts;
		for (i=0; i<4; i++)
		{
			AcGePoint3d ptTmp1;
			if (bIsBranch2)
				ptTmp1 = pts1[i]->AsAcGePoint3d();
			else
				ptTmp1 = pts2[i]->AsAcGePoint3d();

			AcGePoint3d ptTmp2 = ptTmp1.orthoProject(plane);
			if (nIndex==0 || nIndex==2) {
				double dZ = ptTmp2.z;
				double dDist1 = ptTmp2.distanceTo(ptM1),
					dDist2 = ptTmp2.distanceTo(ptM2);
				if (dDist1 > (dDist2+1.0E-6))
					ptTmp2 = AcGePoint3d(ptM2.x, ptM2.y, dZ);
				else
					ptTmp2 = AcGePoint3d(ptM1.x, ptM1.y, dZ);
			}
			tmpPts.Append(new XPoint(ptTmp2));
		}
		
		if (tmpPts.Length() != 4)
			return Acad::eInvalidInput;
		if (bIsBranch2) {
			dc << ::GetFace1(*pts1[0], *pts1[1], *tmpPts[1], *tmpPts[0]);
			dc << ::GetFace1(*pts1[1], *pts1[2], *tmpPts[2], *tmpPts[1]);
			dc << ::GetFace1(*pts1[2], *pts1[3], *tmpPts[3], *tmpPts[2]);
			dc << ::GetFace1(*pts1[3], *pts1[0], *tmpPts[0], *tmpPts[3]);
		}
		else {
			dc << ::GetFace1(*pts2[0], *pts2[1], *tmpPts[1], *tmpPts[0]);
			dc << ::GetFace1(*pts2[1], *pts2[2], *tmpPts[2], *tmpPts[1]);
			dc << ::GetFace1(*pts2[2], *pts2[3], *tmpPts[3], *tmpPts[2]);
			dc << ::GetFace1(*pts2[3], *pts2[0], *tmpPts[0], *tmpPts[3]);
		}
		return Acad::eOk;
	}

	if (nSum==1 || nSum==3 || nSum==5) { // 连接了一根立管
		dc << ::GetFace1(*ptsM[0], *ptsM[1], *pts2[0], *pts2[1]);
		dc << ::GetFace1(*ptsM[1], *ptsM[2], *pts2[3], *pts2[0]);
		dc << ::GetFace1(*ptsM[2], *ptsM[3], *pts2[2], *pts2[3]);
		dc << ::GetFace1(*ptsM[3], *ptsM[0], *pts2[1], *pts2[2]);

		XPoly2D polyV(1); // 主截面
		double dVDAngle = GetIVDAngle(branchArray[0]);
		::GetSquare(*lstBasePts[branchArray[0]], dVDAngle, dWidth1, dHigh1, &polyV, NULL);
		if (polyV.Length() != 4)
			return Acad::eInvalidInput;

		const XVector3D &vtVDuct = GetIDirection(branchArray[0]);
		AcGePlane plane;
		if (vtVDuct.z>1.0E-6) // 向上的立管
			plane.set(ptsM[1]->AsAcGePoint3d(), ptsM[0]->AsAcGePoint3d(), pts2[1]->AsAcGePoint3d());
		else
			plane.set(ptsM[2]->AsAcGePoint3d(), ptsM[3]->AsAcGePoint3d(), pts2[2]->AsAcGePoint3d());

		XPointList tmpPts;
		for (i=0; i<4; i++)
		{
			AcGePoint3d ptTmp1 = polyV[i]->AsAcGePoint3d(),
				ptTmp2 = ptTmp1.orthoProject(plane);
			tmpPts.Append(new XPoint(ptTmp2));
		}
		
		dc << ::GetFace1(*polyV[0], *tmpPts[0], *tmpPts[1], *polyV[1]);
		dc << ::GetFace1(*polyV[1], *tmpPts[1], *tmpPts[2], *polyV[2]);
		dc << ::GetFace1(*polyV[2], *tmpPts[2], *tmpPts[3], *polyV[3]);
		dc << ::GetFace1(*polyV[3], *tmpPts[3], *tmpPts[0], *polyV[0]);
		return Acad::eOk;
	}
	
	XPointList lstPt1, lstPt2, lstPt3, lstPt4, lstPt5, lstPt6;
	::GetTHSplitPts(*ptsM[0], *pts1[1], vtM, vt1, 1, lstPt1);
	::GetTHSplitPts(*ptsM[3], *pts1[2], vtM, vt1, 1, lstPt2),
	::GetTHSplitPts(*ptsM[1], *pts2[0], vtM, vt2, 1, lstPt3),
	::GetTHSplitPts(*ptsM[2], *pts2[3], vtM, vt2, 1, lstPt4),
	::GetTHSplitPts(*pts1[0], *pts2[1], vt1, vt2, 1, lstPt5),
	::GetTHSplitPts(*pts1[3], *pts2[2], vt1, vt2, 1, lstPt6);
	if (lstPt1.Length()!=3 || lstPt2.Length()!=3 || lstPt3.Length()!=3 ||
		lstPt4.Length()!=3 || lstPt5.Length()!=3 || lstPt6.Length()!=3)
		return Acad::eInvalidInput;
	
	dc << ::GetFace1(*lstPt1[1], *lstPt3[1], *ptsM[1], *ptsM[0], FALSE); // 绘制上下面
	dc << ::GetFace1(*lstPt2[1], *lstPt4[1], *ptsM[2], *ptsM[3], FALSE);
	dc << ::GetFace1(*lstPt3[1], *lstPt5[1], *pts2[1], *pts2[0], FALSE);
	dc << ::GetFace1(*lstPt4[1], *lstPt6[1], *pts2[2], *pts2[3], FALSE);
	dc << ::GetFace1(*lstPt5[1], *lstPt1[1], *pts1[1], *pts1[0], FALSE);
	dc << ::GetFace1(*lstPt6[1], *lstPt2[1], *pts1[2], *pts1[3], FALSE);
	dc << ::GetFace2(*lstPt1[1], *lstPt3[1], *lstPt5[1]);
	dc << ::GetFace2(*lstPt2[1], *lstPt4[1], *lstPt6[1]);

	if (m_nDrawMod==4 || m_nDrawMod==5) { // Y型
		dc << ::GetFace1(*lstPt1[0], *lstPt2[0], *lstPt2[1], *lstPt1[1]);
		dc << ::GetFace1(*lstPt1[1], *lstPt2[1], *lstPt2[2], *lstPt1[2]);
		dc << ::GetFace1(*lstPt3[0], *lstPt4[0], *lstPt4[1], *lstPt3[1]);
		dc << ::GetFace1(*lstPt3[1], *lstPt4[1], *lstPt4[2], *lstPt3[2]);

		BOOL bShow(FALSE);
		if (::IsParallel(vt1, vt2) == 0)  // 不平行
			bShow = TRUE;
		dc << ::GetFace1(*lstPt5[1], *lstPt6[1], *lstPt6[0], *lstPt5[0], bShow);
		dc << ::GetFace1(*lstPt5[1], *lstPt6[1], *lstPt6[2], *lstPt5[2], bShow);
	}
	else { // 其他样式
		dc << ::GetFace1(*lstPt5[0], *lstPt6[0], *lstPt6[1], *lstPt5[1]);
		dc << ::GetFace1(*lstPt5[1], *lstPt6[1], *lstPt6[2], *lstPt5[2]);

		if (::IsParallel(vtM, vt1) !=0) {
			dc << ::GetFace1(*lstPt1[0], *lstPt2[0], *lstPt2[2], *lstPt1[2]);
			dc << ::GetFace1(*lstPt3[0], *lstPt4[0], *lstPt4[1], *lstPt3[1]);
			dc << ::GetFace1(*lstPt3[1], *lstPt4[1], *lstPt4[2], *lstPt3[2]);
		}
		else if (::IsParallel(vtM, vt2) != 0) {
			dc << ::GetFace1(*lstPt3[0], *lstPt4[0], *lstPt4[2], *lstPt3[2]);
			dc << ::GetFace1(*lstPt1[0], *lstPt2[0], *lstPt2[1], *lstPt1[1]);
			dc << ::GetFace1(*lstPt1[1], *lstPt2[1], *lstPt2[2], *lstPt1[2]);
		}
		else {
			dc << ::GetFace1(*lstPt1[0], *lstPt2[0], *lstPt2[1], *lstPt1[1]);
			dc << ::GetFace1(*lstPt1[1], *lstPt2[1], *lstPt2[2], *lstPt1[2]);
			dc << ::GetFace1(*lstPt3[0], *lstPt4[0], *lstPt4[1], *lstPt3[1]);
			dc << ::GetFace1(*lstPt3[1], *lstPt4[1], *lstPt4[2], *lstPt3[2]);
		}
	}
	return Acad::eOk;
}


////////////////////////////四通////////////////////////////
Acad::ErrorStatus TDbDuctNode::Draw4T3D(XExplodeDraw &dc) const
{
	if (GetInterfaceNum() != 4) // 保证链表不越界
		return Acad::eInvalidInput;
	XPointList lstBasePts;
	GetPtsIFace(lstBasePts, FALSE, TRUE, FALSE, FALSE); // 1、获取与管线相连点，注：考虑法兰遮挡节点
	if (lstBasePts.Length() != 4)
		return Acad::eInvalidInput;
	AcDbIntArray branchArray = GetBranchNums(m_nMain); // 2、获取支管编号
	if (branchArray.logicalLength() != 3)
		return Acad::eInvalidInput;
	
	const XVector3D &vtM = GetIDirection(m_nMain);
	const XVector3D &vt1 = GetIDirection(branchArray[0]);
	const XVector3D &vt2 = GetIDirection(branchArray[1]);
	const XVector3D &vt3 = GetIDirection(branchArray[2]);
	double dWidthM = GetIWidth(m_nMain),
		dWidth1 = GetIWidth(branchArray[0]),
		dWidth2 = GetIWidth(branchArray[1]),
		dWidth3 = GetIWidth(branchArray[2]),
		dHighM = GetIHeight(m_nMain),
		dHigh1 = GetIHeight(branchArray[0]),
		dHigh2 = GetIHeight(branchArray[1]),
		dHigh3 = GetIHeight(branchArray[1]);
	if (fabs(dHighM) < 1.0E-6) // 注：暂时圆管按照方管处理
		dHighM = dWidthM;
	if (fabs(dHigh1) < 1.0E-6)
		dHigh1 = dWidth1;
	if (fabs(dHigh2) < 1.0E-6)
		dHigh2 = dWidth2;
	if (fabs(dHigh3) < 1.0E-6)
		dHigh3 = dWidth3;
	XPointList ptsM, pts1, pts2, pts3;
	::GetDuctSidePts(*lstBasePts[m_nMain], dWidthM, dHighM, vtM, ptsM);
	::GetDuctSidePts(*lstBasePts[branchArray[0]], dWidth1, dHigh1, vt1, pts1);
	::GetDuctSidePts(*lstBasePts[branchArray[1]], dWidth2, dHigh2, vt2, pts2);
	::GetDuctSidePts(*lstBasePts[branchArray[2]], dWidth3, dHigh3, vt3, pts3);
    // 3、获取风管边线点
	if (pts1.Length()!=4 || pts2.Length()!=4 || ptsM.Length()!=4 || pts3.Length()!=4)
		return Acad::eInvalidInput;
	
	XPointList lstPt1, lstPt2, lstPt3, lstPt4, lstPt5, lstPt6, lstPt7, lstPt8;
	::GetTHSplitPts(*ptsM[0], *pts1[1], vtM, vt1, 1, lstPt1);
	::GetTHSplitPts(*ptsM[3], *pts1[2], vtM, vt1, 1, lstPt2);
	::GetTHSplitPts(*ptsM[1], *pts3[0], vtM, vt3, 1, lstPt3);
	::GetTHSplitPts(*ptsM[2], *pts3[3], vtM, vt3, 1, lstPt4);
	::GetTHSplitPts(*pts2[0], *pts3[1], vt2, vt3, 1, lstPt5);
	::GetTHSplitPts(*pts2[3], *pts3[2], vt2, vt3, 1, lstPt6);
	::GetTHSplitPts(*pts2[1], *pts1[0], vt2, vt1, 1, lstPt7);
	::GetTHSplitPts(*pts2[2], *pts1[3], vt2, vt1, 1, lstPt8);
	if (lstPt1.Length()!=3 || lstPt2.Length()!=3 || lstPt3.Length()!=3 || lstPt4.Length()!=3 ||
		lstPt5.Length()!=3 || lstPt6.Length()!=3 || lstPt7.Length()!=3 || lstPt8.Length()!=3)
		return Acad::eInvalidInput;
	
	dc << ::GetFace1(*lstPt1[1], *lstPt3[1], *ptsM[1], *ptsM[0], FALSE); // 绘制上下面
	dc << ::GetFace1(*lstPt2[1], *lstPt4[1], *ptsM[2], *ptsM[3], FALSE);
	dc << ::GetFace1(*lstPt3[1], *lstPt5[1], *pts3[1], *pts3[0], FALSE);
	dc << ::GetFace1(*lstPt4[1], *lstPt6[1], *pts3[2], *pts3[3], FALSE);
	dc << ::GetFace1(*lstPt5[1], *lstPt7[1], *pts2[1], *pts2[0], FALSE);
	dc << ::GetFace1(*lstPt6[1], *lstPt8[1], *pts2[2], *pts2[3], FALSE);
	dc << ::GetFace1(*lstPt7[1], *lstPt1[1], *pts1[1], *pts1[0], FALSE);
	dc << ::GetFace1(*lstPt8[1], *lstPt2[1], *pts1[2], *pts1[3], FALSE);
	dc << ::GetFace1(*lstPt1[1], *lstPt3[1], *lstPt5[1], *lstPt7[1], FALSE, FALSE, FALSE, FALSE);
	dc << ::GetFace1(*lstPt2[1], *lstPt4[1], *lstPt6[1], *lstPt8[1], FALSE, FALSE, FALSE, FALSE);
	
	dc << ::GetFace1(*lstPt1[0], *lstPt2[0], *lstPt2[1], *lstPt1[1]); // 绘制边面
	dc << ::GetFace1(*lstPt1[1], *lstPt2[1], *lstPt2[2], *lstPt1[2]);
	dc << ::GetFace1(*lstPt3[0], *lstPt4[0], *lstPt4[1], *lstPt3[1]);
	dc << ::GetFace1(*lstPt3[1], *lstPt4[1], *lstPt4[2], *lstPt3[2]);
	dc << ::GetFace1(*lstPt5[0], *lstPt6[0], *lstPt6[1], *lstPt5[1]);
	dc << ::GetFace1(*lstPt5[1], *lstPt6[1], *lstPt6[2], *lstPt5[2]);
	dc << ::GetFace1(*lstPt7[0], *lstPt8[0], *lstPt8[1], *lstPt7[1]);
	dc << ::GetFace1(*lstPt7[1], *lstPt8[1], *lstPt8[2], *lstPt7[2]);
	return Acad::eOk;
}


BOOL TDbDuctNode::DrawCube3d(XPoint pt1, int nIndex1, XPoint pt2, int nIndex2,
							 XVector3D vt, DList<X3DFace> &faces,
							 BOOL bShow1, BOOL bShow2) const
{
	double dWidth1 = GetIWidth(nIndex1),
		dHigh1 = GetIHeight(nIndex1);
	if (fabs(dHigh1) < 1.0E-3)
	{
		dHigh1 = dWidth1;
	}

	double dWidth2 = GetIWidth(nIndex2),
		dHigh2 = GetIHeight(nIndex2);
	if (fabs(dHigh2) < 1.0E-3)
	{
		dHigh2 = dWidth2;
	}

	XPointList pts1, pts2;
	::GetDuctSidePts(pt1, dWidth1, dHigh1, vt, pts1);
	::GetDuctSidePts(pt2, dWidth2, dHigh2, vt, pts2);
	if (pts1.Length()!=4 || pts2.Length()!=4)
	{
		return FALSE;
	}
	
	X3DFace	face;
	face = ::GetFace1(*pts1[0], *pts1[1], *pts2[1], *pts2[0], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	face = ::GetFace1(*pts1[0], *pts1[3], *pts2[3], *pts2[0], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	face = ::GetFace1(*pts1[3], *pts1[2], *pts2[2], *pts2[3], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	face = ::GetFace1(*pts1[1], *pts1[2], *pts2[2], *pts2[1], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	
	if (bShow1) // 起点面
	{
		face = ::GetFace1(*pts1[0], *pts1[1], *pts1[2], *pts1[3]);
		faces.Append(new X3DFace(face));
	}
	if (bShow2) // 终点面
	{
		face = ::GetFace1(*pts2[0], *pts2[1], *pts2[2], *pts2[3]);
		faces.Append(new X3DFace(face));
	}
	return TRUE;
}





/////////////////////////////////////////////////////////////////////////////////
void InitDbDuctNode(BOOL bTrue)
{
    if (bTrue)
	{
        TDbDuctNode::rxInit();
		TDbDuctNode::InitMatchProtocol(TRUE);
    }
	else
	{
		deleteAcRxClass(TDbDuctNode::desc());
		TDbDuctNode::InitMatchProtocol(FALSE);
    }
}





////////////////////////////////所需全局函数/////////////////////////////////////
// 注：1、主要用于获取管径不等时，弯头中的弧段
//     2、其中，1为已知圆心的情况，2为已知角顶点的情况
XCurveSegment GetArcSeg1(XPoint pt1, XPoint ptCen, XPoint pt2,
						 double dWidth1, double dWidth2)
{
	XPoint ptArcMid;
	BOOL bSwitch(TRUE);
	XArc arc = ::GetRightArc(pt1, ptCen, pt2, bSwitch); // 获取优弧
	if (fabs(dWidth1 - dWidth2) > 0.001) // 管线宽度不一样
	{
		arc.MidPoint(ptArcMid);
		if (bSwitch)
			arc = XArc(pt1, ptArcMid, pt2);
		else
			arc = XArc(pt2, ptArcMid, pt1);
	}
	
	XCurveSegment seg;
	seg = arc;
	return seg;
}

XCurveSegment GetArcSeg2(XPoint pt1, XPoint ptInt, XPoint pt2,
						 double dRadius, double dWidth1, double dWidth2)
{
	XPoint ptTmp1, ptTmp2, ptTmpCen;
	AT_cal_fillet(pt1, ptInt, pt2, dRadius, ptTmp1, ptTmpCen, ptTmp2, FALSE); // 获取圆心
	XCurveSegment seg = ::GetArcSeg1(pt1, ptTmpCen, pt2, dWidth1, dWidth2);
	return seg;
}


XCurveSegment GetArcSeg3(XPoint ptStart, XPoint ptCen, XPoint &ptEnd,
						 double dRadius, double dAngle,
						 const AcGeVector3d &vecNormal, const AcGeVector3d &vecRef)
{
	AcGePoint3d pt1 = ptStart.AsAcGePoint3d(),
		pt2 = ptCen.AsAcGePoint3d();
	AcGeVector3d vec1 = pt1 - pt2,
		vec2 = pt1 - pt2;
	vec1 = vec1.rotateBy(dAngle, vecNormal);
	vec2 = vec2.rotateBy(2*PI-dAngle, vecNormal);

	XCurveSegment seg;
	double dDotProduct = vec1.dotProduct(vecRef);
	if (dDotProduct > 1.0E-6)
	{
		vec2 = vec2.normalize();
		AcGePoint3d ptTmp = pt2 + vec2*dRadius;
		ptEnd = XPoint(ptTmp);
		XArc arc(ptEnd, ptStart, dAngle);
		seg = arc;
	}
	else
	{
		vec1 = vec1.normalize();
		AcGePoint3d ptTmp = pt2 + vec1*dRadius;
		ptEnd = XPoint(ptTmp);
		XArc arc(ptStart, ptEnd, dAngle);
		seg = arc;
	}
	return seg;
}


/*============================================================================*
* 函 数 名：    GetDuctTrueMidPts
* 功能描述：    将连接件的位置点ptLoc，向各管线的中线做投影，获取投影点
* 备    注：    主要用于带偏心的三、四通绘制
==============================================================================*/
void GetDuctTrueMidPts(AcDbObjectId id, XPoint ptLoc,
					   const DList<AcDbObjectId> &ids,
					   const AcDbIntArray &types, XPointList &lstPts)
{
	lstPts.Reset();
	DList<XCurveSegment> lstSegs;
 	::GetSegs(id, ptLoc, ids, types, lstSegs);
	int nLen = ids.Length();
	if (lstSegs.Length() != nLen)
	{
		return;
	}

	for (int i=0; i<nLen; i++)
	{
		XPoint ptRes;
		lstSegs[i]->ProjectToMe(ptLoc, ptRes);
		lstPts.Append(new XPoint(ptRes));
	}
}


/*============================================================================*
* 函 数 名：    GetDuctSidePts
* 功能描述：    根据中线点ptMid，获取边线的四个角点
* 备    注：    如果是圆，则取其外接矩形；vtDraw为节点中的GetIDirection(i)
==============================================================================*/
void GetDuctSidePts(XPoint ptMid, double dWidth, double dHigh,
					XVector3D vtDraw, XPointList &lstPt)
{
	AcGeVector3d vt1 = vtDraw.AsAcGeVector3d(), // 长度方向
		vt2 = vt1.perpVector(), // 宽度方向
		vt3 = vt1.crossProduct(vt2); // 高度方向
	
	XVector3D vtZ(vt3);
	vtZ.Normalize();
	vtZ.Scale(dHigh/2.0);
	XPoint ptTmp1 = ptMid + vtZ,
		ptTmp2 = ptMid - vtZ;
	
	XVector3D vtY(vt2);
	vtY.Normalize();
	vtY.Scale(dWidth/2.0);
	XPoint pt1 = ptTmp1 + vtY,
		pt2 = ptTmp1 - vtY,
		pt4 = ptTmp2 + vtY,
		pt3 = ptTmp2 - vtY;
	
	lstPt.Reset();
	lstPt.Append(new XPoint(pt1));
	lstPt.Append(new XPoint(pt2));
	lstPt.Append(new XPoint(pt3));
	lstPt.Append(new XPoint(pt4));
}


/*============================================================================*
* 函 数 名：    Get2LineIntPts
* 功能描述：    求两条线的交点
==============================================================================*/
BOOL Get2LineIntPts(AcGePoint3d pt1, AcGePoint3d pt3, AcGePoint3d pt2,
					AcGePoint3d pt4, AcGePoint3d &ptInt)
{
	AcGePoint3dArray aryPts;
	AcDbLine line1(pt1, pt3),
		line2(pt4, pt2);
	if (line1.intersectWith(&line2, AcDb::kExtendBoth, aryPts) != Acad::eOk)
	{
		return FALSE;
	}

	if (aryPts.logicalLength() == 1) // 两直线直接相交
	{
		ptInt = aryPts[0];
		return TRUE;
	}

	AcGeVector3d vec1 = pt1 - pt3,
		vec2 = pt4 - pt2;
	if (vec1.isParallelTo(vec2) == Adesk::kTrue) // 两直线平行
	{
		AcGeVector3d vec = pt1 - pt2;
		ptInt = pt1 - vec*0.5;
		return TRUE;
	}

	AcGePlane proPlane1(pt3, vec1, vec2); // 投影平面
	AcGePoint3d ptPro1 = pt1.orthoProject(proPlane1), // 先投影到proPlane1平面内
		ptPro2 = pt2.orthoProject(proPlane1),
		ptPro3 = pt3.orthoProject(proPlane1),
		ptPro4 = pt4.orthoProject(proPlane1);
	AcDbLine l1(ptPro1, ptPro3),
		l2(ptPro4, ptPro2);
	AcGePoint3dArray IntPts1;
	if (l1.intersectWith(&l2, AcDb::kExtendBoth, IntPts1) != Acad::eOk) // 求交点
	{
		return FALSE;
	}
	if (IntPts1.logicalLength() < 1) // 没有交点
	{
		return FALSE;
	}
		
	AcGePlane proPlane2(pt4, vec1, vec2);
	ptPro1 = pt1.orthoProject(proPlane2); // 再投影到proPlane2平面内
	ptPro2 = pt2.orthoProject(proPlane2);
	ptPro3 = pt3.orthoProject(proPlane2);
	ptPro4 = pt4.orthoProject(proPlane2);
	AcDbLine l3(ptPro1, ptPro3),
		l4(ptPro4, ptPro2);
	AcGePoint3dArray IntPts2;
	if (l3.intersectWith(&l4, AcDb::kExtendBoth, IntPts2) != Acad::eOk) // 求交点
	{
		return FALSE;
	}
	if (IntPts2.logicalLength() < 1)
	{
		return FALSE;
	}

	AcGePoint3d ptInt1 = IntPts1[0], // 注：交点只可能有一个
		ptInt2 = IntPts2[0];
	vec1 = ptInt1 - ptInt2;
	ptInt = ptInt1 - vec1*0.5;
	return TRUE;
}


/*============================================================================*
* 函 数 名：    GetTHSplitPts
* 功能描述：    将DuctNode中的边线，分隔成指定的份数
* 备    注：    1、point1、point2：要获得的点的起止点，带Z坐标；
                   vt1、vt2：方向(GetIDirection(i))；
				   pointMid：弧中点，用来确定优劣弧及方向
                2、nSplitNum：从pt1到pt2的曲线上，分隔点的数量
				   0——返回2点，直线
				   1——返回3点，交点，虾米弯例外
				3、nMod：切割方式
				   0——用于弯头，两边为50短线，不够50时，用1
				   1——保证中间段为相切弧，取较短距离的0.9
				   2——用于风管，整体为一弧段
				   3——虾米弯
==============================================================================*/
void GetTHSplitPts(XPoint point1, XPoint point2, XVector3D vt1, XVector3D vt2,
				   int nSplitNum, XPointList &lstPts, int nMod, XPoint pointMid)
{
	lstPts.Reset();
	lstPts.Append(new XPoint(point1));
	if (nSplitNum == 0)
	{
		lstPts.Append(new XPoint(point2));
		return; // 注：总2个点
	}

	AcGePoint3d pt1 = point1.AsAcGePoint3d(),
		pt2 = point2.AsAcGePoint3d();
	AcGeVector3d vec1 = vt1.AsAcGeVector3d(), // 原来向量
		vec2 = vt2.AsAcGeVector3d();
	vec1.normalize();
	vec2.normalize();

	AcGePoint3d ptInt, ptCen;
	AcGePoint3d pt3 = pt1 - vec1*800, // 确定交点方向
		pt4 = pt2 - vec2*800;
	if (!::Get2LineIntPts(pt1, pt3, pt2, pt4, ptInt)) // 交点
	{
		return; // 注：非正常情况，只有一个点
	}
	
	if ((nSplitNum == 1) && (nMod != 3) && (nMod != 2))
	{
		lstPts.Append(new XPoint(ptInt));
		lstPts.Append(new XPoint(point2));
		return; // 注：没有弧段，总3个点
	}


	int nMode(nMod);
	double dDist1 = ptInt.distanceTo(pt1),
		dDist2 = ptInt.distanceTo(pt2);
	if ((nMod == 0) && (dDist1<50+1.0E-5 || dDist2<50+1.0E-5))
	{
		nMode = 1; // 不够50长度短线，改为0.9倍短线，注：从此往下应该用nMode
	}

	if (nMode == 1) // 保证中间段为相切弧，取较短距离的0.9
	{
		vec1 = ptInt - pt1;
		vec2 = ptInt - pt2;
		vec1.normalize();
		vec2.normalize();
		
		double dDist = dDist1>(dDist2+1.0E-6)?(0.9*dDist2):(0.9*dDist1); // 距顶点的距离
		AcGePoint3d ptRet1 = ptInt - vec1*dDist,
			ptRet2 = ptInt - vec2*dDist;
		lstPts.Append(new XPoint(ptRet1));
		if (nSplitNum == 2) // 注：没有弧段，总4个点
		{
			lstPts.Append(new XPoint(ptRet2));
			lstPts.Append(new XPoint(point2));
			return;
		}
		
		// 3、获得圆弧分隔点
		AcGeVector3d vecTmp = ptRet2 - ptRet1;
		AcGePoint3d ptMid1 = ptRet1 + vecTmp*0.5; // 直线中点
		double dTmpDist1 = ptMid1.distanceTo(ptRet1),
			dTmpDist2 = ptMid1.distanceTo(ptInt),
			dRadius = (dTmpDist1*dDist)/dTmpDist2, // 弧半径
			dTmp = sqrt(dRadius*dRadius + dDist*dDist) - dRadius;
		
		vecTmp = ptMid1 - ptInt;
		vecTmp.normalize();
		AcGePoint3d ptMid2 = ptInt + vecTmp*dTmp; // 弧中点
		
		AcGeCircArc3d arc(ptRet1, ptMid2, ptRet2); // 4、构造圆弧，平分为nSplitNum-1段
		double dStartParam = arc.paramOf(arc.startPoint()),
			dEndParam = arc.paramOf(arc.endPoint()),
			dLen = arc.length(dStartParam, dEndParam);
		dLen /= (nSplitNum-1);
		for (int i=1; i<nSplitNum-1; i++)
		{
			double dNewParam = arc.paramAtLength(dStartParam, dLen*i);
			AcGePoint3d ptTmp = arc.evalPoint(dNewParam);
			lstPts.Append(new XPoint(ptTmp));
		}
		lstPts.Append(new XPoint(ptRet2));
		lstPts.Append(new XPoint(point2)); // 5、获得全部拆分点
		return;
	}


	AcGePoint3d ptA1(pt1), ptA2(pt2);
	if (nMode == 0) // 注：统一代码使用
	{
		ptA1 = pt1 - vec1*50;
		ptA2 = pt2 - vec2*50;
	}

	AcGeVector3d vec3 = vec1.perpVector(), // 垂直向量
		vec4 = vec2.perpVector(),
		vecLine = ptA2 - ptA1; // 1—>2
	vec3.normalize();
	vec4.normalize();

	int nAType(0); // 1—>2顺时针
	double dAngle = vec1.angleTo(vec2, AcGeVector3d::kZAxis);
	if (dAngle > PI + 1.0E-6)
	{
		nAType += 1; // 2——>1为顺时针
	}
	
	AcGePoint3d	ptTmp = pointMid.AsAcGePoint3d();
	if ((nMod == 0) || (nMod == 3)) // 注：弯头为了防止内外弧发生位置错误
	{
		ptTmp = ptInt;
	}
	AcGeVector3d vecPerp = ptTmp - pt1;
	dAngle = vecLine.angleTo(vecPerp, AcGeVector3d::kZAxis);
	if (dAngle > PI + 1.0E-6)
	{
		nAType += 2; // 劣弧
	}
	
	AcGePoint3d pt5 = ptA1 + vec3*800, // 确定圆心方向
		pt6 = ptA2 - vec4*800;
	if ((nAType == 2) || (nAType == 3))
	{
		pt5 = ptA1 - vec3*800;
		pt6 = ptA2 + vec4*800;
	}

	if (!::Get2LineIntPts(ptA1, pt5, ptA2, pt6, ptCen)) // 圆心
	{
		return; // 注：非正常情况，只有一个点
	}

	vec3 = ptA1 - ptCen;
	vec4 = ptA2 - ptCen;
	dAngle = vec4.angleTo(vec3, AcGeVector3d::kZAxis);
	if (dAngle > PI + 1.0E-6)
	{
		dAngle = 2*PI - dAngle;
	}
	dAngle *= 0.5; // 夹角一半

	double dDist = ptA1.distanceTo(ptA2)*0.5,
		dRadius = dDist/fabs(sin(dAngle)); // 弧半径
	dDist1 = sqrt(dRadius*dRadius - dDist*dDist);
	dDist2 = (nAType==0||nAType==3)?(dRadius-dDist1):(dRadius+dDist1);
	dDist2 = (nAType==2||nAType==3)?(-dDist2):dDist2; // 两中点距离

	vec2 = vecLine.perpVector(); // 垂直方向
	vec2.normalize();
	
	AcGePoint3d ptMid = ptA2 - vecLine*0.5, // 弦中点
		ptArcMid = ptMid + vec2*dDist2;     // 弧中点
	AcGeCircArc3d arc(ptA1, ptArcMid, ptA2);
	double dStartParam = arc.paramOf(arc.startPoint()),
		dEndParam = arc.paramOf(arc.endPoint()),
		dLen = arc.length(dStartParam, dEndParam);

	if (nMode == 0) // 50短线
	{
		lstPts.Append(new XPoint(ptA1));
		if (nSplitNum == 2) // 注：没有弧段，总4个点
		{
			lstPts.Append(new XPoint(ptA2));
			lstPts.Append(new XPoint(point2));
			return;
		}
		
		dLen /= (nSplitNum-1);
		for (int i=1; i<nSplitNum-1; i++)
		{
			double dNewParam = arc.paramAtLength(dStartParam, dLen*i);
			AcGePoint3d ptTmp = arc.evalPoint(dNewParam);
			lstPts.Append(new XPoint(ptTmp));
		}
		lstPts.Append(new XPoint(ptA2));
	}
	else // 2、3
	{
		if (nSplitNum == 1)
		{
			lstPts.Append(new XPoint(ptArcMid));
			lstPts.Append(new XPoint(point2));
			return;
		}

		if (nMode == 2) // 用于风管，整体为一弧段
		{
			dLen /= (nSplitNum+1);
			for (int i=1; i<nSplitNum+1; i++)
			{
				double dNewParam = arc.paramAtLength(dStartParam, dLen*i);
				AcGePoint3d ptTmp = arc.evalPoint(dNewParam);
				lstPts.Append(new XPoint(ptTmp));
			}
		}
		else // 虾米弯
		{
			dLen /= (nSplitNum*2.0);
			for (int i=1; i<nSplitNum+1; i++)
			{
				double dNewParam = arc.paramAtLength(dStartParam, dLen*i);
				if (i != 1)
				{
					dNewParam = arc.paramAtLength(dStartParam, dLen*(i*2-1));
				}
				AcGePoint3d ptTmp = arc.evalPoint(dNewParam);
				lstPts.Append(new XPoint(ptTmp));
			}
		}
	}
	lstPts.Append(new XPoint(point2)); // 5、获得全部拆分点
}