#include "stdafx.h"
#include "ImpHvacTee.h"
#include "AuxTools.h"
#include "AecDbObjXDataMap.h"
#include "AecDbEntityBase.h"
#include "KTCADUtilityEx.h"

extern double MayAsMUnit(double dVal);
extern AcDb3dPolyline *Format3dPolyline(const AcGePoint3dArray &arPts);
static AcGeTol g_stol;
void GetEndPointIndex(const AcGePoint3dArray &ptArr, int &nIndex1, int &nIndex2, AcGeVector3d* pRangeDir = NULL)
{
	if (NULL == pRangeDir)
	{
		double dMaxDist(0.0), dDistNow(0.0);
		int i(0);
		// 先找出一端的点索引
		for (i = 0; i < ptArr.length(); i++)
		{
			dDistNow = ptArr[i].distanceTo(AcGePoint3d::kOrigin);
			if (dDistNow > dMaxDist)
			{
				nIndex1 = i;
				dMaxDist = dDistNow;
			}
		}

		// 另一端
		dMaxDist = 0.0;
		for (i = 0; i < ptArr.length(); i++)
		{
			dDistNow = ptArr[i].distanceTo(ptArr[nIndex1]);
			if (dDistNow > dMaxDist)
			{
				nIndex2 = i;
				dMaxDist = dDistNow;
			}
		}
	}
	else
	{
		const int iLen = ptArr.length();
		if (iLen < 1)
		{
			return;
		}

		// 获取投影后的点集
		AcGeLine3d line(ptArr[0], *pRangeDir);
		AcGePoint3dArray arpt;
		arpt.append(ptArr[0]);
		for (int i = 1; i < iLen; ++i)
		{
			arpt.append(line.closestPointTo(ptArr[i]));
		}

		// 查找极值
		nIndex1 = 0;
		double dPositive = 0.0;
		nIndex2 = 0;
		double dMinus = 0.0;
		AcGeVector3d vtIterate;
		for (i = 1; i < iLen; ++i)
		{
			vtIterate = arpt[i] - arpt[0];
			if (pRangeDir->angleTo(vtIterate) <1e-6)
			{
				if (vtIterate.length() > dPositive)
				{
					dPositive = vtIterate.length();
					nIndex1 = i;
				}
			} 
			else
			{
				if (vtIterate.length() > -dMinus)
				{
					dMinus = -vtIterate.length();
					nIndex2 = i;
				}
			}
		}
	}
}

ImpHvacTee::ImpHvacTee()
{
	g_stol.setEqualPoint(1.0);
	g_stol.setEqualVector(1.0 / 10.0);
	m_pXDataMap = NULL;
	m_pOwnerEnt = NULL;
}

ImpHvacTee::~ImpHvacTee()
{
}

Acad::ErrorStatus ImpHvacTee::transformBy( const AcGeMatrix3d& xform )
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

	// 获取各点位置
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);

	// 变换位置
	ptStart.transformBy(xform);
	ptBran.transformBy(xform);
	ptEnd.transformBy(xform);

	// 更新点
	m_pXDataMap->SetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->SetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->SetAt(HTEE_EndPoint, ptEnd);

	// 向量变换
	AcGeVector3d vtStart, vtEnd, vtBran;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	vtStart.transformBy(xform);
	vtEnd.transformBy(xform);
	vtBran.transformBy(xform);
	vtStart.normalize();
	vtEnd.normalize();
	vtBran.normalize();

	m_pXDataMap->SetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->SetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->SetAt(HTEE_BranchDir, vtBran);

	// 设置尺寸
	double dScale = xform.scale();
	double dStaWidth(0.0), dEndWidth(0.), dBranWidth(0.0), dThick(0.0), dBranThick(0.0);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStaWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);
	m_pXDataMap->GetAt(HTEE_Thick, dThick);
	m_pXDataMap->GetAt(HTEE_BranchThick, dBranThick);

	dStaWidth *= dScale;
	dEndWidth *= dScale;
	dBranWidth *= dScale;
	dThick *= dScale;
	dBranThick *= dScale;

	m_pXDataMap->SetAt(HTEE_StartWidth, dStaWidth);
	m_pXDataMap->SetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->SetAt(HTEE_BranchWidth, dBranWidth);
	m_pXDataMap->SetAt(HTEE_Thick, dThick);
	m_pXDataMap->SetAt(HTEE_BranchThick, dBranThick);

	double dEndThick(0.0);
	if (m_pXDataMap->GetAt(HTEE_EndThick, dEndThick))
	{
		dEndThick *= dScale;
		m_pXDataMap->SetAt(HTEE_EndThick, dEndThick);
	}

	return Acad::eOk;
}


AecEqui::Position ImpHvacTee::ExplainGripIndex( int nIndex ) const
{
	AecEqui::Position ePos = AecEqui::eStart;

	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	if (IsHorzAlignment())
	{
		if (nIndex == 0)
			ePos = AecEqui::eStart;
		else if (nIndex == 1)
			ePos = AecEqui::eEnd;
		else if (nIndex == 2)
			ePos = AecEqui::eBr1;
		else if (nIndex == 3)
			ePos = AecEqui::eCommand0;
		else if (nIndex == 4)
			ePos = AecEqui::eCommand1;
		else if (nIndex == 5)
			ePos = AecEqui::eCommand2;
		else if (nIndex == 6)
			ePos = AecEqui::eCommand3;
	}
	else if (IsSideVertAlignment())
	{
		if (nIndex == 0)
			ePos = AecEqui::eStart;
		else if (nIndex == 1)
			ePos = AecEqui::eEnd;
		else if (nIndex == 2)
			ePos = AecEqui::eBr1;
		else if (nIndex == 3)
		{
			if (eType == AecHvac::eVShapeBranch && eSectType == eCircle)
				ePos = AecEqui::eCommand2;
			else
				ePos = AecEqui::eCommand0;
		}
		else if (nIndex == 4)
			ePos = AecEqui::eCommand2;
	}
	else if (IsFaceVertAlignment())
	{
		if (nIndex == 0)
			ePos = AecEqui::eStart;
		else if (nIndex == 1)
			ePos = AecEqui::eEnd;
		else if (nIndex == 2)
			ePos = AecEqui::eBr1;
		else if (nIndex == 3)
		{
			if (eType == AecHvac::eVShapeBranch && eSectType == eCircle)
				ePos = AecEqui::eCommand2;
			else
				ePos = AecEqui::eCommand0;
		}
		else if (nIndex == 4)
			ePos = AecEqui::eCommand1;
		else if (nIndex == 5)
			ePos = AecEqui::eCommand2;
	}
	return ePos;
}

void ImpHvacTee::list() const
{
	ASSERT(NULL != m_pXDataMap);

	// 管件类型
	acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t   暖通：三通"));

	// 截面类型
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	switch (eSectType)
	{
	case eRect:	acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t   截面：矩形"));	break;
	case eCircle:	acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t   截面：圆形"));	break;
	case eOblate:		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t   截面：扁圆形"));	break;
	}

	double dRadRatio = 0.0;
	m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);
	acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t曲率值：%.2f"), dRadRatio);

	// 圆型截面显示直径
	if (eCircle == eSectType)
	{
		double dStartDiameter = 0.0, dEndDiameter = 0.0;
		m_pXDataMap->GetAt(HTEE_StartDiameter, dStartDiameter);
		m_pXDataMap->GetAt(HTEE_EndDiameter, dEndDiameter);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端直径：%.2f  末端直径：%.2f"), dStartDiameter, dEndDiameter);
		double dBranchDiameter = 0.0;
		m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranchDiameter);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管直径：%.2f"), dBranchDiameter);
	}
	// 非圆型截面显示宽度和厚度
	else
	{
		double dStartWidth = 0.0, dEndWidth = 0.0, dThick = 0.0;
		m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
		m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
		m_pXDataMap->GetAt(HTEE_Thick, dThick);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端宽度：%.2f  末端宽度：%.2f  厚度：%.2f"), dStartWidth, dEndWidth, dThick);
		double dBranchWidth = 0.0, dBranchThick = 0.0;
		m_pXDataMap->GetAt(HTEE_BranchWidth, dBranchWidth);
		m_pXDataMap->GetAt(HTEE_BranchThick, dBranchThick);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t支管宽度：%.2f  支管宽度：%.2f"), dBranchWidth, dBranchThick);

		double dEndThick(0.0);
		if (m_pXDataMap->GetAt(HTEE_EndThick, dEndThick))
			acutPrintf(_T("\n\t\t\t\t\t\t\t\t末端厚度：%.2f"), dEndThick);
	}

	// 起点
	AcGePoint3d pt;
	m_pXDataMap->GetAt(HTEE_StartPoint, pt);
	acutPrintf(_T("\n\t\t\t\t\t\t\t\t自 点，X=%.4f\t  Y=%.4f\t  Z=%.4f"), pt.x, pt.y, pt.z);

	// 终点
	m_pXDataMap->GetAt(HTEE_EndPoint, pt);
	acutPrintf(_T("\n\t\t\t\t\t\t\t\t到 点，X=%.4f\t  Y=%.4f\t  Z=%.4f"), pt.x, pt.y, pt.z);

	// 支管
	m_pXDataMap->GetAt(HTEE_BranchPoint, pt);
	acutPrintf(_T("\n\t\t\t\t\t\t\t\t支 管，X=%.4f\t  Y=%.4f\t  Z=%.4f"), pt.x, pt.y, pt.z);
}

AcGeVector3d ImpHvacTee::StartVect() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vt;
	m_pXDataMap->GetAt(HTEE_StartDir, vt);	
	return vt.normalize();
}

AcGeVector3d ImpHvacTee::EndVect() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vt;
	m_pXDataMap->GetAt(HTEE_EndDir, vt);	
	return vt.normalize();	
}

AcGeVector3d ImpHvacTee::BranVect() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vt;
	m_pXDataMap->GetAt(HTEE_BranchDir, vt);	
	return vt.normalize();	
}

AcGeVector3d ImpHvacTee::normal() const
{
	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	AcGeVector3d vtNormal;
	if (AecHvac::eVShapeBranch == eType && eRect == eSectType)
	{
		AcGePoint3d ptStart, ptEnd;
		m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
		m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
		AcGeVector3d vtEToS = ptStart - ptEnd;
		vtNormal = vtEToS.crossProduct(BranVect());
		vtNormal.normalize();
	} 
	else
	{
		vtNormal = StartVect().crossProduct(BranVect());
		if (vtNormal.length() < 1e-6)
		{
			AcGePoint3d ptS;
			m_pXDataMap->GetAt(HTEE_StartPoint, ptS);
			AcGePoint3d ptE;
			m_pXDataMap->GetAt(HTEE_EndPoint, ptE);
			AcGePoint3d ptB;
			m_pXDataMap->GetAt(HTEE_BranchPoint, ptB);
			AcGeVector3d vtFakeS = ptS - ptE;
			AcGeVector3d vtFakeB = ptB - ptE;
			vtNormal = vtFakeS.crossProduct(vtFakeB);
		}
		vtNormal.normalize();
	}
	return vtNormal;
}

BOOL ImpHvacTee::GetInclineCirPts(AcGePoint3dArray &arPts) const
{
	ASSERT(m_pXDataMap != NULL);
	
	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran;
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	double dPlusEdge = 0.0;

	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);

	AcGeVector3d vtStartP = vtStart;
	AcGeVector3d vtEndP = vtEnd;
	AcGeVector3d vtBranP = vtBran;
	
	if(!IsValidConst(NULL))
	{
		AcGePlane plane(ptStart, normal());
		ptBran = ptBran.orthoProject(plane);
		ptEnd = ptEnd.orthoProject(plane);
	}

	vtStartP.rotateBy(PI * 0.5, normal());
	vtEndP.rotateBy(PI * 0.5, normal());
	vtBranP.rotateBy(PI * 0.5, normal());
	vtStartP.normalize();
	vtEndP.normalize();
	vtBranP.normalize();
	
	// 0 - 17
	arPts.append(ptStart - vtStartP * dStartWidth * 0.5);
	arPts.append(ptStart);
	arPts.append(ptStart + vtStartP * dStartWidth * 0.5);
	arPts.append(ptEnd - vtEndP * dEndWidth * 0.5);
	arPts.append(ptEnd);
	arPts.append(ptEnd + vtEndP * dEndWidth * 0.5);
	arPts.append(ptBran - vtBranP * dBranWidth * 0.5);
	arPts.append(ptBran);
	arPts.append(ptBran + vtBranP * dBranWidth * 0.5);
	arPts.append(arPts[0] - vtStart * dPlusEdge);
	arPts.append(arPts[1] - vtStart * dPlusEdge);
	arPts.append(arPts[2] - vtStart * dPlusEdge);
	arPts.append(arPts[3] - vtEnd * dPlusEdge);
	arPts.append(arPts[4] - vtEnd * dPlusEdge);
	arPts.append(arPts[5] - vtEnd * dPlusEdge);
	arPts.append(arPts[6] - vtBran * dPlusEdge);
	arPts.append(arPts[7] - vtBran * dPlusEdge);
	arPts.append(arPts[8] - vtBran * dPlusEdge);

	AcGeVector3d vtTmp1, vtTmp2;
	vtTmp1 = arPts[15] - arPts[11];
	vtTmp2 = arPts[16] - arPts[10];

	// 18
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	AcGeVector3d vtTmp = AcGeVector3d::kIdentity;
	if (GetIntersectWith(arPts[10], arPts[11], vtTmp2.normalize(), vtTmp1.normalize(), ptTmp))
	{
		vtTmp = ptTmp - arPts[17];
	}
	else
	{
		vtTmp = BranVect();
	}

	vtTmp1 = arPts[12] - arPts[11];
	vtTmp1.normalize();
	vtTmp.normalize();
	if (!GetIntersectWith(arPts[17], arPts[12], vtTmp, vtTmp1, ptTmp))
		return FALSE;
	
	arPts.append(ptTmp);
	
	// 19
	vtTmp = arPts[18] - arPts[17];
	vtTmp.normalize();
	ptTmp = arPts[17] + vtTmp * arPts[11].distanceTo(arPts[15]);
	ptTmp = TAuxTools::Mid(ptTmp, arPts[11]);
	arPts.append(ptTmp);

	return arPts.length() > 0;
}

BOOL ImpHvacTee::GetInclineCirPts2d(AcGePoint3dArray &arPts) const
{
	ASSERT(m_pXDataMap != NULL);

	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran, vtNor(normal());
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	double dPlusEdge = 0.0;

	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	AcGeVector3d vtStartP = vtStart;
	AcGeVector3d vtEndP = vtEnd;
	AcGeVector3d vtBranP = vtBran;

	if(!IsValidConst(NULL))
	{
		AcGePlane plane(ptStart, normal());
		ptBran = ptBran.orthoProject(plane);
		ptEnd = ptEnd.orthoProject(plane);
	}

	vtStartP.rotateBy(PI * 0.5, normal());
	vtEndP.rotateBy(PI * 0.5, normal());
	vtBranP.rotateBy(PI * 0.5, normal());
	vtStartP.normalize();
	vtEndP.normalize();
	vtBranP.normalize();

	// 0 - 17
	arPts.append(ptStart - vtStartP * dStartWidth * 0.5);
	arPts.append(ptStart);
	arPts.append(ptStart + vtStartP * dStartWidth * 0.5);
	arPts.append(ptEnd - vtEndP * dEndWidth * 0.5);
	arPts.append(ptEnd);
	arPts.append(ptEnd + vtEndP * dEndWidth * 0.5);
	arPts.append(ptBran - vtBranP * dBranWidth * 0.5);
	arPts.append(ptBran);
	arPts.append(ptBran + vtBranP * dBranWidth * 0.5);
	arPts.append(arPts[0] - vtStart * dPlusEdge);
	arPts.append(arPts[1] - vtStart * dPlusEdge);
	arPts.append(arPts[2] - vtStart * dPlusEdge);
	arPts.append(arPts[3] - vtEnd * dPlusEdge);
	arPts.append(arPts[4] - vtEnd * dPlusEdge);
	arPts.append(arPts[5] - vtEnd * dPlusEdge);
	arPts.append(arPts[6] - vtBran * dPlusEdge);
	arPts.append(arPts[7] - vtBran * dPlusEdge);
	arPts.append(arPts[8] - vtBran * dPlusEdge);

	AcGeVector3d vtTmp1, vtTmp2;
	vtTmp1 = arPts[15] - arPts[11];
	vtTmp2 = arPts[16] - arPts[10];

	// 18
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	AcGeVector3d vtTmp = AcGeVector3d::kIdentity;
	if (GetIntersectWith(arPts[10], arPts[11], vtTmp2.normalize(), vtTmp1.normalize(), ptTmp))
		vtTmp = ptTmp - arPts[17];
	else
		vtTmp = BranVect();

	vtTmp1 = arPts[12] - arPts[11];
	vtTmp1.normalize();
	vtTmp.normalize();
	if (!GetIntersectWith(arPts[17], arPts[12], vtTmp, vtTmp1, ptTmp))
		return FALSE;

	arPts.append(ptTmp);

	// 19
	vtTmp = arPts[18] - arPts[17];
	vtTmp.normalize();
	ptTmp = arPts[17] + vtTmp * arPts[11].distanceTo(arPts[15]);

	Midpoint(ptTmp, arPts[11], ptTmp)
	arPts.append(ptTmp);

	// 对于倾斜三通和竖直三通,特殊处理,找到合适的点
	AcGeVector3d vtZAxis = TAuxTools::GetUcsZvt();
	AcGePlane plan(TAuxTools::Mid(ptStart, ptEnd), vtZAxis);

	// 翻边余量在平面上的距离
	double dStrPlus(0.0), dBranPlus(0.0), dDis(0.0);
	vtTmp = arPts[10] - arPts[1];
	vtTmp = vtTmp.orthoProject(vtZAxis);
	dStrPlus = vtTmp.length();
	vtTmp = arPts[7] - arPts[16];
	vtTmp = vtTmp.orthoProject(vtZAxis);
	dBranPlus = vtTmp.length();
	double dRatio = arPts[11].distanceTo(arPts[19]);

	double dMinDiffAng = PI/12;
	//GetGlobalContext()->GetAt(KEY_MINDIFFANG,dMinDiffAng);
	m_pXDataMap->GetAt(KEY_MINDIFFANG,dMinDiffAng);
	if (dMinDiffAng < 1e-6)
		dMinDiffAng = PI / 12;

	// 分成nSect个扇形截面
	int nSect = int(PI * 2 / dMinDiffAng);

	// ptJudge用来判断三通投影到平面后的内外边线,距离ptJudge近的为内边线,远的为外边线
	if (vtNor.isPerpendicularTo(TAuxTools::GetUcsZvt()))
		vtTmp1 = vtNor;				// 竖直三通(法向量垂直于Z轴,但vtStart不平行Z轴)
	else
		vtTmp1 = ptBran - ptEnd;	// 一般倾斜三通
	
	AcGePoint3d ptJudge;
	ptJudge = ptEnd + vtTmp1 * 10000;
	ptJudge = ptJudge.orthoProject(plan);

	// 主管截面
	AcGePoint3dArray arptSides, arPtJudge;
	AcGePoint3d pt = ptStart + vtNor * dStartWidth * 0.5;
	int i(0);
	for (; i <= nSect; i++)
	{
		if (i < 3)
			arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptStart));
		else
			break;
	}
	arPtJudge.append(ptJudge);

	// 尾管截面
	pt = ptEnd + vtNor * dEndWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		if (i < 3)
			arptSides.append(pt.rotateBy(dMinDiffAng, vtEnd, ptEnd));
		else
			break;
	}
	arPtJudge.append(ptJudge);

	// 支管截面
	pt = ptBran + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		if (i < 3)
			arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, ptBran));
		else
			break;
	}
	arPtJudge.append(ptJudge);

	// 支管近主管端截面(插入主管的截面)
	pt = arPts[19] + vtNor * dRatio;
	for (i = 0; i <= nSect; i++)
	{
		if (i < 3)
			arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, arPts[19]));
		else
			break;
	}
	arPtJudge.append(ptJudge);

	// 每个截面圆投影后求两个焦点,并设置高度为中点高度
	if (!TAuxTools::GetPrjPtsFromCircle(arptSides, arPtJudge))
		return FALSE;

	Midpoint(ptStart, ptEnd, ptTmp);
	for (i = 0; i < arPtJudge.length(); i++)
	{
		arPtJudge[i].z = ptTmp.z;
	}

	// 新的0-8
	arPts[2] = arPtJudge[0];
	arPts[0] = arPtJudge[1];
	Midpoint(arPts[0], arPts[2], arPts[1]);
	arPts[3] = arPtJudge[2];
	arPts[5] = arPtJudge[3];
	Midpoint(arPts[3], arPts[5], arPts[4]);
	arPts[6] = arPtJudge[4];
	arPts[8] = arPtJudge[5];
	Midpoint(arPts[6], arPts[8], arPts[7]);

	// 新的9-17
	vtStart = vtStart.orthoProject(vtZAxis);
	vtEnd = vtEnd.orthoProject(vtZAxis);
	vtBran = vtBran.orthoProject(vtZAxis);
	arPts[9] = arPts[0] - vtStart.normalize() * dStrPlus;
	arPts[10] = arPts[1] - vtStart * dStrPlus;
	arPts[11] = arPts[2] - vtStart * dStrPlus;

	arPts[12] = arPts[3] - vtEnd.normalize() * dStrPlus;
	arPts[13] = arPts[4] - vtEnd * dStrPlus;
	arPts[14] = arPts[5] - vtEnd * dStrPlus;

	arPts[15] = arPts[6] - vtBran.normalize() * dBranPlus;
	arPts[16] = arPts[7] - vtBran * dBranPlus;
	arPts[17] = arPts[8] - vtBran * dBranPlus;

	// 竖直三通,主管支管重叠
	if (IsIncVertAlignment())
	{
		vtNor = arPts[8] - arPts[6];
		arPts[18] = arPts[19] - vtNor.normalize() * dRatio;

		// 20
		arPts.append(arPts[19] + vtNor * dRatio);
		if (arPts[20].distanceTo(ptJudge) < arPts[18].distanceTo(ptJudge))
		{
			ptTmp = arPts[18];
			arPts[20] = arPts[18];
			arPts[18] = ptTmp;
		}
	}
	// 一般倾斜三通
	else if (IsInclineAlignment())													
	{
		// 18
		AcGeLine3d line(arPts[11], arPts[12]);
		AcGeLine3d line2(arPts[8], arPts[17]);
		if (Adesk::kTrue != line.intersectWith(line2, arPts[18]))
			return FALSE;
		// 19
		Midpoint(arPtJudge[6], arPtJudge[7], arPts[19]);
	}
	else
	{
		return FALSE;
	}

	return arPts.length() > 0;
}

BOOL ImpHvacTee::IsNeedMakeAllCurves(AcGePoint3dArray& arPtJudge) const
{
	AcGeLineSeg3d seg1(arPtJudge[11], arPtJudge[12]);
	return (Adesk::kFalse == seg1.isOn(arPtJudge[18]));
}

void ImpHvacTee::GetArcPoint(AcDbPolyline &polyLine, AcGePoint3dArray &ptArcArr) const
{
	if (polyLine.numVerts() != 4)
		return;
	
	double dPara1(0.0), dPara2(0.0);
	double dPar1, dPar2;
	AcGePoint3d pt0, pt1, pt2, pt3, ptMid;
	
	polyLine.getPointAt(0, pt0);
	polyLine.getPointAt(1, pt1);
	polyLine.getPointAt(2, pt2);
	polyLine.getPointAt(3, pt3);
	
	polyLine.getParamAtPoint(pt0, dPar1);
	polyLine.getParamAtPoint(pt1, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
	ptArcArr.append(pt0);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt1);
	
	polyLine.getParamAtPoint(pt1, dPar1);
	polyLine.getParamAtPoint(pt2, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt2);
	
	polyLine.getParamAtPoint(pt2, dPar1);
	polyLine.getParamAtPoint(pt3, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt3);
}

BOOL ImpHvacTee::GetInsertCirPts(AcGePoint3dArray &arPts) const
{
	ASSERT(m_pXDataMap != NULL);

	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran, vtNormal(normal());// Lixl add 调用一次就好
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	AcGeVector3d vtStartP = vtStart;
	AcGeVector3d vtEndP = vtEnd;
	AcGeVector3d vtBranP = vtBran;

	if(!IsValidConst(NULL))
	{
		AcGePlane plane(ptStart, /*normal()*/vtNormal);
		ptBran = ptBran.orthoProject(plane);
		ptEnd = ptEnd.orthoProject(plane);
	}

	vtStartP.rotateBy(PI * 0.5, /*normal()*/vtNormal);
	vtEndP.rotateBy(PI * 0.5, /*normal()*/vtNormal);
	vtBranP.rotateBy(PI * 0.5, /*normal()*/vtNormal);
	vtStartP.normalize();
	vtEndP.normalize();
	vtBranP.normalize();

	// 0 - 8
	arPts.append(ptStart - vtStartP * dStartWidth * 0.5);
	arPts.append(ptStart);
	arPts.append(ptStart + vtStartP * dStartWidth * 0.5);
	arPts.append(ptEnd - vtEndP * dEndWidth * 0.5);
	arPts.append(ptEnd);
	arPts.append(ptEnd + vtEndP * dEndWidth * 0.5);
	arPts.append(ptBran - vtBranP * dBranWidth * 0.5);
	arPts.append(ptBran);
	arPts.append(ptBran + vtBranP * dBranWidth * 0.5);

	AcGeVector3d vtTmp1, vtTmp2;
	vtTmp1 = arPts[2] - arPts[3];
	vtTmp2 = - vtTmp1;
	// 9 - 10
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	if (!GetIntersectWith(arPts[6], arPts[3], vtBran.normalize(), vtTmp1.normalize(), ptTmp))
		return FALSE;
	arPts.append(ptTmp);
	if (!GetIntersectWith(arPts[8], arPts[2], vtBran.normalize(), vtTmp2.normalize(), ptTmp))
		return FALSE;
	arPts.append(ptTmp);

	// 11
	vtBran.normalize();
	double dDis1 =  arPts[6].distanceTo(arPts[9]);
	double dDis2 = arPts[8].distanceTo(arPts[10]);
	ptTmp = ptBran - vtBran * ((dDis1 + dDis2) * 0.5 + dBranWidth * 0.15);
	arPts.append(ptTmp);

	// 12
	if (!GetIntersectWith(ptStart, ptBran, vtStart.normalize(), vtBran.normalize(), ptTmp))
		return FALSE;
	arPts.append(ptTmp);

	return arPts.length() > 0;
}

BOOL ImpHvacTee::GetInsertCirPtsOnHidePlan(AcGePoint3dArray &arPts) const
{
	ASSERT(m_pXDataMap != NULL);

	AcGePoint3d ptStart, ptEnd, ptBran, ptCenter;
	AcGeVector3d vtStart, vtEnd, vtBran;
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	// 计算三通中点消隐面
	Midpoint(ptStart, ptEnd, ptCenter);
	AcGePlane prjPlan(ptCenter, TAuxTools::GetUcsZvt());

	// 点和向量向消隐面投影
	ptStart = ptStart.orthoProject(prjPlan);
	ptEnd = ptEnd.orthoProject(prjPlan);
	ptBran = ptBran.orthoProject(prjPlan);

	// 平面向量
	vtStart = ptStart - ptCenter;
	vtBran = ptBran - ptCenter;
	vtEnd = ptEnd - ptCenter;
	vtStart.normalize();
	vtBran.normalize();
	vtEnd.normalize();

	AcGeVector3d vtStartP = vtStart;
	AcGeVector3d vtEndP = vtEnd;
	AcGeVector3d vtBranP = vtBran;

	AcGeVector3d vtRotateNor = vtStart.crossProduct(vtBran);
	vtStartP.rotateBy(PI * 0.5, vtRotateNor);
	vtEndP.rotateBy(PI * 0.5, vtRotateNor);
	vtBranP.rotateBy(PI * 0.5, vtRotateNor);

	// 0 - 8
	AcGePoint3d pt3d;
	arPts.append(ptStart - vtStartP * dStartWidth * 0.5);
	arPts.append(ptStart);
	arPts.append(ptStart + vtStartP * dStartWidth * 0.5);

	arPts.append(ptEnd - vtEndP * dEndWidth * 0.5);
	arPts.append(ptEnd);
	arPts.append(ptEnd + vtEndP * dEndWidth * 0.5);

	AcGePoint3d pt = ptBran - vtBranP * dBranWidth * 0.5;
	arPts.append(pt);
	arPts.append(ptBran);
	pt = ptBran + vtBranP * dBranWidth * 0.5;
	arPts.append(pt);
	
	AcGeVector3d vtTmp1, vtTmp2;
	vtTmp1 = arPts[2] - arPts[3];
	vtTmp2 = - vtTmp1;
	// 9 - 10
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	if (!GetIntersectWith(arPts[6], arPts[3], vtBran, vtTmp1, ptTmp))
		return FALSE;
	arPts.append(ptTmp);
	if (!GetIntersectWith(arPts[8], arPts[2], vtBran, vtTmp2, ptTmp))
		return FALSE;
	arPts.append(ptTmp);

	// 11
	vtBran.normalize();
	double dDis1 =  arPts[6].distanceTo(arPts[9]);
	double dDis2 = arPts[8].distanceTo(arPts[10]);
	ptTmp = ptBran - vtBran * ((dDis1 + dDis2) * 0.5 + dBranWidth * 0.15);
	arPts.append(ptTmp);

	// 12
	if (!GetIntersectWith(ptStart, ptBran, vtStart, vtBran, ptTmp))
		return FALSE;
	arPts.append(ptTmp);

	return arPts.length() > 0;
}

BOOL ImpHvacTee::GetIntersectWith(AcGePoint3d &pt1,AcGePoint3d &pt2,AcGeVector3d &vt1,AcGeVector3d &vt2,AcGePoint3d &ptIntersect) const
{
	AcGeLine3d line1,line2;
	line1.set(pt1,vt1);
	line2.set(pt2,vt2);
	return line1.intersectWith(line2, ptIntersect);
}

BOOL ImpHvacTee::GetIntersectWith(AcGePoint3d &pt1,AcGePoint3d &pt2,AcGePoint3d &pt3,AcGePoint3d &pt4,AcGePoint3d &ptIntersect) const
{
	AcGeLine3d line1,line2;
	line1.set(pt1,pt2);
	line2.set(pt3,pt4);
	return line1.intersectWith(line2, ptIntersect);
}

BOOL ImpHvacTee::IsHorzAlignment() const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	return normal().isParallelTo(vtZAxis, g_stol);	
}

BOOL ImpHvacTee::IsSideVertAlignment() const
{
	ASSERT(NULL != m_pXDataMap);

	AcGeVector3d vtNormal = normal();
	if (vtNormal.length() < 1e-3)
		return FALSE;

	// 取得位置点
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);

	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	AecHvac::HvacTeeType eType;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	if (AecHvac::eVShapeBranch == eType)
	{
		return StartVect().isPerpendicularTo(vtZAxis, g_stol) && vtNormal.isPerpendicularTo(vtZAxis, g_stol);
	}
	else
	{
		return StartVect().isParallelTo(vtZAxis, g_stol);
	}
}

BOOL ImpHvacTee::IsFaceVertAlignment() const
{	
	ASSERT(NULL != m_pXDataMap);

	AcGeVector3d vtNormal = normal();
	if (vtNormal.length() < 1e-3)
		return FALSE;
	
	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	AecHvac::HvacTeeType eType;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	ESection eSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (AecHvac::eVShapeBranch == eType && eRect == eSectType)
	{
		return StartVect().isParallelTo(vtZAxis, g_stol);
	}
	if (AecHvac::eVShapeBranch == eType && eCircle == eSectType)
	{
		AcGePoint3d ptStart, ptEnd;
		m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
		m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
		AcGeVector3d vtStart = ptEnd - ptStart;
		return vtStart.isPerpendicularTo(vtZAxis, g_stol) && vtNormal.isPerpendicularTo(vtZAxis, g_stol);
	}
	else
	{
		return StartVect().isPerpendicularTo(vtZAxis, g_stol) && vtNormal.isPerpendicularTo(vtZAxis, g_stol);
	}
}

// 倾斜垂直放置
BOOL ImpHvacTee::IsIncVertAlignment() const
{	
	ASSERT(NULL != m_pXDataMap);

	AcGeVector3d vtNormal = normal();
	if (vtNormal.length() < 1e-3)
		return FALSE;

	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	AecHvac::HvacTeeType eType;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	ESection eSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (AecHvac::eVShapeBranch == eType && eRect == eSectType)
	{
		return StartVect().isPerpendicularTo(vtZAxis, g_stol);
	}
	else
	{
		return vtNormal.isPerpendicularTo(vtZAxis, g_stol);
	}
}

BOOL ImpHvacTee::IsInclineAlignment() const
{
	ASSERT(NULL != m_pXDataMap);

	AcGeVector3d vtNormal(normal());
	if (vtNormal.length() < 1e-3)
		return FALSE;

	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	AcGeVector3d vtStart;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	
	AecHvac::HvacTeeType eType;
	ESection eSectType;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (AecHvac::eVShapeBranch == eType && eRect == eSectType)
	{
		return !vtStart.isParallelTo(vtZAxis, g_stol) && !vtStart.isPerpendicularTo(vtZAxis, g_stol) ;
	}
	return !(vtNormal.isParallelTo(vtZAxis, g_stol)) && !(vtNormal.isPerpendicularTo(vtZAxis, g_stol));
}

BOOL ImpHvacTee::IsSingleLine() const
{
	ASSERT(NULL != m_pXDataMap);

	BOOL bSingleLine = FALSE;
	m_pXDataMap->GetAt(HVAC_IsSingleLine, (int&)bSingleLine);
	return bSingleLine;
}

BOOL ImpHvacTee::IsBaseLine() const
{
	ASSERT(NULL != m_pXDataMap);

	BOOL bBaseLine = FALSE;
	m_pXDataMap->GetAt(HVAC_HasBaseLine, (int&)bBaseLine);
	return bBaseLine;
}

Acad::ErrorStatus ImpHvacTee::Draw3d(AcGiDraw &mode) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotImplementedYet;

	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	ESection eSectType = eRect;

	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	if(!IsValidConst(NULL) && eRect == eSectType)
	{
		DrawSpecial3d(mode);
		return Acad::eOk;
	}

	if (eType == AecHvac::eOrthoBranch)
	{
		if (eSectType == eRect)
			DrawOrthoRect3d(mode);
		else if (eSectType == eCircle)
			DrawInsertCircle3d(mode);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eInsertBranch || eType == AecHvac::eInsertIntubBranch)//承插
	{
		if (eSectType == eRect)
			DrawInsertRect3d(mode);
		else if (eSectType == eCircle)
		{
			DrawInsertBranchCircle3d(mode);//承插
		}
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eInclineBranch)//斜接
	{
		if (eSectType == eRect)
			DrawInclineRect3d(mode);
		else if (eSectType == eCircle)
		{
			DrawInclineBranchCircle3d(mode);//斜接
		}
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eYShapeBranch)
	{
		if (eSectType == eRect)
			DrawYShapeRect3d(mode);
		else if (eSectType == eCircle)
			DrawYShapeCircle3d(mode);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eVShapeBranch)
	{
		if (eSectType == eRect)
			DrawVShapeRect3d(mode);
		else if (eSectType == eCircle)
			DrawVShapeCircle3d(mode);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eTShapeBranch)
	{
		if (eSectType == eRect)
			DrawTShapeRect3d(mode);
		else if (eSectType == eCircle)
			DrawTShapeCircle3d(mode);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eArcuateBranch)
	{
		if (eSectType == eRect)
			DrawArcuateRect3d(mode);
		else if (eSectType == eCircle)
			DrawArcuateCircle3d(mode);
		else if (eSectType == eOblate)
			;
	}
	else if(eType == AecHvac::eArcuateIntubBranch)
	{
		if (eSectType == eRect)
			DrawArcuateIntubRect3d(mode);
		else if (eSectType == eCircle)
			DrawArcuateCircle3d(mode);
		else if (eSectType == eOblate)
			;
	}

	return Acad::eOk;
}

static bool GetSamplePoints(AcDbCurve *pCurve, int nDivSegs, AcGePoint3dArray &arPts)
{
	if (pCurve == NULL) return FALSE;

	double dS = 0, dE = 0;
	pCurve->getStartParam(dS);
	pCurve->getEndParam(dE);

	double dStep = (dE - dS) / nDivSegs;
	AcGePoint3d pt;

	for (int i = 0; i <= nDivSegs; i++)
	{
		if (Acad::eOk == pCurve->getPointAtParam(dS, pt))
		{
			arPts.append(pt);
		}
		dS += dStep;
	}

	return true;
}

void ImpHvacTee::DrawInsertBranchCircle3d(AcGiDraw &mode) const
{
	//开始端斜接直边长度 50
	double dLDisFrSta = 50;//毫米

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtEnd, vtBran,vtStart;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	double dStartWidth = 0, dEndWidth = 0, dBranWidth = 0;
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	vtEnd.normalize(); vtBran.normalize();
	AcGeVector3d vtBran45 = vtEnd + vtBran;
	vtBran45.normalize();

	//示意弧弦高
	double dArch = 50;

	AcGeVector3d vtNorm = vtEnd.crossProduct(vtBran);

	AcGePoint3d ptB1 = ptStart;
	ptB1 += vtBran * dStartWidth * 0.5;
	ptB1 += vtEnd * dLDisFrSta;

	AcGeVector3d vtL = vtEnd.orthoProject(vtBran45);
	vtL.normalize();

	AcGePoint3d ptB2Cen = ptB1 + vtL * dBranWidth * 0.5;

	AcGeLine3d lnC(ptB2Cen, vtBran45);
	AcGeLine3d lnM(ptStart, ptEnd);

	AcGePoint3d ptInt;
	if (lnM.intersectWith(lnC, ptInt))
	{
		double dM = ptStart.distanceTo(ptEnd);
		AcGePoint3d ptBrnFr = lnM.closestPointTo(ptBran);
		double dB = ptBrnFr.distanceTo(ptBran);

		double dL = dB * sqrt(2.0);
		AcGePoint3d ptBr2 = ptInt + dL * vtBran45;

		//down arc
		AcGePoint3d pt2 = ptBr2 + vtL * dBranWidth * 0.5;
		AcGeLine3d rayL2(pt2, vtBran45);

		AcGePoint3d ptSD = ptStart + vtBran * dStartWidth * 0.5;
		AcGePoint3d ptED = ptEnd + vtBran * dEndWidth * 0.5;
		AcGeLine3d lnD(ptSD, ptED);

		//下面弧段 45度
		double dRadRatio = 1.0;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);

		double dR = dRadRatio * dBranWidth;
		AcGePoint3d ptCen = ptBr2 - dR * vtL;

		//内弧
		AcGeVector3d vtM = vtL + vtEnd;
		vtM.normalize();

		double dMinDiffAng = PI / 12;
		m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
		if (dMinDiffAng < 1e-6)
		{
			dMinDiffAng = PI / 12;
		}

		//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
		int nSect = int(PI * 2 / dMinDiffAng);
		AcGeVector3d vtNor = normal();

		// 直管
		AcGePoint3dArray arptSides;
		AcGePoint3d pt = ptStart + vtNor * dStartWidth * 0.5;
		for (int i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptStart));
		}
		pt = ptEnd + vtNor * dEndWidth * 0.5;
		for (i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptEnd));
		}
		DrawMesh(mode, 2, nSect + 1, arptSides.asArrayPtr());

		//支管
		arptSides.setLogicalLength(0);
		pt = ptInt + vtNor * dBranWidth * 0.5;
		AcGeVector3d vtAxis = ptBr2 - ptInt;
		for (int i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, ptInt));
		}
		pt = ptBr2 + vtNor * dBranWidth * 0.5;
		for (i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, ptBr2));
		}
		DrawMesh(mode, 2, nSect + 1, arptSides.asArrayPtr());

		//弯头段
		AcDbArc *pArc = KTCADUtilityEx::FormatArc(ptCen + vtL * dR, ptCen + vtM * dR, ptCen + vtEnd * dR);
		if (pArc != NULL)
		{
			AcGePoint3dArray arPts;
			GetSamplePoints(pArc, 4, arPts);

			AcGePoint3d pt0, pt1;
			AcGeVector3d vtSeg;
			for (int ii = 0; ii < arPts.length() - 1; ii++)
			{
				pt0 = arPts.at(ii);
				pt1 = arPts.at(ii + 1);

				arptSides.setLogicalLength(0);
				pt = pt0 + vtNor * dBranWidth * 0.5;
				pArc->getFirstDeriv(pt0, vtAxis);
				for (int i = 0; i <= nSect; i++)
				{
					arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, pt0));
				}
				pt = pt1 + vtNor * dBranWidth * 0.5;
				pArc->getFirstDeriv(pt1, vtAxis);
				for (i = 0; i <= nSect; i++)
				{
					arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, pt1));
				}
				DrawMesh(mode, 2, nSect + 1, arptSides.asArrayPtr());
			}
			delete pArc;
		}
	}
}

bool ImpHvacTee::GetInsertBranchCircle2DInfs(AcArray<AecInterface> &arInfs) const
{
	//开始端斜接直边长度 50
	double dLDisFrSta = 50;//毫米

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtEnd, vtBran, vtStart;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	double dStartWidth = 0, dEndWidth = 0, dBranWidth = 0;
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	vtEnd.normalize(); vtBran.normalize();
	AcGeVector3d vtBran45 = vtEnd + vtBran;
	vtBran45.normalize();

	AecInterface inf;
	inf.ptPos = ptStart;
	inf.vtDir = vtStart;
	inf.dSize1 = dStartWidth;
	inf.dSize2 = 0.0;
	inf.nSectType = 1;
	arInfs.append(inf);

	inf.ptPos = ptEnd;
	inf.vtDir = vtEnd;
	arInfs.append(inf);


	//示意弧弦高
	double dArch = 50;

	AcGeVector3d vtNorm = vtEnd.crossProduct(vtBran);

	AcGePoint3d ptB1 = ptStart;
	ptB1 += vtBran * dStartWidth * 0.5;
	ptB1 += vtEnd * dLDisFrSta;

	AcGeVector3d vtL = vtEnd.orthoProject(vtBran45);
	vtL.normalize();

	AcGePoint3d ptB2Cen = ptB1 + vtL * dBranWidth * 0.5;

	AcGeLine3d lnC(ptB2Cen, vtBran45);
	AcGeLine3d lnM(ptStart, ptEnd);

	AcGePoint3d ptInt;
	if (lnM.intersectWith(lnC, ptInt))
	{
		double dM = ptStart.distanceTo(ptEnd);
		AcGePoint3d ptBrnFr = lnM.closestPointTo(ptBran);
		double dB = ptBrnFr.distanceTo(ptBran);

		double dL = dB * sqrt(2.0);
		AcGePoint3d ptBr2 = ptInt + dL * vtBran45;

		//down arc
		AcGePoint3d pt2 = ptBr2 + vtL * dBranWidth * 0.5;
		AcGeLine3d rayL2(pt2, vtBran45);

		AcGePoint3d ptSD = ptStart + vtBran * dStartWidth * 0.5;
		AcGePoint3d ptED = ptEnd + vtBran * dEndWidth * 0.5;
		AcGeLine3d lnD(ptSD, ptED);

		//下面弧段 45度
		double dRadRatio = 1.0;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);

		double dR = dRadRatio * dBranWidth;
		AcGePoint3d ptCen = ptBr2 - dR * vtL;

		//内弧
		AcGeVector3d vtM = vtL + vtEnd;
		vtM.normalize();

		double dMinDiffAng = PI / 12;
		m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
		if (dMinDiffAng < 1e-6)
		{
			dMinDiffAng = PI / 12;
		}

		//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
		int nSect = int(PI * 2 / dMinDiffAng);
		AcGeVector3d vtNor = normal();

		inf.ptPos = ptCen + vtEnd * dR;
		inf.vtDir = vtBran;
		inf.dSize1 = dBranWidth;
		arInfs.append(inf);
		
		return true;
	}
	return false;
}

bool ImpHvacTee::GetInclineBranchCircle2DInfs(AcArray<AecInterface> &arInfs) const
{
	//开始端斜接直边长度 50
	double dLDisFrSta = 0;//毫米

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtEnd, vtBran, vtStart;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	double dStartWidth = 0, dEndWidth = 0, dBranWidth = 0;
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	vtEnd.normalize(); vtBran.normalize();
	AcGeVector3d vtBran45 = vtEnd + vtBran;
	vtBran45.normalize();

	AecInterface inf;
	inf.ptPos = ptStart;
	inf.vtDir = vtStart;
	inf.dSize1 = dStartWidth;
	inf.dSize2 = 0.0;
	inf.nSectType = 1;
	arInfs.append(inf);

	inf.ptPos = ptEnd;
	inf.vtDir = vtEnd;
	arInfs.append(inf);

	//示意弧弦高
	double dArch = 50;

	AcGeVector3d vtNorm = vtEnd.crossProduct(vtBran);

	AcGePoint3d ptB1 = ptStart;
	ptB1 += vtBran * dStartWidth * 0.5;
	ptB1 += vtEnd * dLDisFrSta;

	AcGeVector3d vtL = vtEnd.orthoProject(vtBran45);
	vtL.normalize();

	AcGePoint3d ptB2Cen = ptStart;

	AcGeLine3d lnC(ptB2Cen, vtBran45);
	AcGeLine3d lnM(ptStart, ptEnd);

	AcGePoint3d ptInt;
	//if (lnM.intersectWith(lnC, ptInt))
	{
		ptInt = ptStart;
		double dM = ptStart.distanceTo(ptEnd);
		AcGePoint3d ptBrnFr = lnM.closestPointTo(ptBran);
		double dB = ptBrnFr.distanceTo(ptBran);

		double dL = dB * sqrt(2.0);
		AcGePoint3d ptBr2 = ptInt + dL * vtBran45;

		double dInR = lnC.distanceTo(ptB1);

		//down arc
		AcGePoint3d pt2 = ptBr2 + vtL * dBranWidth * 0.5;
		AcGePoint3d pt1 = ptB1 + vtL * dInR * 2.0;

		AcGeLine3d rayL2(pt2, pt1);

		AcGePoint3d ptSD = ptStart + vtBran * dStartWidth * 0.5;
		AcGePoint3d ptED = ptEnd + vtBran * dEndWidth * 0.5;
		AcGeLine3d lnD(ptSD, ptED);

		AcGePoint3d pt3;
		if (lnD.intersectWith(rayL2, pt3))
		{
			AcGePoint3d ptM;
			Midpoint(ptB1, pt3, ptM);
			ptM -= vtBran * dArch;
		}

		//下面弧段 45度
		double dRadRatio = 1.0;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);

		double dR = dRadRatio * dBranWidth;
		AcGePoint3d ptCen = ptBr2 - dR * vtL;

		//内弧
		AcGeVector3d vtM = vtL + vtEnd;
		vtM.normalize();

		double dMinDiffAng = PI / 12;
		m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
		if (dMinDiffAng < 1e-6)
		{
			dMinDiffAng = PI / 12;
		}

		//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
		int nSect = int(PI * 2 / dMinDiffAng);
		AcGeVector3d vtNor = normal();

		inf.ptPos = ptCen + vtEnd * dR;
		inf.vtDir = vtBran;
		inf.dSize1 = dBranWidth;
		arInfs.append(inf);

		return true;
	}
	return false;
}

void ImpHvacTee::DrawInclineBranchCircle3d(AcGiDraw &mode) const
{
	//开始端斜接直边长度 50
	double dLDisFrSta = 0;//毫米

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtEnd, vtBran, vtStart;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	double dStartWidth = 0, dEndWidth = 0, dBranWidth = 0;
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	vtEnd.normalize(); vtBran.normalize();
	AcGeVector3d vtBran45 = vtEnd + vtBran;
	vtBran45.normalize();

	//示意弧弦高
	double dArch = 50;

	AcGeVector3d vtNorm = vtEnd.crossProduct(vtBran);

	AcGePoint3d ptB1 = ptStart;
	ptB1 += vtBran * dStartWidth * 0.5;
	ptB1 += vtEnd * dLDisFrSta;

	AcGeVector3d vtL = vtEnd.orthoProject(vtBran45);
	vtL.normalize();

	AcGePoint3d ptB2Cen = ptStart;

	AcGeLine3d lnC(ptB2Cen, vtBran45);
	AcGeLine3d lnM(ptStart, ptEnd);

	AcGePoint3d ptInt;
	//if (lnM.intersectWith(lnC, ptInt))
	{
		ptInt = ptStart;
		double dM = ptStart.distanceTo(ptEnd);
		AcGePoint3d ptBrnFr = lnM.closestPointTo(ptBran);
		double dB = ptBrnFr.distanceTo(ptBran);

		double dL = dB * sqrt(2.0);
		AcGePoint3d ptBr2 = ptInt + dL * vtBran45;

		double dInR = lnC.distanceTo(ptB1);

		//down arc
		AcGePoint3d pt2 = ptBr2 + vtL * dBranWidth * 0.5;
		AcGePoint3d pt1 = ptB1 + vtL * dInR * 2.0;

		AcGeLine3d rayL2(pt2, pt1);

		AcGePoint3d ptSD = ptStart + vtBran * dStartWidth * 0.5;
		AcGePoint3d ptED = ptEnd + vtBran * dEndWidth * 0.5;
		AcGeLine3d lnD(ptSD, ptED);

		AcGePoint3d pt3;
		if (lnD.intersectWith(rayL2, pt3))
		{
			AcGePoint3d ptM;
			Midpoint(ptB1, pt3, ptM);
			ptM -= vtBran * dArch;
		}

		//下面弧段 45度
		double dRadRatio = 1.0;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);

		double dR = dRadRatio * dBranWidth;
		AcGePoint3d ptCen = ptBr2 - dR * vtL;

		//内弧
		AcGeVector3d vtM = vtL + vtEnd;
		vtM.normalize();

		double dMinDiffAng = PI / 12;
		m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
		if (dMinDiffAng < 1e-6)
		{
			dMinDiffAng = PI / 12;
		}

		//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
		int nSect = int(PI * 2 / dMinDiffAng);
		AcGeVector3d vtNor = normal();

		// 直管
		AcGePoint3dArray arptSides;
		AcGePoint3d pt = ptStart + vtNor * dStartWidth * 0.5;
		for (int i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptStart));
		}
		pt = ptEnd + vtNor * dEndWidth * 0.5;
		for (i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptEnd));
		}
		DrawMesh(mode, 2, nSect + 1, arptSides.asArrayPtr());

		//支管
		AcGeLine3d lnS(ptB1, ptBr2 - vtL * 0.5 * dBranWidth);
		double dSInR = lnS.distanceTo(ptStart);

		arptSides.setLogicalLength(0);
		pt = ptInt + vtNor * dSInR;
		AcGeVector3d vtAxis = ptBr2 - ptInt;
		for (int i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, ptInt));
		}
		pt = ptBr2 + vtNor * dBranWidth * 0.5;
		for (i = 0; i <= nSect; i++)
		{
			arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, ptBr2));
		}
		DrawMesh(mode, 2, nSect + 1, arptSides.asArrayPtr());

		//弯头段
		AcDbArc *pArc = KTCADUtilityEx::FormatArc(ptCen + vtL * dR, ptCen + vtM * dR, ptCen + vtEnd * dR);
		if (pArc != NULL)
		{
			AcGePoint3dArray arPts;
			GetSamplePoints(pArc, 4, arPts);

			AcGePoint3d pt0, pt1;
			AcGeVector3d vtSeg;
			for (int ii = 0; ii < arPts.length() - 1; ii++)
			{
				pt0 = arPts.at(ii);
				pt1 = arPts.at(ii + 1);

				arptSides.setLogicalLength(0);
				pt = pt0 + vtNor * dBranWidth * 0.5;
				pArc->getFirstDeriv(pt0, vtAxis);
				for (int i = 0; i <= nSect; i++)
				{
					arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, pt0));
				}
				pt = pt1 + vtNor * dBranWidth * 0.5;
				pArc->getFirstDeriv(pt1, vtAxis);
				for (i = 0; i <= nSect; i++)
				{
					arptSides.append(pt.rotateBy(dMinDiffAng, vtAxis, pt1));
				}
				DrawMesh(mode, 2, nSect + 1, arptSides.asArrayPtr());
			}
			delete pArc;
		}
	}
}

BOOL ImpHvacTee::DrawMesh(AcGiDraw &mode,const Adesk::UInt32 rows,const Adesk::UInt32 columns,const AcGePoint3d* pVertexList) const
{
	AcGePoint3dArray vertexArray;
	AcArray<Adesk::Int32> faceArray;

	int nV0 = 0,nV1 = 0,nV2 = 0;
	int nV3= 0;
	int nFaceIndex = 0;
	AcGePoint3d ptFace[4];

	for (int i = 0;i < rows - 1;i++)
	{
		for (int j = 0;j < columns - 1;j++)
		{
			nV0 = i * columns + j;
			nV1 = nV0 + 1;

			//第二行,第一个
			nV2 = (i + 1) * columns + j;

			nV3 = nV2 + 1;

			//三角:nV0-nV1-nV2
			faceArray.append(3);
			faceArray.append(nV0);//v0
			faceArray.append(nV1);//v1
			faceArray.append(nV2);//v2

			ptFace[0] = pVertexList[nV0];
			ptFace[1] = pVertexList[nV1];
			ptFace[2] = pVertexList[nV2];
			ptFace[3] = ptFace[0];
			//mode.DrawFace(ptFace);

			//三角:nV2-nV1-nV3
			faceArray.append(3);
			faceArray.append(nV2);//v2
			faceArray.append(nV1);//v1
			faceArray.append(nV3);//v3

			ptFace[0] = pVertexList[nV2];
			ptFace[1] = pVertexList[nV1];
			ptFace[2] = pVertexList[nV3];
			ptFace[3] = ptFace[0];
			//mode.DrawFace(ptFace);
		}
	}

	if (!faceArray.isEmpty())
	{
		int nIndex = 0;
		for (int i = 0;i < rows;i++)
		{
			for (int j = 0;j < columns;j++)
			{
				nIndex = i * columns + j;
				vertexArray.append(pVertexList[nIndex]);
			}
		}

		AcDbSubDMesh* pSubMesh = new AcDbSubDMesh;
		if ( Acad::eOk == pSubMesh->setSubDMesh(vertexArray,faceArray,0) )
		{
			mode.DrawEntity(pSubMesh);
			m_ar3DDrableBufPtrs_.append(pSubMesh);

			//有时候失败? 
			/*Acad::ErrorStatus es;
			AcDb3dSolid* pSolid = new AcDb3dSolid;
			if ( Acad::eOk == (es = pSubMesh->convertToSolid(false,false,pSolid) ) )
			{
				mode.DrawEntity(pSolid);
			}
			delete pSubMesh;
			*/
			return TRUE;
		}
		delete pSubMesh;
	}

	mode.DrawMeshS(rows,columns,pVertexList,false);
	return FALSE;
}

BOOL ImpHvacTee::DrawShell(AcGiDraw &mode,const Adesk::UInt32 nbVertex,const AcGePoint3d* pVertexList,const Adesk::UInt32 faceListSize,const Adesk::Int32* pFaceList) const
{
	AcGePoint3dArray vertexArray;
	AcArray<Adesk::Int32> faceArray;

	for(int i = 0;i < nbVertex;i++)
	{
		vertexArray.append(pVertexList[i]);
	}
	for (int j = 0;j < faceListSize;j++)
	{
		faceArray.append(pFaceList[j]);
	}

	AcDbSubDMesh* pSubMesh = new AcDbSubDMesh;
	if ( Acad::eOk == pSubMesh->setSubDMesh(vertexArray,faceArray,0) )
	{
		mode.DrawEntity(pSubMesh);
		m_ar3DDrableBufPtrs_.append(pSubMesh);

		//有时候失败? 
		/*Acad::ErrorStatus es;
		AcDb3dSolid* pSolid = new AcDb3dSolid;
		if ( Acad::eOk == (es = pSubMesh->convertToSolid(false,false,pSolid) ) )
		{
			mode.DrawEntity(pSolid);
		}
		delete pSubMesh;
		*/
		return TRUE;
	}
	delete pSubMesh;

	mode.DrawShell(nbVertex,pVertexList,faceListSize,pFaceList);
	return FALSE;
}

void ImpHvacTee::Move3DBuffer(AcDbVoidPtrArray& ar3DBuffer) const
{
	if (!m_ar3DDrableBufPtrs_.isEmpty())
	{
		ar3DBuffer.append(m_ar3DDrableBufPtrs_);
		m_ar3DDrableBufPtrs_.removeAll();
	}
}

bool ImpHvacTee::Has3DBuffer() const
{
	return !m_ar3DDrableBufPtrs_.isEmpty();
}

/*
	常规三通三维画法,各点示意图
//								
// 					0━━━━━━━━━8━━━━━━━7	 
// 					┃	                    		  ┃
// 		 			┃	                    		  ┃
// 					 ━━━━━━━━━━━━━━━━━	
// 					┃	            ┃   			  ┃
// 					┃	            ┃    			  ┃
// 					1━━━━━2    ┃	   5━━━━━6	
//      		              ┃    ┃    ┃			
//      	                  ┃    ┃    ┃			
//      	                  ┃    ┃    ┃			
//      	                  ┃    ┃    ┃			
//      	                   3━━━━━4			
//                                						   
*/

// 不同厚度、不同对齐方式或不同高度的三通绘制(暂定) add by hh 2011-01-11
BOOL ImpHvacTee::DrawSpecial3d(AcGiDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3dArray arptUp, arptDown;
	if (!GetInterfaceKeyPt(arptUp, arptDown))
	{
		return FALSE;
	}

	// 上面
	AcGePoint3d ptArUpPoly[4] = {arptUp[0], arptUp[1], arptUp[5], arptUp[4]};
	// 下面
	AcGePoint3d ptArDownPoly[4] = {arptDown[0], arptDown[1], arptDown[5], arptDown[4]};
	// 背面
	AcGePoint3d ptArBack[4] = {arptUp[0], arptDown[0], arptUp[5],  arptDown[5]};
	// 左侧面
	AcGePoint3d ptArLeft[4] = {arptUp[1], arptDown[1], arptUp[2],  arptDown[2]};
	// 右侧面
	AcGePoint3d ptArRight[4] = {arptUp[3], arptDown[3], arptUp[4],  arptDown[4]};
	// 支管上
	AcGePoint3d ptArColUp[4] = {arptUp[1], arptUp[2], arptUp[4],  arptUp[3]};
	// 支管下
	AcGePoint3d ptArColDown[4] = {arptDown[1], arptDown[2], arptDown[4],  arptDown[3]};

	DrawMesh(mode,2, 2, ptArUpPoly);
	DrawMesh(mode,2, 2, ptArDownPoly);
	DrawMesh(mode,2, 2, ptArBack);
	DrawMesh(mode,2, 2, ptArLeft);
	DrawMesh(mode,2, 2, ptArRight);
	DrawMesh(mode,2, 2, ptArColUp);
	DrawMesh(mode,2, 2, ptArColDown);

	return TRUE;
}

void ImpHvacTee::DrawOrthoRect3d(AcGiDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (9 != arptUp.length() || 9 != arptDown.length())
	{
		return;
	}

	//  上面
	AcGePoint3d ptArrUpPoly[9] = {arptUp[0], arptUp[1], arptUp[2], arptUp[3], 
								arptUp[4], arptUp[5], arptUp[6], arptUp[7], arptUp[8]};
	// 下面
	AcGePoint3d ptArrDownPoly[9] = {arptDown[0], arptDown[1], arptDown[2], arptDown[3], 
								arptDown[4], arptDown[5], arptDown[6], arptDown[7], arptDown[8]};
	// 背面　
	AcGePoint3d ptArrBack[6] = {arptUp[0], arptDown[0], arptUp[8],  arptDown[8], arptUp[7],  arptDown[7]};
	// 左侧面
	AcGePoint3d ptArrLeft[6] = {arptUp[1], arptDown[1], arptUp[2], arptDown[2], arptUp[3], arptDown[3]};
 	// 右侧面
	AcGePoint3d ptArrRight[6] = {arptUp[4], arptDown[4], arptUp[5], arptDown[5], arptUp[6], arptDown[6]};

#if ARX > 20
	int lFaceList[10] = { 9,0,1,2,3,4,5,6,7,8 };
#else
	long lFaceList[10] = { 9,0,1,2,3,4,5,6,7,8 };
#endif
	DrawShell(mode,9, ptArrUpPoly, 10, lFaceList);
	DrawShell(mode,9, ptArrDownPoly, 10, lFaceList);
	DrawMesh(mode,3, 2, ptArrBack);
	DrawMesh(mode,3, 2, ptArrLeft);
  	DrawMesh(mode,3, 2, ptArrRight);
}

void ImpHvacTee::DrawInsertRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (10 != arptUp.length() || 10 != arptDown.length())
	{
		return;
	}

	//  上面
	AcGePoint3d ptArrUp[10] = {arptUp[0], arptUp[1], arptUp[7], arptUp[8], arptUp[9],
									arptUp[2], arptUp[3], arptUp[4], arptUp[5], arptUp[6]};
	// 下面
	AcGePoint3d ptArrDown[10] = {arptDown[0], arptDown[1], arptDown[7], arptDown[8], arptDown[9],
									arptDown[2], arptDown[3], arptDown[4], arptDown[5], arptDown[6]};
	// 洞面
	AcGePoint3d ptArrHoleFace[8] = {arptUp[1], arptUp[7], arptDown[7], arptDown[1], arptUp[2], arptUp[6],
									arptDown[6], arptDown[2]};
	// 背面
	AcGePoint3d ptArrBackSide[6] = {arptUp[0], arptDown[0], arptUp[9], arptDown[9], arptUp[8], arptDown[8]};
	// 左侧面
	AcGePoint3d ptArrBranchLeft[6] = {arptUp[2], arptDown[2], arptUp[3],  arptDown[3], arptUp[4], arptDown[4]};
	// 右侧面
	AcGePoint3d ptArrBranchRight[4] = {arptUp[5], arptDown[5], arptUp[6],  arptDown[6]};

#if ARX > 20
	int lFaceList[12] = { 5, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9 };
	int lHoleFace[10] = { 4, 0, 1, 2, 3, -4, 4, 5, 6, 7 };
#else
	long lFaceList[12] = { 5, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9 };
	long lHoleFace[10] = { 4, 0, 1, 2, 3, -4, 4, 5, 6, 7 };
#endif
	DrawShell(mode,10, ptArrUp, 12, lFaceList);
	DrawShell(mode,10, ptArrDown, 12, lFaceList);
	DrawShell(mode,8, ptArrHoleFace, 10, lHoleFace);
	DrawMesh(mode,3, 2, ptArrBackSide);
	DrawMesh(mode,3, 2, ptArrBranchLeft);
	DrawMesh(mode,2, 2, ptArrBranchRight);
}

void ImpHvacTee::DrawInclineRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (10 != arptUp.length() || 10 != arptDown.length())
	{
		return;
	}

	//  上面
	AcGePoint3d ptArrUpPoly[10] = {arptUp[0], arptUp[1], arptUp[2], arptUp[3], arptUp[4],
									arptUp[5], arptUp[6], arptUp[7], arptUp[8], arptUp[9]};
	// 下面
	AcGePoint3d ptArrDownPoly[10] = {arptDown[0], arptDown[1], arptDown[2], arptDown[3], arptDown[4],
									arptDown[5], arptDown[6], arptDown[7], arptDown[8], arptDown[9]};
	// 背面
	AcGePoint3d ptArrBack[6] = {arptUp[0], arptDown[0], arptUp[9],  arptDown[9], arptUp[8],  arptDown[8]};
	// 左侧面
	AcGePoint3d ptArrLeft[8] = {arptUp[1], arptDown[1], arptUp[2], arptDown[2], arptUp[3], arptDown[3],
								arptUp[4], arptDown[4]};
	// 右侧面
	AcGePoint3d ptArrRight[6] = {arptUp[5], arptDown[5], arptUp[6], arptDown[6], arptUp[7], arptDown[7]};

	DrawMesh(mode,3, 2, ptArrBack);
#if ARX > 20
	int lFaceList[11] = { 10,0,1,2,3,4,5,6,7,8,9 };
#else
	long lFaceList[11] = { 10,0,1,2,3,4,5,6,7,8,9 };
#endif
	DrawShell(mode,10, ptArrUpPoly, 11, lFaceList);
	DrawShell(mode,10, ptArrDownPoly, 11, lFaceList);
	DrawMesh(mode,4, 2, ptArrLeft);
  	DrawMesh(mode,3, 2, ptArrRight);
}

void ImpHvacTee::DrawYShapeRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取上下表面关键点数据
	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (17 != arptUp.length() || 17 != arptDown.length())
	{
		return;
	}

	// 在上表面上添加弧线部分的数据
	double dAng = PI / 12;
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dAng);
	if (dAng < 1e-6)
	{
		dAng = PI / 12;
	}
	AcGeVector3d vtNormal(normal());
	int iLen15 = -1;
	iLen15 = FixPtsData(arptUp, 15, dAng, vtNormal);
	if (-1 == iLen15)
	{
		return;
	}
	int iLen13 = -1;
	iLen13 = FixPtsData(arptUp, 13, dAng, vtNormal);
	if (-1 == iLen13)
	{
		return;
	}
	int iLen8 = -1;
	iLen8 = FixPtsData(arptUp, 8, dAng, vtNormal);
	if (-1 == iLen8)
	{
		return;
	}
	int iLen3 = -1;
	iLen3 = FixPtsData(arptUp, 3, dAng, vtNormal);
	if (-1 == iLen3)
	{
		return;
	}

	// 在下表面上添加弧线部分的数据
	if (iLen15 != FixPtsData(arptDown, 15, dAng, vtNormal))
	{
		return;
	}
	if (iLen13 != FixPtsData(arptDown, 13, dAng, vtNormal))
	{
		return;
	}
	if (iLen8 != FixPtsData(arptDown, 8 ,dAng, vtNormal))
	{
		return;
	}
	if (iLen3 != FixPtsData(arptDown, 3, dAng, vtNormal))
	{
		return;
	}

	// 背面
	AcGePoint3dArray arptBack;
	arptBack.append(arptUp[0]);
	arptBack.append(arptDown[0]);
	int iEnd = 10 - 2 + iLen3 + iLen8;
	for (int i = arptUp.length() - 1; i > iEnd; i--)
	{
		arptBack.append(arptUp[i]);
		arptBack.append(arptDown[i]);
	}

	// 左侧面
	AcGePoint3dArray arptLeft;
	int iIndex = 1;
	for (i = 0; i < iLen3 + 4; i++)
	{
		arptLeft.append(arptUp[iIndex]);
		arptLeft.append(arptDown[iIndex]);
		iIndex++;
	}

	// 右侧面
	AcGePoint3dArray arptRight;
	for (i = 0; i < iLen8 + 4; i++)
	{
		arptRight.append(arptUp[iIndex]);
		arptRight.append(arptDown[iIndex]);
		iIndex++;
	}

#if ARX > 20
	CArray<int, int> arlgIndex;
#else
	CArray<long, long> arlgIndex;
#endif
	
	int iTot = arptUp.length();
	arlgIndex.Add(iTot);
	for (i = 0; i < iTot; i++)
	{
		arlgIndex.Add(i);
	}
	DrawShell(mode,iTot, arptUp.asArrayPtr(), (iTot + 1), &(arlgIndex[0]));
	DrawShell(mode,iTot, arptDown.asArrayPtr(), (iTot + 1), &(arlgIndex[0]));
	DrawMesh(mode,arptBack.length() / 2, 2, arptBack.asArrayPtr());
  	DrawMesh(mode,arptLeft.length() / 2, 2, arptLeft.asArrayPtr());
	DrawMesh(mode,arptRight.length() / 2, 2, arptRight.asArrayPtr());
}

void ImpHvacTee::DrawVShapeRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (13 != arptUp.length() || 13 != arptDown.length())
	{
		return;
	}

	//  上面
	AcGePoint3d ptArrUpPoly[13] = {arptUp[0], arptUp[1], arptUp[2], arptUp[3], arptUp[4], arptUp[5],
									arptUp[6], arptUp[7], arptUp[8], arptUp[9], arptUp[10], arptUp[11],
									arptUp[12]};
	// 下面
	AcGePoint3d ptArrDownPoly[13] = {arptDown[0], arptDown[1], arptDown[2], arptDown[3], arptDown[4],
										arptDown[5], arptDown[6], arptDown[7], arptDown[8], arptDown[9],
										arptDown[10], arptDown[11], arptDown[12]};
	// 背面
	AcGePoint3d ptArrBack[10] = {arptUp[12], arptDown[12], arptUp[11], arptDown[11], arptUp[10], 
									arptDown[10], arptUp[9], arptDown[9], arptUp[8], arptDown[8]};
	// 左侧面
	AcGePoint3d ptArrLeft[8] = {arptUp[0], arptDown[0], arptUp[1], arptDown[1], arptUp[2], arptDown[2],
								arptUp[3], arptDown[3]};
	// 右侧面
	AcGePoint3d ptArrRight[8] = {arptUp[4], arptDown[4], arptUp[5], arptDown[5], arptUp[6], arptDown[6],
									arptUp[7], arptDown[7]};

#if ARX > 20
	int lFaceList[14] = { 13, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
#else
	long lFaceList[14] = { 13, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
#endif
	DrawShell(mode,13, ptArrUpPoly, 14, lFaceList);
	DrawShell(mode,13, ptArrDownPoly, 14, lFaceList);
	DrawMesh(mode,5, 2, ptArrBack);
	DrawMesh(mode,4, 2, ptArrLeft);
  	DrawMesh(mode,4, 2, ptArrRight);
}

void ImpHvacTee::DrawTShapeRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取上下表面关键点数据
	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (14 != arptUp.length() || 14 != arptDown.length())
	{
		return;
	}

	// 在上表面上添加弧线部分的数据
	double dAng = PI / 12;
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dAng);
	if (dAng < 1e-6)
	{
		dAng = PI / 12;
	}
	AcGePoint3dArray arptInsert;
	AcGeVector3d vtNormal(normal());
	int iLen8 = -1;
	iLen8 = FixPtsData(arptUp, 8, dAng, vtNormal);
	if (-1 == iLen8)
	{
		return;
	}
	int iLen3 = -1;
	iLen3 = FixPtsData(arptUp, 3, dAng, vtNormal);
	if (-1 == iLen3)
	{
		return;
	}

	// 在下表面上添加弧线部分的数据
	if (iLen8 != FixPtsData(arptDown, 8 ,dAng, vtNormal))
	{
		return;
	}
	if (iLen3 != FixPtsData(arptDown, 3, dAng, vtNormal))
	{
		return;
	}

	int iFix = iLen3 + iLen8 - 2;

	// 背面
	AcGePoint3d ptArrBack[4] = {arptUp[0], arptDown[0], arptUp[11 + iFix], arptDown[11 + iFix]};
	// 左侧面
	AcGePoint3dArray arptLeft;
	int iIndex = 1;
	int iEnd = iLen3 + 4;
	for (int i = 0; i < iEnd; i++)
	{
		arptLeft.append(arptUp[iIndex]);
		arptLeft.append(arptDown[iIndex]);
		iIndex++;
	}
	// 右侧面
	AcGePoint3dArray arptRight;
	iEnd = iLen8 + 4;
	for (i = 0; i < iEnd; i++)
	{
		arptRight.append(arptUp[iIndex]);
		arptRight.append(arptDown[iIndex]);
		iIndex++;
	}

#if ARX > 20
	CArray<int, int> arlgIndex;
#else
	CArray<long, long> arlgIndex;
#endif
	int iTot = arptUp.length();
	arlgIndex.Add(iTot);
	for (i = 0; i < iTot; i++)
	{
		arlgIndex.Add(i);
	}
	DrawShell(mode,iTot, arptUp.asArrayPtr(), (iTot + 1), &(arlgIndex[0]));
	DrawShell(mode,iTot, arptDown.asArrayPtr(), (iTot + 1), &(arlgIndex[0]));
	DrawMesh(mode,2, 2, ptArrBack);
	DrawMesh(mode,arptLeft.length() / 2, 2, arptLeft.asArrayPtr());
	DrawMesh(mode,arptRight.length() / 2, 2, arptRight.asArrayPtr());
}

void ImpHvacTee::DrawArcuateRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取上下表面关键点数据
	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (13 != arptUp.length() || 13 != arptDown.length())
	{
		return;
	}
	
	// 在上表面上添加弧线部分的数据
	double dAng = PI / 12;
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dAng);
	if (dAng < 1e-6)
	{
		dAng = PI / 12;
	}
	AcGePoint3dArray arptInsert;
	AcGeVector3d vtNormal(normal());
	int iLen8 = -1;
	iLen8 = FixPtsData(arptUp, 8, dAng, vtNormal);
	if (-1 == iLen8)
	{
		return;
	}
	int iLen3 = -1;
	iLen3 = FixPtsData(arptUp, 3, dAng, vtNormal);
	if (-1 == iLen3)
	{
		return;
	}

	// 在下表面上添加弧线部分的数据
	if (iLen8 != FixPtsData(arptDown, 8 ,dAng, vtNormal))
	{
		return;
	}
	if (iLen3 != FixPtsData(arptDown, 3, dAng, vtNormal))
	{
		return;
	}
	
	int iFix = iLen3 + iLen8 -2;

	// 背面
	AcGePoint3d ptArrBack[4] = {arptUp[0], arptDown[0], arptUp[11 + iFix], arptDown[11 + iFix]};

	// 左侧面
	AcGePoint3dArray arptLeft;
	int iIndex = 1;
	int iEnd = iLen3 + 4;
	for (int i = 0; i < iEnd; i++)
	{
		arptLeft.append(arptUp[iIndex]);
		arptLeft.append(arptDown[iIndex]);
		iIndex++;
	}
	// 右侧面
	AcGePoint3dArray arptRight;
	iEnd = iLen8 + 4;
	for (i = 0; i < iEnd; i++)
	{
		arptRight.append(arptUp[iIndex]);
		arptRight.append(arptDown[iIndex]);
		iIndex++;
	}

#if ARX > 20
	CArray<int, int> arlgIndex;
#else
	CArray<long, long> arlgIndex;
#endif

	int iTot = arptUp.length();
	arlgIndex.Add(iTot);
	for (i = 0; i < iTot; i++)
	{
		arlgIndex.Add(i);
	}
	DrawShell(mode,iTot, arptUp.asArrayPtr(), (iTot + 1), &(arlgIndex[0]));
	DrawShell(mode,iTot, arptDown.asArrayPtr(), (iTot + 1), &(arlgIndex[0]));
	DrawMesh(mode,2, 2, ptArrBack);
	DrawMesh(mode,arptLeft.length() / 2, 2, arptLeft.asArrayPtr());
	DrawMesh(mode,arptRight.length() / 2, 2, arptRight.asArrayPtr());
}

void ImpHvacTee::DrawArcuateIntubRect3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取上下表面关键点数据
	AcGePoint3dArray arptUp, arptDown;
	if (!GetTwoSideKeyPt(arptUp, arptDown, TRUE))
	{
		return;
	}
	if (13 != arptUp.length() || 13 != arptDown.length())
	{
		return;
	}
	
	// 在上表面上添加弧线部分的数据
	double dAng = PI / 12;
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dAng);
	if (dAng < 1e-6)
	{
		dAng = PI / 12;
	}
	AcGePoint3dArray arptInsert;
	AcGeVector3d vtNormal(normal());
	int iLen8 = -1;
	iLen8 = FixPtsData(arptUp, 8, dAng, vtNormal);
	if (-1 == iLen8)
	{
		return;
	}
	int iLen3 = -1;
	iLen3 = FixPtsData(arptUp, 3, dAng, vtNormal);
	if (-1 == iLen3)
	{
		return;
	}
	
	// 在下表面上添加弧线部分的数据
	if (iLen8 != FixPtsData(arptDown, 8 ,dAng, vtNormal))
	{
		return;
	}
	if (iLen3 != FixPtsData(arptDown, 3, dAng, vtNormal))
	{
		return;
	}
	
	int iFix = iLen3 + iLen8 -2;
	
	// 上面
	AcGePoint3dArray arptUpFace;
	arptUpFace.append(arptUp[0]);
	arptUpFace.append(arptUp[1]);
	arptUpFace.append(arptUp[10 + iFix]);
	arptUpFace.append(arptUp[11 + iFix]);
	arptUpFace.append(arptUp[2]);
	int iIndex = 3;
	for (int i = 0; i < iLen3; i++)
	{
		arptUpFace.append(arptUp[iIndex]);
		iIndex++;
	}
	arptUpFace.append(arptUp[4 + iLen3 - 1]);
	arptUpFace.append(arptUp[5 + iLen3 - 1]);
	arptUpFace.append(arptUp[6 + iLen3 - 1]);
	arptUpFace.append(arptUp[7 + iLen3 - 1]);
	iIndex = 7 + iLen3;
	for (i = 0; i < iLen8; i++)
	{
		arptUpFace.append(arptUp[iIndex]);
		iIndex++;
	}
	arptUpFace.append(arptUp[9 + iFix]);

	// 下面
	AcGePoint3dArray arptDownFace;
	arptDownFace.append(arptDown[0]);
	arptDownFace.append(arptDown[1]);
	arptDownFace.append(arptDown[10 + iFix]);
	arptDownFace.append(arptDown[11 + iFix]);
	arptDownFace.append(arptDown[2]);
	iIndex = 3;
	for (i = 0; i < iLen3; i++)
	{
		arptDownFace.append(arptDown[iIndex]);
		iIndex++;
	}
	arptDownFace.append(arptDown[4 + iLen3 - 1]);
	arptDownFace.append(arptDown[5 + iLen3 - 1]);
	arptDownFace.append(arptDown[6 + iLen3 - 1]);
	arptDownFace.append(arptDown[7 + iLen3 - 1]);
	iIndex = 7 + iLen3;
	for (i = 0; i < iLen8; i++)
	{
		arptDownFace.append(arptDown[iIndex]);
		iIndex++;
	}
	arptDownFace.append(arptDown[9 + iFix]);


	// 洞面
	AcGePoint3d ptArrHoleFace[8] = {arptUp[1], arptUp[10 + iFix], arptDown[10 + iFix], arptDown[1],
									arptUp[2], arptUp[9 + iFix], arptDown[9 + iFix], arptDown[2]};

	// 背面
	AcGePoint3d ptArrBackSide[4] = {arptUp[0], arptDown[0], arptUp[11 + iFix], arptDown[11 + iFix]};

	// 左侧面
	AcGePoint3dArray arptBranchLeft;
	arptBranchLeft.append(arptUp[2]);
	arptBranchLeft.append(arptDown[2]);
	iIndex = 3;
	for (i = 0; i < iLen3; i++)
	{
		arptBranchLeft.append(arptUp[iIndex]);
		arptBranchLeft.append(arptDown[iIndex]);
		iIndex++;
	}
	arptBranchLeft.append(arptUp[4 + iLen3 - 1]);
	arptBranchLeft.append(arptDown[4 + iLen3 - 1]);
	arptBranchLeft.append(arptUp[5 + iLen3 - 1]);
	arptBranchLeft.append(arptDown[5 + iLen3 - 1]);

	// 右侧面
	AcGePoint3dArray arptBranchRight;
	arptBranchRight.append(arptUp[6 + iLen3 - 1]);
	arptBranchRight.append(arptDown[6 + iLen3 - 1]);
	arptBranchRight.append(arptUp[7 + iLen3 - 1]);
	arptBranchRight.append(arptDown[7 + iLen3 - 1]);
	iIndex = 7 + iLen3;
	for (i = 0; i < iLen8; i++)
	{
		arptBranchRight.append(arptUp[iIndex]);
		arptBranchRight.append(arptDown[iIndex]);
		iIndex++;
	}
	arptBranchRight.append(arptUp[9 + iFix]);
	arptBranchRight.append(arptDown[9 + iFix]);
	
	// 添加上下表面
#if ARX > 20
	int* pFaceList = new int[12 + iLen3 + iLen8];
	int* pHead = pFaceList;
#else
	long* pFaceList = new long[12 + iLen3 + iLen8];
	long* pHead = pFaceList;
#endif

	*pFaceList = 4;
	pFaceList++;
	*pFaceList = 0;
	pFaceList++;
	*pFaceList = 1;
	pFaceList++;
	*pFaceList = 2;
	pFaceList++;
	*pFaceList = 3;
	pFaceList++;
	*pFaceList = iLen3 + iLen8 + 6;
	iIndex = 4;
	for (i = 0; i < iLen3 + iLen8 + 6; i++)
	{
		pFaceList++;
		*pFaceList = iIndex;
		iIndex++;
	}
	DrawShell(mode,10 + iLen3 + iLen8, arptUpFace.asArrayPtr(), 12 + iLen3 + iLen8, pHead);
	DrawShell(mode,10 + iLen3 + iLen8, arptDownFace.asArrayPtr(), 12 + iLen3 + iLen8, pHead);
	delete []pHead;

	// 添加洞面
#if ARX > 20
	int lHoleFace[10] = { 4, 0, 1, 2, 3, -4, 4, 5, 6, 7 };
#else
	long lHoleFace[10] = { 4, 0, 1, 2, 3, -4, 4, 5, 6, 7 };
#endif
	
	DrawShell(mode,8, ptArrHoleFace, 10, lHoleFace);
	DrawMesh(mode,2, 2, ptArrBackSide);
	DrawMesh(mode,3 + iLen3, 2, arptBranchLeft.asArrayPtr());
	DrawMesh(mode,3 + iLen8, 2, arptBranchRight.asArrayPtr());
}

void ImpHvacTee::DrawOrthoCircle3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);
	
}

void ImpHvacTee::DrawInsertCircle3d( AcGiDraw &mode ) const
{
	//圆型普通三通
	AcGePoint3dArray arPts;
	if (!GetInsertCirPts(arPts))
		return;
	
	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran;
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	
	double dMinDiffAng = PI/12;
	m_pXDataMap->GetAt(KEY_MINDIFFANG,dMinDiffAng);
	if (dMinDiffAng < 1e-6)
	{
		dMinDiffAng = PI / 12;
	}
	
	//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
	int nSect = int(PI * 2 / dMinDiffAng);
	AcGeVector3d vtNor = normal();
	
	// 直管
	AcGePoint3dArray arptSides;
	AcGePoint3d pt = ptStart + vtNor * dStartWidth * 0.5;
	for (int i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptStart));
	}
	pt = ptEnd + vtNor * dEndWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, ptEnd));
	}
	DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
	
	// 支管
	arptSides.setLogicalLength(0);
	pt = ptBran + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, ptBran));
	}
	
	AcGePoint3d ptBr2 = AcGePoint3d::kOrigin;
	double dDis1 = arPts[6].distanceTo(arPts[9]);
	double dDis2 = arPts[8].distanceTo(arPts[10]);
	dDis1 = dDis1 > dDis2 ? dDis1 : dDis2;

	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	if (eSectType == eCircle)
		ptBr2 = arPts[7] - vtBran * (dDis1 + 0.5 * dBranWidth);
	else
		ptBr2 = arPts[7] - vtBran * dDis1;
	
	pt = ptBr2 + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, ptBr2));
	}
	DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());	
}

void ImpHvacTee::DrawInclineCircle3d( AcGiDraw &mode ) const
{
	//圆型 斜插三通
	AcGePoint3dArray arPts;
	if (!GetInclineCirPts(arPts))
		return;
	
	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran;
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	
	double dMinDiffAng = PI/12;
	m_pXDataMap->GetAt(KEY_MINDIFFANG,dMinDiffAng);
	if (dMinDiffAng < 1e-6)
	{
		dMinDiffAng = PI / 12;
	}
	
	//按照90°弯头分成nSect1个圆截面，每个圆截面分成nSect个点
	int nSect = int(PI * 2 / dMinDiffAng);
	AcGeVector3d vtNor = normal();
	
	AcGeVector3d vtMain = arPts[10] - arPts[13];
	vtMain.normalize();
	// 主管
	AcGePoint3dArray arptSides;
	AcGePoint3d pt = arPts[10] + vtNor * dStartWidth * 0.5;
	for (int i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtMain, arPts[10]));
	}
	pt = arPts[13] + vtNor * dEndWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtMain, arPts[13]));
	}
	DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());

	// 直边段
	/*arptSides.setLogicalLength(0);
	pt = arPts[1] + vtNor * dStartWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, arPts[1]));
	}
	pt = arPts[10] + vtNor * dStartWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtStart, arPts[10]));
	}
	DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());

	arptSides.setLogicalLength(0);
	pt = arPts[4] + vtNor * dEndWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtEnd, arPts[4]));
	}
	pt = arPts[13] + vtNor * dEndWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtEnd, arPts[13]));
	}
	DrawMesh(mode,2, nSect + 1, arptSides.asArrayPtr());
	*/

	// 支管直边
	/*arptSides.setLogicalLength(0);
	pt = arPts[7] + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, arPts[7]));
	}
	pt = arPts[16] + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, arPts[16]));
	}
	DrawMesh(mode,2, nSect + 1, arptSides.asArrayPtr());
	*/

	// 支管
	arptSides.setLogicalLength(0);
	pt = ptBran + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, arPts[16]));
	}

	vtMain = arPts[16] - arPts[19];
	vtMain.normalize();
	pt = arPts[19] + vtNor * dBranWidth * 0.5;// arPts[19].distanceTo(arPts[11]) * 0.8;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtMain, arPts[19]));
	}

	pt = arPts[19];
	AcDbLine ln(ptStart, ptEnd);
	AcGePoint3d pt2 = pt;
	ln.getClosestPointTo(pt, vtMain,pt2);

	pt = pt2;
	pt += vtNor * dStartWidth * 0.5;// arPts[19].distanceTo(arPts[11]) * 0.8;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtBran, pt2));
	}

	DrawMesh(mode, 3, nSect + 1, arptSides.asArrayPtr());

	// 支管
	/*vtMain = arPts[16] - arPts[19];
	vtMain.normalize();
	arptSides.setLogicalLength(0);
	pt = arPts[16] + vtNor * dBranWidth * 0.5;
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtMain, arPts[16]));
	}
	
	pt = arPts[19] + vtNor * arPts[19].distanceTo(arPts[11]);
	for (i = 0; i <= nSect; i++)
	{
		arptSides.append(pt.rotateBy(dMinDiffAng, vtMain, arPts[19]));
	}
	DrawMesh(mode,2, nSect + 1 , arptSides.asArrayPtr());
	*/
}

// Y形圆三通3D绘制，采用分别绘制两个（变径）弯头合并在一块，以减小难度
// 每个弯头用中心线作为每段圆的中心点
void ImpHvacTee::DrawYShapeCircle3d( AcGiDraw &mode ) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3dArray ptArr;
	if (!GetSectMidKeyPt(ptArr) || ptArr.length() != 17)
		return;

	AcGePoint3d ptSta, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptSta);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	double dStaRadius(0.0), dEndRadius(0.0), dBranRadius(0.0);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStaRadius);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndRadius);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranRadius);
	dStaRadius *= 0.5;
	dEndRadius *= 0.5;
	dBranRadius *= 0.5;

	AcGeVector3d vtStart(StartVect()), vtBran(BranVect()), vtEnd(EndVect()), vtNormal(normal());
	double dFlan(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dFlan);

	double dMinAngle(PI / 12), dCirMinAng(PI / 12);	// 圆的分度角
	//GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinAngle);
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinAngle);
	if (dMinAngle < 1e-6)
	{
		dMinAngle = PI / 12;
	}
	int nCirPart = int(PI * 2 / dMinAngle) + 1;
	dCirMinAng = PI * 2 / nCirPart;

	int i(0), k(0);

	// 起始端弯头//////////////////////////////////////////////////////////////////////////
	AcGePoint3dArray ptStaToMesh;
	AcGePoint3d ptEveCenter;	// 每段圆对应圆心
	int nStaRowNum(0);			// 网格行数

	// 法兰端直圆
	AcGeVector3d vtStaPer = vtNormal;
	ptEveCenter = ptSta;
	AcGePoint3d ptNow = ptEveCenter + dStaRadius * vtNormal;
	for (i = 0; i < nCirPart; i++)
	{
		ptStaToMesh.append(ptNow);
		ptNow.rotateBy(dCirMinAng, vtStart, ptEveCenter);
	}
	ptStaToMesh.append(ptStaToMesh.at(0));
	
	ptEveCenter = TAuxTools::Mid(ptArr[2], ptArr[16]);
	ptNow = ptEveCenter + dStaRadius * vtNormal;
	for (i = 0; i < nCirPart; i++)
	{
		ptStaToMesh.append(ptNow);
		ptNow.rotateBy(dCirMinAng, vtStart, ptEveCenter);
	}
	ptStaToMesh.append(ptStaToMesh.at(nCirPart + 1));
	nStaRowNum = 2;

	// 起始端弧
	AcGeVector3d vtBranPerl = vtBran;
	vtBranPerl.rotateBy(PI * 0.5, vtNormal);
	AcGePoint3d ptStaArcEnd = ptArr[4] + dBranRadius * vtBranPerl;	// 起始端圆弧终点
	AcGeLine3d lineStaPerl(ptArr[16], ptArr[2]);
	AcGeLine3d lineBranPerl(ptStaArcEnd, ptStaArcEnd + 100 * vtBranPerl);
	AcGePoint3d ptStaCenter;	// 起始端弧圆心
	if (lineStaPerl.intersectWith(lineBranPerl, ptStaCenter) != Adesk::kTrue)
		return;

	double dStaArcAngle = (fabs)((ptEveCenter - ptStaCenter).angleTo(ptStaArcEnd - ptStaCenter));
	int nStaPart = int(dStaArcAngle / dMinAngle) + 1;
	nStaPart *= 2;

	double dStaMinAngle = dStaArcAngle / nStaPart;
	// 起始端弧每段半径调整值（按起始端和支管段线性变化）
	double dStaRadOff = (dBranRadius - dStaRadius) / nStaPart;
	double dStaRadNow(dStaRadius);		// 针对每段弧半径
	AcGeVector3d vtStaEveRot;	// 每段弧法向

	for (i = 0; i < nStaPart; i++)
	{
		ptEveCenter.rotateBy(-dStaMinAngle, vtNormal, ptStaCenter);
		dStaRadNow += dStaRadOff; 
		ptNow = ptEveCenter + dStaRadNow * vtNormal;

		vtStaEveRot = ptEveCenter - ptStaCenter;
		vtStaEveRot.rotateBy(PI * 0.5, vtNormal);
		vtStaEveRot.normalize();

		for (k = 0; k < nCirPart; k++)
		{
			ptStaToMesh.append(ptNow);
			ptNow.rotateBy(dCirMinAng, vtStaEveRot, ptEveCenter);
		}
		ptStaToMesh.append(ptEveCenter + dStaRadNow * vtNormal);

		nStaRowNum++;
	}

	// 起始端支管直管段
	ptEveCenter = ptBran;
	ptNow = ptEveCenter + dBranRadius * vtNormal;
	for (i = 0; i < nCirPart + 1; i++)
	{
		ptStaToMesh.append(ptNow);
		ptNow.rotateBy(-dCirMinAng, vtBran, ptEveCenter);
	}
	nStaRowNum++;

	// 末端弯头
	AcGePoint3dArray ptEndToMesh;
	int nEndRowNum(0);

	// 法兰端直圆
	AcGeVector3d vtEndPer = vtNormal;
	ptEveCenter = ptEnd;
	ptNow = ptEveCenter + dEndRadius * vtNormal;
	for (i = 0; i < nCirPart; i++)
	{
		ptEndToMesh.append(ptNow);
		ptNow.rotateBy(-dCirMinAng, vtEnd, ptEveCenter);
	}
	ptEndToMesh.append(ptEndToMesh.at(0));
	
	ptEveCenter = TAuxTools::Mid(ptArr[9], ptArr[12]);
	ptNow = ptEveCenter + dEndRadius * vtNormal;
	for (i = 0; i < nCirPart; i++)
	{
		ptEndToMesh.append(ptNow);
		ptNow.rotateBy(-dCirMinAng, vtEnd, ptEveCenter);
	}
	ptEndToMesh.append(ptEndToMesh.at(nCirPart + 1));
	nEndRowNum = 2;

	// 末端端弧
	AcGePoint3d ptEndArcEnd = ptArr[7] - dBranRadius * vtBranPerl;	// 起始端圆弧终点
	AcGeLine3d lineEndPerl(ptArr[12], ptArr[9]);
	lineBranPerl.set(ptEndArcEnd, ptEndArcEnd + 100 * vtBranPerl);
	AcGePoint3d ptEndCenter;	// 末端端弧圆心
	if (lineEndPerl.intersectWith(lineBranPerl, ptEndCenter) != Adesk::kTrue)
		return;

	double dEndArcAngle = (fabs)((ptEveCenter - ptEndCenter).angleTo(ptEndArcEnd - ptEndCenter));
	int nEndPart = int(dEndArcAngle / dMinAngle) + 1;

	double dEndMinAngle = dEndArcAngle / nEndPart;
	// 末端弧每段半径调整值（按起始端和支管段线性变化）
	double dEndRadOff = (dBranRadius - dEndRadius) / nEndPart;
	double dEndRadNow(dEndRadius);		// 针对每段弧半径
	AcGeVector3d vtEndEveRot;	// 每段弧法向

	for (i = 0; i < nEndPart; i++)
	{
		ptEveCenter.rotateBy(dEndMinAngle, vtNormal, ptEndCenter);
		dEndRadNow += dEndRadOff; 
		ptNow = ptEveCenter + dEndRadNow * vtNormal;

		vtEndEveRot = ptEveCenter - ptEndCenter;
		vtEndEveRot.rotateBy(PI * 0.5, vtNormal);
		vtEndEveRot.normalize();

		for (k = 0; k < nCirPart; k++)
		{
			ptEndToMesh.append(ptNow);
			ptNow.rotateBy(dCirMinAng, vtEndEveRot, ptEveCenter);
		}
		ptEndToMesh.append(ptEveCenter + dEndRadNow * vtNormal);

		nEndRowNum++;
	}

	// 末端支管直管段
	ptEveCenter = ptBran;
	ptNow = ptEveCenter + dBranRadius * vtNormal;
	for (i = 0; i < nCirPart + 1; i++)
	{
		ptEndToMesh.append(ptNow);
		ptNow.rotateBy(dCirMinAng, vtBran, ptEveCenter);
	}
	nEndRowNum++;

	DrawMesh(mode,nStaRowNum, nCirPart + 1, ptStaToMesh.asArrayPtr());
	DrawMesh(mode,nEndRowNum, nCirPart + 1, ptEndToMesh.asArrayPtr());	
}

void ImpHvacTee::DrawVShapeCircle3d( AcGiDraw &mode ) const
{
	//圆型 V型三通
	ASSERT(NULL != m_pXDataMap);
	
	AcGeVector3d vtNormal(normal());
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()), vtBran(BranVect());
	AcGeVector3d vtStaSide(vtStart), vtEndSide(vtEnd), vtBranSide(vtBran);	// 每管向量垂直向量
	vtStaSide.rotateBy(PI*0.5, vtNormal);
	vtEndSide.rotateBy(PI*0.5, vtNormal);
	vtBranSide.rotateBy(PI*0.5, vtNormal);
	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0),dPlusEdge(50.0);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	vtBran.normalize();
	
	AcGePoint3dArray arpts, arptsMeshS,arptsMeshE,arptsMeshB, arptsMeshBE;
	GetVShapeCirclePts(arpts);
	
	double dMinDiffAng = PI/12;
	//GetGlobalContext()->GetAt(KEY_MINDIFFANG,dMinDiffAng);
	m_pXDataMap->GetAt(KEY_MINDIFFANG,dMinDiffAng);
	if (dMinDiffAng < 1e-6)
	{
		dMinDiffAng = PI / 12;
	}
	//开始面
	int nSect = int(2 * PI / dMinDiffAng) + 1;
	AcGePoint3d pt,ptCen,pt1,ptCen1,ptB,ptCenB;
	pt = arpts[10] + vtNormal * dStartWidth * 0.5;
	pt1 = arpts[11] + vtNormal * dEndWidth * 0.5;
	ptB = arpts[12] + vtNormal * dBranWidth * 0.5;

	arptsMeshS.append(pt);
	arptsMeshE.append(pt1);
	arptsMeshB.append(ptB);
	for (int i = 0; i < nSect; i++)
	{	
		//开始端面
		pt.rotateBy(dMinDiffAng, vtStart, arpts[10]);
		arptsMeshS.append(pt);
		
		//结束端面
		pt1.rotateBy(dMinDiffAng, vtEnd, arpts[11]);
		arptsMeshE.append(pt1);
		
		//支管端面
		ptB.rotateBy(dMinDiffAng, -vtBran, arpts[12]);
		arptsMeshB.append(ptB);
	}

	//开始面
	ptCen = arpts[10] - vtStart * dPlusEdge;
	ptCen1 = arpts[11] - vtEnd * dPlusEdge;
	pt = ptCen + vtNormal * dStartWidth * 0.5;
	pt1 = ptCen1 + vtNormal * dEndWidth * 0.5;
	arptsMeshS.append(pt);
	arptsMeshE.append(pt1);
	for (i = 0; i < nSect; i++)
	{	
		//开始端面
		pt.rotateBy(dMinDiffAng, vtStart, ptCen);
		arptsMeshS.append(pt);
		
		//结束端面
		pt1.rotateBy(dMinDiffAng, vtEnd, ptCen1);
		arptsMeshE.append(pt1);
	}

	//终止面
	pt = arpts[14] + vtNormal * arpts[14].distanceTo(arpts[2]);
	arptsMeshS.append(pt);
	
	pt1 = arpts[15] + vtNormal * arpts[15].distanceTo(arpts[5]);
	arptsMeshE.append(pt1);
	
	ptCenB = arpts[12] - vtBran * 50;
	ptB = ptCenB + vtNormal * dBranWidth * 0.5;
	arptsMeshB.append(ptB);
	arptsMeshBE.append(ptB);

	for (i = 0; i < nSect; i++)
	{
		//开始端面
		pt.rotateBy(dMinDiffAng, vtStart, arpts[14]);
		arptsMeshS.append(pt);
		
		//结束端面
		pt1.rotateBy(dMinDiffAng, vtEnd, arpts[15]);
		arptsMeshE.append(pt1);
		
		//支管端面
		ptB.rotateBy(dMinDiffAng, -vtBran, ptCenB);
		arptsMeshB.append(ptB);
		arptsMeshBE.append(ptB);
	}

	arptsMeshS.append(arptsMeshBE);
	arptsMeshE.append(arptsMeshBE);

	DrawMesh(mode,4 , nSect + 1, arptsMeshS.asArrayPtr());
	DrawMesh(mode,4 , nSect + 1, arptsMeshE.asArrayPtr());
	DrawMesh(mode,2 , nSect + 1, arptsMeshB.asArrayPtr());
}

void ImpHvacTee::DrawTShapeCircle3d( AcGiDraw &mode ) const
{
	
}

void ImpHvacTee::DrawArcuateCircle3d( AcGiDraw &mode ) const
{
	DrawInsertCircle3d(mode);
}

// 2DCurve
Acad::ErrorStatus ImpHvacTee::Draw2d( AcGiDraw &mode ) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}
	
	AecComplexCurve cplCurve;
	MakeCurves(cplCurve);
	
	AecComplexCurveDraw edage;
	edage.SetEdage(cplCurve);
	
	AcDbObjectId idReal = m_idDoubleLayer;
	AcDbObjectId idDash = m_idDashLayer;
	AcDbObjectId idCent = m_idCenterLayer;
	
	edage.Draw2d(mode,idReal,idDash,idCent,NULL,FALSE,FALSE);

	AecComplexCurve cplCen;
	GetCurvesInSide(cplCen);

	edage.SetEdage(cplCen);
	edage.Draw2d(mode,idReal,idDash,idCent,NULL,FALSE,FALSE);

	return Acad::eOk;
}

BOOL ImpHvacTee::MakeCurves( AecComplexCurve& cplCurve ) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	return CusTomMakeCurves(cplCurve, 0);
}

BOOL ImpHvacTee::GetCurvesInSide( AecComplexCurve& cplCurve ) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	return CusTomMakeCurves(cplCurve, 1);
}

BOOL ImpHvacTee::CusTomMakeCurves( AecComplexCurve& cplCurve, const int &nOutOrIn) const
{
	ASSERT(NULL != m_pXDataMap);
	
	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	ESection eSectType = eRect;
	
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	
	if (eType == AecHvac::eOrthoBranch)
	{
		if (eSectType == eRect)
			return MakeOrthoRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
		{
			return MakeInsertCircle2DCurves(cplCurve, nOutOrIn);
		}
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eInsertBranch)//承插
	{
		if (eSectType == eRect)
			return MakeInsertRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
		{
			//承插 -- 圆型
			return MakeInsertBranchCircle2DCurves(cplCurve, nOutOrIn);
		}
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eInsertIntubBranch)
	{
		if (eSectType == eRect)
			return MakeInsertIntubRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
			return MakeInsertCircle2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eInclineBranch)//斜接
	{
		if (eSectType == eRect)
			return MakeInclineRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
		{
			//斜接 -- 圆型
			m_pXDataMap->SetAt(HVAC_PlusEdge, 0.1);//
			return MakeInclineBranchCircle2DCurves(cplCurve, nOutOrIn);
		}
		else if (eSectType == eOblate);
	}
	else if (eType == AecHvac::eYShapeBranch)
	{
		if (eSectType == eRect)
			return MakeYShapeRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
			return MakeYShapeCircle2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eVShapeBranch)
	{
		if (eSectType == eRect)
			return MakeVShapeRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
			return MakeVShapeCircle2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eTShapeBranch)
	{
		if (eSectType == eRect)
			return MakeTShapeRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
			;
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eArcuateBranch)
	{
		if (eSectType == eRect)
			return MakeArcuateRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
			return MakeInsertCircle2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eOblate)
			;
	}
	else if (eType == AecHvac::eArcuateIntubBranch)
	{
		if (eSectType == eRect)
			return MakeArcuateIntubRect2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eCircle)
			return MakeInsertCircle2DCurves(cplCurve, nOutOrIn);
		else if (eSectType == eOblate)
			;
	}
	return FALSE;		
}

//承插 -- 圆型
BOOL ImpHvacTee::MakeInsertBranchCircle2DCurves(AecComplexCurve & cplCurve, const int &nOutOrIn) const
{
	//开始端斜接直边长度 50
	double dLDisFrSta = 50;//毫米

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtEnd, vtBran;
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	double dStartWidth = 0, dEndWidth = 0, dBranWidth = 0;
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	vtEnd.normalize(); vtBran.normalize();
	AcGeVector3d vtBran45 = vtEnd + vtBran;
	vtBran45.normalize();

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;
	
	//示意弧弦高
	double dArch = 50;

	AcGeVector3d vtNorm = vtEnd.crossProduct(vtBran);
	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//平放
	{
		AcGePoint3d ptB1 = ptStart;
		ptB1 += vtBran * dStartWidth * 0.5;
		ptB1 += vtEnd * dLDisFrSta;

		AcGeVector3d vtL = vtEnd.orthoProject(vtBran45);
		vtL.normalize();

		AcGePoint3d ptB2Cen = ptB1 + vtL * dBranWidth * 0.5;

		AcGeLine3d lnC(ptB2Cen,vtBran45);
		AcGeLine3d lnM(ptStart, ptEnd);

		AcGePoint3d ptInt;
		if (lnM.intersectWith(lnC, ptInt))
		{
			double dM = ptStart.distanceTo(ptEnd);
			AcGePoint3d ptBrnFr = lnM.closestPointTo(ptBran);
			double dB = ptBrnFr.distanceTo(ptBran);

			double dL = dB * sqrt(2.0);
			AcGePoint3d ptBr2 = ptInt +  dL * vtBran45;

			//sta
			tCurveEle.ptGe[0] = ptStart - vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptStart + vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//top
			tCurveEle.ptGe[0] = ptStart - vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd - vtBran * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//end
			tCurveEle.ptGe[0] = ptEnd - vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd + vtBran * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//dowmL
			tCurveEle.ptGe[0] = ptStart + vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptB1;
			tCurveEle.ptGe[2] = ptB1;
			cplCurve.append(tCurveEle);

			//down arc
			AcGePoint3d pt2 = ptBr2 + vtL * dBranWidth * 0.5;
			AcGeLine3d rayL2(pt2, vtBran45);

			AcGePoint3d ptSD = ptStart + vtBran * dStartWidth * 0.5;
			AcGePoint3d ptED = ptEnd + vtBran * dEndWidth * 0.5;
			AcGeLine3d lnD(ptSD, ptED);

			AcGePoint3d pt3;
			if (lnD.intersectWith(rayL2, pt3))
			{
				AcGePoint3d ptM;
				Midpoint(ptB1, pt3,ptM);
				ptM -= vtBran * dArch;

				//拟合弧
				tCurveEle.ptGe[0] = ptB1;
				tCurveEle.ptGe[1] = ptM;
				tCurveEle.ptGe[2] = pt3;
				cplCurve.append(tCurveEle);

				//downR
				tCurveEle.ptGe[0] = pt3;
				tCurveEle.ptGe[1] = ptEnd + vtBran * 0.5 * dEndWidth;;
				tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
				cplCurve.append(tCurveEle);
			}

			//br
			tCurveEle.ptGe[0] = ptB1;
			tCurveEle.ptGe[1] = ptBr2 - vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = ptBr2 - vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[1] = ptBr2 + vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = pt3;
			tCurveEle.ptGe[1] = ptBr2 + vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//下面弧段 45度
			double dRadRatio = 1.0;
			m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);

			double dR = dRadRatio * dBranWidth;
			AcGePoint3d ptCen = ptBr2 - dR * vtL;

			//内弧
			AcGeVector3d vtM = vtL + vtEnd;
			vtM.normalize();

			tCurveEle.ptGe[0] = ptCen + vtL * (dR - 0.5 * dBranWidth);
			tCurveEle.ptGe[1] = ptCen + vtM * (dR - 0.5 * dBranWidth);
			tCurveEle.ptGe[2] = ptCen + vtEnd * (dR - 0.5 * dBranWidth);
			cplCurve.append(tCurveEle);

			//外弧
			tCurveEle.ptGe[0] = ptCen + vtL * (dR + 0.5 * dBranWidth);
			tCurveEle.ptGe[1] = ptCen + vtM * (dR + 0.5 * dBranWidth);
			tCurveEle.ptGe[2] = ptCen + vtEnd * (dR + 0.5 * dBranWidth);
			cplCurve.append(tCurveEle);

			//封口
			tCurveEle.ptGe[0] = ptCen + vtEnd * (dR - 0.5 * dBranWidth);
			tCurveEle.ptGe[1] = ptCen + vtEnd * (dR + 0.5 * dBranWidth);
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//分段线
			AcDbArc *pArc = KTCADUtilityEx::FormatArc(ptCen + vtL * dR, ptCen + vtM * dR, ptCen + vtEnd * dR);
			if (pArc != NULL)
			{
				AcGePoint3dArray arPts;
				GetSamplePoints(pArc, 4, arPts);

				AcGeVector3d vtSeg;
				for (int ii = 1;ii < arPts.length() - 1;ii++)
				{
					vtSeg = arPts.at(ii) - ptCen;
					vtSeg.normalize();
					
					tCurveEle.ptGe[0] = arPts.at(ii) - vtSeg * 0.5 * dBranWidth;
					tCurveEle.ptGe[1] = arPts.at(ii) + vtSeg * 0.5 * dBranWidth;
					tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
					tCurveEle.nColorIndex = 4;
					cplCurve.append(tCurveEle);
				}

				delete pArc;
			}


			//中心线
			tCurveEle.ptGe[0] = ptStart;
			tCurveEle.ptGe[1] = ptEnd;
			tCurveEle.ptGe[2] = ptEnd;
			tCurveEle.idSubLay = m_idCenterLayer;//... 图层取
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = ptInt;
			tCurveEle.ptGe[1] = ptBr2;
			tCurveEle.ptGe[2] = ptBr2;
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = ptCen + vtL * dR;
			tCurveEle.ptGe[1] = ptCen + vtM * dR;
			tCurveEle.ptGe[2] = ptCen + vtEnd * dR;
			cplCurve.append(tCurveEle);
		}
	}
	else//其他放置
	{
		//竖放情况 1
		if ( vtBran.isParallelTo(AcGeVector3d::kZAxis) )
		{
			AcGeVector3d vtNorm = normal();
			vtNorm.normalize();

			//sta
			tCurveEle.ptGe[0] = ptStart - vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptStart + vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//top
			tCurveEle.ptGe[0] = ptStart - vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd - vtNorm * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//end
			tCurveEle.ptGe[0] = ptEnd - vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd + vtNorm * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//down
			tCurveEle.ptGe[0] = ptStart + vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd + vtNorm * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//中心线
			tCurveEle.ptGe[0] = ptStart;
			tCurveEle.ptGe[1] = ptEnd;
			tCurveEle.ptGe[2] = ptEnd;
			tCurveEle.idSubLay = m_idCenterLayer;//... 图层取
			cplCurve.append(tCurveEle);
		}
	}
	return FALSE;
}

//斜接 -- 圆型
BOOL ImpHvacTee::MakeInclineBranchCircle2DCurves(AecComplexCurve &cplCurve, const int &nOutOrIn) const
{
	//开始端斜接直边长度 50
	double dLDisFrSta = 0;//毫米

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtEnd, vtBran;
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	double dStartWidth = 0, dEndWidth = 0, dBranWidth = 0;
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	vtEnd.normalize(); vtBran.normalize();
	AcGeVector3d vtBran45 = vtEnd + vtBran;
	vtBran45.normalize();

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	//示意弧弦高
	double dArch = 50;

	AcGeVector3d vtNorm = vtEnd.crossProduct(vtBran);
	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//平放
	{
		AcGePoint3d ptB1 = ptStart;
		ptB1 += vtBran * dStartWidth * 0.5;
		ptB1 += vtEnd * dLDisFrSta;

		AcGeVector3d vtL = vtEnd.orthoProject(vtBran45);
		vtL.normalize();

		AcGePoint3d ptB2Cen = ptStart;

		AcGeLine3d lnC(ptB2Cen, vtBran45);
		AcGeLine3d lnM(ptStart, ptEnd);

		AcGePoint3d ptInt;
		//if (lnM.intersectWith(lnC, ptInt))
		{
			ptInt = ptStart;
			double dM = ptStart.distanceTo(ptEnd);
			AcGePoint3d ptBrnFr = lnM.closestPointTo(ptBran);
			double dB = ptBrnFr.distanceTo(ptBran);

			double dL = dB * sqrt(2.0);
			AcGePoint3d ptBr2 = ptInt + dL * vtBran45;

			//sta
			tCurveEle.ptGe[0] = ptStart - vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptStart + vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//top
			tCurveEle.ptGe[0] = ptStart - vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd - vtBran * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//end
			tCurveEle.ptGe[0] = ptEnd - vtBran * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd + vtBran * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//dowmL==0
			//tCurveEle.ptGe[0] = ptStart + vtBran * 0.5 * dStartWidth;
			//tCurveEle.ptGe[1] = ptB1;
			//tCurveEle.ptGe[2] = ptB1;
			//cplCurve.append(tCurveEle);

			double dInR = lnC.distanceTo(ptB1);

			//down arc
			AcGePoint3d pt2 = ptBr2 + vtL * dBranWidth * 0.5;
			AcGePoint3d pt1 = ptB1 + vtL * dInR * 2.0;

			AcGeLine3d rayL2(pt2, pt1);

			AcGePoint3d ptSD = ptStart + vtBran * dStartWidth * 0.5;
			AcGePoint3d ptED = ptEnd + vtBran * dEndWidth * 0.5;
			AcGeLine3d lnD(ptSD, ptED);

			AcGePoint3d pt3;
			if (lnD.intersectWith(rayL2, pt3))
			{
				AcGePoint3d ptM;
				Midpoint(ptB1, pt3, ptM);
				ptM -= vtBran * dArch;

				//拟合线
				tCurveEle.ptGe[0] = ptStart;
				tCurveEle.ptGe[1] = pt3;
				tCurveEle.ptGe[2] = pt3;
				cplCurve.append(tCurveEle);

				//downR
				tCurveEle.ptGe[0] = pt3;
				tCurveEle.ptGe[1] = ptEnd + vtBran * 0.5 * dEndWidth;;
				tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
				cplCurve.append(tCurveEle);
			}

			//br
			tCurveEle.ptGe[0] = ptB1;
			tCurveEle.ptGe[1] = ptBr2 - vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = ptBr2 - vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[1] = ptBr2 + vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = pt3;
			tCurveEle.ptGe[1] = ptBr2 + vtL * 0.5 * dBranWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//下面弧段 45度
			double dRadRatio = 1.0;
			m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);

			double dR = dRadRatio * dBranWidth;
			AcGePoint3d ptCen = ptBr2 - dR * vtL;

			//内弧
			AcGeVector3d vtM = vtL + vtEnd;
			vtM.normalize();

			tCurveEle.ptGe[0] = ptCen + vtL * (dR - 0.5 * dBranWidth);
			tCurveEle.ptGe[1] = ptCen + vtM * (dR - 0.5 * dBranWidth);
			tCurveEle.ptGe[2] = ptCen + vtEnd * (dR - 0.5 * dBranWidth);
			cplCurve.append(tCurveEle);

			//外弧
			tCurveEle.ptGe[0] = ptCen + vtL * (dR + 0.5 * dBranWidth);
			tCurveEle.ptGe[1] = ptCen + vtM * (dR + 0.5 * dBranWidth);
			tCurveEle.ptGe[2] = ptCen + vtEnd * (dR + 0.5 * dBranWidth);
			cplCurve.append(tCurveEle);

			//封口
			tCurveEle.ptGe[0] = ptCen + vtEnd * (dR - 0.5 * dBranWidth);
			tCurveEle.ptGe[1] = ptCen + vtEnd * (dR + 0.5 * dBranWidth);
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//分段线
			AcDbArc *pArc = KTCADUtilityEx::FormatArc(ptCen + vtL * dR, ptCen + vtM * dR, ptCen + vtEnd * dR);
			if (pArc != NULL)
			{
				AcGePoint3dArray arPts;
				GetSamplePoints(pArc, 4, arPts);

				AcGeVector3d vtSeg;
				for (int ii = 1; ii < arPts.length() - 1; ii++)
				{
					vtSeg = arPts.at(ii) - ptCen;
					vtSeg.normalize();

					tCurveEle.ptGe[0] = arPts.at(ii) - vtSeg * 0.5 * dBranWidth;
					tCurveEle.ptGe[1] = arPts.at(ii) + vtSeg * 0.5 * dBranWidth;
					tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
					tCurveEle.nColorIndex = 4;
					cplCurve.append(tCurveEle);
				}

				delete pArc;
			}

			//中心线
			tCurveEle.ptGe[0] = ptStart;
			tCurveEle.ptGe[1] = ptEnd;
			tCurveEle.ptGe[2] = ptEnd;
			tCurveEle.idSubLay = m_idCenterLayer;//... 图层取
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = ptStart;
			tCurveEle.ptGe[1] = ptBr2;
			tCurveEle.ptGe[2] = ptBr2;
			cplCurve.append(tCurveEle);

			tCurveEle.ptGe[0] = ptCen + vtL * dR;
			tCurveEle.ptGe[1] = ptCen + vtM * dR;
			tCurveEle.ptGe[2] = ptCen + vtEnd * dR;
			cplCurve.append(tCurveEle);
		}
	}
	else//其他放置
	{
		//竖放情况 1
		if (vtBran.isParallelTo(AcGeVector3d::kZAxis))
		{
			AcGeVector3d vtNorm = normal();
			vtNorm.normalize();

			//sta
			tCurveEle.ptGe[0] = ptStart - vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptStart + vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//top
			tCurveEle.ptGe[0] = ptStart - vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd - vtNorm * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//end
			tCurveEle.ptGe[0] = ptEnd - vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd + vtNorm * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//down
			tCurveEle.ptGe[0] = ptStart + vtNorm * 0.5 * dStartWidth;
			tCurveEle.ptGe[1] = ptEnd + vtNorm * 0.5 * dEndWidth;
			tCurveEle.ptGe[2] = tCurveEle.ptGe[1];
			cplCurve.append(tCurveEle);

			//中心线
			tCurveEle.ptGe[0] = ptStart;
			tCurveEle.ptGe[1] = ptEnd;
			tCurveEle.ptGe[2] = ptEnd;
			tCurveEle.idSubLay = m_idCenterLayer;//... 图层取
			cplCurve.append(tCurveEle);
		}
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeOrthoRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeOrthoRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);
	else if (IsInclineAlignment())
		return MakeOrthoRectHoriz2DCurves(cplCurve, nOutOrIn);
	return FALSE;
}

BOOL ImpHvacTee::MakeInsertRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeInsertRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeInsertIntubRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeInsertRectHoriz2DCurves(cplCurve, nOutOrIn, TRUE);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn, TRUE);

	return FALSE;
}

BOOL ImpHvacTee::MakeInclineRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeInclineRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeYShapeRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeYShapeRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeVShapeRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeVShapeRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeTShapeRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeTShapeRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeArcuateRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeArcuateRectHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeArcuateIntubRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeArcuateRectHoriz2DCurves(cplCurve, nOutOrIn, TRUE);
	else if (IsSideVertAlignment())
		return MakeRectSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeRectFaceVert2DCurves(cplCurve, nOutOrIn, TRUE);

	return FALSE;
}

BOOL ImpHvacTee::MakeOrthoCircle2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeOrthoCircleHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeOrthoCircleSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeOrthoCircleFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeInsertCircle2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeInsertCircleHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeInsertCircleSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeInsertCircleFaceVert2DCurves(cplCurve, nOutOrIn);
	else if (IsInclineAlignment())
		return MakeOrthoCircleIncline2DCurves(cplCurve, nOutOrIn);
	return FALSE;
}

BOOL ImpHvacTee::MakeInclineCircle2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeInclineCircleHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeInclineCircleSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsIncVertAlignment())
		return MakeInclineCircleFaceVert2DCurves(cplCurve, nOutOrIn);
	else if (IsInclineAlignment())
		return MakeInclineCircleInc2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeYShapeCircle2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeYShapeCircleHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeYShapeCircleSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeYShapeCircleFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

BOOL ImpHvacTee::MakeVShapeCircle2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	if (IsHorzAlignment())
		return MakeVShapeCircleHoriz2DCurves(cplCurve, nOutOrIn);
	else if (IsSideVertAlignment())
		return MakeVShapeCircleSideVert2DCurves(cplCurve, nOutOrIn);
	else if (IsFaceVertAlignment())
		return MakeVShapeCircleFaceVert2DCurves(cplCurve, nOutOrIn);

	return FALSE;
}

/*
	常规三通二维画法,各点示意图

// 			  	0━━━━━━━━━8━━━━━━━7		   
// 				┃	                    		  ┃		   
// 				┃	                    		  ┃ 		   
// 			     ━━━━━━━━━━━━━━━━━		  
// 				┃	              ┃   			  ┃		   
// 				┃	              ┃    		  ┃		   
// 			 	 1━━━━━2     ┃	 5━━━━6		   
//                          ┃    ┃    ┃					
//                          ┃    ┃    ┃				    	
//                          ┃    ┃    ┃				    	
//                          ┃    ┃    ┃				    	
//                           3━━━━━4				    	
*/

BOOL ImpHvacTee::MakeOrthoRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AcGePoint3d ptCross = GetCenterPt();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);

		return TRUE;
	}
	else
	{
		if (nOutOrIn == 1)
		{
			AcGePoint3dArray ptMidArr;
			GetSectMidKeyPt(ptMidArr);
			if (9 != ptMidArr.length())
			{
				return FALSE;
			}
			if (ptMidArr.length() > 5)
				DrawValve(cplCurve, ptMidArr[5]);

			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptCross = GetCenterPt();
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
			}
			return TRUE;
		}
		else if (nOutOrIn == 0)
		{
			AcGePoint3dArray ptMidArr;
			GetSectMidKeyPt(ptMidArr);
			if (9 != ptMidArr.length())
			{
				return FALSE;
			}

			// 添加非端部的外部线条
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[1], ptMidArr[2], ptMidArr[2]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[2], ptMidArr[3], ptMidArr[3]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[4], ptMidArr[5], ptMidArr[5]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[5], ptMidArr[6], ptMidArr[6]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[7], ptMidArr[8], ptMidArr[8]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[8], ptMidArr[0], ptMidArr[0]);

			// 添加端部线条
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[0], ptMidArr[1], ptMidArr[1]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[3], ptMidArr[4], ptMidArr[4]);
			AutoAppendPt(cplCurve, tCurveEle, ptMidArr[6], ptMidArr[7], ptMidArr[7]);
		}
		return TRUE;
	}
}

BOOL ImpHvacTee::MakeInsertRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn, BOOL bIntub ) const
{
	// 获取起点终点和分支点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	// 设置单位曲线的参数
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	// 单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AcGePoint3d ptCross = GetCenterPt();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);

		return TRUE;
	}
	else
	{
		// 处理中截面上的点
		AcGePoint3dArray arptMid;
		GetSectMidKeyPt(arptMid);
		if (10 != arptMid.length())
		{
			return FALSE;
		}
		AcGePlane plane = GetStdPrjPlan(ptStart);
		for (int iNum = 2; iNum <= 6; iNum++)
		{
			arptMid[iNum] = arptMid[iNum].orthoProject(plane);
		}

		// 非单线模式的外部线条
		if (0 == nOutOrIn)
		{
			// 添加非端线的外轮廓线
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[1], arptMid[2], arptMid[2]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[3], arptMid[3]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[3], arptMid[4], arptMid[4]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[5], arptMid[6], arptMid[6]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[6], arptMid[7], arptMid[7]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[8], arptMid[9], arptMid[9]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[9], arptMid[0], arptMid[0]);

			// 添加端线
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			if (!bIntub)
			{
				AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[1], arptMid[1]);
				AutoAppendPt(cplCurve, tCurveEle, arptMid[7], arptMid[8], arptMid[8]);
			}

			AutoAppendPt(cplCurve, tCurveEle, arptMid[4], arptMid[5], arptMid[5]);
		}
		else
		{
			// 非单线模式的内部线条
			// 非中心线的内部线条
			AcGePoint3d ptIntersect;
			AcGeVector3d vtStart(StartVect());
			double dDis = 200;
			AcGePoint3d ptExtend1 = arptMid[1] + vtStart * dDis;
			AcGeVector3d vtEnd(EndVect());
			AcGePoint3d ptExtend6 = arptMid[6] + vtEnd * dDis;
			if(Adesk::kTrue == GetIntersectPointByPts(arptMid[1], ptExtend1, arptMid[6], ptExtend6, ptIntersect))
			{
				tCurveEle.dWidth = GetEdgeLineWidth();
				AutoAppendPt(cplCurve, tCurveEle, arptMid[2], ptIntersect, ptIntersect);
				AutoAppendPt(cplCurve, tCurveEle, ptIntersect, arptMid[6], arptMid[6]);
			}
			else
			{
				tCurveEle.dWidth = GetEdgeLineWidth();
				AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[6], arptMid[6]);
			}
			if (arptMid.length() > 6)
				DrawValve(cplCurve, arptMid[6]);

			// 中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptCross = GetCenterPt();
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
			}
		}
		return TRUE;
	}
}

BOOL ImpHvacTee::MakeInclineRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 获取起点终点和分支点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	
	// 设置单位曲线的参数
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;
	
	// 单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AcGePoint3d ptCross = GetCenterPt();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
		
		return TRUE;
	}
	else
	{
		// 非单线模式的外部线条
		AcGePoint3dArray arptMid;
		GetSectMidKeyPt(arptMid);
		if (10 != arptMid.length())
		{
			return FALSE;
		}
		if (0 == nOutOrIn)
		{
			// 添加非端线的外轮廓线
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[1], arptMid[2], arptMid[2]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[3], arptMid[3]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[3], arptMid[4], arptMid[4]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[5], arptMid[6], arptMid[6]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[6], arptMid[7], arptMid[7]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[8], arptMid[9], arptMid[9]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[9], arptMid[0], arptMid[0]);
			
			// 添加端线
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[1], arptMid[1]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[4], arptMid[5], arptMid[5]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[7], arptMid[8], arptMid[8]);
		}
		else
		{
			if (arptMid.length() > 6)
				DrawValve(cplCurve, arptMid[6]);

			// 中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptCross = GetCenterPt();
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
			}
		}
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeYShapeRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 获取起点终点和分支点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	// 设置单位曲线的参数
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;
	
	// 单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AcGePoint3d ptCross = GetCenterPt();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
		
		return TRUE;
	}
	else
	{
		// 非单线模式的外部线条
		AcGePoint3dArray arptMid;
		GetSectMidKeyPt(arptMid);
		if (17 != arptMid.length())
		{
			return FALSE;
		}
		if (0 == nOutOrIn)
		{
			// 添加非端线的外部轮廓线
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[1], arptMid[2], arptMid[2]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[3], arptMid[4]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[4], arptMid[5], arptMid[5]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[6], arptMid[7], arptMid[7]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[7], arptMid[8], arptMid[9]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[9], arptMid[10], arptMid[10]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[11], arptMid[12], arptMid[12]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[12], arptMid[13], arptMid[14]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[14], arptMid[15], arptMid[16]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[16], arptMid[0], arptMid[0]);

			// 添加端线
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[1], arptMid[1]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[5], arptMid[6], arptMid[6]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[10], arptMid[11], arptMid[11]);
		}
		else
		{
			// 得到中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptCross = GetCenterPt();
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
			}
		}
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeVShapeRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 获取起点终点和分支点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	// 设置单位曲线的参数
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	// 单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptBran, ptBran);
		AutoAppendPt(cplCurve, tCurveEle, ptEnd, ptBran, ptBran);
		
		return TRUE;
	}
	else
	{
		// 非单线模式的外部线条
		AcGePoint3dArray arptMid;
		GetSectMidKeyPt(arptMid);
		if (13 != arptMid.length())
		{
			return FALSE;
		}
		if (0 == nOutOrIn)
		{
			// 添加非端线的外部轮廓线
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[1], arptMid[1]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[1], arptMid[2], arptMid[2]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[3], arptMid[3]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[4], arptMid[5], arptMid[5]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[5], arptMid[6], arptMid[6]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[6], arptMid[7], arptMid[7]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[8], arptMid[9], arptMid[9]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[9], arptMid[10], arptMid[10]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[10], arptMid[11], arptMid[11]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[11], arptMid[12], arptMid[12]);
			
			// 添加端线
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[12], arptMid[12]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[3], arptMid[4], arptMid[4]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[7], arptMid[8], arptMid[8]);
		}
		else
		{
			// 中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptStartExt = TAuxTools::Mid(arptMid[1], arptMid[11]);
				AcGePoint3d ptEndExt = TAuxTools::Mid(arptMid[9], arptMid[6]);
				AcGePoint3d ptBranExt = TAuxTools::Mid(arptMid[2], arptMid[5]);
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptStartExt, ptStartExt);
				AutoAppendPt(cplCurve, tCurveEle, ptEnd, ptEndExt, ptEndExt);
				AutoAppendPt(cplCurve, tCurveEle, ptBran, ptBranExt, ptBranExt);
				AutoAppendPt(cplCurve, tCurveEle, ptBranExt, ptStartExt, ptStartExt);
				AutoAppendPt(cplCurve, tCurveEle, ptBranExt, ptEndExt, ptEndExt);
			}
		}
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeTShapeRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 获取起点终点和分支点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	
	// 设置单位曲线的参数
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;
	
	// 单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AcGePoint3d ptCross = GetCenterPt();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
		
		return TRUE;
	}
	else
	{
		// 非单线模式的外部线条
		AcGePoint3dArray arptMid;
		GetSectMidKeyPt(arptMid);
		if (14 != arptMid.length())
		{
			return FALSE;
		}
		if (0 == nOutOrIn)
		{
			// 添加非端线的外部轮廓线
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[1], arptMid[2], arptMid[2]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[3], arptMid[4]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[4], arptMid[5], arptMid[5]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[6], arptMid[7], arptMid[7]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[7], arptMid[8], arptMid[9]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[9], arptMid[10], arptMid[10]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[11], arptMid[12], arptMid[12]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[12], arptMid[13], arptMid[13]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[13], arptMid[0], arptMid[0]);
			
			// 添加端线
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[1], arptMid[1]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[5], arptMid[6], arptMid[6]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[10], arptMid[11], arptMid[11]);
		}
		else
		{
			// 得到中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptCross = GetCenterPt();
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
			}
		}
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeArcuateRectHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn, BOOL bIntub /*= FALSE*/ ) const
{
	// 获取起点终点和分支点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	
	// 设置单位曲线的参数
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;
	
	// 单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AcGePoint3d ptCross = GetCenterPt();
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
		AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
		
		return TRUE;
	}
	else
	{
		// 非单线模式的外部线条
		AcGePoint3dArray arptMid;
		GetSectMidKeyPt(arptMid);
		if (13 != arptMid.length())
		{
			return FALSE;
		}
		if (0 == nOutOrIn)
		{
			// 添加非端线的外部轮廓线
			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[1], arptMid[2], arptMid[2]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[3], arptMid[4]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[4], arptMid[5], arptMid[5]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[6], arptMid[7], arptMid[7]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[7], arptMid[8], arptMid[9]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[9], arptMid[10], arptMid[10]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[11], arptMid[12], arptMid[12]);
			AutoAppendPt(cplCurve, tCurveEle, arptMid[12], arptMid[0], arptMid[0]);
			
			// 添加端线及管壁线
			if (bIntub)
			{
				AutoAppendPt(cplCurve, tCurveEle, arptMid[2], arptMid[9], arptMid[9]);
			}
			tCurveEle.dWidth = GetEndLineWidth();
			tCurveEle.idSubLay = m_pOwnerEnt->layerId();
			AutoAppendPt(cplCurve, tCurveEle, arptMid[5], arptMid[6], arptMid[6]);

			if (!bIntub)
			{
				AutoAppendPt(cplCurve, tCurveEle, arptMid[0], arptMid[1], arptMid[1]);
				AutoAppendPt(cplCurve, tCurveEle, arptMid[10], arptMid[11], arptMid[11]);
			}
		}
		else
		{
			if (arptMid.length() > 9)
				DrawValve(cplCurve, arptMid[9]);

			// 中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AcGePoint3d ptCross = GetCenterPt();
				AutoAppendPt(cplCurve, tCurveEle, ptStart, ptCross, ptCross);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptEnd, ptEnd);
				AutoAppendPt(cplCurve, tCurveEle, ptCross, ptBran, ptBran);
			}
		}
	}
	return TRUE;
}

/*	常规三通侧垂直对应点图

// 			  	0━━━━━━━━━8━━━━━━━7		    ━━━━━━  
// 				┃	                    		 ┃	       ┃	       ┃ 	   
// 				┃	                    		  ┃ 	   ┃	       ┃ 	   
// 			     ━━━━━━━━━━━━━━━━━		   ┃━━━━  ┃
// 				┃	              ┃   			 ┃  	   ┃	       ┃ 	   
// 				┃	              ┃    		  ┃	           ┃		   ┃ 	   
// 			 	 1━━━━━2     ┃	 5━━━━6		       ┃━━━━  ┃
//                          ┃    ┃    ┃				   ┃          ┃	
//                          ┃    ┃    ┃				   ┃          ┃	 	
//                          ┃    ┃    ┃				   ┃          ┃	 	
//                          ┃    ┃    ┃				   ┃          ┃	 	
//                           3━━━━━4				    ━━━━━━	 	
*/
BOOL ImpHvacTee::MakeRectSideVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	// 绘制基准面，不在此面上的点都投影到此面上
	AcGePlane planStd = GetStdPrjPlan(ptBran);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	// 找出单线外部点索引
	AcGePoint3dArray arptBase;
	arptBase.append(ptStart.orthoProject(planStd));
	arptBase.append(ptEnd.orthoProject(planStd));
	arptBase.append(ptBran.orthoProject(planStd));
	int nBaseEn1(0), nBaseEn2(0);
	GetEndPointIndex(arptBase, nBaseEn1, nBaseEn2);

	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AutoAppendPt(cplCurve, tCurveEle, arptBase[nBaseEn1], arptBase[nBaseEn2], arptBase[nBaseEn2]);

		return TRUE;
	}
	else
	{
		AcGePoint3dArray arptDown, arptUp;
		GetTwoSideKeyPt(arptUp, arptDown);
		if (arptUp.length() < 2 || arptDown.length() < 2)
		{
			return FALSE;
		}

		// 去掉弧线上的点
		AecHvac::HvacTeeType eType;
		m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
		if (AecHvac::eYShapeBranch == eType)
		{
			arptUp.removeAt(15);
			arptUp.removeAt(13);
			arptUp.removeAt(8);
			arptUp.removeAt(3);
			arptDown.removeAt(15);
			arptDown.removeAt(13);
			arptDown.removeAt(8);
			arptDown.removeAt(3);
		}
		else if (AecHvac::eTShapeBranch == eType || AecHvac::eArcuateBranch == eType || eType == AecHvac::eArcuateIntubBranch)
		{
			arptUp.removeAt(8);
			arptUp.removeAt(3);
			arptDown.removeAt(8);
			arptDown.removeAt(3);
		}

		// 找出外部点索引
		int nEnd1(0), nEnd2(0);
		AcGePoint3dArray arptUpPrj, arptDownPrj;
		int i(0);
		for (i = 0;  i < arptUp.length() && i < arptDown.length(); i++)
		{
			arptUpPrj.append(arptUp[i].orthoProject(planStd));
			arptDownPrj.append(arptDown[i].orthoProject(planStd));
		}
		AcGePoint3dArray arptTranseform(arptUpPrj);
		if (AecHvac::eInsertBranch == eType || eType == AecHvac::eInsertIntubBranch)
		{
			AcGeVector3d vtPrj = arptTranseform[1] - arptTranseform[0];
			AcDbDatabase* pDb = acdbCurDwg();
			AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
			double dAng = (pDb->ucsxdir()).angleTo(vtPrj, vtZAxis);
			vtPrj = (pDb->ucsydir()).rotateBy(dAng, vtZAxis);
			AcGePlane planPrj(arptTranseform[1], vtPrj);
			for (int j = 2; j <= 6; j++)
			{
				arptTranseform[j] = (arptTranseform[j]).orthoProject(planPrj);
			}
		}
		GetEndPointIndex(arptTranseform, nEnd1, nEnd2);

		if (nOutOrIn == 1)
		{
			// 添加非中心线的内部线条
			tCurveEle.dWidth = GetEdgeLineWidth();
			if (AecHvac::eInsertBranch == eType || AecHvac::eInsertIntubBranch == eType)
			{
				// 计算投影内部线条构成
				AcGePoint3d ptVertex = arptTranseform[nEnd1];
				if (arptTranseform[nEnd2].distanceTo(arptTranseform[3])
					< arptTranseform[nEnd1].distanceTo(arptTranseform[3]))
				{
					ptVertex = arptTranseform[nEnd2];
				}
				int iMark = 0;
				if (ptVertex.distanceTo(arptTranseform[7])
					< ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 1;
				}
				else if (ptVertex.distanceTo(arptTranseform[7])
					> ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 2;
				}

				for (int i = 0; i < arptUpPrj.length() && i < arptDownPrj.length(); i++)
				{
					if (i == nEnd1 || i == nEnd2)
					{
						continue;
					}
					if (arptUpPrj[i].distanceTo(arptUpPrj[nEnd1]) < 1e-2
						|| arptUpPrj[i].distanceTo(arptUpPrj[nEnd2]) < 1e-2)
					{
						continue;
					}

					switch(iMark)
					{
					case 0:
						if (1 ==i || 7 ==i)
						{
							continue;
						}
						break;
					case 1:
						if (7 ==i)
						{
							continue;
						}
						break;
					case 2:
						if (1 ==i)
						{
							continue;
						}
						break;
					default:
						break;
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[i], arptDownPrj[i], arptDownPrj[i]);
				}
				if (0 != iMark)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[6], arptUpPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[6], arptDownPrj[6]);
				}
			}
			else if (AecHvac::eArcuateIntubBranch == eType)
			{
				// 计算投影内部线条构成
				AcGePoint3d ptVertex = arptTranseform[nEnd1];
				if (arptTranseform[nEnd2].distanceTo(arptTranseform[3])
					< arptTranseform[nEnd1].distanceTo(arptTranseform[3]))
				{
					ptVertex = arptTranseform[nEnd2];
				}
				int iMark = 0;
				if (ptVertex.distanceTo(arptTranseform[8])
					< ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 1;
				}
				else if (ptVertex.distanceTo(arptTranseform[8])
					> ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 2;
				}
				
				for (int i = 0; i < arptUpPrj.length() && i < arptDownPrj.length(); i++)
				{
					if (i == nEnd1 || i == nEnd2)
					{
						continue;
					}
					if (arptUpPrj[i].distanceTo(arptUpPrj[nEnd1]) < 1e-2
						|| arptUpPrj[i].distanceTo(arptUpPrj[nEnd2]) < 1e-2)
					{
						continue;
					}
					
					switch(iMark)
					{
					case 0:
						if (1 ==i || 8 ==i)
						{
							continue;
						}
						break;
					case 1:
						if (8 ==i)
						{
							continue;
						}
						break;
					case 2:
						if (1 ==i)
						{
							continue;
						}
						break;
					default:
						break;
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[i], arptDownPrj[i], arptDownPrj[i]);
				}
				if (0 != iMark)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[7], arptUpPrj[7]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[7], arptDownPrj[7]);
				}
			}
			else
			{
				for (int i = 0; i < arptUpPrj.length() && i < arptDownPrj.length(); i++)
				{
					if (i == nEnd1 || i == nEnd2)
					{
						continue;
					}
					if (arptUpPrj[i].distanceTo(arptUpPrj[nEnd1]) < 1e-2
						|| arptUpPrj[i].distanceTo(arptUpPrj[nEnd2]) < 1e-2)
					{
						continue;
					}

					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[i], arptDownPrj[i], arptDownPrj[i]);
				}
			}

			// 中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AutoAppendPt(cplCurve, tCurveEle, arptBase[nBaseEn1], arptBase[nBaseEn2], arptBase[nBaseEn2]);
			}	
		}
		else if (nOutOrIn == 0)
		{
			if (eType == AecHvac::eInsertBranch || eType == AecHvac::eInsertIntubBranch)
			{
				// 计算投影内部线条构成
				AcGePoint3d ptVertex = arptTranseform[nEnd1];
				BOOL bJudge = TRUE;
				if (arptTranseform[nEnd2].distanceTo(arptTranseform[3])
					< arptTranseform[nEnd1].distanceTo(arptTranseform[3]))
				{
					ptVertex = arptTranseform[nEnd2];
					bJudge = FALSE;
				}
				int iMark = 0;
				if (ptVertex.distanceTo(arptTranseform[7])
					< ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 1;
				}
				else if (ptVertex.distanceTo(arptTranseform[7])
					> ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 2;
				}
				tCurveEle.dWidth = GetEdgeLineWidth();
				switch(iMark)
				{
				case 0:
					if (nEnd1 == 0 || nEnd2 == 0)
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[0], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[0], arptDownPrj[1], arptDownPrj[1]);
					}
					else
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[8], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[8], arptDownPrj[1], arptDownPrj[1]);
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[1], arptUpPrj[2], arptUpPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[4], arptUpPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[1], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[4], arptDownPrj[4]);
					break;
				case 1:
					if (nEnd1 == 0 || nEnd2 == 0)
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[0], arptUpPrj[7], arptUpPrj[7]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[0], arptDownPrj[7], arptDownPrj[7]);
					}
					else
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[8], arptUpPrj[7], arptUpPrj[7]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[8], arptDownPrj[7], arptDownPrj[7]);
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[7], arptUpPrj[6], arptUpPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[6], arptUpPrj[4], arptUpPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[7], arptDownPrj[6], arptDownPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[6], arptDownPrj[4], arptDownPrj[4]);
					break;
				case 2:
					if (nEnd1 == 0 || nEnd2 == 0)
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[0], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[0], arptDownPrj[1], arptDownPrj[1]);
					}
					else
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[8], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[8], arptDownPrj[1], arptDownPrj[1]);
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[1], arptUpPrj[2], arptUpPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[4], arptUpPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[1], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[4], arptDownPrj[4]);
					break;
				default:
					break;
				}

				// 上下两边
				if (bJudge)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd2], arptDownPrj[nEnd2], arptDownPrj[nEnd2]);
					tCurveEle.dWidth = GetEndLineWidth();
					tCurveEle.idSubLay = m_pOwnerEnt->layerId();
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd1], arptUpPrj[nEnd1], arptUpPrj[nEnd1]);
				} 
				else
				{
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd1], arptUpPrj[nEnd1], arptUpPrj[nEnd1]);
					tCurveEle.dWidth = GetEndLineWidth();
					tCurveEle.idSubLay = m_pOwnerEnt->layerId();
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd2], arptDownPrj[nEnd2], arptDownPrj[nEnd2]);
				}
			}
			else if (AecHvac::eArcuateIntubBranch == eType)
			{
				// 计算投影内部线条构成
				AcGePoint3d ptVertex = arptTranseform[nEnd1];
				BOOL bJudge = TRUE;
				if (arptTranseform[nEnd2].distanceTo(arptTranseform[3])
					< arptTranseform[nEnd1].distanceTo(arptTranseform[3]))
				{
					ptVertex = arptTranseform[nEnd2];
					bJudge = FALSE;
				}
				int iMark = 0;
				if (ptVertex.distanceTo(arptTranseform[8])
					< ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 1;
				}
				else if (ptVertex.distanceTo(arptTranseform[8])
					> ptVertex.distanceTo(arptTranseform[1]))
				{
					iMark = 2;
				}
				tCurveEle.dWidth = GetEdgeLineWidth();
				switch(iMark)
				{
				case 0:
					if (nEnd1 == 0 || nEnd2 == 0)
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[0], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[0], arptDownPrj[1], arptDownPrj[1]);
					}
					else
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[9], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[9], arptDownPrj[1], arptDownPrj[1]);
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[1], arptUpPrj[2], arptUpPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[4], arptUpPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[1], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[4], arptDownPrj[4]);
					break;
				case 1:
					if (nEnd1 == 0 || nEnd2 == 0)
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[0], arptUpPrj[8], arptUpPrj[8]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[0], arptDownPrj[8], arptDownPrj[8]);
					}
					else
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[9], arptUpPrj[8], arptUpPrj[8]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[9], arptDownPrj[8], arptDownPrj[8]);
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[8], arptUpPrj[7], arptUpPrj[7]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[7], arptUpPrj[4], arptUpPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[8], arptDownPrj[7], arptDownPrj[7]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[7], arptDownPrj[4], arptDownPrj[4]);
					break;
				case 2:
					if (nEnd1 == 0 || nEnd2 == 0)
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[0], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[0], arptDownPrj[1], arptDownPrj[1]);
					}
					else
					{
						AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[8], arptUpPrj[1], arptUpPrj[1]);
						AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[8], arptDownPrj[1], arptDownPrj[1]);
					}
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[1], arptUpPrj[2], arptUpPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[4], arptUpPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[1], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[4], arptDownPrj[4]);
					break;
				default:
					break;
				}
				
				// 上下两边
				if (bJudge)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd2], arptDownPrj[nEnd2], arptDownPrj[nEnd2]);
					tCurveEle.dWidth = GetEndLineWidth();
					tCurveEle.idSubLay = m_pOwnerEnt->layerId();
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd1], arptUpPrj[nEnd1], arptUpPrj[nEnd1]);
				} 
				else
				{
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd1], arptUpPrj[nEnd1], arptUpPrj[nEnd1]);
					tCurveEle.dWidth = GetEndLineWidth();
					tCurveEle.idSubLay = m_pOwnerEnt->layerId();
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd2], arptDownPrj[nEnd2], arptDownPrj[nEnd2]);
				}
			}
			else
			{
				tCurveEle.dWidth = GetEdgeLineWidth();
				AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd1], arptUpPrj[nEnd2], arptUpPrj[nEnd2]);
				AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd2], arptDownPrj[nEnd1], arptDownPrj[nEnd1]);

				AcGePoint3d ptEnd1;
				Midpoint(arptUpPrj[nEnd1], arptDownPrj[nEnd1], ptEnd1);
				AcGePoint3d ptEnd2;
				Midpoint(arptUpPrj[nEnd2], arptDownPrj[nEnd2], ptEnd2);
				if (ptEnd1.distanceTo(ptBran) < ptEnd2.distanceTo(ptBran))
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd2], arptDownPrj[nEnd2], arptDownPrj[nEnd2]);
					tCurveEle.dWidth = GetEndLineWidth();
					tCurveEle.idSubLay = m_pOwnerEnt->layerId();
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd1], arptUpPrj[nEnd1], arptUpPrj[nEnd1]);
				} 
				else
				{
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[nEnd1], arptUpPrj[nEnd1], arptUpPrj[nEnd1]);
					tCurveEle.dWidth = GetEndLineWidth();
					tCurveEle.idSubLay = m_pOwnerEnt->layerId();
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[nEnd2], arptDownPrj[nEnd2], arptDownPrj[nEnd2]);
				}
			}
		}
	}
	return TRUE;
}

/*	常规三通正垂直对应点图

// 			  	0━━━━━━━━━8━━━━━━━7		    A━━━━━━━━━━━━━━━B 
// 				┃	                    		  ┃	   ┃			 ┃			┃		┃
// 				┃	                    		  ┃ 	   ┃		     ┃			┃		┃
// 			     ━━━━━━━━━━━━━━━━━		   ┃     ·     ┃			┃		┃
// 				┃	              ┃   			  ┃  	   ┃	         ┃		    ┃		┃
// 				┃	              ┃    		  ┃	   ┃		     ┃		    ┃		┃
// 			 	 1━━━━━2     ┃	 5━━━━6		  　 C━━━━━━━━━━━━━━━D
//                          ┃    ┃    ┃				   
//                          ┃    ┃    ┃				   
//                          ┃    ┃    ┃				   
//                          ┃    ┃    ┃				   
//                           3━━━━━4				    
*/
BOOL ImpHvacTee::MakeRectFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn, BOOL bIntub /*= FALSE*/ ) const
{
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	// 绘制基准面，不在此面上的点都投影到此面上
	AcGePlane planStd = GetStdPrjPlan(ptStart);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	// 找出单线外部点索引
	AcGePoint3dArray arptBase;
	arptBase.append(ptStart.orthoProject(planStd));
	arptBase.append(ptEnd.orthoProject(planStd));
	arptBase.append(ptBran.orthoProject(planStd));
	int nBaseEn1(0), nBaseEn2(0);
	GetEndPointIndex(arptBase, nBaseEn1, nBaseEn2);

	//单线模式
	if (IsSingleLine())
	{
		tCurveEle.dWidth = GetEdgeLineWidth();
		AutoAppendPt(cplCurve, tCurveEle, arptBase[nBaseEn1], arptBase[nBaseEn2], arptBase[nBaseEn2]);

		return TRUE;
	}
	else
	{
		AcGePoint3dArray arptDown, arptUp;
		GetTwoSideKeyPt(arptUp, arptDown);
		if (arptUp.length() < 2 || arptDown.length() < 2)
		{
			return FALSE;
		}
		AcGePoint3dArray arptUpPrj, arptDownPrj;
		int i(0);
		for (i = 0;  i < arptUp.length() && i < arptDown.length(); i++)
		{
			arptUpPrj.append(arptUp[i].orthoProject(planStd));
			arptDownPrj.append(arptDown[i].orthoProject(planStd));
		}

		if (1 == nOutOrIn)
		{
			AcDbDatabase* pDb = acdbCurDwg();
			AcGeVector3d vtUcsZ = pDb->ucsxdir().crossProduct(pDb->ucsydir());
			if (BranVect().angleTo(vtUcsZ) < PI * 0.51)
			{
				// 添加非中心线的内部线条
				tCurveEle.dWidth = GetEdgeLineWidth();
				AecHvac::HvacTeeType eType;
				m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
				if (AecHvac::eInsertBranch == eType || eType == AecHvac::eInsertIntubBranch)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[4], arptDownPrj[4], arptDownPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[5], arptDownPrj[5], arptDownPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[3], arptUpPrj[3]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[3], arptUpPrj[5], arptUpPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[3], arptDownPrj[3]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[3], arptDownPrj[5], arptDownPrj[5]);
				}
				else if (AecHvac::eInclineBranch == eType)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[4], arptDownPrj[4], arptDownPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[5], arptDownPrj[5], arptDownPrj[5]);
				}
				else if (AecHvac::eOrthoBranch == eType)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[3], arptDownPrj[3], arptDownPrj[3]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[4], arptDownPrj[4], arptDownPrj[4]);
				}
				else if (AecHvac::eVShapeBranch == eType)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[3], arptDownPrj[3], arptDownPrj[3]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[4], arptDownPrj[4], arptDownPrj[4]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[9], arptDownPrj[9], arptDownPrj[9]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[10], arptDownPrj[10], arptDownPrj[10]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[11], arptDownPrj[11], arptDownPrj[11]);
				}
				else if (AecHvac::eYShapeBranch == eType || AecHvac::eTShapeBranch == eType)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[5], arptDownPrj[5], arptDownPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[6], arptDownPrj[6], arptDownPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[9], arptDownPrj[9], arptDownPrj[9]);
				}
				else if (AecHvac::eArcuateBranch == eType)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[5], arptDownPrj[5], arptDownPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[6], arptDownPrj[6], arptDownPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[9], arptDownPrj[9], arptDownPrj[9]);
				}
				else if (AecHvac::eArcuateIntubBranch == eType)
				{
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptDownPrj[2], arptDownPrj[2]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[5], arptDownPrj[5], arptDownPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[6], arptDownPrj[6], arptDownPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[9], arptDownPrj[9], arptDownPrj[9]);
					
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[2], arptUpPrj[5], arptUpPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[5], arptUpPrj[6], arptUpPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[6], arptUpPrj[9], arptUpPrj[9]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[2], arptDownPrj[5], arptDownPrj[5]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[5], arptDownPrj[6], arptDownPrj[6]);
					AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[6], arptDownPrj[9], arptDownPrj[9]);
				}
			}

			// 中心线
			if (IsBaseLine())
			{
				tCurveEle.dWidth = GetCentLineWidth();
				tCurveEle.idSubLay = m_idCenterLayer;
				AutoAppendPt(cplCurve, tCurveEle, arptBase[nBaseEn1], arptBase[nBaseEn2], arptBase[nBaseEn2]);
			}
		}
		else if (0 == nOutOrIn)
		{
			AcGePoint3dArray arptMiddlePlane;
			GetSectMidKeyPt(arptMiddlePlane);
			AcGePoint3dArray arptGetIdx;
			for (int iGetIdx = 0; iGetIdx < arptMiddlePlane.length(); ++iGetIdx)
			{
				arptGetIdx.append(arptMiddlePlane[iGetIdx].orthoProject(planStd));
			}
			int iEnd1 = 0;
			int iEnd2 = 0;
			AcGeVector3d vtRangeDir = StartVect();
			GetEndPointIndex(arptGetIdx, iEnd1, iEnd2, &vtRangeDir);

			tCurveEle.dWidth = GetEdgeLineWidth();
			AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[iEnd1], arptUpPrj[iEnd2], arptUpPrj[iEnd2]);
			AutoAppendPt(cplCurve, tCurveEle, arptDownPrj[iEnd1], arptDownPrj[iEnd2], arptDownPrj[iEnd2]);
			
			if (!bIntub)
			{
				tCurveEle.dWidth = GetEndLineWidth();
				tCurveEle.idSubLay = m_pOwnerEnt->layerId();
				AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[iEnd1], arptDownPrj[iEnd1], arptDownPrj[iEnd1]);
				AutoAppendPt(cplCurve, tCurveEle, arptUpPrj[iEnd2], arptDownPrj[iEnd2], arptDownPrj[iEnd2]);
			}
		}
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeOrthoCircleHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	return TRUE;
}

BOOL ImpHvacTee::MakeInsertCircleHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInsertCirPts(arPts))
		return FALSE;

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	double dEndLineWidth = GetEndLineWidth();
	double dWidth = GetEdgeLineWidth();
	AcDbObjectId idEnd = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEnd);
	if (IsSingleLine() || (IsBaseLine() && nOutOrIn == 1))
	{
		if (!IsSingleLine())
		{
			AcDbObjectId idCenter;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
			tCurveEle.idSubLay = idCenter;

			dWidth = GetCentLineWidth();
		}
		AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[12], arPts[12], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[7], arPts[12], arPts[12], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[4], arPts[12], arPts[12], dWidth);
	}
	else if (0 == nOutOrIn)
	{				
		AutoAppendPt(cplCurve, tCurveEle, arPts[0], arPts[5], arPts[5], dWidth);		
		AutoAppendPt(cplCurve, tCurveEle, arPts[3], arPts[10], arPts[10], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[6], arPts[6], dWidth);		
		AutoAppendPt(cplCurve, tCurveEle, arPts[8], arPts[10], arPts[10], dWidth);	
		AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[2], arPts[2], dWidth);
		// change by zh 圆形等径三通二维显示特殊处理
		//AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[11], arPts[10], dWidth);
		ESection eSect = eRect;
		AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
		m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
		double dStaWidth(0.0), dEndWidth(0.0), dBranWidth(0.0);
		m_pXDataMap->GetAt(HTEE_StartWidth, dStaWidth);
		m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
		m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);
		if (eSect == eCircle && eType == AecHvac::eOrthoBranch)
		{
			if (fabs(dStaWidth - dEndWidth) < 1.0E-3 &&
				fabs(dEndWidth - dBranWidth) < 1.0E-3 &&
				fabs(dBranWidth - dStaWidth) < 1.0E-3)
			{
				AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[12], arPts[12], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[12], arPts[12], dWidth);
			}
			else
				AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[11], arPts[10], dWidth);
	    }
		else
			AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[11], arPts[10], dWidth); 
		//
		tCurveEle.idSubLay = idEnd;
		AutoAppendPt(cplCurve, tCurveEle, arPts[0], arPts[2], arPts[2], dEndLineWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[3], arPts[5], arPts[5], dEndLineWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[6], arPts[8], arPts[8], dEndLineWidth);
	}
	return TRUE;	
}

// 圆形截面三通,倾斜放置下,椭圆端线画法,供所有三通2D绘制函数使用
// 此函数只画各管端部的椭圆投影线
BOOL ImpHvacTee::GetAllIncCircleEndEdge2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn,
											   BOOL bDrawSta/* = TRUE*/, BOOL bDrawEnd/* = TRUE*/, BOOL bDrawBran/* = TRUE*/) const
{
	ASSERT(NULL != m_pXDataMap);

	// 使用三通数据
	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran, vtDir, vtZAxis(TAuxTools::GetUcsZvt());
	double dStartWidth(200.0), dEndWidth(200.0), dBranWidth(200.0);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	int i(0), iRes(-1);
	AcGePoint3dArray arPtsEdge;
	AcDbPolyline* pLine = new AcDbPolyline;
	if (NULL == pLine)
		return FALSE;

	// 曲线元素
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	// 边线宽
	double dEndLineWidth = GetEndLineWidth();
	// 边线图层
	AcDbObjectId idEnd = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEnd);
	tCurveEle.dWidth = dEndLineWidth;
	tCurveEle.idSubLay = idEnd;
	// 不是单线风管的情况下,才画内轮廓线
	if (1 == nOutOrIn && !IsSingleLine())
	{
		// 只画高的一端的内轮廓线
		if (ptStart.z > ptEnd.z)
		{
			// 起点端内轮廓线
			if (bDrawSta)
			{
				iRes = TAuxTools::GetEllipsePtsFromCircle(arPtsEdge, ptStart, dStartWidth, -vtStart, vtZAxis, *pLine, -vtStart);
				if (-1 != iRes)
				{
					for (i = 0; i < arPtsEdge.length()-1; i++)//Lixl modify 2011-11-23
					{						
						AutoAppendPt(cplCurve, tCurveEle, arPtsEdge[i], arPtsEdge[i+1], arPtsEdge[i+1], dEndLineWidth);
					}
				}
			}
		}
		else
		{
			// 终点端内轮廓线
			if (bDrawEnd)
			{
				iRes = TAuxTools::GetEllipsePtsFromCircle(arPtsEdge, ptEnd, dEndWidth, vtEnd, vtZAxis, *pLine, -vtEnd);
				if (-1 != iRes)
				{
					for (i = 0; i < arPtsEdge.length()-1; i++)//Lixl modify 2011-11-23
					{						
						AutoAppendPt(cplCurve, tCurveEle, arPtsEdge[i], arPtsEdge[i+1], arPtsEdge[i+1], dEndLineWidth);
					}
				}
			}
		}

		// 支管端内轮廓线
		if (bDrawBran)
		{
			pLine->reset(Adesk::kFalse, i);
			arPtsEdge.setLogicalLength(0);
			if (ptBran.z > ptStart.z)
			{
				iRes = TAuxTools::GetEllipsePtsFromCircle(arPtsEdge, ptBran, dBranWidth, vtBran, vtZAxis, *pLine, -vtBran);
				if (-1 != iRes)
				{
					for (i = 0; i < arPtsEdge.length()-1; i++)//Lixl modify 2011-11-23
					{						
						AutoAppendPt(cplCurve, tCurveEle, arPtsEdge[i], arPtsEdge[i+1], arPtsEdge[i+1], dEndLineWidth);
					}
				}
			}
		}
	} 
	else if (0 == nOutOrIn)
	{
		// 起点端外轮廓线
		if (bDrawSta)
		{
			iRes = TAuxTools::GetEllipsePtsFromCircle(arPtsEdge, ptStart, dStartWidth, vtStart, vtZAxis, *pLine, vtStart);
			if (-1 != iRes)
			{
				for (i = 0; i < arPtsEdge.length()-1; i++)//Lixl modify 2011-11-23
				{						
					AutoAppendPt(cplCurve, tCurveEle, arPtsEdge[i], arPtsEdge[i+1], arPtsEdge[i+1], dEndLineWidth);
				}
			}
		}

		// 终点端外轮廓线
		if (bDrawEnd)
		{
			pLine->reset(Adesk::kFalse, i);
			arPtsEdge.setLogicalLength(0);
			iRes = TAuxTools::GetEllipsePtsFromCircle(arPtsEdge, ptEnd, dEndWidth, vtEnd, vtZAxis, *pLine, vtEnd);
			if (-1 != iRes)
			{
				for (i = 0; i < arPtsEdge.length()-1; i++)//Lixl modify 2011-11-23
				{						
					AutoAppendPt(cplCurve, tCurveEle, arPtsEdge[i], arPtsEdge[i+1], arPtsEdge[i+1], dEndLineWidth);
				}
			}
		}

		// 支管端外轮廓线
		if (bDrawBran)
		{
			pLine->reset(Adesk::kFalse, i);
			arPtsEdge.setLogicalLength(0);
			iRes = TAuxTools::GetEllipsePtsFromCircle(arPtsEdge, ptBran, dBranWidth, vtBran, vtZAxis, *pLine, vtBran);
			if (-1 != iRes)
			{
				for (i = 0; i < arPtsEdge.length()-1; i++)//Lixl modify 2011-11-23
				{						
					AutoAppendPt(cplCurve, tCurveEle, arPtsEdge[i], arPtsEdge[i+1], arPtsEdge[i+1], dEndLineWidth);
				}
			}
		}
	}

	if (NULL != pLine)
		delete pLine;
	
	return TRUE;
}

// 普通样式倾斜三通2D绘制
BOOL ImpHvacTee::MakeOrthoCircleIncline2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInsertCirPtsOnHidePlan(arPts))
		return FALSE;

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	double dEndLineWidth = GetEndLineWidth();
	double dWidth = GetEdgeLineWidth();
	AcDbObjectId idEnd = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEnd);

	GetAllIncCircleEndEdge2DCurves(cplCurve, nOutOrIn);
	if (nOutOrIn == 1)
	{
		// 单线,就用端部图层, 双线的话,就修改为中心线图层
		if (!IsSingleLine())
		{
			AcDbObjectId idCenter;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
			tCurveEle.idSubLay = idCenter;
			dWidth = GetCentLineWidth();
		}
		AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[12], arPts[12], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[7], arPts[12], arPts[12], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[4], arPts[12], arPts[12], dWidth);
	}
	else if (0 == nOutOrIn)
	{				
		AutoAppendPt(cplCurve, tCurveEle, arPts[0], arPts[5], arPts[5], dWidth);		
		AutoAppendPt(cplCurve, tCurveEle, arPts[3], arPts[10], arPts[10], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[6], arPts[6], dWidth);		
		AutoAppendPt(cplCurve, tCurveEle, arPts[8], arPts[10], arPts[10], dWidth);	
		AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[2], arPts[2], dWidth);
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeInclineCircleHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInclineCirPts(arPts))
		return FALSE;
	
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));	
	double dEndLineWidth = GetEndLineWidth();
	double dWidth = GetEdgeLineWidth();
	AcDbObjectId idEnd = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEnd);
	if (IsSingleLine() || (IsBaseLine() && nOutOrIn == 1))
	{
		if (!IsSingleLine())
		{
			AcDbObjectId idCenter;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
			tCurveEle.idSubLay = idCenter;

			dWidth = GetCentLineWidth();
		}

		AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[10], arPts[10], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[7], arPts[16], arPts[16], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[4], arPts[13], arPts[13], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[16], arPts[16], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[13], arPts[13], dWidth);
	}
	else if (0 == nOutOrIn)
	{				
		AutoAppendPt(cplCurve, tCurveEle, arPts[2], arPts[11], arPts[11], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[11], arPts[15], arPts[15], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[15], arPts[6], arPts[6], dWidth);		
		AutoAppendPt(cplCurve, tCurveEle, arPts[8], arPts[17], arPts[17], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[17], arPts[18], arPts[18], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[18], arPts[12], arPts[12], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[12], arPts[3], arPts[3], dWidth);		
		AutoAppendPt(cplCurve, tCurveEle, arPts[5], arPts[14], arPts[14], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[14], arPts[9], arPts[9], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[0], arPts[0], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[10], arPts[10], dWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[18], arPts[18], dWidth);
		tCurveEle.idSubLay = idEnd;
		AutoAppendPt(cplCurve, tCurveEle, arPts[0], arPts[2], arPts[2], dEndLineWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[3], arPts[5], arPts[5], dEndLineWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPts[6], arPts[8], arPts[8], dEndLineWidth);
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeInclineCircleInc2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInclineCirPts2d(arPts))
		return FALSE;

	AcGePoint3d ptStart, ptEnd, ptBran;
	AcGeVector3d vtStart, vtEnd, vtBran, vtDir, vtZAxis(TAuxTools::GetUcsZvt()), vtNor(normal());
	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0), dPlusEdge(0.0);
	AecHvac::HvacTeeType eTeeType = AecHvac::eOrthoBranch;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eTeeType);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);

	// 投影面
	AcGePlane plan(TAuxTools::Mid(ptStart, ptEnd), vtZAxis);
	// 尾管端线曲线
	AcGeCircArc3d arc1, arc2, arc3;
	// 支管边线曲线
	AcGeLineSeg3d seg1, seg2;
	AcGePoint3d ptBranU, ptBranD, ptCenU, ptCenD, ptSU, ptSD, ptED, ptEU, ptInter;
	ptSD = arPts[2].orthoProject(plan);
	ptSU = arPts[0].orthoProject(plan);
	ptED = arPts[3].orthoProject(plan);
	ptEU = arPts[5].orthoProject(plan);
	ptBranD = arPts[6].orthoProject(plan);
	ptBranU = arPts[8].orthoProject(plan);
	ptCenD = arPts[18].orthoProject(plan);
	ptCenU = arPts[20].orthoProject(plan);

	AcGePoint3dArray arPtEdge;
	AcDbPolyline *pLine = new AcDbPolyline;
	if (NULL == pLine)
		return FALSE;
	vtDir = ptEnd - ptStart;
	int iRes(0), i(0);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));	
	double dEndLineWidth = GetEndLineWidth();
	double dWidth = GetEdgeLineWidth();
	AcDbObjectId idEnd = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEnd);
	
	if (nOutOrIn == 1)
	{
		if (!IsSingleLine())
		{
			AcDbObjectId idCenter;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
			tCurveEle.idSubLay = idCenter;

			dWidth = GetCentLineWidth();
		}
		
		// 画中心线
		if (IsBaseLine())
		{
			AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[10], arPts[10], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[7], arPts[16], arPts[16], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[4], arPts[13], arPts[13], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[16], arPts[16], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[13], arPts[13], dWidth);
			GetAllIncCircleEndEdge2DCurves(cplCurve, nOutOrIn);
		}
	}
	else if (0 == nOutOrIn)
	{
		// 普通倾斜斜接三通
		if (!(vtNor.isPerpendicularTo(TAuxTools::GetUcsZvt())))
		{
			// 支管边线与主管端线投影后交叉,需按另一种方法画2D线
			if (IsNeedMakeAllCurves(arPts))
			{
				std::vector<AcGeCurve3d*> segComs;
			} 
			else
			{
				GetAllIncCircleEndEdge2DCurves(cplCurve, nOutOrIn);
				AutoAppendPt(cplCurve, tCurveEle, arPts[2], arPts[11], arPts[11], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[11], arPts[15], arPts[15], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[15], arPts[6], arPts[6], dWidth);		
				AutoAppendPt(cplCurve, tCurveEle, arPts[8], arPts[17], arPts[17], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[17], arPts[18], arPts[18], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[18], arPts[12], arPts[12], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[12], arPts[3], arPts[3], dWidth);		
				AutoAppendPt(cplCurve, tCurveEle, arPts[5], arPts[14], arPts[14], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[14], arPts[9], arPts[9], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[9], arPts[0], arPts[0], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[10], arPts[10], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[18], arPts[18], dWidth);
			}
		}
	}	
	if (NULL != pLine)
		delete pLine;

	return TRUE;	
}

BOOL ImpHvacTee::MakeYShapeCircleHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	return MakeYShapeRectHoriz2DCurves(cplCurve, nOutOrIn);
}

BOOL ImpHvacTee::MakeVShapeCircleHoriz2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arpts;
	GetVShapeCirclePts(arpts);
	
	AecEqui::AecCurveElement el;
	memset(&el,0,sizeof(AecEqui::AecCurveElement));
	//外轮廓
	double dEdgeWidth = GetEdgeLineWidth();
	double dCenWidth = GetCentLineWidth();
	double dEndLineWidth = GetEndLineWidth();
	AcDbObjectId idBaseLayer(NULL), idEndLayer(NULL);

	int nSize = arpts.length() - 1;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
	
	//外轮廓
	if (0 == nOutOrIn)
	{
		el.dWidth = dEdgeWidth;
		el.ptGe[0] = arpts[1];
		el.ptGe[1] = arpts[16];
		el.ptGe[2] = arpts[16];
		cplCurve.append(el);
		el.ptGe[0] = arpts[16];
		el.ptGe[1] = arpts[2];
		el.ptGe[2] = arpts[2];
		cplCurve.append(el);
		for (int i = 2; i < 5; i++)
		{
			if (i != 3)
			{
				el.ptGe[0] = arpts[i];
				el.ptGe[1] = arpts[i + 1];
				el.ptGe[2] = arpts[i + 1];
				cplCurve.append(el);
			}
		}
		el.ptGe[0] = arpts[5];
		el.ptGe[1] = arpts[17];
		el.ptGe[2] = arpts[17];
		cplCurve.append(el);
		el.ptGe[0] = arpts[17];
		el.ptGe[1] = arpts[6];
		el.ptGe[2] = arpts[6];
		cplCurve.append(el);

		el.ptGe[0] = arpts[7];
		el.ptGe[1] = arpts[8];
		el.ptGe[2] = arpts[8];
		cplCurve.append(el);
		el.ptGe[0] = arpts[8];
		el.ptGe[1] = arpts[9];
		el.ptGe[2] = arpts[9];
		cplCurve.append(el);

		el.idSubLay = idEndLayer;
		el.dWidth = dEndLineWidth;
		el.ptGe[0] = arpts[0];
		el.ptGe[1] = arpts[1];
		el.ptGe[2] = arpts[1];
		cplCurve.append(el);
		el.ptGe[0] = arpts[3];
		el.ptGe[1] = arpts[4];
		el.ptGe[2] = arpts[4];
		cplCurve.append(el);
		el.ptGe[0] = arpts[6];
		el.ptGe[1] = arpts[7];
		el.ptGe[2] = arpts[7];
		cplCurve.append(el);
	}
	else if (1 == nOutOrIn)
	{
		BOOL bHasBaseLine = FALSE;
		m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
		if (bHasBaseLine || IsSingleLine())
		{
			el.gsMark = -1;
			if (IsSingleLine())
				el.dWidth = dEdgeWidth;
			else
				el.dWidth = dCenWidth;
			el.ptGe[0] = arpts[13];
			el.ptGe[1] = arpts[8];
			el.ptGe[2] = arpts[8];
			cplCurve.append(el);
			
			el.ptGe[0] = arpts[12];
			el.ptGe[1] = arpts[13];
			el.ptGe[2] = arpts[13];
			cplCurve.append(el);
			
			el.ptGe[0] = arpts[13];
			el.ptGe[1] = arpts[10];
			el.ptGe[2] = arpts[10];
			cplCurve.append(el);
			
			el.ptGe[0] = arpts[13];
			el.ptGe[1] = arpts[11];
			el.ptGe[2] = arpts[11];
			cplCurve.append(el);
		}
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeOrthoCircleSideVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	return TRUE;
}

BOOL ImpHvacTee::MakeInsertCircleSideVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInsertCirPts(arPts))
		return FALSE;

	double dStartWidth = 0.0;
	double dBranWidth = 0.0;
	AcGeVector3d vtNor = normal();
	AcGeVector3d vtBran = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

	AcGePoint3dArray arPtsV;
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	ptTmp = arPts[0];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[1];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[2];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[7];
	arPtsV.append(ptTmp);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));

	// 主管圆
	double dEdgeWidth = GetEdgeLineWidth();
	AutoAppendPt(cplCurve, tCurveEle, arPtsV[1] - vtNor * dStartWidth * 0.5, arPtsV[2], arPtsV[1] + vtNor * dStartWidth * 0.5, dEdgeWidth);
	AutoAppendPt(cplCurve, tCurveEle, arPtsV[1] - vtNor * dStartWidth * 0.5, arPtsV[0], arPtsV[1] + vtNor * dStartWidth * 0.5, dEdgeWidth);
	
	// 支管直段
	if (dStartWidth - dBranWidth > 0.0001)
	{
		AcGePoint3d ptIntersect1,ptIntersect2;
		//求出直线于圆弧的交点
		AcGeCircArc3d circArc(arPtsV[0], arPtsV[1] - vtNor * dStartWidth * 0.5, arPtsV[2]);
		//定义求交直线
		AcGeLine3d *pLine = new AcGeLine3d(arPtsV[3] - vtNor * dBranWidth * 0.5, arPtsV[1] - vtNor * dBranWidth * 0.5);
		int nNum=0;//交点数
		circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
		delete pLine;
		if (2 == nNum)
		{
			AcGePoint3d ptGeTmp = arPtsV[3] - vtNor * dBranWidth * 0.5;			
			if (ptGeTmp.distanceTo(ptIntersect1) < ptGeTmp.distanceTo(ptIntersect2))
			{
				AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] - vtNor * dBranWidth * 0.5, ptIntersect1, ptIntersect1, dEdgeWidth);
			}
			else
			{
				AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] - vtNor * dBranWidth * 0.5, ptIntersect2, ptIntersect2, dEdgeWidth);				
			}
		}

		AcGeCircArc3d circArc1(arPtsV[0], arPtsV[1] + vtNor * dStartWidth * 0.5, arPtsV[2]);
		pLine = new AcGeLine3d(arPtsV[3] + vtNor * dBranWidth * 0.5, arPtsV[1] + vtNor * dBranWidth * 0.5);
		nNum = 0;
		circArc1.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
		delete pLine;
		if (2 == nNum)
		{
			AcGePoint3d ptGeTmp = arPtsV[3] + vtNor * dBranWidth * 0.5;			
			if (ptGeTmp.distanceTo(ptIntersect1) < ptGeTmp.distanceTo(ptIntersect2))
			{
				AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, ptIntersect1, ptIntersect1, dEdgeWidth);
			}
			else
			{
				AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, ptIntersect2, ptIntersect2, dEdgeWidth);				
			}
		}
	}
	else if (fabs(dStartWidth - dBranWidth) < 0.0001)
	{
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] - vtNor * dBranWidth * 0.5, 
			arPtsV[1] - vtNor * dStartWidth * 0.5, arPtsV[1] - vtNor * dStartWidth * 0.5, dEdgeWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, 
			arPtsV[1] + vtNor * dStartWidth * 0.5, arPtsV[1] + vtNor * dStartWidth * 0.5, dEdgeWidth);
	}

	// 支管弧段
	AcDbPolyline pPolyLine;
	int iRes = TAuxTools::GetEllipseFromCircle(arPtsV[3], dBranWidth, vtBran, vtZAxis, pPolyLine, arPtsV[3] - arPtsV[1]);
					
	if (iRes == 2 || iRes == 0)
	{
		AcGePoint3dArray arPtsEll;
		TAuxTools::GetArcPoint(pPolyLine, arPtsEll);//Lixl add 2011-11-23
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, 
			arPtsEll[3], arPtsV[3] - vtNor * dBranWidth * 0.5, dEdgeWidth);
	}
	else if (iRes == 1)
	{
		tCurveEle.idSubLay = m_pOwnerEnt->layerId();
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, 
			arPtsV[3] - vtNor * dBranWidth * 0.5, arPtsV[3] - vtNor * dBranWidth * 0.5, GetEndLineWidth());
	}
	return TRUE;
}

BOOL ImpHvacTee::MakeInclineCircleSideVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInclineCirPts(arPts))
		return FALSE;

	double dStartWidth = 0.0;
	double dBranWidth = 0.0;
	AcGeVector3d vtNor = normal();
	AcGeVector3d vtBran = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	
	AcGePoint3dArray arPtsV;
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	ptTmp = arPts[0];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[1];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[2];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[16];
	ptTmp.z = arPts[7].z;
	arPtsV.append(ptTmp);
 	ptTmp = arPts[7];
	arPtsV.append(ptTmp);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));

	AcGePoint3d pt1, pt2;
	// 支管直段
	double dEdgeWidth = GetEdgeLineWidth();
	if (dStartWidth - dBranWidth > 0.0001)
	{
		AcGePoint3d ptIntersect1,ptIntersect2;
		//求出直线于圆弧的交点
		AcGeCircArc3d circArc(arPtsV[0], arPtsV[1] - vtNor * dStartWidth * 0.5, arPtsV[2]);
		//定义求交直线
		AcGeLine3d *pLine = new AcGeLine3d(arPtsV[3] - vtNor * dBranWidth * 0.5, arPtsV[1] - vtNor * dStartWidth * 0.5);
		int nNum=0;//交点数
		circArc.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
		delete pLine;
		if (2 == nNum)
		{
			AcGePoint3d ptGeTmp = arPtsV[3] - vtNor * dBranWidth * 0.5;			
			if (ptGeTmp.distanceTo(ptIntersect1) < ptGeTmp.distanceTo(ptIntersect2))
			{
				pt1 = ptIntersect1;
			}
			else
			{
				pt1 = ptIntersect2;							
			}
			AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] - vtNor * dBranWidth * 0.5, pt1, pt1, dEdgeWidth);	
		}
		
		AcGeCircArc3d circArc1(arPtsV[0], arPtsV[1] + vtNor * dStartWidth * 0.5, arPtsV[2]);
		pLine = new AcGeLine3d(arPtsV[3] + vtNor * dBranWidth * 0.5, arPtsV[1] + vtNor * dStartWidth * 0.5);
		nNum = 0;
		circArc1.intersectWith(*pLine, nNum, ptIntersect1, ptIntersect2);
		delete pLine;
		if (2 == nNum)
		{
			AcGePoint3d ptGeTmp = arPtsV[3] + vtNor * dBranWidth * 0.5;			
			if (ptGeTmp.distanceTo(ptIntersect1) < ptGeTmp.distanceTo(ptIntersect2))
			{
				pt2 = ptIntersect1;				
			}
			else
			{
				pt2 = ptIntersect2;		
			}
			AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, pt2, pt2, dEdgeWidth);
		}
	}
	else if (fabs(dStartWidth - dBranWidth) < 0.0001)
	{
		pt1 = arPtsV[1] - vtNor * dStartWidth * 0.5;
		pt2 = arPtsV[1] + vtNor * dStartWidth * 0.5;
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] - vtNor * dBranWidth * 0.5, pt1, pt1, dEdgeWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, pt2, pt2, dEdgeWidth);
	}

	// 主管弧段
	AutoAppendPt(cplCurve, tCurveEle, pt1, arPtsV[0], pt2, dEdgeWidth);
	AutoAppendPt(cplCurve, tCurveEle, pt1, arPtsV[2], pt2, dEdgeWidth);

	// 支管弧段
	AcDbPolyline pPolyLine;
	int iRes = TAuxTools::GetEllipseFromCircle(arPtsV[3], dBranWidth, vtBran, vtZAxis, pPolyLine, /*arPtsV[4] - arPtsV[1]*/vtBran);
	
	if (iRes == 2 || iRes == 0)
	{
		AcGePoint3dArray arPtsEll;
		TAuxTools::GetArcPoint(pPolyLine, arPtsEll);

		for(int i = 0; i < arPtsEll.length()-1; i++)
		{
			tCurveEle.ptGe[0] = arPtsEll[i];
			tCurveEle.ptGe[1] = arPtsEll[i+1];
			tCurveEle.ptGe[2] = arPtsEll[i+1];
			cplCurve.append(tCurveEle);
		}
	}
	else if (iRes == 1)
	{
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, 
			arPtsV[3] - vtNor * dBranWidth * 0.5, arPtsV[3] - vtNor * dBranWidth * 0.5, dEdgeWidth);
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeYShapeCircleSideVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	
	AcGePlane planStd =GetStdPrjPlan(ptBran);
	ptStart = ptStart.orthoProject(planStd);
	ptEnd = ptEnd.orthoProject(planStd);
	ptBran = ptBran.orthoProject(planStd);

	AcGeVector3d vtBran(BranVect());
	AcGeVector3d vtBranPerl = vtBran;
	vtBranPerl.rotateBy(PI * 0.5, TAuxTools::GetUcsZvt());

	// 求出半径
	double dStartRadius(0.0), dEndRadius(0.0), dBranRadius(0.0);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartRadius);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndRadius);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranRadius);
	dStartRadius *= 0.5;
	dEndRadius *= 0.5;
	dBranRadius *= 0.5;

	AecEqui::AecCurveElement cCurveEle;
	memset(&cCurveEle, 0, sizeof(AecEqui::AecCurveElement));

	// 单线模式
	double dEdgeWidth = GetEdgeLineWidth();
	if (IsSingleLine())
	{
		// 离支管点较远点
		double dStartDist = ptStart.distanceTo(ptBran);
		double dEndDist = ptEnd.distanceTo(ptBran);
		AcGePoint3d &ptFar = dStartDist > dEndDist ? ptStart:ptEnd;

		AutoAppendPt(cplCurve, cCurveEle, ptFar, ptBran, ptBran, dEdgeWidth);
		return TRUE;
	}

	// 法兰咬边
	double dFlanPlus(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dFlanPlus);

	// 支管端左右点，及法兰左右点
	AcGePoint3d ptBranLeft = ptBran - dBranRadius * vtBranPerl;
	AcGePoint3d ptBranRight = ptBran + dBranRadius * vtBranPerl;
	AcGePoint3d ptBranLeftFlan = ptBranLeft - dFlanPlus * vtBran;
	AcGePoint3d ptBranRightFlan = ptBranRight - dFlanPlus * vtBran;
	
	// 首尾较大管径对应值及点
	double &dBigDia = dStartRadius > dEndRadius ? dStartRadius:dEndRadius;
	AcGePoint3d &ptBig = dStartRadius > dEndRadius ? ptStart:ptEnd;

	if (nOutOrIn == 0)
	{
		AcGePoint3d ptUpLeft = ptBig - dBigDia * vtBranPerl;
		AcGePoint3d ptUpRight = ptBig + dBigDia * vtBranPerl;
		AcGePoint3d ptOutArc = ptBig - dBigDia * vtBran;
		AutoAppendPt(cplCurve, cCurveEle, ptBranRight, ptBranRightFlan, ptBranRightFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranRightFlan, ptUpRight, ptUpRight, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptUpRight, ptOutArc, ptUpLeft, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptUpLeft, ptBranLeftFlan, ptBranLeftFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranLeftFlan, ptBranLeft, ptBranLeft, dEdgeWidth);

		cCurveEle.idSubLay = m_pOwnerEnt->layerId();
		AutoAppendPt(cplCurve, cCurveEle, ptBranLeft, ptBranRight, ptBranRight, GetEndLineWidth());
	}
	else if (nOutOrIn == 1)
	{
		// 首尾较小管径对应值及点
		double &dSmallDia = dStartRadius < dEndRadius ? dStartRadius:dEndRadius;
		AcGePoint3d &ptSmall = dStartRadius < dEndRadius ? ptStart:ptEnd;
	
		// 小圆
		AcGePoint3d ptUpLeft = ptSmall - dSmallDia * vtBranPerl;
		AcGePoint3d ptUpRight = ptSmall + dSmallDia * vtBranPerl;
		AcGePoint3d ptOutArc = ptSmall - dSmallDia * vtBran;
		AcGePoint3d ptInArc = ptSmall + dSmallDia * vtBran;
	
		AutoAppendPt(cplCurve, cCurveEle, ptBranRight, ptBranRightFlan, ptBranRightFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranRightFlan, ptUpRight, ptUpRight, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptUpRight, ptOutArc, ptUpLeft, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptUpLeft, ptBranLeftFlan, ptBranLeftFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranLeftFlan, ptBranLeft, ptBranLeft, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranLeftFlan, ptBranRightFlan, ptBranRightFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptUpLeft, ptInArc, ptUpRight, dEdgeWidth);
	
		// 半个大圆
		ptUpLeft = ptBig - dBigDia * vtBranPerl;
		ptUpRight = ptBig + dBigDia * vtBranPerl;
		ptInArc = ptBig + dBigDia * vtBran;
		AutoAppendPt(cplCurve, cCurveEle, ptUpLeft, ptInArc, ptUpRight, dEdgeWidth);

		// 中心线
		if (IsBaseLine())
		{
			AcDbObjectId idCenter;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
			cCurveEle.idSubLay = idCenter;

			// 离支管点较远点
			double dStartDist = ptStart.distanceTo(ptBran);
			double dEndDist = ptEnd.distanceTo(ptBran);
			AcGePoint3d &ptFar = dStartDist > dEndDist ? ptStart:ptEnd;

			double dCentWidth = GetCentLineWidth();
			AutoAppendPt(cplCurve, cCurveEle, ptFar, ptBran, ptBran, dCentWidth);
		}
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeVShapeCircleSideVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	AcGeVector3d vtNormal(normal());
	AcGeVector3d vtNormalSide = vtNormal;
	vtNormalSide.rotateBy(PI*0.5, vtZAxis);
	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0),dPlusEdge(50.0);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	
	AcGePoint3dArray arpts;
	GetVShapeCirclePts(arpts);

	AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
	int nHasBaseLine = 1;
	idBaseLayer;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
	m_pXDataMap->GetAt(HVAC_HasBaseLine, nHasBaseLine);
	AecEqui::AecCurveElement el;
	memset(&el,0,sizeof(AecEqui::AecCurveElement));
	int nRet = -1;
	AcGePoint3d ptS,ptSU,ptSD,ptBase,ptBaseL,ptBaseR,ptBaseLU,ptBaseRU;
	ptBase = arpts[12];
	ptS = arpts[10];
	ptS.z = ptBase.z;
	ptBaseL = ptBase + vtNormal * dBranWidth * 0.5 ;
	ptBaseR = ptBase - vtNormal * dBranWidth * 0.5 ;
	ptBaseLU = ptBaseL - BranVect() * dPlusEdge ;
	ptBaseRU = ptBaseR - BranVect() * dPlusEdge ;
	if (nOutOrIn == 0)
	{
		el.ptGe[0] = ptBaseL; 
		el.ptGe[1] = ptBaseR;
		el.ptGe[2] = ptBaseR;
		cplCurve.append(el);
		el.ptGe[0] = ptBaseL; 
		el.ptGe[1] = ptBaseLU;
		el.ptGe[2] = ptBaseLU;
		cplCurve.append(el);
		el.ptGe[0] = ptBaseR; 
		el.ptGe[1] = ptBaseRU;
		el.ptGe[2] = ptBaseRU;
		cplCurve.append(el);

		AcDbPolyline pPolyLine1,pPolyLine2;
		AcGePoint3dArray ptsEll;
		nRet = TAuxTools::GetEllipseFromCircle(ptS, dStartWidth, StartVect(), vtZAxis, 
			pPolyLine1,vtNormal);
		if (nRet == 2)
		{
			ptsEll.setLogicalLength(0);

			TAuxTools::GetArcPoint(pPolyLine1, ptsEll);
			for(int i = 0; i < ptsEll.length()-1; i++)
			{
				el.ptGe[0] = ptsEll[i];
				el.ptGe[1] = ptsEll[i+1];
				el.ptGe[2] = ptsEll[i+1];
				cplCurve.append(el);				
			}
		}
		nRet = TAuxTools::GetEllipseFromCircle(ptS, dStartWidth, StartVect(), vtZAxis, 
			pPolyLine2,-vtNormal);
		if (nRet == 2)
		{
			ptsEll.setLogicalLength(0);

			TAuxTools::GetArcPoint(pPolyLine2, ptsEll);
			for(int i = 0; i < ptsEll.length()-1; i++)
			{
				el.ptGe[0] = ptsEll[i];
				el.ptGe[1] = ptsEll[i+1];
				el.ptGe[2] = ptsEll[i+1];
				cplCurve.append(el);				
			}
			ptSU = ptsEll.first();
			ptSD = ptsEll.last();

			el.ptGe[0] = ptSU;
			el.ptGe[1] = ptBaseLU;
			el.ptGe[2] = ptBaseLU;
			cplCurve.append(el);

			el.ptGe[0] = ptSD;
			el.ptGe[1] = ptBaseRU;
			el.ptGe[2] = ptBaseRU;
			cplCurve.append(el);
		}
		else
		{
			AcGePoint3d ptStart, ptEnd, ptBran;
			m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
			m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
			m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

			AcGeVector3d vtNorm = normal();
			vtNorm.normalize();

			//sta
			el.idSubLay = m_idDoubleLayer;
			el.ptGe[0] = ptStart - vtNorm * 0.5 * dStartWidth;
			el.ptGe[1] = ptStart + vtNorm * 0.5 * dStartWidth;
			el.ptGe[2] = el.ptGe[1];
			cplCurve.append(el);

			//top
			el.ptGe[0] = ptStart - vtNorm * 0.5 * dStartWidth;
			el.ptGe[1] = ptEnd - vtNorm * 0.5 * dEndWidth;
			el.ptGe[2] = el.ptGe[1];
			cplCurve.append(el);

			//end
			el.ptGe[0] = ptEnd - vtNorm * 0.5 * dStartWidth;
			el.ptGe[1] = ptEnd + vtNorm * 0.5 * dEndWidth;
			el.ptGe[2] = el.ptGe[1];
			cplCurve.append(el);

			//down
			el.ptGe[0] = ptStart + vtNorm * 0.5 * dStartWidth;
			el.ptGe[1] = ptEnd + vtNorm * 0.5 * dEndWidth;
			el.ptGe[2] = el.ptGe[1];
			cplCurve.append(el);

			//中心线
			el.ptGe[0] = ptStart;
			el.ptGe[1] = ptEnd;
			el.ptGe[2] = ptEnd;
			el.idSubLay = m_idCenterLayer;//... 图层取
			cplCurve.append(el);
		}
	}
	else if (nOutOrIn == 1)
	{
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeOrthoCircleFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	return TRUE;
}

BOOL ImpHvacTee::MakeInsertCircleFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3dArray arPts;
	if (!GetInsertCirPts(arPts))
		return FALSE;
	
	double dStartWidth = 0.0;
	double dEndWidth = 0.0;
	double dBranWidth = 0.0;
	AcGeVector3d vtNor = normal();
	AcGeVector3d vtBran = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	
	AcGePoint3dArray arPtsV;
	AcGePoint3d ptTmp = AcGePoint3d::kOrigin;
	ptTmp = arPts[2];
	ptTmp.z = arPts[1].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[3];
	ptTmp.z = arPts[1].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[7];
	ptTmp.z = arPts[1].z;
	arPtsV.append(ptTmp);	
	
	double dDis1 = arPts[6].distanceTo(arPts[9]);
	double dDis2 = arPts[8].distanceTo(arPts[10]);
	dDis1 = dDis1 > dDis2 ? dDis1 : dDis2;
	ptTmp = arPts[7] - vtBran * dDis1;
	ptTmp.z = arPts[1].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[6];
	ptTmp.z = arPts[1].z;
	arPtsV.append(ptTmp);
	ptTmp = arPts[8];
	ptTmp.z = arPts[1].z;
	arPtsV.append(ptTmp);
	
	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	
	// 主管
	double dEdgeWidth = GetEdgeLineWidth();
	double dEndLineWidth = GetEndLineWidth();
	AcDbObjectId idEnd = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEnd);
	
	AutoAppendPt(cplCurve, tCurveEle, arPtsV[0] - vtNor * dStartWidth * 0.5, 
		arPtsV[1] - vtNor * dEndWidth * 0.5, arPtsV[1] - vtNor * dEndWidth * 0.5, dEdgeWidth);
	AutoAppendPt(cplCurve, tCurveEle, arPtsV[0] + vtNor * dStartWidth * 0.5, 
		arPtsV[1] + vtNor * dEndWidth * 0.5, arPtsV[1] + vtNor * dEndWidth * 0.5, dEdgeWidth);

	// 支管
	if (BranVect().angleTo(vtZAxis) < PI * 0.51)
	{
		// 支管直段
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[2] - vtNor * dBranWidth * 0.5, 
			arPtsV[3] - vtNor * dBranWidth * 0.5, arPtsV[3] - vtNor * dBranWidth * 0.5, dEdgeWidth);
		AutoAppendPt(cplCurve, tCurveEle, arPtsV[2] + vtNor * dBranWidth * 0.5, 
			arPtsV[3] + vtNor * dBranWidth * 0.5, arPtsV[3] + vtNor * dBranWidth * 0.5, dEdgeWidth);
		
		// 支管椭圆弧
		AcDbPolyline pPolyLine;
		int iRes = TAuxTools::GetEllipseFromCircle(arPtsV[2], dBranWidth, vtBran, vtZAxis, pPolyLine, arPtsV[3] - arPtsV[2]);
		
		if (iRes == 2)
		{
			AcGePoint3dArray arPtsEll;

			TAuxTools::GetArcPoint(pPolyLine, arPtsEll);
			AutoAppendPt(cplCurve, tCurveEle, arPtsV[2] + vtNor * dBranWidth * 0.5, 
				arPtsEll[3], arPtsV[2] - vtNor * dBranWidth * 0.5, dEdgeWidth);
			AcDbPolyline pPolyLine1;
			iRes = TAuxTools::GetEllipseFromCircle(arPtsV[2], dBranWidth, vtBran, vtZAxis, pPolyLine1, arPtsV[2] - arPtsV[3]);
			if (iRes == 2)
			{
				AcGePoint3dArray arPtsEll1;

				TAuxTools::GetArcPoint(pPolyLine1, arPtsEll1);
				AutoAppendPt(cplCurve, tCurveEle, arPtsV[2] + vtNor * dBranWidth * 0.5, 
					arPtsEll1[3], arPtsV[2] - vtNor * dBranWidth * 0.5, dEdgeWidth);
			}
			AcDbPolyline pPolyLine2;
			iRes = TAuxTools::GetEllipseFromCircle(arPtsV[3], dBranWidth, vtBran, vtZAxis, pPolyLine2, arPtsV[3] - arPtsV[2]);
			if (iRes == 2)
			{
				AcGePoint3dArray arPtsEll2;

				TAuxTools::GetArcPoint(pPolyLine2, arPtsEll2);
				AutoAppendPt(cplCurve, tCurveEle, arPtsV[3] + vtNor * dBranWidth * 0.5, 
					arPtsEll2[3], arPtsV[3] - vtNor * dBranWidth * 0.5, dEdgeWidth);
			}
		}
		else if (iRes == 0)
		{
			AutoAppendPt(cplCurve, tCurveEle, arPtsV[2] + vtNor * dBranWidth * 0.5, 
				arPtsV[4], arPtsV[2] - vtNor * dBranWidth * 0.5, dEdgeWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPtsV[2] + vtNor * dBranWidth * 0.5, 
				arPtsV[5], arPtsV[2] - vtNor * dBranWidth * 0.5, dEdgeWidth);
		}
	}

	tCurveEle.idSubLay = idEnd;
	AutoAppendPt(cplCurve, tCurveEle, arPtsV[0] - vtNor * dStartWidth * 0.5, 
		arPtsV[0] + vtNor * dStartWidth * 0.5, arPtsV[0] + vtNor * dStartWidth * 0.5, dEndLineWidth);
	AutoAppendPt(cplCurve, tCurveEle, arPtsV[1] - vtNor * dEndWidth * 0.5, 
		arPtsV[1] + vtNor * dEndWidth * 0.5, arPtsV[1] + vtNor * dEndWidth * 0.5, dEndLineWidth);

	return TRUE;	
}

BOOL ImpHvacTee::MakeInclineCircleFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 以下是符合攀钢用户要求的表达方式,三通正面垂直放置绘制方法
	AcGePoint3dArray arPts;
	if (!GetInclineCirPts2d(arPts))
		return FALSE;

	// 3个端点
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	// 3个方向
	AcGeVector3d vtStart, vtEnd, vtBran;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);
	// 端口宽度,咬口余量
	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0), dPlusEdge(0.0);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranWidth);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	// 法向,Z轴
	AcGeVector3d vtNor, vtZAxis;
	vtNor = normal();
	vtZAxis = TAuxTools::GetUcsZvt();
	// 投影面
	AcGePoint3d ptTmp;
	Midpoint(ptStart, ptEnd, ptTmp);
	AcGePlane plan(ptTmp, vtZAxis);
	AcGePoint3d ptOrg = AcGePoint3d::kOrigin.orthoProject(plan);
	plan.set(ptOrg, vtZAxis);
	double dEl = ptOrg.asVector().length();
	if (!ptOrg.asVector().isCodirectionalTo(vtZAxis))
		dEl *= -1;

	// 3个端口2D下边界点
	AcGePoint3d ptSU, ptSD, ptED, ptEU, ptBranU, ptBranD;
	ptSD = arPts[2].orthoProject(plan);
	ptSU = arPts[0].orthoProject(plan);
	ptED = arPts[3].orthoProject(plan);
	ptEU = arPts[5].orthoProject(plan);
	ptBranD = arPts[6].orthoProject(plan);
	ptBranU = arPts[8].orthoProject(plan);

	AecEqui::AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	// 实际边线宽
	double dWidth = GetEdgeLineWidth();

	// 内部线
	if (nOutOrIn == 1)
	{
		if (IsSingleLine())
		{
			// 主管单线
			AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[10], arPts[10], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[13], arPts[13], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[13], arPts[4], arPts[4], dWidth);
			// 支管单线
			AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[16], arPts[16], dWidth);
			AutoAppendPt(cplCurve, tCurveEle, arPts[16], arPts[7], arPts[7], dWidth);
		}
		else
		{
			// 3个端口内部半个椭圆端线
			GetAllIncCircleEndEdge2DCurves(cplCurve, 1);

			// 是否绘制中心线
			BOOL bBaseLine = FALSE;
			m_pXDataMap->GetAt(HVAC_HasBaseLine, (int&)bBaseLine);
			if (bBaseLine)
			{
				tCurveEle.gsMark = -1;

				// 设置中心线图层和线宽
				dWidth = GetCentLineWidth();
				
				AutoAppendPt(cplCurve, tCurveEle, arPts[1], arPts[10], arPts[10], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[13], arPts[13], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[13], arPts[4], arPts[4], dWidth);
				// 支管中心线
				AutoAppendPt(cplCurve, tCurveEle, arPts[10], arPts[16], arPts[16], dWidth);
				AutoAppendPt(cplCurve, tCurveEle, arPts[16], arPts[7], arPts[7], dWidth);
			}
		}
	}
	else if (0 == nOutOrIn)
	{
		tCurveEle.gsMark = 0;

		int iRes(0), i(0);
		AcDbPolyline DbPLine;

		// 计算用的支管边线
		AcDbLine lineBranU(ptSU, ptBranU);
		AcDbLine lineBranD(ptSD, ptBranD);
		
		BOOL bInterU(FALSE), bInterD(FALSE);    // 2D下,主管边线和直管边线是否相交
		AcGePoint3d ptInterU, ptInterD;         // 2D下,主管边界和支管边界可能的交点
		AcGePoint3dArray arPtEdge;
		Acad::ErrorStatus es = Acad::eOk;

		// 支管口直径大于尾管口直径,则,支管边线于主管边线相交
		if (dBranWidth > dEndWidth)
		{
			AcDbLine lineSU(ptSU, ptEU);
			AcDbLine lineSD(ptSD, ptED);

 			if (ptBran.z > ptEnd.z)// 支管高,画支管边线,和支管另一端端线
 			{
				// 支管边线
				AutoAppendPt(cplCurve, tCurveEle, ptSU, ptBranU, ptBranU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptSD, ptBranD, ptBranD, dWidth);

				// 支管端线
				ptTmp.set(ptBran.x, ptBran.y, dEl);
				iRes = TAuxTools::GetEllipseFromCircle(ptTmp, dBranWidth, vtBran, vtZAxis, DbPLine, vtBran);
				if (-1 != iRes)
				{
					DbPLine.setElevation(dEl);
					arPtEdge.setLogicalLength(0);

					// 支管端线和主管边线是否有交点
					ptInterU = ptSU;
					es = lineSU.intersectWith(&DbPLine, AcDb::kOnBothOperands, arPtEdge);
					if (es == Acad::eOk && arPtEdge.length() == 1)
						ptInterU = arPtEdge[0];

					arPtEdge.setLogicalLength(0);
					ptInterD = ptSD;
					es = lineSD.intersectWith(&DbPLine, AcDb::kOnBothOperands, arPtEdge);
					if (es == Acad::eOk && arPtEdge.length() == 1)
						ptInterD = arPtEdge[0];
				}

				// 绘制主管边线
				AutoAppendPt(cplCurve, tCurveEle, ptInterU, ptEU, ptEU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptInterD, ptED, ptED, dWidth);

				GetAllIncCircleEndEdge2DCurves(cplCurve, 0, TRUE, TRUE, TRUE);
			}
			else // 支管低,不画支管另一端端线,从交点开始画支管边线
			{
				// 绘制主管边线
				AutoAppendPt(cplCurve, tCurveEle, ptSU, ptEU, ptEU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptSD, ptED, ptED, dWidth);

				// 绘制支管边线
				AutoAppendPt(cplCurve, tCurveEle, ptSU, ptBranU, ptBranU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptSD, ptBranD, ptBranD, dWidth);

				// 3个端口端线
				GetAllIncCircleEndEdge2DCurves(cplCurve, 0, TRUE, TRUE, TRUE);
			}
		} 
 		else if (dBranWidth < dEndWidth)// 支管口直径小于尾管口直径,则支管边线于主管边线肯定不相交,支管边线和尾部端线可能相交
		{
			// 支管高,画整个支管边线
			if (ptBran.z > ptEnd.z)
			{
				// 绘制主管边线
				AutoAppendPt(cplCurve, tCurveEle, ptSU, ptEU, ptEU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptSD, ptED, ptED, dWidth);
				// 绘制支管边线
				AutoAppendPt(cplCurve, tCurveEle, ptSU, ptBranU, ptBranU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptSD, ptBranD, ptBranD, dWidth);
				// 3个端口端线
				GetAllIncCircleEndEdge2DCurves(cplCurve, 0, TRUE, TRUE, TRUE);
			}
			else// 支管低
			{
				// 绘制主管边线
				AutoAppendPt(cplCurve, tCurveEle, ptSU, ptEU, ptEU, dWidth);
				AutoAppendPt(cplCurve, tCurveEle, ptSD, ptED, ptED, dWidth);

				// 支管边线可能与尾管端线相交,若相交,从相交部分画起,并画支管端线,否则,不画支管边线和端线
				// 尾管端线的外轮廓线
				ptTmp.set(ptEnd.x, ptEnd.y, dEl);
				AcGeVector3d vtDir = ptEnd - ptStart;
				vtDir.normalize();
				iRes = TAuxTools::GetEllipseFromCircle(ptTmp, dEndWidth, vtDir, vtZAxis, DbPLine, vtDir);
				if (-1 != iRes)
				{
					DbPLine.setElevation(dEl);

					
					// 支管端线和尾管端线是否有交点
					ptInterU = ptSU;
					es = lineBranU.intersectWith(&DbPLine, AcDb::kOnBothOperands, arPtEdge);
					if (es == Acad::eOk && arPtEdge.length() == 1)
					{
						// 有交点,从交点开始绘制支管边线
						ptInterU = arPtEdge[0];

						arPtEdge.setLogicalLength(0);
						ptInterD = ptSD;
						es = lineBranD.intersectWith(&DbPLine, AcDb::kOnBothOperands, arPtEdge);
						if (es == Acad::eOk && arPtEdge.length() == 1)
						{
							ptInterD = arPtEdge[0];

							// 绘制支管边线
							AutoAppendPt(cplCurve, tCurveEle, ptInterU, ptBranU, ptBranU, dWidth);
							AutoAppendPt(cplCurve, tCurveEle, ptInterD, ptBranD, ptBranD, dWidth);
							// 绘制支管端线
							GetAllIncCircleEndEdge2DCurves(cplCurve, 0, FALSE, FALSE, TRUE);
						}
					}
					else// 与尾管端线无焦点,查看支管点的位置
					{
						// 支管点在主管起止点之外,并且支管端线的内轮廓线和尾管端线的外轮廓线无焦点的时候,可以绘制支管边线和端线
						AcGePoint3d pt1, pt2, pt3;
						Midpoint(ptSU, ptSD, pt1);
						Midpoint(ptEU, ptED, pt2);
						Midpoint(ptBranU, ptBranD, pt3);
						iRes = TAuxTools::PositionOnLine(pt1, pt2, pt3);
						if (0 != iRes)
						{
							AcDbPolyline DbBraLine;
							ptTmp.set(ptBran.x, ptBran.y, dEl);
							iRes = TAuxTools::GetEllipseFromCircle(ptTmp, dBranWidth, -vtBran, vtZAxis, DbBraLine, -vtBran);
							if (-1 != iRes)
							{
								arPtEdge.setLogicalLength(0);
								if (Acad::eOk == DbBraLine.intersectWith(&DbPLine, AcDb::kOnBothOperands, arPtEdge))
								{
									if (arPtEdge.length() == 0)
									{
										// 绘制支管边线
										AutoAppendPt(cplCurve, tCurveEle, ptSU, ptBranU, ptBranU, dWidth);
										AutoAppendPt(cplCurve, tCurveEle, ptSD, ptBranD, ptBranD, dWidth);
										// 绘制支管端线
										GetAllIncCircleEndEdge2DCurves(cplCurve, 0, FALSE, FALSE, TRUE);
									}
								}
							}
						}
					}
				}

				GetAllIncCircleEndEdge2DCurves(cplCurve, 0, TRUE, TRUE, FALSE);
			}
		}
 		// 尾管与支管管径相等,不画支管边线
		else
		{
			// 绘制主管边线
			AutoAppendPt(cplCurve, tCurveEle, ptSU, ptEU, ptEU, dWidth);
			AutoAppendPt(cplCurve, tCurveEle, ptSD, ptED, ptED, dWidth);

			if (ptBran.z > ptEnd.z)// 支管高,画支管端线
			{
				GetAllIncCircleEndEdge2DCurves(cplCurve, 0, TRUE, TRUE, TRUE);
			}
			else                   // 支管低,被主管遮挡,不画支管端线
			{
				GetAllIncCircleEndEdge2DCurves(cplCurve, 0, TRUE, TRUE, FALSE);
			}
		}
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeYShapeCircleFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	
	AcGePlane planStd =GetStdPrjPlan(ptStart);
	ptEnd = ptEnd.orthoProject(planStd);
	ptBran = ptBran.orthoProject(planStd);

	AcGeVector3d vtStart(StartVect());
	AcGeVector3d vtStartPerl = vtStart;
	vtStartPerl.rotateBy(PI * 0.5, TAuxTools::GetUcsZvt());

	// 求出半径
	double dStartRadius(0.0), dEndRadius(0.0), dBranRadius(0.0);
	m_pXDataMap->GetAt(HTEE_StartDiameter, dStartRadius);
	m_pXDataMap->GetAt(HTEE_EndDiameter, dEndRadius);
	m_pXDataMap->GetAt(HTEE_BranchDiameter, dBranRadius);
	dStartRadius *= 0.5;
	dEndRadius *= 0.5;
	dBranRadius *= 0.5;

	AecEqui::AecCurveElement cCurveEle;
	memset(&cCurveEle, 0, sizeof(AecEqui::AecCurveElement));

	// 单线模式
	double dEdgeWidth = GetEdgeLineWidth();
	if (IsSingleLine())
	{
		AutoAppendPt(cplCurve, cCurveEle, ptStart, ptBran, ptBran, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBran, ptEnd, ptEnd, dEdgeWidth);
		return TRUE;
	}
	
	// 中间支管点上下点
	AcGePoint3d ptBranUp, ptBranDown;
	ptBranUp = ptBran - dBranRadius * vtStartPerl; 
	ptBranDown = ptBran + dBranRadius * vtStartPerl; 

	// 法兰咬边
	double dFlanPlus(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dFlanPlus);

	// 起始端上下点、起始法兰端上下点
	AcGePoint3d ptStartUp = ptStart - dStartRadius * vtStartPerl;
	AcGePoint3d ptStartDown = ptStart + dStartRadius * vtStartPerl;
	AcGePoint3d ptStartUpFlan = ptStartUp - dFlanPlus * vtStart;
	AcGePoint3d ptStartDownFlan = ptStartDown - dFlanPlus * vtStart;

	AcGePoint3d ptEndUp = ptEnd - dEndRadius * vtStartPerl;
	AcGePoint3d ptEndDown = ptEnd + dEndRadius * vtStartPerl;
	AcGePoint3d ptEndUpFlan = ptEndUp + dFlanPlus * vtStart;
	AcGePoint3d ptEndDownFlan = ptEndDown + dFlanPlus * vtStart;

	if (nOutOrIn == 0)
	{
		AutoAppendPt(cplCurve, cCurveEle, ptStartDown, ptStartDownFlan, ptStartDownFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptStartDownFlan, ptBranDown, ptBranDown, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranDown, ptEndDownFlan, ptEndDownFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptEndDownFlan, ptEndDown, ptEndDown, dEdgeWidth);

		AutoAppendPt(cplCurve, cCurveEle, ptEndUp, ptEndUpFlan, ptEndUpFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptEndUpFlan, ptBranUp, ptBranUp, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptBranUp, ptStartUpFlan, ptStartUpFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptStartUpFlan, ptStartUp, ptStartUp, dEdgeWidth);

		double dEndWidth = GetEndLineWidth();
		cCurveEle.idSubLay = m_pOwnerEnt->layerId();
		AutoAppendPt(cplCurve, cCurveEle, ptStartUp, ptStartDown, ptStartDown, dEndWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptEndDown, ptEndUp, ptEndUp, dEndWidth);
	}
	else if (nOutOrIn == 1)
	{
		AcDbDatabase* pDb = acdbCurDwg();
		AcGeVector3d vtUcsZ = pDb->ucsxdir().crossProduct(pDb->ucsydir());
		if (BranVect().angleTo(vtUcsZ) < PI * 0.51)
		{
			// 中间支管投影形成的圆
			AcGePoint3d ptLeft = ptBran + dBranRadius * vtStart;
			AcGePoint3d ptRight = ptBran - dBranRadius * vtStart;
			AutoAppendPt(cplCurve, cCurveEle, ptBranDown, ptRight, ptBranUp, dEdgeWidth);
			AutoAppendPt(cplCurve, cCurveEle, ptBranUp, ptLeft, ptBranDown, dEdgeWidth);
		}

		// 法兰线
		AutoAppendPt(cplCurve, cCurveEle, ptStartDownFlan, ptStartUpFlan, ptStartUpFlan, dEdgeWidth);
		AutoAppendPt(cplCurve, cCurveEle, ptEndDownFlan, ptEndUpFlan, ptEndUpFlan, dEdgeWidth);

		// 中心线
		if (IsBaseLine())
		{
			AcDbObjectId idCenter;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
			cCurveEle.idSubLay = idCenter;

			double dCentWidth = GetCentLineWidth();
			AutoAppendPt(cplCurve, cCurveEle, ptStart, ptBran, ptBran, dCentWidth);
			AutoAppendPt(cplCurve, cCurveEle, ptBran, ptEnd, ptEnd, dCentWidth);
		}
	}
	return TRUE;	
}

BOOL ImpHvacTee::MakeVShapeCircleFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	AcGeVector3d vtNormal(normal());
	AcGeVector3d vtNormalSide = vtNormal;
	vtNormalSide.rotateBy(PI*0.5, vtZAxis);
	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0),dPlusEdge(50.0);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);
	
	AcGePoint3dArray arpts;
	GetVShapeCirclePts(arpts);

	AcDbObjectId idBaseLayer(NULL), idSideLayer(NULL);
	int nHasBaseLine = 1;
	idBaseLayer;// = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
	m_pXDataMap->GetAt(HVAC_HasBaseLine, nHasBaseLine);
	AecEqui::AecCurveElement el;
	memset(&el,0,sizeof(AecEqui::AecCurveElement));
	int nRet = -1;
	AcGePoint3d ptS,ptE,ptSU,ptSD,ptS1U,ptS1D,ptEU,ptED,ptE1U,ptE1D,ptBase;
	ptBase = arpts[12];
	ptS = arpts[10];
	ptE = arpts[11];
	ptS.z = ptBase.z;
	ptE.z = ptBase.z;

	AcGeVector3d vtStoE = ptS - ptE;

	if (nOutOrIn == 0)
	{
		AcDbDatabase* pDb = acdbCurDwg();
		AcGeVector3d vtUcsZ = pDb->ucsxdir().crossProduct(pDb->ucsydir());
		if (BranVect().angleTo(vtUcsZ) < PI * 0.51)
		{
			//中心圆
			el.ptGe[0] = arpts[12] + vtNormal * dBranWidth * 0.5 ;
			el.ptGe[1] = arpts[12] + vtNormalSide * dBranWidth * 0.5 ;
			el.ptGe[2] = arpts[12] - vtNormal * dBranWidth * 0.5 ;
			cplCurve.append(el);
			
			el.ptGe[0] = arpts[12] + vtNormal * dBranWidth * 0.5 ;
			el.ptGe[1] = arpts[12] - vtNormalSide * dBranWidth * 0.5 ;
			el.ptGe[2] = arpts[12] - vtNormal * dBranWidth * 0.5 ;
			cplCurve.append(el);
		}

		//两端的椭圆
		AcDbPolyline pPolyLine1, pPolyLine2, pPolyLine3, pPolyLine4, pPLs,pPLe;
		AcGePoint3dArray ptsEll;
		nRet = TAuxTools::GetEllipseFromCircle(ptS, dStartWidth, StartVect(), vtZAxis, 
			pPolyLine1,vtStoE);
		if (nRet == 2)
		{
			ptsEll.setLogicalLength(0);

			TAuxTools::GetArcPoint(pPolyLine1, ptsEll);//Lixl add 2011-11-23
			for(int i = 0; i < ptsEll.length()-1; i++)
			{
				el.ptGe[0] = ptsEll[i];
				el.ptGe[1] = ptsEll[i+1];
				el.ptGe[2] = ptsEll[i+1];
				cplCurve.append(el);				
			}
		}
		nRet = TAuxTools::GetEllipseFromCircle(ptS, dStartWidth, StartVect(), vtZAxis, 
			pPolyLine2,-vtStoE);
		if (nRet == 2)
		{
			ptsEll.setLogicalLength(0);

			TAuxTools::GetArcPoint(pPolyLine2, ptsEll);//Lixl add 2011-11-23
			for(int i = 0; i < ptsEll.length()-1; i++)
			{
				el.ptGe[0] = ptsEll[i];
				el.ptGe[1] = ptsEll[i+1];
				el.ptGe[2] = ptsEll[i+1];
				cplCurve.append(el);				
			}
			ptSU = ptsEll.last();
			ptSD = ptsEll.first();
		}
		nRet = TAuxTools::GetEllipseFromCircle(ptE, dEndWidth, EndVect(), vtZAxis, 
			pPolyLine3, vtStoE);
		if (nRet == 2)
		{
			ptsEll.setLogicalLength(0);

			TAuxTools::GetArcPoint(pPolyLine2, ptsEll);//Lixl add 2011-11-23
			for(int i = 0; i < ptsEll.length()-1; i++)
			{
				el.ptGe[0] = ptsEll[i];
				el.ptGe[1] = ptsEll[i+1];
				el.ptGe[2] = ptsEll[i+1];
				cplCurve.append(el);				
			}
		}
		nRet = TAuxTools::GetEllipseFromCircle(ptE, dEndWidth, EndVect(), vtZAxis, 
			pPolyLine4, -vtStoE);
		if (nRet == 2)
		{
			ptsEll.setLogicalLength(0);

			TAuxTools::GetArcPoint(pPolyLine4, ptsEll);//Lixl add 2011-11-23
			for(int i = 0; i < ptsEll.length()-1; i++)
			{
				el.ptGe[0] = ptsEll[i];
				el.ptGe[1] = ptsEll[i+1];
				el.ptGe[2] = ptsEll[i+1];
				cplCurve.append(el);				
			}
			ptEU = ptsEll.last();
			ptED = ptsEll.first();
		}
		ptS1U = arpts[12] - vtNormal * dBranWidth * 0.5;
		ptS1D = arpts[12] + vtNormal * dBranWidth * 0.5;

		el.ptGe[0] = ptSU;
		el.ptGe[1] = ptS1U;
		el.ptGe[2] = ptS1U;
		cplCurve.append(el);
		el.ptGe[0] = ptSD;
		el.ptGe[1] = ptS1D;
		el.ptGe[2] = ptS1D;
		cplCurve.append(el);
		el.ptGe[0] = ptEU;
		el.ptGe[1] = ptS1U;
		el.ptGe[2] = ptS1U;
		cplCurve.append(el);
		el.ptGe[0] = ptED;
		el.ptGe[1] = ptS1D;
		el.ptGe[2] = ptS1D;
		cplCurve.append(el);
	}
	else if (nOutOrIn == 1)
	{
		el.gsMark = -1;
		el.idSubLay = idBaseLayer;
		el.ptGe[0] = ptED;
		el.ptGe[1] = ptS1D;
		el.ptGe[2] = ptS1D;
		cplCurve.append(el);
	}
	return TRUE;
}

int ImpHvacTee::AutoAppendPt( AecComplexCurve &cplCurve, AecEqui::AecCurveElement &cplEle, 
								const AcGePoint3d &ptS, const AcGePoint3d &ptMid, const AcGePoint3d &ptE) const
{
	cplEle.ptGe[0] = ptS;
	cplEle.ptGe[1] = ptMid;
	cplEle.ptGe[2] = ptE;

	return cplCurve.append(cplEle);
}

int ImpHvacTee::AutoAppendPt(AecComplexCurve &cplCurve, AecEqui::AecCurveElement &cplEle, 
							   const AcGePoint3d &ptS, const AcGePoint3d &ptMid, const AcGePoint3d &ptE,
							   double dWidth) const
{
	cplEle.ptGe[0] = ptS;
	cplEle.ptGe[1] = ptMid;
	cplEle.ptGe[2] = ptE;
	cplEle.dWidth = dWidth;
	
	return cplCurve.append(cplEle);
}

/*
	得到大部分矩形截面三通中截面9个关键点
	不适合类型，返回FALSE, 稍有变化的情函数中况予以说明
	
//						
// 			  	0━━━━━━━━━8━━━━━━━7		   
// 				┃	                    		  ┃		   
// 				┃	                    		  ┃ 		   
// 			     ━━━━━━━━━━━━━━━━━		  
// 				┃	              ┃   			  ┃		   
// 				┃	              ┃    		  ┃		   
// 			 	 1━━━━━2     ┃	 5━━━━6		   
//                          ┃    ┃    ┃					
//                          ┃    ┃    ┃				    	
//                          ┃    ┃    ┃				    	
//                          ┃    ┃    ┃				    	
//                           3━━━━━4				    	
//                                						   
*/
BOOL ImpHvacTee::GetSectMidKeyPt(AcGePoint3dArray &ptArr, BOOL bDefault) const
{
	ASSERT(NULL != m_pXDataMap);

	double dExten(100);	// 做辅助线延长
	ESection eSect = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);

	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	// add by hh 2011-01-14 避免三通接口不在同一高度时2D图案绘制错误
	if(!bDefault && !IsValidConst(NULL))
	{
		AcGePlane plane(ptStart, normal());
		ptBran = ptBran.orthoProject(plane);
		ptEnd = ptEnd.orthoProject(plane);
	}

	AcGeVector3d vtNormal(normal());
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()), vtBran(BranVect());
	AcGeVector3d vtStaSide(vtStart), vtEndSide(vtEnd), vtBranSide(vtBran);	// 每管向量垂直向量
	vtStaSide.rotateBy(PI*0.5, vtNormal);
	vtEndSide.rotateBy(PI*0.5, vtNormal);
	vtBranSide.rotateBy(PI*0.5, vtNormal);

	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);

	double dHalfStaWidth = dStartWidth * 0.5;
	double dHalfEndWidth = dEndWidth * 0.5;
	double dHalfBranWidth = dBranWidth * 0.5;

	AcGePoint3d ptFitCenter = GetCenterPt();
	AcGeVector3d vtCenTOEnd = ptEnd - ptFitCenter;
	vtCenTOEnd.normalize();
	if (eType == AecHvac::eInsertBranch || eType == AecHvac::eInsertIntubBranch)
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9;
		pt0 = ptStart - dHalfStaWidth * vtStaSide;
		pt1 = ptStart + dHalfStaWidth * vtStaSide;
		pt4 = ptBran - dHalfBranWidth * vtBranSide;
		pt5 = ptBran + dHalfBranWidth * vtBranSide;
		pt7 = ptEnd - dHalfEndWidth * vtEndSide;
		pt8 = ptEnd + dHalfEndWidth * vtEndSide;
		
		AcGePoint3d ptExt1, ptExt2, ptInserct;	// 用于做辅助线的延长点,交点
		pt9 = pt0;

		AcGePlane plan(pt4, vtNormal);
		AcGePoint3d pt1Prj = pt1.orthoProject(plan);
		double dFlange = 0.0;
		m_pXDataMap->GetAt(HVAC_PlusEdge, dFlange);
		pt2 = pt1Prj - vtStart * dFlange;
		pt3 = pt4 - vtBran * dFlange;

		AcGePoint3d pt7Prj = pt7.orthoProject(plan);
		ptExt1 = pt5 + vtBran * dExten;
		ptExt2 = pt7Prj + vtEnd * dExten;
		if (Adesk::kTrue == GetIntersectPointByPts(pt5, ptExt1, pt7Prj, ptExt2, ptInserct))
		{
			pt6 = ptInserct;
		}
		else
		{
			pt6 = pt7;
		}

		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
		ptArr.append(pt9);
	}
	else if (AecHvac::eInclineBranch == eType)
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9;
		pt0 = ptStart - dHalfStaWidth * vtStaSide;
		pt1 = ptStart + dHalfStaWidth * vtStaSide;
		pt4 = ptBran - dHalfBranWidth * vtBranSide;
		pt5 = ptBran + dHalfBranWidth * vtBranSide;
		pt7 = ptEnd - dHalfEndWidth * vtEndSide;
		pt8 = ptEnd + dHalfEndWidth * vtEndSide;

		AcGePoint3d ptExt1, ptExt2, ptInserct;	// 用于做辅助线的延长点,交点
		pt9 = pt0;

		double dFlange = 0.0;
		m_pXDataMap->GetAt(HVAC_PlusEdge, dFlange);
		pt2 = pt1 - vtStart * dFlange;
		pt3 = pt4 - vtBran * dFlange;
		
		ptExt1 = pt5 + vtBran * dExten;
		ptExt2 = pt7 + vtEnd * dExten;
		if (Adesk::kTrue == GetIntersectPointByPts(pt5, ptExt1, pt7, ptExt2, ptInserct))
		{
			pt6 = ptInserct;
		}
		else
		{
			pt6 = pt7;
		}

		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
		ptArr.append(pt9);
	}
	else if (AecHvac::eYShapeBranch == eType)
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8;
		AcGePoint3d pt9, pt10, pt11, pt12, pt13, pt14, pt15, pt16;
		pt0 = ptStart - dHalfStaWidth * vtStaSide;
		pt1 = ptStart + dHalfStaWidth * vtStaSide;
		pt5 = ptBran - dHalfBranWidth * vtBranSide;
		pt6 = ptBran + dHalfBranWidth * vtBranSide;
		pt10 = ptEnd - dHalfEndWidth * vtEndSide;
		pt11 = ptEnd + dHalfEndWidth * vtEndSide;

		double dFlange = 0.0;
		m_pXDataMap->GetAt(HVAC_PlusEdge, dFlange);
		pt2 = pt1 - vtStart * dFlange;
		pt4 = pt5 - vtBran * dFlange;
		pt7 = pt6 - vtBran * dFlange;
		pt9 = pt10 - vtEnd * dFlange;
		pt12 = pt11 - vtEnd * dFlange;
		pt16 = pt0 - vtStart * dFlange;

		//WULW
		AcGePoint3d ptCor1,ptCor2;
		GetIntersectWith(pt1, pt2, pt4, pt5, ptCor1);
		GetIntersectWith(pt6, pt7, pt9, pt10, ptCor2);
		double dminEbr = dHalfBranWidth;
		if (dHalfBranWidth > dHalfEndWidth)
		{
			dminEbr = dHalfEndWidth;
		}
		double dminSbr = dHalfBranWidth;
		if (dHalfBranWidth > dHalfStaWidth)
		{
			dminSbr = dHalfStaWidth;
		}
		double dAngleS(0.0),dAngleE(0.0);
		double dRadRatio = 1.5;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRadRatio);
		dAngleS = vtBran.angleTo(vtStart);
		dAngleS *= 0.5;
		dAngleE = vtBran.angleTo(vtEnd);
		dAngleE *= 0.5;
		double dLengthS = dRadRatio * dminSbr / tan(dAngleS) + dFlange;
		double dLengthE = dRadRatio * dminEbr / tan(dAngleE) + dFlange;
		//交点到圆心CORTOCEN
		double dC2Cs = sqrt(dminSbr * dRadRatio * dminSbr * dRadRatio + (dLengthS - dFlange) * (dLengthS - dFlange));
		double dC2Ce = sqrt(dminEbr * dRadRatio * dminEbr * dRadRatio + (dLengthE - dFlange) * (dLengthE - dFlange));

		AcGeVector3d vtRs = vtStart + vtBran;
		vtRs.normalize();
		pt3 = ptCor1 + vtRs * (dC2Cs - dminSbr * dRadRatio);
		AcGeVector3d vtRe = vtEnd + vtBran;
		vtRe.normalize();
		pt8 = ptCor2 + vtRe * (dC2Ce - dminEbr * dRadRatio);
		
		pt4 = ptCor1 + vtBran * (dLengthS - dFlange);
		pt7 = ptCor2 + vtBran * (dLengthE - dFlange);

		pt13 = pt12;
		pt14 = pt12 + vtStart * 0.1;
		pt15 = pt16;

		//大圆
		AcGePoint3d ptCens = ptCor1 + vtRs * dC2Cs;
		AcGePoint3d ptCene = ptCor2 + vtRe * dC2Ce;
		AcGePoint3d ptInter1,ptInter2;
		AcGeCircArc3d circleS(ptCens,vtNormal,(dminSbr * dRadRatio + dStartWidth));
		AcGeCircArc3d circleE(ptCene,vtNormal,(dminEbr * dRadRatio + dEndWidth));
		int nn(0);
		if(circleS.intersectWith(circleE,nn,ptInter1,ptInter2))
		{
			if(pt0.distanceTo(ptInter1) > pt0.distanceTo(ptInter2))
			{
				ptInter1 = ptInter2;
			}
			AcGeVector3d vtRs1,vtRe1,vtRs2,vtRe2;
			vtRs1 = pt16 - ptCens;
			vtRs2 = ptInter1 - ptCens;
			vtRe1 = pt12 - ptCene;
			vtRe2 = ptInter1 - ptCene;
			pt13 = ptCene + (vtRe1 + vtRe2).normalize() * (dminEbr * dRadRatio + dEndWidth);
			pt15 = ptCens + (vtRs1 + vtRs2).normalize() * (dminSbr * dRadRatio + dStartWidth);
			pt14 = ptInter1;
		}
		// add by dyc on 2014-01-21 解决Y型三通在比较大坐标值情况下以后后变成T型问题,求两圆交点
		else if(TAuxTools::CircleInsertWith(circleS, circleE, ptInter1, ptInter2)) 
		{
			if(pt0.distanceTo(ptInter1) > pt0.distanceTo(ptInter2))
			{
				ptInter1 = ptInter2;
			}
			AcGeVector3d vtRs1,vtRe1,vtRs2,vtRe2;
			vtRs1 = pt16 - ptCens;
			vtRs2 = ptInter1 - ptCens;
			vtRe1 = pt12 - ptCene;
			vtRe2 = ptInter1 - ptCene;
			pt13 = ptCene + (vtRe1 + vtRe2).normalize() * (dminEbr * dRadRatio + dEndWidth);
			pt15 = ptCens + (vtRs1 + vtRs2).normalize() * (dminSbr * dRadRatio + dStartWidth);
			pt14 = ptInter1;
		}

		// 添加点
		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
		ptArr.append(pt9);
		ptArr.append(pt10);
		ptArr.append(pt11);
		ptArr.append(pt12);
		ptArr.append(pt13);
		ptArr.append(pt14);
		ptArr.append(pt15);
		ptArr.append(pt16);
	}
	else if (AecHvac::eVShapeBranch == eType)
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6;
		AcGePoint3d pt7, pt8, pt9, pt10, pt11, pt12;
		pt0 = ptStart + dHalfStaWidth * vtStaSide;
		pt12 = ptStart - dHalfStaWidth * vtStaSide;
		pt3 = ptBran - dHalfBranWidth * vtBranSide;
		pt4 = ptBran + dHalfBranWidth * vtBranSide;
		pt7 = ptEnd - dHalfEndWidth * vtEndSide;
		pt8 = ptEnd + dHalfEndWidth * vtEndSide;

		double dFlange = 0.0;
		m_pXDataMap->GetAt(HVAC_PlusEdge, dFlange);
		pt1 = pt0 - vtStart * dFlange;
		pt11 = pt12 - vtStart * dFlange;
		pt2 = pt3 - vtBran * dFlange;
		pt5 = pt4 - vtBran * dFlange;
		pt6 = pt7 - vtEnd * dFlange;
		pt9 = pt8 - vtEnd * dFlange;

		AcGeLine3d lineS(pt11, pt5);
		AcGeLine3d lineE(pt9, pt2);
		if(Adesk::kTrue != lineS.intersectWith(lineE, pt10))
		{
			return FALSE;
		}

		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
		ptArr.append(pt9);
		ptArr.append(pt10);
		ptArr.append(pt11);
		ptArr.append(pt12);
	}
	else if (AecHvac::eTShapeBranch == eType)
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6;
		AcGePoint3d pt7, pt8, pt9, pt10, pt11, pt12, pt13;
		pt0 = ptStart - dHalfStaWidth * vtStaSide;
		pt1 = ptStart + dHalfStaWidth * vtStaSide;
		pt5 = ptBran - dHalfBranWidth * vtBranSide;
		pt6 = ptBran + dHalfBranWidth * vtBranSide;
		pt10 = ptEnd - dHalfEndWidth * vtEndSide;
		pt11 = ptEnd + dHalfEndWidth * vtEndSide;

		double dFlange = 0.0;
		m_pXDataMap->GetAt(HVAC_PlusEdge, dFlange);
		pt2 = pt1 - vtStart * dFlange;
		pt4 = pt5 - vtBran * dFlange;
		pt7 = pt6 - vtBran * dFlange;
		pt9 = pt10 - vtEnd * dFlange;
		pt12 = pt11 - vtEnd * dFlange;
		pt13 = pt0 - vtStart * dFlange;

		// 计算pt3和pt8
		double dRatio = 1.5;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRatio);
		if (!GetPtOnLowArc(pt1, pt2, dStartWidth, pt5, pt4, dBranWidth, dRatio, pt3)
			|| !GetPtOnLowArc(pt10, pt9, dEndWidth, pt6, pt7, dBranWidth, dRatio, pt8))
		{
			return FALSE;
		}

		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
		ptArr.append(pt9);
		ptArr.append(pt10);
		ptArr.append(pt11);
		ptArr.append(pt12);
		ptArr.append(pt13);
	}
	else if (AecHvac::eArcuateBranch == eType || AecHvac::eArcuateIntubBranch == eType)
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6;
		AcGePoint3d pt7, pt8, pt9, pt10, pt11, pt12;
		pt0 = ptStart - dHalfStaWidth * vtStaSide;
		pt1 = ptStart + dHalfStaWidth * vtStaSide;
		pt5 = ptBran - dHalfBranWidth * vtBranSide;
		pt6 = ptBran + dHalfBranWidth * vtBranSide;
		pt10 = ptEnd - dHalfEndWidth * vtEndSide;
		pt11 = ptEnd + dHalfEndWidth * vtEndSide;

		double dFlange = 0.0;
		m_pXDataMap->GetAt(HVAC_PlusEdge, dFlange);
		pt4 = pt5 - vtBran * dFlange;
		pt12 = pt0 - vtStart * dFlange;

		double dRatio = 1.5;
		m_pXDataMap->GetAt(HTEE_RadRatio, dRatio);
		if (AecHvac::eArcuateBranch == eType)
		{
			//  计算pt2
			pt2 = pt1 - vtStart * dFlange;

			// 计算pt3
			if (!GetPtOnLowArc(pt1, pt2, dStartWidth, pt5, pt4, dBranWidth, dRatio, pt3))
			{
				return FALSE;
			}

			// 计算pt7
			pt7 = pt6 - vtBran * (pt5.distanceTo(pt4));
			AcGeLine3d lineSE(ptStart, ptEnd);
			if (lineSE.distanceTo(pt7) < dHalfStaWidth)
			{
				// 设置pt7，pt8，pt9
				AcGeLine3d line6(pt6, vtBran);
				AcGeLine3d line10(pt10, vtEnd);
				if (Adesk::kTrue != line6.intersectWith(line10, pt7))
				{
					return FALSE;
				}
				pt8 = pt7;
				pt9 = pt7;
			}
			else
			{
				// 计算pt9
				AcGeCircArc3d arcSB(pt4, pt3, pt2);
				AcGePoint3d ptCenter = arcSB.center();
				AcGeCircArc3d cirSB(ptCenter, vtNormal, ptCenter.distanceTo(pt7));
				double dToGetPt9 = AcGeLine3d(pt2, pt12).distanceTo(pt10);
				dToGetPt9 = max(dToGetPt9, pt10.distanceTo(pt2));
				dToGetPt9 *= 1.2;
				pt9 = pt10 - vtEnd * dToGetPt9;
				AcGeLineSeg3d seg10To9(pt10, pt9);
				int iIntNum = 0;
				AcGePoint3d ptVertual;
				cirSB.intersectWith(seg10To9, iIntNum, pt9, ptVertual);
				if (0 == iIntNum)
				{
					pt9 = pt10 - vtCenTOEnd * dToGetPt9;
					// change by hh 2011-08-18 支持不等厚的圆角三通
					// AcGeLineSeg3d seg10To9Fixed(pt10, pt9);
					AcGePlane pl(ptCenter, vtNormal);
					AcGePoint3d ptTmp1 = pt10.orthoProject(pl);
					AcGePoint3d ptTmp2 = pt9.orthoProject(pl);
					AcGeLineSeg3d seg10To9Fixed(ptTmp1, ptTmp2);

					cirSB.intersectWith(seg10To9Fixed, iIntNum, pt9, ptVertual);
					if (1 != iIntNum)
					{
						return FALSE;
					}
				}
				
				// 计算pt8
				pt8 = TAuxTools::Mid(pt7, pt9);
				AcGeVector3d vtDir8 = pt8 - ptCenter;
				vtDir8.normalize();
				vtDir8 *= cirSB.radius();
				pt8 = ptCenter + vtDir8;
			}
		} 
		else
		{
			// 计算pt2
			AcGePlane plane(pt5, vtNormal);
			AcGePoint3d pt1Prj = pt1.orthoProject(plane);
			pt2 = pt1Prj - vtStart * dFlange;

			// 计算pt3
			AcGePoint3d pt2Prj = pt2.orthoProject(plane);
			if (!GetPtOnLowArc(pt1Prj, pt2Prj, dStartWidth, pt5, pt4, dBranWidth, dRatio, pt3))
			{
				return FALSE;
			}

			// 计算pt7
			pt7 = pt6 - vtBran * (pt5.distanceTo(pt4));
			AcGeLine3d lineSE(ptStart.orthoProject(plane), ptEnd.orthoProject(plane));
			if (lineSE.distanceTo(pt7) < dHalfStaWidth)
			{
				// 设置pt7，pt8，pt9
				AcGeLine3d line6(pt6, vtBran);
				AcGeLine3d line10(pt10.orthoProject(plane), vtEnd);
				if (Adesk::kTrue != line6.intersectWith(line10, pt7))
				{
					return FALSE;
				}
				pt8 = pt7;
				pt9 = pt7;
			}
			else
			{
				// 计算pt9
				AcGeCircArc3d arcSB(pt4, pt3, pt2Prj);
				AcGePoint3d ptCenter = arcSB.center();
				AcGeCircArc3d cirSB(ptCenter, vtNormal, ptCenter.distanceTo(pt7));
				double dToGetPt9 = AcGeLine3d(pt2, pt12).distanceTo(pt10);
				dToGetPt9 = max(dToGetPt9, pt10.distanceTo(pt2));
				dToGetPt9 *= 1.2;
				AcGePoint3d pt10Prj = pt10.orthoProject(plane);
				pt9 = pt10Prj - vtEnd * dToGetPt9;
				AcGeLineSeg3d seg10To9(pt10Prj, pt9);
				int iIntNum = 0;
				AcGePoint3d ptVertual;
				cirSB.intersectWith(seg10To9, iIntNum, pt9, ptVertual);
				if (0 == iIntNum)
				{
					pt9 = pt10Prj - vtCenTOEnd * dToGetPt9;
					AcGeLineSeg3d seg10To9Fixed(pt10Prj, pt9);
					cirSB.intersectWith(seg10To9Fixed, iIntNum, pt9, ptVertual);
					if (1 != iIntNum)
					{
						return FALSE;
					}
				}
				
				// 计算pt8
				pt8 = TAuxTools::Mid(pt7, pt9);
				AcGeVector3d vtDir8 = pt8 - ptCenter;
				vtDir8.normalize();
				vtDir8 *= cirSB.radius();
				pt8 = ptCenter + vtDir8;
			}
		}

		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
		ptArr.append(pt9);
		ptArr.append(pt10);
		ptArr.append(pt11);
		ptArr.append(pt12);
	}
	else
	{
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8;
		pt0 = ptStart - dHalfStaWidth * vtStaSide;
		pt1 = ptStart + dHalfStaWidth * vtStaSide;
		pt3 = ptBran - dHalfBranWidth * vtBranSide;
		pt4 = ptBran + dHalfBranWidth * vtBranSide;
		pt6 = ptEnd - dHalfEndWidth * vtEndSide;
		pt7 = ptEnd + dHalfEndWidth * vtEndSide;

 		AcGePoint3d ptExt1, ptExt2, ptInserct;	// 用于做辅助线的延长点,交点
		pt8 = pt0;

		ptExt1 = pt1 + dExten * vtStart;
		ptExt2 = pt3 + dExten * vtBran;
		if (GetIntersectPointByPts(pt1, ptExt1, pt3, ptExt2, ptInserct) == Adesk::kTrue)
			pt2 = ptInserct;
		else
			pt2 = pt1;

		ptExt1 = pt4 + dExten * vtBran;
		ptExt2 = pt6 + dExten * vtEnd;
		if (GetIntersectPointByPts(pt4, ptExt1, pt6, ptExt2, ptInserct) == Adesk::kTrue)
			pt5 = ptInserct;
		else
			pt5 = pt4;

		ptArr.append(pt0);
		ptArr.append(pt1);
		ptArr.append(pt2);
		ptArr.append(pt3);
		ptArr.append(pt4);
		ptArr.append(pt5);
		ptArr.append(pt6);
		ptArr.append(pt7);
		ptArr.append(pt8);
	}

	return TRUE;	
}

// 得到三通接口处上下两面的六个点
BOOL ImpHvacTee::GetInterfaceKeyPt(AcGePoint3dArray &ptUpArr, AcGePoint3dArray &ptDownArr) const
{
//   0━━━━━━━━━━━━━━━━5	
// 	┃	                    		  ┃
// 	┃	                    		  ┃
//   ━━━━━━━━━━━━━━━━━	
// 	┃	              ┃   			  ┃
// 	┃	              ┃    		  ┃
//   1━━━━━┓    ┃    ┏━━━━4	
//              ┃    ┃    ┃
//              ┃    ┃    ┃
//              ┃    ┃    ┃
//              ┃    ┃    ┃
//               2━━━━━3

	ASSERT(NULL != m_pXDataMap);
	
	ESection eSect = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
		
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	
	AcGeVector3d vtNormal(normal());
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()), vtBran(BranVect());
	AcGeVector3d vtStaSide(vtStart), vtEndSide(vtEnd), vtBranSide(vtBran);	// 每管向量垂直向量
	vtStaSide.rotateBy(PI*0.5, vtNormal);
	vtEndSide.rotateBy(PI*0.5, vtNormal);
	vtBranSide.rotateBy(PI*0.5, vtNormal);
	
	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);	
	double dHalfStaWidth = dStartWidth * 0.5;
	double dHalfEndWidth = dEndWidth * 0.5;
	double dHalfBranWidth = dBranWidth * 0.5;

	double dStartThick(0.0), dEndThick(0.0), dBranThick(0.0);
	if(eRect != eSect) // 圆形三通按方形处理
	{
		dStartThick = dStartWidth;
		dEndThick = dEndWidth;
		dBranThick = dBranWidth;
	}
	else
	{
		m_pXDataMap->GetAt(HTEE_Thick, dStartThick);
		m_pXDataMap->GetAt(HTEE_EndThick, dEndThick);
		m_pXDataMap->GetAt(HTEE_BranchThick, dBranThick);
		if(1e-6 >= dEndThick)
			dEndThick = dStartThick;
	}

	double dHalfStaThick = dStartThick * 0.5;
	double dHalfEndThick = dEndThick * 0.5;
	double dHalfBranThick = dBranThick * 0.5;

	// pt0
	AcGePoint3d ptUp, ptDown;
	ptUp = ptStart - vtStaSide * dHalfStaWidth;
	ptUp = ptUp + vtNormal * dHalfStaThick;
	ptUpArr.append(ptUp);
	ptDown = ptUp - vtNormal * dStartThick;
	ptDownArr.append(ptDown);

	// pt1
	ptUp = ptStart + vtStaSide * dHalfStaWidth;
	ptUp = ptUp + vtNormal * dHalfStaThick;
	ptUpArr.append(ptUp);
	ptDown = ptUp - vtNormal * dStartThick;
	ptDownArr.append(ptDown);

	// pt2
	ptUp = ptBran - vtBranSide * dHalfBranWidth;
	ptUp = ptUp + vtNormal * dHalfBranThick;
	ptUpArr.append(ptUp);
	ptDown = ptUp - vtNormal * dBranThick;
	ptDownArr.append(ptDown);

	// pt3
	ptUp = ptBran + vtBranSide * dHalfBranWidth;
	ptUp = ptUp + vtNormal * dHalfBranThick;
	ptUpArr.append(ptUp);
	ptDown = ptUp - vtNormal * dBranThick;
	ptDownArr.append(ptDown);

	// pt4
	ptUp = ptEnd - vtEndSide * dHalfEndWidth;
	ptUp = ptUp + vtNormal * dHalfEndThick;
	ptUpArr.append(ptUp);
	ptDown = ptUp - vtNormal * dEndThick;
	ptDownArr.append(ptDown);

	// pt5
	ptUp = ptEnd + vtEndSide * dHalfEndWidth;
	ptUp = ptUp + vtNormal * dHalfEndThick;
	ptUpArr.append(ptUp);
	ptDown = ptUp - vtNormal * dEndThick;
	ptDownArr.append(ptDown);

	return TRUE;
}

/*
	得到大部分矩形截面三通18(上下各9个）关键点
	不适合类型，返回FALSE, 稍有变化的情况予以说明
	
//						
// 			  	0━━━━━━━━━8━━━━━━━7		   
// 				┃	                    		  ┃		   
// 				┃	                    		  ┃ 		   
// 			     ━━━━━━━━━━━━━━━━━		  
// 				┃	              ┃   			  ┃		   
// 				┃	              ┃    		  ┃		   
// 			 	 1━━━━━2     ┃	 5━━━━6		   
//                          ┃    ┃    ┃					
//                          ┃    ┃    ┃				    	
//                          ┃    ┃    ┃				    	
//                          ┃    ┃    ┃				    	
//                           3━━━━━4				    	
//                                						   
*/

BOOL ImpHvacTee::GetTwoSideKeyPt(AcGePoint3dArray &ptUpArr, AcGePoint3dArray &ptDownArr, BOOL bDefault) const
{
	if(NULL == m_pXDataMap)
		return FALSE;

	ESection eSect = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
	if (eSect != eRect)
		return FALSE;

	if(!GetSectMidKeyPt(ptUpArr, bDefault))
		return FALSE;

	double dThick = 0, dEndThick = 0, dBraThick = 0;
	m_pXDataMap->GetAt(HTEE_Thick, dThick);
	if(!m_pXDataMap->GetAt(HTEE_EndThick, dEndThick))
		dEndThick = dThick;
	if(!m_pXDataMap->GetAt(HTEE_BranchThick, dBraThick))
		dBraThick = dThick;

	AcGeVector3d vtOffsetS = dThick * normal() * 0.5;
	AcGeVector3d vtOffsetE = dEndThick * normal() * 0.5;
	AcGeVector3d vtOffsetB = dBraThick * normal() * 0.5;

	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);

	int i = 0;
	if(AecHvac::eInsertBranch == eType || AecHvac::eInsertIntubBranch == eType || AecHvac::eInclineBranch == eType)
	{
		for(i = 0; i < ptUpArr.length(); i++)
		{
			if(1 >= i || 9 <= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetS);
				ptUpArr[i] += vtOffsetS;
			}
			else if(7 == i || 8 == i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetE);
				ptUpArr[i] += vtOffsetE;
			}
			else
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetB);
				ptUpArr[i] += vtOffsetB;
			}
		}
	}
	else if(AecHvac::eYShapeBranch == eType)
	{
		for(i = 0; i < ptUpArr.length(); i++)
		{
			if(3 >= i || 14 <= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetS);
				ptUpArr[i] += vtOffsetS;
			}
			else if(8 <= i && 13 >= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetE);
				ptUpArr[i] += vtOffsetE;
			}
			else
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetB);
				ptUpArr[i] += vtOffsetB;
			}
		}
	}
	else if(AecHvac::eVShapeBranch == eType)
	{
		for(i = 0; i < ptUpArr.length(); i++)
		{
			if(2 >= i || 10 <= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetS);
				ptUpArr[i] += vtOffsetS;
			}
			else if(5 <= i && 9 >= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetE);
				ptUpArr[i] += vtOffsetE;
			}
			else
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetB);
				ptUpArr[i] += vtOffsetB;
			}
		}	
	}
	else if(AecHvac::eTShapeBranch == eType)
	{
		for(i = 0; i < ptUpArr.length(); i++)
		{
			if(3 >= i || 13 <= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetS);
				ptUpArr[i] += vtOffsetS;
			}
			else if(8 <= i && 12 >= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetE);
				ptUpArr[i] += vtOffsetE;
			}
			else
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetB);
				ptUpArr[i] += vtOffsetB;
			}
		}	
	}
	else if(AecHvac::eArcuateBranch == eType || AecHvac::eArcuateIntubBranch == eType)
	{
		for(i = 0; i < ptUpArr.length(); i++)
		{
			if(3 >= i || 12 <= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetS);
				ptUpArr[i] += vtOffsetS;
			}
			else if(10 == i || 11 == i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetE);
				ptUpArr[i] += vtOffsetE;
			}
			else
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetB);
				ptUpArr[i] += vtOffsetB;
			}
		}
	}
	else
	{
		for(i = 0; i < ptUpArr.length(); i++)
		{
			if(1 >= i || 8 <= i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetS);
				ptUpArr[i] += vtOffsetS;
			}
			else if(6 == i || 7 == i)
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetE);
				ptUpArr[i] += vtOffsetE;
			}
			else
			{
				ptDownArr.append(ptUpArr[i] - vtOffsetB);
				ptUpArr[i] += vtOffsetB;
			}
		}
	}
	return TRUE;
}

AcGePlane ImpHvacTee::GetStdPrjPlan( const AcGePoint3d &ptOnPlan ) const
{
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	AcGePlane planStd(ptOnPlan, vtZAxis);
	AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd);
	planStd.set(ptPrj, vtZAxis);

	return planStd;
}

Adesk::Boolean ImpHvacTee::GetIntersectPointByPts( AcGePoint3d ptL1Sta, AcGePoint3d ptL1End, 
				 AcGePoint3d ptL2Sta, AcGePoint3d ptL2End, AcGePoint3d &ptInersect ) const
{
	AcGeLine3d line1(ptL1Sta, ptL1End);
	AcGeLine3d line2(ptL2Sta, ptL2End);
	return line1.intersectWith(line2, ptInersect);
}

AcGePoint3d ImpHvacTee::GetCenterPt() const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptStart, ptEnd, ptBran, ptCross;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtNormal = normal();
	AcGePlane planStd(ptStart, vtNormal);
	AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd);
	planStd.set(ptPrj, vtNormal);

	ptEnd = ptEnd.orthoProject(planStd);
	ptBran = ptBran.orthoProject(planStd);

	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()), vtBran(BranVect());
	AcGeLine3d lineMain(ptStart, ptStart + 100 * vtStart);
	AcGeLine3d lineBran(ptBran, ptBran + 100 * vtBran);
	if (!lineMain.intersectWith(lineBran, ptCross))
	{
		lineMain.set(ptEnd, ptEnd + 100 * vtEnd);	// 看末管跟支管是否有交点
		if (!lineMain.intersectWith(lineBran, ptCross))
		{
			ptCross	= TAuxTools::Mid(ptStart, ptEnd);	// 没有交点时按中点算
		}
	}
	return ptCross;
}

BOOL ImpHvacTee::GetPtOnLowArc(const AcGePoint3d& ptOnPort1, AcGePoint3d& ptExtend1, const double dPortSize1,
								const AcGePoint3d& ptOnPort2, AcGePoint3d& ptExtend2, const double dPortSize2,
								const double dCR, AcGePoint3d& ptOnCurve) const
{
	// 获取端口延长线交点
	AcGeLine3d line1(ptOnPort1, ptExtend1);
	AcGeLine3d line2(ptOnPort2, ptExtend2);
	AcGePoint3d ptIntersect;
	if (Adesk::kTrue != line1.intersectWith(line2, ptIntersect))
	{
		return FALSE;
	}

	// 计算弧线半径
	double dRadius = (dCR - 0.5) * min(dPortSize1, dPortSize2);

	// 计算弧线圆心
	AcGeVector3d vt1 = ptOnPort1 - ptIntersect;
	vt1.normalize();
	AcGeVector3d vt2 = ptOnPort2 - ptIntersect;
	vt2.normalize();
	AcGeVector3d vtDir = vt1 + vt2;
	vtDir.normalize();
	double dAng = vtDir.angleTo(vt1);
	double dLength = dRadius / sin(dAng);
	AcGePoint3d ptCenter = ptIntersect + dLength * vtDir;

	// 计算弧上点
	ptOnCurve = ptCenter - dRadius * vtDir;

	// 修正弧线端点
	ptExtend1 = line1.closestPointTo(ptCenter);
	ptExtend2 = line2.closestPointTo(ptCenter);

	return TRUE;
}

void ImpHvacTee::DepartArcByAngle(const AcGePoint3d& ptStart, const AcGePoint3d& ptOnCurve,
									const AcGePoint3d& ptEnd, double dAng, AcGePoint3dArray& arptPtsOnCur,
									const AcGeVector3d& vtNormal, int iPartNum) const
{
	// 计算点的个数
	AcGeCircArc3d arc(ptStart, ptOnCurve, ptEnd);
	AcGePoint3d ptCenter = arc.center();
	AcGeVector3d vtStart = arc.startPoint() - ptCenter;
	AcGeVector3d vtEnd = arc.endPoint() - ptCenter;
	double dTotAng = arc.endAng() - arc.startAng();
	if (0 == iPartNum)
	{
		iPartNum = int(floor(dTotAng / dAng));
	}
	double dPartAng = dTotAng / iPartNum;

	// 计算圆弧是否顺时针
	BOOL bCLockwise = TRUE;
	AcGeVector3d vtSToOC = ptOnCurve - ptStart;
	AcGeVector3d vtSToE = ptEnd - ptStart;
	double dCLockAng = vtSToOC.angleTo(vtSToE, vtNormal);
	if (dCLockAng < PI)
	{
		bCLockwise = FALSE;
	}

	// 计算点
	if (bCLockwise)
	{
		dPartAng *= -1;
	}
	AcGePoint3d ptTmp;
	AcGeVector3d vtRotate = vtStart;
	int iVertNum = iPartNum - 1;
	for (int i = iVertNum; i > 0; i--)
	{
		vtRotate.rotateBy(dPartAng, vtNormal);
		ptTmp = ptCenter + vtRotate;
		arptPtsOnCur.append(ptTmp);
	}
}

int ImpHvacTee::FixPtsData(AcGePoint3dArray& arpt, int iPos, double dAng,
							 const AcGeVector3d& vtNormal) const
{
	AcGePoint3dArray arptInsert;
	DepartArcByAngle(arpt[iPos - 1], arpt[iPos], arpt[iPos + 1], dAng, arptInsert, vtNormal);
	arpt.removeAt(iPos);
	int iIndex = iPos;
	int iLen = arptInsert.length();
	for (int i = 0; i < iLen; i++)
	{
		arpt.insertAt(iIndex, arptInsert[i]);
		iIndex++;
	}
	return iLen;
}

void ImpHvacTee::DrawValve(AecComplexCurve& cplCurve, AcGePoint3d ptStart) const
{
	if (m_pXDataMap == NULL)
		return;

	BOOL bDrawValue(FALSE);
	m_pXDataMap->GetAt(HTEE_HasValve, bDrawValue);
	if (!bDrawValue)
		return;
	
	// 阀门长度
	double dLen(0.0);
	m_pXDataMap->GetAt(HTEE_EndWidth, dLen);
	dLen *= 0.5 * 1.414;

	// vt：求阀门方向
	AcGeVector3d vtZTee = TAuxTools::GetUcsZvt();
	AcGeVector3d vt;
	m_pXDataMap->GetAt(HTEE_EndDir, vt);

	//根据支管和尾管的向量计算当前三通的本地系统的Z方向，确定三通方位
	AcGeVector3d vtBranch;
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBranch);
	vtZTee = vt.crossProduct(vtBranch);
	vtZTee.normalize();

	vt.rotateBy(-PI * 0.75, vtZTee);
	AcGePoint3d ptEnd = ptStart + dLen * vt;

	// 添加绘制
	AecEqui::AecCurveElement cCurveEle;
	memset(&cCurveEle, 0, sizeof(AecEqui::AecCurveElement));
	cCurveEle.bHided = FALSE;
	cCurveEle.dWidth = 0.0;
	cCurveEle.gsMark = 0;

	cCurveEle.ptGe[0] = ptStart;
	cCurveEle.ptGe[1] = ptEnd;
	cCurveEle.ptGe[2] = ptEnd;
	cplCurve.append(cCurveEle);
}

//////////////////////////////////////////////////////////////////////////
//						0 (9)              7
// 			  	        /\                /\           		   
// 				    10 /  \	             /  \ 11	   		   
// 				  	  /    \            /    \  		    		   
// 			         / 		\          /      \6
// 				   1 \       \        / 	 /		   		   
// 				    16\	      \      /      / 17       	    	  		   
// 			 	       \       \    /      /   	             		   
//                      \       \  /      /				
//                       \       \/8     /			    	
//                        \  14  ┃ 15	/			    	
//                      2  ┃    ┃13  ┃5				    	
//                          -━━━━━-				    	
//                          3    12	   4		
//			   
BOOL ImpHvacTee::GetVShapeCirclePts(AcGePoint3dArray &ptArr) const
{
	ASSERT(NULL != m_pXDataMap);

	double dExten(100);	// 做辅助线延长
	ESection eSect = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
	if (eSect != eCircle)
		return FALSE;

	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);

	AcGeVector3d vtNormal(normal());
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect()), vtBran(BranVect());
	AcGeVector3d vtStaSide(vtStart), vtEndSide(vtEnd), vtBranSide(vtBran);	// 每管向量垂直向量
	vtStaSide.rotateBy(PI*0.5, vtNormal);
	vtEndSide.rotateBy(PI*0.5, vtNormal);
	vtBranSide.rotateBy(PI*0.5, vtNormal);

	double dStartWidth(0.0), dEndWidth(0.0), dBranWidth(0.0),dPlusEdge = MayAsMUnit(50);
	m_pXDataMap->GetAt(HTEE_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HTEE_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HTEE_BranchWidth, dBranWidth);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlusEdge);

	vtBran.normalize();
	vtStart.normalize();
	vtEnd.normalize();
	vtStaSide.normalize();
	vtEndSide.normalize();
	vtBranSide.normalize();

	double dHalfStaWidth = dStartWidth * 0.5;
	double dHalfEndWidth = dEndWidth * 0.5;
	double dHalfBranWidth = dBranWidth * 0.5;
	AcGePoint3d pt,ptEdge,ptCen;
	//0-1
	pt = ptStart - dHalfStaWidth * vtStaSide;
	ptArr.append(pt);
	pt = ptStart + dHalfStaWidth * vtStaSide;
	ptArr.append(pt);

	//2-5有法兰咬边
	ptEdge = ptBran - vtBran * dPlusEdge;
	pt = ptEdge - dHalfBranWidth * vtBranSide;
	ptArr.append(pt);
	pt = ptBran - dHalfBranWidth * vtBranSide;
	ptArr.append(pt);
	pt = ptBran + vtBranSide * dHalfBranWidth;
	ptArr.append(pt);
	pt = ptEdge + dHalfBranWidth * vtBranSide;
	ptArr.append(pt);
	//6,7
	pt = ptEnd - dHalfEndWidth * vtEndSide;
	ptArr.append(pt);
	pt = ptEnd + dHalfEndWidth * vtEndSide;
	ptArr.append(pt);

	AcGeVector3d vts,vte;
	GetIntersectWith(ptArr[0],ptArr[7], vtStart, vtEnd,pt);
	if (vtStart.isParallelTo(vtEnd))//平行取中
		pt = TAuxTools::Mid(ptArr[0], ptArr[7]);
	ptArr.append(pt);
	//9
	ptArr.append(ptArr[0]);

	//三个中心点10,11,12,(法兰咬边13)
	ptArr.append(ptStart);
	ptArr.append(ptEnd);
	ptArr.append(ptBran);
	ptArr.append(ptEdge);
	//下圆心14，15
	vts = ptArr[0] - ptArr[8];
	vte = ptArr[7] - ptArr[8]; 
	GetIntersectWith(ptArr[2], ptArr[0], vtStaSide, vts, pt);
	if (vtStart.isParallelTo(vts))//平行取中
		pt = TAuxTools::Mid(ptArr[2], ptArr[0]);

	ptCen = TAuxTools::Mid(ptArr[2], pt);
	ptArr.append(ptCen);
	GetIntersectWith(ptArr[5], ptArr[7], vtEndSide, vte, pt);
	if (vtEndSide.isParallelTo(vte))//平行取中
		pt = TAuxTools::Mid(ptArr[5], ptArr[7]);

	ptCen = TAuxTools::Mid(ptArr[5], pt); 
	ptArr.append(ptCen);
	//新曾开始和末点的法兰直边段16,17
	pt = ptArr[1] - vtStart * dPlusEdge;
	ptArr.append(pt);
	pt = ptArr[6] - vtEnd * dPlusEdge;
	ptArr.append(pt);
	return TRUE;
}

void ImpHvacTee::GetArcPoint(AcDbPolyline &polyLine, AcGePoint3dArray &ptArcArr)
{
	if (polyLine.numVerts() != 4)
		return;
	
	double dPara1(0.0), dPara2(0.0);
	double dPar1, dPar2;
	AcGePoint3d pt0, pt1, pt2, pt3, ptMid;
	
	polyLine.getPointAt(0, pt0);
	polyLine.getPointAt(1, pt1);
	polyLine.getPointAt(2, pt2);
	polyLine.getPointAt(3, pt3);
	
	polyLine.getParamAtPoint(pt0, dPar1);
	polyLine.getParamAtPoint(pt1, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2) * 0.5, ptMid);
	ptArcArr.append(pt0);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt1);
	
	polyLine.getParamAtPoint(pt1, dPar1);
	polyLine.getParamAtPoint(pt2, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2) * 0.5, ptMid);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt2);
	
	polyLine.getParamAtPoint(pt2, dPar1);
	polyLine.getParamAtPoint(pt3, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2) * 0.5, ptMid);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt3);
}

double ImpHvacTee::GetEdgeLineWidth() const
{
	ASSERT(NULL != m_pXDataMap);
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);

	return dWidth;
}

double ImpHvacTee::GetCentLineWidth() const
{
	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HVAC_CentWidth, dWidth);

	return dWidth;
}

double ImpHvacTee::GetEndLineWidth() const
{
	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HVAC_EndWidth, dWidth);

	return dWidth;
}

BOOL ImpHvacTee::IsValidConst(AecDbObjXDataMap* pXMap) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptCenter = GetCenterPt();
	AcGePoint3d ptStart, ptEnd, ptBranch;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBranch);

	AcGeVector3d vtNornal = normal();
	AcGeVector3d vtStart, vtEnd, vtBranch;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBranch);

	double dSThick = 0, dBThick = 0, dEThick = 0;
	m_pXDataMap->GetAt(HTEE_Thick, dSThick);
	m_pXDataMap->GetAt(HTEE_EndThick, dEThick);
	m_pXDataMap->GetAt(HTEE_BranchThick, dBThick);

	AecHvac::HvacTeeType eTeeType(AecHvac::eOrthoBranch);
	ESection eSectType(eRect);
	m_pXDataMap->GetAt(HTEE_Type, (int&)eTeeType);
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	// 构造与三通接口方向一致的三条线
	AcGeLine3d lineStart(ptStart - vtStart * 500, ptStart + vtStart * 500);
	AcGeLine3d lineBranch(ptBranch - vtBranch * 500, ptBranch + vtBranch * 500);
	AcGeLine3d lineEnd(ptEnd - vtEnd * 500, ptEnd + vtEnd * 500);

	AcGeVector3d vtPrjNormal = vtStart.crossProduct(vtBranch);
	AcGePlane planePrj(ptStart, vtPrjNormal);

	AcGePoint3d ptIntersect1, ptIntersect2;
	lineStart.projIntersectWith(lineBranch, vtPrjNormal, ptIntersect1, ptIntersect2);
	AcGeTol tol;
	tol.setEqualPoint(1);
	tol.setEqualVector(1 / 10.0);
	double dDist = ptIntersect1.distanceTo(ptIntersect2);
	double dEleSub = 1.1e-3;
	if(dDist < dEleSub)
	{
		if (!lineStart.intersectWith(lineBranch, ptIntersect1, tol))
			return FALSE;
		
		AcGeLineSeg3d segStart(ptStart, vtStart);
		AcGeLineSeg3d segBranch(ptBranch, vtBranch);

		AcGeTol tol2;
		tol2.setEqualPoint(1e-3);
		if ((segStart.isOn(ptIntersect1, tol2) || segBranch.isOn(ptIntersect1, tol2)))
			return FALSE;
		if (dDist > fabs(dSThick - dBThick) / 2.0 + dEleSub)
			return FALSE;
		
		double dDisStartToEnd = fabs(planePrj.signedDistanceTo(ptStart) - planePrj.signedDistanceTo(ptEnd));
		double dDisBranchToEnd = fabs(planePrj.signedDistanceTo(ptBranch) - planePrj.signedDistanceTo(ptEnd));
		
		if (dDisStartToEnd > fabs(dSThick - dEThick) / 2.0 + dEleSub)
			return FALSE;
		else if (dDisBranchToEnd > fabs(dBThick - dEThick) / 2.0 + dEleSub)
			return FALSE;
	}
	else if ((AecHvac::eInsertBranch == eTeeType || AecHvac::eInsertIntubBranch == eTeeType
		|| AecHvac::eArcuateIntubBranch == eTeeType) && eRect == eSectType)
	{
		if (dSThick < dBThick - dEleSub || dDist > fabs(dSThick - dBThick) / 2.0 + dEleSub)
		{
			return FALSE;
		}
		
		double dDisStartToEnd = fabs(planePrj.signedDistanceTo(ptStart) - planePrj.signedDistanceTo(ptEnd));
		double dDisBranchToEnd = fabs(planePrj.signedDistanceTo(ptBranch) - planePrj.signedDistanceTo(ptEnd));
		
		if (dDisStartToEnd > fabs(dSThick - dEThick) / 2.0 + dEleSub)
			return FALSE;
		else if (dBThick > dEThick + dEleSub || dDisBranchToEnd > fabs(dBThick - dEThick) / 2.0 + dEleSub)
			return FALSE;
	}
	else
	{
		return FALSE;
	}
	return TRUE;
}

BOOL ImpHvacTee::GetInterfaceSizeData(int nIndex, AecInterface& pipeInterface) const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取对象类型
	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);

	// 获取截面类型
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	// 获取接口截面、宽度、厚度数据key值
	LPCTSTR pszWidthKey, pszThickKey;
	switch (nIndex)
	{
	case 0:
		pszWidthKey = ((eCircle == eSectType) ? HTEE_StartDiameter : HTEE_StartWidth);
		pszThickKey = HTEE_Thick;
		break;
	case 1:
		pszWidthKey = ((eCircle == eSectType) ? HTEE_EndDiameter : HTEE_EndWidth);

		{
			double dEndThick(0.0);
			if (m_pXDataMap->GetAt(HTEE_EndThick, dEndThick))
				pszThickKey = HTEE_EndThick;
			else
				pszThickKey = HTEE_Thick;
		}

		break;
	case 2:
		pszWidthKey = ((eCircle == eSectType) ? HTEE_BranchDiameter : HTEE_BranchWidth);
		pszThickKey = ((AecHvac::eInsertBranch == eType || AecHvac::eInsertIntubBranch == eType) ? HTEE_BranchThick : HTEE_Thick);
		break;
	default:
		return FALSE;
	}

	// 获取尺寸
	double dWidth = 0.0, dThick = 0.0;
	m_pXDataMap->GetAt(pszWidthKey, dWidth);
	m_pXDataMap->GetAt(pszThickKey, dThick);

	// 设置接口数据
	pipeInterface.nSectType = eSectType;
	pipeInterface.dSize1 = dWidth;
	pipeInterface.dSize2 = dThick;

	return TRUE;
}

bool ImpHvacTee::GetInterface(AcArray<AecInterface>& arInfs) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	// 获取各点位置
	AcGePoint3d ptStart, ptEnd, ptBran;
	m_pXDataMap->GetAt(HTEE_StartPoint, ptStart);
	m_pXDataMap->GetAt(HTEE_BranchPoint, ptBran);
	m_pXDataMap->GetAt(HTEE_EndPoint, ptEnd);

	AecHvac::HvacTeeType eType = AecHvac::eOrthoBranch;
	m_pXDataMap->GetAt(HTEE_Type, (int&)eType);
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HVAC_SectType, (int &)eSectType);

	// 求各端方向
	AcGeVector3d vtStart, vtEnd, vtBran;
	m_pXDataMap->GetAt(HTEE_StartDir, vtStart);
	m_pXDataMap->GetAt(HTEE_EndDir, vtEnd);
	m_pXDataMap->GetAt(HTEE_BranchDir, vtBran);

	if (eType == AecHvac::eInsertBranch)//承插
	{
		if (eSectType == eCircle)
		{
			//承插 -- 圆型
			return GetInsertBranchCircle2DInfs(arInfs);
		}
	}
	else if (eType == AecHvac::eInclineBranch)//斜接
	{
		if (eSectType == eCircle)
		{
			return GetInclineBranchCircle2DInfs(arInfs);
		}
	}

	AecInterface inf;
	inf.idOwner = m_pOwnerEnt->objectId();
	for (int nIndex = 0;nIndex < 3;nIndex++)
	{
		switch(nIndex)
		{
		case 0:
			{
				// 没有管件连接
				inf.vtDir = vtStart;
				inf.ptPos = ptStart;
				GetInterfaceSizeData(nIndex, inf);
				break;
			}
		case 1:
			{
				// 没有管件连接
				inf.vtDir = vtEnd;
				inf.ptPos = ptEnd;
				GetInterfaceSizeData(nIndex, inf);
				break;
			}
		case 2:
			{
				// 没有管件连接
				inf.vtDir = vtBran;
				inf.ptPos = ptBran;
				GetInterfaceSizeData(nIndex, inf);
				break;
			}
			default:
				break;
		}
		arInfs.append(inf);
	}
	return true;
}