envi-code/SourceCode/Code2026/CoreLibrary/Implement/i_ImpHvacReducer.cpp

#include "stdafx.h"

#include "ImpHvacReducer.h"
#include "AecDbObjXDataMap.h"
#include "AuxTools.h"
#include "math.h"
#include "dbxutil.h"
#include "dbsymutl.h"

using namespace AecEqui;

extern double MayAsMUnit(double dVal);
ImpHvacReducer::ImpHvacReducer()
{
	m_pXDataMap = NULL;
	m_pOwnerEnt = NULL;
}

ImpHvacReducer::~ImpHvacReducer()
{
}

void ImpHvacReducer::list() const
{
	if (NULL == m_pXDataMap)
		return;

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

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

	// 圆型截面显示直径
	if (eCircle == eStartSectType)
	{
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HRED_StartDiameter, dDiameter);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t始端直径：%.2f"), dDiameter);
	}
	// 非圆型截面显示宽度和厚度
	else
	{
		double dWidth = 0.0, dThick = 0.0;
		m_pXDataMap->GetAt(HRED_StartWidth, dWidth);
		m_pXDataMap->GetAt(HRED_StartThick, dThick);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t始端宽度：%.2f  始端厚度：%.2f"), dWidth, dThick);
	}

	// 圆型截面显示直径
	if (eCircle == eEndSectType)
	{
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HRED_EndDiameter, dDiameter);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t末端直径：%.2f"), dDiameter);
	}
	// 非圆型截面显示宽度和厚度
	else
	{
		double dWidth = 0.0, dThick = 0.0;
		m_pXDataMap->GetAt(HRED_EndWidth, dWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dThick);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t末端宽度：%.2f  末端厚度：%.2f"), dWidth, dThick);
	}

	// 起点
	AcGePoint3d pt;
	m_pXDataMap->GetAt(HRED_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(HRED_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);
}

BOOL ImpHvacReducer::IsHorzAlignment() const
{
	// 获得法向量
	AcGeVector3d vtSect;
	m_pXDataMap->GetAt(HRED_StartDir, vtSect);

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

	return vtSect.isPerpendicularTo(vtZAxis);
}

BOOL ImpHvacReducer::IsVertAlignment() const
{
	// 获得法向量
	AcGeVector3d vtSect;
	m_pXDataMap->GetAt(HRED_StartDir, vtSect);

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

	return vtSect.isParallelTo(vtZAxis);
}

BOOL ImpHvacReducer::IsInclineAlignment() const
{
	// 获得法向量
	AcGeVector3d vtSect;
	m_pXDataMap->GetAt(HRED_StartDir, vtSect);

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

	return !vtSect.isPerpendicularTo(vtZAxis) && !vtSect.isParallelTo(vtZAxis);
}

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

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

	return bSingleLine;
}

AcGeVector3d ImpHvacReducer::GetSectNormal() const
{
	ASSERT(NULL != m_pXDataMap);

	AcGeVector3d vtSta;
	m_pXDataMap->GetAt(HRED_StartDir, vtSta);
	if (!vtSta.isParallelTo(TAuxTools::GetUcsZvt()))
	{
		if (!vtSta.isPerpendicularTo(TAuxTools::GetUcsZvt()))
			return vtSta;
		else
			vtSta = vtSta.orthoProject(TAuxTools::GetUcsZvt());
	}	
	return vtSta;
}

Acad::ErrorStatus ImpHvacReducer::Draw3d(AcGiDraw& mode) const
{
	if (NULL == m_pXDataMap)
		return Acad::eOk;
	
	// 变径类型
	ESection eStartSectType = eRect;
	ESection eEndSectType = eRect;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

	AcDbObjectId idLayBk = mode.GetLayerId();
	mode.SetLayer(m_idDoubleLayer);
	// 始端截面
	switch (eStartSectType)
	{
	case eRect:		// 矩形
		// 末端截面
		switch (eEndSectType)
		{
		case eRect:	// 矩形
			ExplodeRect2Rect3d(mode);
			break;
		case eCircle:	// 园形
			ExplodeRect2Cir3d(mode);
			break;
		case eOblate:		// 扁圆形
			break;
		}
		break;

	case eCircle:		// 园形
		// 末端截面
		switch (eEndSectType)
		{
		case eRect:	// 矩形
			ExplodeCir2Rect3d(mode);
			break;
		case eCircle:	// 园形
			ExplodeCir2Cir3d(mode);
			break;
		case eOblate:		// 扁圆形
			break;
		}
		break;

	case eOblate:			// 扁圆形
		// 末端截面
		switch (eEndSectType)
		{
		case eRect:	// 矩形
			break;
		case eCircle:	// 园形
			break;
		case eOblate:		// 扁圆形
			break;
		}
		break;
	}
	mode.SetLayer(idLayBk);
	return Acad::eOk;
}

BOOL ImpHvacReducer::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 ImpHvacReducer::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 ImpHvacReducer::Move3DBuffer(AcDbVoidPtrArray& ar3DBuffer) const
{
	if (!m_ar3DDrableBufPtrs_.isEmpty())
	{
		ar3DBuffer.append(m_ar3DDrableBufPtrs_);
		m_ar3DDrableBufPtrs_.removeAll();
	}
}

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

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

	AecComplexCurve cplCen;
	GetCurvesInSide(cplCen);

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

	return Acad::eOk;
}

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

	// 变径类型
	ESection eStartSectType = eRect;
	ESection eEndSectType = eRect;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

	int nType = 0;
	if (IsHorzAlignment())			// 水平
	{
		switch (eStartSectType)
		{
		case eRect:		// 矩形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeRect2Rect2DCurves(cplCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeRect2Cir2DCurves(cplCurve,nType);
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;
		case eCircle:		// 圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeCir2Rect2DCurves(cplCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeCir2Cir2DCurves(cplCurve,nType);
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;
		case eOblate:			// 扁圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				break;
			case eCircle:	// 园形
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if(IsVertAlignment())	// 立管
	{
		switch (eStartSectType)
		{
		case eRect:		// 矩形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeRect2Rect2DCurvesVer(cplCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeRect2Cir2DCurvesVer(cplCurve,nType);
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;			
		case eCircle:		// 圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeCir2Rect2DCurvesVer(cplCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeCir2Cir2DCurvesVer(cplCurve,nType);
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;			
		case eOblate:			// 扁圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				break;
			case eCircle:	// 圆形
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if (IsInclineAlignment())	//倾斜变径二维Lixl
	{
		switch (eStartSectType)
		{
		case eRect:		// 矩形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeRect2Rect2DCurves(cplCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeRect2Cir2DCurves(cplCurve,nType);
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;
		case eCircle:		// 圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeCir2Rect2DCurves(cplCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeIncCir2Cir2DCurves(cplCurve,nType);
				break;
			case eOblate:		// 扁圆形
				break;
			}
			break;
		}		
	}
	return FALSE;
}

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

	// 变径类型
	ESection eStartSectType = eRect;
	ESection eEndSectType = eRect;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

	int nType = 1;
	if (IsHorzAlignment())		// 水平
	{
		switch (eStartSectType)
		{
		case eRect:		// 矩形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeRect2Rect2DCurves(compCurve, nType);
				break;
			case eCircle:	// 园形
				return MakeRect2Cir2DCurves(compCurve, nType);
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		case eCircle:		// 园形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeCir2Rect2DCurves(compCurve, nType);
				break;
			case eCircle:	// 园形
				return MakeCir2Cir2DCurves(compCurve, nType);
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		case eEllispe:			// 扁圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				break;
			case eCircle:	// 园形
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if(IsVertAlignment())	// 立管
	{
		switch (eStartSectType)
		{
		case eRect:		// 矩形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeRect2Rect2DCurvesVer(compCurve, nType);
				break;
			case eCircle:	// 园形
				return MakeRect2Cir2DCurvesVer(compCurve, nType);
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		case eCircle:		// 园形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeCir2Rect2DCurvesVer(compCurve, nType);
				break;
			case eCircle:	// 园形
				return MakeCir2Cir2DCurvesVer(compCurve, nType);
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		case eEllispe:			// 扁圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				break;
			case eCircle:	// 园形
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if (IsInclineAlignment())
	{
		switch (eStartSectType)
		{
		case eRect:		// 矩形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeRect2Rect2DCurves(compCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeRect2Cir2DCurves(compCurve,nType);
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		case eCircle:		// 圆形
			switch (eEndSectType)
			{
			case eRect:	// 矩形
				return MakeCir2Rect2DCurves(compCurve,nType);
				break;
			case eCircle:	// 圆形
				return MakeIncCir2Cir2DCurves(compCurve,nType);
				break;
			case eEllispe:		// 扁圆形
				break;
			}
			break;
		}		
	}
	return FALSE;
}

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

	// 取得位置点和法向
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal, vtSta;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	m_pXDataMap->GetAt(HRED_StartDir, vtSta);

	// 变换位置
	ptStart.transformBy(xform);
	ptEnd.transformBy(xform);
	vtNormal.transformBy(xform);
	vtSta.transformBy(xform);
	vtNormal.normalize();
	vtSta.normalize();

	// 更新点和法向
	m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->SetAt(KEY_NORMAL, vtNormal);
	m_pXDataMap->SetAt(HRED_StartDir, vtSta);

	// 设置尺寸
	double dScale = xform.scale();
	double dStaWidth(0.0), dEndWidth(0.), dStaThick(0.0), dEndThick(0.0);
	m_pXDataMap->GetAt(HRED_StartWidth, dStaWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HRED_StartThick, dStaThick);
	m_pXDataMap->GetAt(HRED_EndThick, dEndThick);

	dStaWidth *= dScale;
	dEndWidth *= dScale;
	dStaThick *= dScale;
	dEndThick *= dScale;
	m_pXDataMap->SetAt(HRED_StartWidth, dStaWidth);
	m_pXDataMap->SetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->SetAt(HRED_StartThick, dStaThick);
	m_pXDataMap->SetAt(HRED_EndThick, dEndThick);

	return Acad::eOk;
}

AecEqui::Position ImpHvacReducer::ExplainGripIndex(int nIndex) const
{
	AecEqui::Position ePos = AecEqui::eStart;
	switch(nIndex)
	{
	case 0:
		ePos = AecEqui::eStart;
		break;
	case 1:
		ePos = AecEqui::eEnd;
		break;
	case 2:
		ePos = AecEqui::eCommand0;
		break;
	case 3:
		ePos = AecEqui::eCommand1;
		break;
	}
	return ePos;
}

// 绘制三维图形（方对方）
void ImpHvacReducer::ExplodeRect2Rect3d(AcGiDraw& mode) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartWidth = MayAsMUnit(200.0), dStartThick = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), 
		dEndThick = MayAsMUnit(400.0), dPlusEdge(GetPlusEdge());

	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);

	// 计算8顶点
	AcGeVector3d vtSect = GetSectNormal();
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();		
	AcGePoint3dArray arPtS, arPtE;		
	arPtS.append(ptStart + dStartWidth * vt / 2.0 + dStartThick * vtNormal / 2.0);
	arPtS.append(arPtS.at(0) - dStartWidth * vt);
	arPtS.append(arPtS.at(1) - dStartThick * vtNormal);
	arPtS.append(arPtS.at(0) - dStartThick * vtNormal);
	arPtS.append(arPtS.at(0));	
	arPtE.append(ptEnd + dEndWidth * vt / 2.0 + dEndThick * vtNormal / 2.0);
	arPtE.append(arPtE.at(0) - dEndWidth * vt);
	arPtE.append(arPtE.at(1) - dEndThick * vtNormal);
	arPtE.append(arPtE.at(0) - dEndThick * vtNormal);
	arPtE.append(arPtE.at(0));

	// 考虑法兰余量添加5行4列点
	AcGePoint3dArray arPoint;
	for(int i = 0; i < 5; i++)
	{
		arPoint.append(arPtS.at(i));
		arPoint.append(arPtS.at(i) - dPlusEdge * vtSect);
		arPoint.append(arPtE.at(i) + dPlusEdge * vtSect);
		arPoint.append(arPtE.at(i));		
	}
	
	DrawMesh(mode,5, 4, arPoint.asArrayPtr());
}

// 构建二维图形（方对方）
BOOL ImpHvacReducer::MakeRect2Rect2DCurves(AecComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectType);
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	if ((eSectType == eRect) && !vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 取厚
	{
		m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);	
	}

	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);	
	AcDbObjectId idEndLayer, idBaseLayer;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
				
	BOOL bHasBaseLine = FALSE;
	m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
	
	AecCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	curEle.idSubLay = m_idDoubleLayer;

	AcGeVector3d vtSect = GetSectNormal();
	// 2D下绘制，截面方向向XY平面投影，后计算图形在XY平面上的关键点Lixl
	vtSect = vtSect.orthoProject(TAuxTools::GetUcsZvt());
	// 绘单线
	if (IsSingleLine())
	{
		AcGeVector3d vtDir = ptStart - ptEnd;
		AcGePoint3d ptS, ptM, ptE;
		vtDir.normalize();
		ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
		if (ptStart.distanceTo(ptEnd) > MayAsMUnit(120.0))
		{
			ptS = ptM + vtDir * 60.0;
			ptE = ptM - vtDir * 60.0;
			curEle.ptGe[0] = ptStart;
			curEle.ptGe[1] = ptS;
			curEle.ptGe[2] = ptS;
			cplCurve.append(curEle);
			curEle.ptGe[0] = ptEnd;
			curEle.ptGe[1] = ptE;
			curEle.ptGe[2] = ptE;
			cplCurve.append(curEle);
		}
		else
		{
			ptS = ptStart;
			ptE = ptEnd;
		}	

		vtDir.rotateBy(PI/2, TAuxTools::GetUcsZvt());
		double dS = MayAsMUnit(20.0), dE = MayAsMUnit(50.0);
		if (dStartWidth > dEndWidth)
		{
			dS = MayAsMUnit(50.0);
			dE = MayAsMUnit(20.0);
		}	
		curEle.ptGe[0] = ptS + (dS + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[1] = ptS - (dS + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[2] = ptS - (dS + MayAsMUnit(10.0)) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + (dE + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[1] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[2] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptS + dS * vtDir;
		curEle.ptGe[1] = ptE + dE * vtDir;
		curEle.ptGe[2] = ptE + dE * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptS - dS * vtDir;
		curEle.ptGe[1] = ptE - dE * vtDir;
		curEle.ptGe[2] = ptE - dE * vtDir;
		cplCurve.append(curEle);
		return TRUE;
	}	
	
	if (0 == nType)
	{
		AcGeVector3d vt = vtSect;
		//vt.rotateBy(PI / 2.0, vtNormal);
		vt.rotateBy(PI / 2.0, TAuxTools::GetUcsZvt());
		vt.normalize();		
		AcGePoint3d arPoint[4], arPointIn[4];
		arPoint[0] = ptStart - dStartWidth * vt / 2.0;
		arPoint[1] = ptStart + dStartWidth * vt / 2.0;
		arPoint[2] = ptEnd + dEndWidth * vt / 2.0;
		arPoint[3] = ptEnd - dEndWidth * vt / 2.0;
		arPointIn[0] = arPoint[0] - dPlusEdge * vtSect;
		arPointIn[1] = arPoint[1] - dPlusEdge * vtSect;
		arPointIn[2] = arPoint[2] + dPlusEdge * vtSect;
		arPointIn[3] = arPoint[3] + dPlusEdge * vtSect;

		curEle.dWidth = GetEdgeLineWidth();
		curEle.ptGe[0] = arPoint[1];
		curEle.ptGe[1] = arPointIn[1];
		curEle.ptGe[2] = arPointIn[1];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPoint[0];
		curEle.ptGe[1] = arPointIn[0];
		curEle.ptGe[2] = arPointIn[0];
		cplCurve.append(curEle);

		curEle.ptGe[0] = arPointIn[1];
		curEle.ptGe[1] = arPointIn[2];
		curEle.ptGe[2] = arPointIn[2];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[0];
		curEle.ptGe[1] = arPointIn[3];
		curEle.ptGe[2] = arPointIn[3];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[2];
		curEle.ptGe[1] = arPoint[2];
		curEle.ptGe[2] = arPoint[2];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[3];
		curEle.ptGe[1] = arPoint[3];
		curEle.ptGe[2] = arPoint[3];
		cplCurve.append(curEle);

		curEle.idSubLay = idEndLayer;		// 两端图层
		curEle.dWidth = GetEndLineWidth();
		curEle.ptGe[0] = arPoint[0];
		curEle.ptGe[1] = arPoint[1];
		curEle.ptGe[2] = arPoint[1];
		cplCurve.append(curEle);			
		
		curEle.ptGe[0] = arPoint[2];
		curEle.ptGe[1] = arPoint[3];
		curEle.ptGe[2] = arPoint[3];
		cplCurve.append(curEle);			
	}
	else if (1 == nType)
	{
		if (bHasBaseLine)
		{
			curEle.idSubLay = m_idCenterLayer;		// 基线图层
			curEle.dWidth = GetCentLineWidth();
			curEle.ptGe[0] = ptStart;
			curEle.ptGe[1] = ptStart - dPlusEdge * vtSect;
			curEle.ptGe[2] = ptStart - dPlusEdge * vtSect;
			cplCurve.append(curEle);

			curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
			curEle.ptGe[1] = ptEnd + dPlusEdge * vtSect;
			curEle.ptGe[2] = ptEnd + dPlusEdge * vtSect;
			cplCurve.append(curEle);
			
			curEle.ptGe[0] = ptEnd + dPlusEdge * vtSect;
			curEle.ptGe[1] = ptEnd;
			curEle.ptGe[2] = ptEnd;
			cplCurve.append(curEle);
		}		
	}
	return TRUE;
}

// 倾斜变径: 圆对圆
BOOL ImpHvacReducer::MakeIncCir2Cir2DCurves(AecComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = 0.0;
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	ESection eStaSectType = eRect;
	ESection eEndSectType = eRect;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStaSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	if ((eStaSectType == eRect) && !vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 取厚
	{
		m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);	
	}

	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);	
	AcDbObjectId idEndLayer, idBaseLayer;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);

	// 中心线图层
	BOOL bHasBaseLine = FALSE;
	m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);

	AecCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	curEle.idSubLay = m_idDoubleLayer;

	AcGeVector3d vtSect = GetSectNormal();
	int i(0), nRet(0);
	AcDbPolyline* pLine = new AcDbPolyline;
	if (NULL == pLine)
		return FALSE;
	AcGePoint3dArray arPtsCir;
	AcGeVector3d vt = vtSect.crossProduct(vtNormal);
	vt.normalize();		

	// 绘单线
	if (IsSingleLine())
	{
		AcGeVector3d vtDir = ptStart - ptEnd;
		vtDir.orthoProject(TAuxTools::GetUcsZvt());
		vtDir.normalize();
		AcGePoint3d ptS, ptM, ptE;
		ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
		if (ptStart.distanceTo(ptEnd) > MayAsMUnit(120.0))
		{
			ptS = ptM + vtDir * MayAsMUnit(60.0);
			ptE = ptM - vtDir * MayAsMUnit(60.0);
			curEle.ptGe[0] = ptStart;
			curEle.ptGe[1] = ptS;
			curEle.ptGe[2] = ptS;
			cplCurve.append(curEle);
			curEle.ptGe[0] = ptEnd;
			curEle.ptGe[1] = ptE;
			curEle.ptGe[2] = ptE;
			cplCurve.append(curEle);
		}
		else
		{
			ptS = ptStart;
			ptE = ptEnd;
		}	

		vtDir.rotateBy(PI/2, TAuxTools::GetUcsZvt());
		double dS = MayAsMUnit(20.0), dE = MayAsMUnit(50.0);
		if (dStartWidth > dEndWidth)
		{
			dS = MayAsMUnit(50.0);
			dE = MayAsMUnit(20.0);
		}	
		curEle.ptGe[0] = ptS + (dS + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[1] = ptS - (dS + MayAsMUnit(10.0))* vtDir;
		curEle.ptGe[2] = ptS - (dS + MayAsMUnit(10.0)) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + (dE + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[1] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
		curEle.ptGe[2] = ptE - (dE + MayAsMUnit(10.0)) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptS + dS * vtDir;
		curEle.ptGe[1] = ptE + dE * vtDir;
		curEle.ptGe[2] = ptE + dE * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptS - dS * vtDir;
		curEle.ptGe[1] = ptE - dE * vtDir;
		curEle.ptGe[2] = ptE - dE * vtDir;
		cplCurve.append(curEle);
		return TRUE;
	}	

	if (0 == nType)
	{		
		AcGePoint3d arPoint[4];
		arPoint[0] = ptStart - dStartWidth * vt / 2.0;
		arPoint[1] = ptStart + dStartWidth * vt / 2.0;
		arPoint[2] = ptEnd + dEndWidth * vt / 2.0;
		arPoint[3] = ptEnd - dEndWidth * vt / 2.0;

		curEle.idSubLay = idEndLayer;		// 两端图层
		curEle.dWidth = GetEndLineWidth();
		// 末端半个椭圆
		vt = -vtSect;//起点指向终点
		if (eEndSectType == eCircle)
		{
			nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptEnd, dEndWidth, vt, TAuxTools::GetUcsZvt(), *pLine, vt);
			if (-1 != nRet)
			{
				for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
				{
					curEle.ptGe[0] = arPtsCir[i];
					curEle.ptGe[1] = arPtsCir[i+1];
					curEle.ptGe[2] = arPtsCir[i+1];
					cplCurve.append(curEle);
				}
				arPoint[2] = arPtsCir.first();
				arPoint[3] = arPtsCir.last();
			}
		} 
		else
		{
		}

		arPtsCir.setLogicalLength(0);
		pLine->reset(Adesk::kFalse, i);
		if (eStaSectType == eCircle)
		{
			nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptStart, dStartWidth, -vt, TAuxTools::GetUcsZvt(), *pLine, -vt);
			if (-1 != nRet)
			{
				for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
				{
					curEle.ptGe[0] = arPtsCir[i];
					curEle.ptGe[1] = arPtsCir[i+1];
					curEle.ptGe[2] = arPtsCir[i+1];
					cplCurve.append(curEle);
				}
				arPoint[0] = arPtsCir.first();
				arPoint[1] = arPtsCir.last();
			}
		} 
		else
		{

		}
		
		vt = -vtSect.crossProduct(vtNormal);
		AcGePoint3d ptJudge = ptStart + vt * MayAsMUnit(10000);
		ptJudge.z = (ptStart.z + ptEnd.z) * 0.5;
		arPoint[0].z = ptJudge.z;
		arPoint[1].z = ptJudge.z;
		arPoint[2].z = ptJudge.z;
		arPoint[3].z = ptJudge.z;

		AcGePoint3d ptTmp;
		// 0,3点在上, 1,2点在下
		if (arPoint[0].distanceTo(ptJudge) < arPoint[1].distanceTo(ptJudge))
		{
			ptTmp = arPoint[0];
			arPoint[0] = arPoint[1];
			arPoint[1] = ptTmp;
		}
		if (arPoint[3].distanceTo(ptJudge) < arPoint[2].distanceTo(ptJudge))
		{
			ptTmp = arPoint[3];
			arPoint[3] = arPoint[2];
			arPoint[2] = ptTmp;
		}
		// 变径边线
		curEle.idSubLay = AcDbObjectId::kNull;
		curEle.dWidth = GetEdgeLineWidth();
		curEle.ptGe[0] = arPoint[0];
		curEle.ptGe[1] = arPoint[3];
		curEle.ptGe[2] = arPoint[3];
		cplCurve.append(curEle);

		curEle.ptGe[0] = arPoint[1];
		curEle.ptGe[1] = arPoint[2];
		curEle.ptGe[2] = arPoint[2];
		cplCurve.append(curEle);
	}
	else if (1 == nType)
	{
		if (bHasBaseLine)
		{
			curEle.idSubLay = m_idCenterLayer;		// 基线图层
			curEle.dWidth = GetCentLineWidth();
			curEle.ptGe[0] = ptStart;
			curEle.ptGe[1] = ptEnd;
			curEle.ptGe[2] = ptEnd;
			cplCurve.append(curEle);
		}
		
		// 内部端线
		curEle.idSubLay = idEndLayer;
		curEle.dWidth = GetEndLineWidth();
		vt = -vtSect;
		// 起点高,画起点内半个椭圆
		if (ptStart.z > ptEnd.z)
		{
			nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptStart, dStartWidth, vt, TAuxTools::GetUcsZvt(), *pLine, vt);
			if (-1 != nRet)
			{
				for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
				{
					curEle.ptGe[0] = arPtsCir[i];
					curEle.ptGe[1] = arPtsCir[i+1];
					curEle.ptGe[2] = arPtsCir[i+1];
					cplCurve.append(curEle);
				}
			}
		}
		else	// 终点高,画终点内部半个椭圆
		{
			nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptEnd, dEndWidth, vt, TAuxTools::GetUcsZvt(), *pLine, -vt);
			if (-1 != nRet)
			{
				for (i = 0; i < arPtsCir.length()-1; i++)//Lixl add 2011-11-23
				{
					curEle.ptGe[0] = arPtsCir[i];
					curEle.ptGe[1] = arPtsCir[i+1];
					curEle.ptGe[2] = arPtsCir[i+1];
					cplCurve.append(curEle);
				}
			}
		}
	}

	if (NULL != pLine)
		delete pLine;	

	return TRUE;
}

// 绘制三维图形（方对圆）
void ImpHvacReducer::ExplodeRect2Cir3d(AcGiDraw& mode, BOOL bStartIsRound) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = MayAsMUnit(200.0), dStartThick = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), 
		dEndThick = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();

	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	AcGeVector3d vtSect = GetSectNormal();
	if (bStartIsRound)
	{
		m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
		m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
		m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);		
	}
	else
	{
		m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
		m_pXDataMap->GetAt(HRED_StartThick, dEndThick);
		m_pXDataMap->GetAt(HRED_EndWidth, dStartWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dStartThick);
		m_pXDataMap->GetAt(HRED_StartPoint, ptEnd);
		m_pXDataMap->GetAt(HRED_EndPoint, ptStart);	
		vtSect = -vtSect;
	}
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	
	double dMinDiffAng = PI / 12.0;	// 圆弧分割的角度
	//GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinDiffAng);
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
	int nSect = int(PI / (2.0 * dMinDiffAng)) + 1;	// 每PI/2圆弧分成的段数
	dMinDiffAng = PI / (2.0 * nSect);
	
	// 起始端圆分割点
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();		
	AcGePoint3dArray arCirPt;
	AcGePoint3d ptCir;
	ptCir = ptStart + vt * dStartWidth / 2.0;
	arCirPt.append(ptCir);
	for (int i = 1; i < 4 * nSect; i++)
	{
		ptCir.rotateBy(dMinDiffAng, vtSect, ptStart);
		arCirPt.append(ptCir);
	}
	arCirPt.append(ptStart + vt * dStartWidth / 2.0);		// 最后一个封闭，可消除计算误差

	// 终止端矩形顶点
	AcGePoint3dArray arRectPt;
	arRectPt.append(ptEnd + dEndWidth * vt / 2.0 - dEndThick * vtNormal / 2.0);
	arRectPt.append(arRectPt.at(0) + dEndThick * vtNormal);
	arRectPt.append(arRectPt.at(1) - dEndWidth * vt);
	arRectPt.append(arRectPt.at(0) - dEndWidth * vt);
	arRectPt.append(arRectPt.at(0));
	
	// 4*(nSect+1)+1行4列网格点
	AcGePoint3dArray arPoint;
	for (i = 0; i < 4; i++)
	{
		// 圆上点和矩形边
		arPoint.append(arCirPt.at(i * nSect));
		arPoint.append(arCirPt.at(i * nSect) - dPlusEdge * vtSect);
		arPoint.append(arRectPt.at(i) + dPlusEdge * vtSect);
		arPoint.append(arRectPt.at(i));
		
		// 圆上边和矩形顶点
		for (int j = 0; j < nSect; j++)
		{
			arPoint.append(arCirPt.at(i * nSect + j));
			arPoint.append(arCirPt.at(i * nSect + j) - dPlusEdge * vtSect);
			arPoint.append(arRectPt.at(i + 1) + dPlusEdge * vtSect);
			arPoint.append(arRectPt.at(i + 1));
		}
	}
	arPoint.append(arCirPt.at(0));
	arPoint.append(arCirPt.at(0) - dPlusEdge * vtSect);
	arPoint.append(arRectPt.at(0) + dPlusEdge * vtSect);	
	arPoint.append(arRectPt.at(0));	
	
	DrawMesh(mode,4 * (nSect + 1) + 1, 4, arPoint.asArrayPtr());
}

// 构建二维图形（方对圆）
BOOL ImpHvacReducer::MakeRect2Cir2DCurves(AecComplexCurve& cplCurve, int &nType, BOOL bStartIsRound) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtSect = GetSectNormal();
	if (bStartIsRound)
	{
		m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
		if (vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))	// 宽厚颠倒
		{
			m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
		}
		// LixlModify支持倾斜管上的变径
		else if (!vtNormal.isPerpendicularTo(TAuxTools::GetUcsZvt()))
		{
			m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
		}
		else
		{
			m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);
		}
		
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);		
	}
	else
	{
		vtSect = -vtSect;
		if (vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))
		{
			m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
		}
		// LixlModify支持倾斜管上的变径
		else if (!vtNormal.isPerpendicularTo(TAuxTools::GetUcsZvt()))
		{
			m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
		}
		else
		{
			m_pXDataMap->GetAt(HRED_StartThick, dEndWidth);
		}
		
		m_pXDataMap->GetAt(HRED_EndWidth, dStartWidth);
		m_pXDataMap->GetAt(HRED_StartPoint, ptEnd);
		m_pXDataMap->GetAt(HRED_EndPoint, ptStart);	
	}
	
	AcDbObjectId idEndLayer, idBaseLayer;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
	//TDbFittingBase* pFit = TDbFittingBase::cast(m_pOwnerEnt);
	//if (NULL != pFit)
	//	idBaseLayer = pFit->CenterLayer();
	BOOL bHasBaseLine = FALSE;
	m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
	
	AecCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	curEle.idSubLay = m_idDoubleLayer;

	// 绘单线
	if (IsSingleLine())
	{
		AcGeVector3d vtDir = ptStart - ptEnd;
		AcGePoint3d ptS, ptM, ptE;
		vtDir.normalize();
		ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
		if (ptStart.distanceTo(ptEnd) > MayAsMUnit(120.0))
		{
			ptS = ptM + vtDir * MayAsMUnit(60.0);
			ptE = ptM - vtDir * MayAsMUnit(60.0);
			curEle.ptGe[0] = ptStart;
			curEle.ptGe[1] = ptS;
			curEle.ptGe[2] = ptS;
			cplCurve.append(curEle);
			curEle.ptGe[0] = ptEnd;
			curEle.ptGe[1] = ptE;
			curEle.ptGe[2] = ptE;
			cplCurve.append(curEle);			
		}
		else
		{
			ptS = ptStart;
			ptE = ptEnd;
		}		
		
		vtDir.rotateBy(PI / 2.0, TAuxTools::GetUcsZvt());		
		curEle.ptGe[0] = ptS + MayAsMUnit(10.0) * vtDir;		// ptS是圆断面
		curEle.ptGe[1] = ptS - MayAsMUnit(10.0) * vtDir;
		curEle.ptGe[2] = ptS - MayAsMUnit(10.0) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + MayAsMUnit(60.0) * vtDir;
		curEle.ptGe[1] = ptE - MayAsMUnit(60.0) * vtDir;
		curEle.ptGe[2] = ptE - MayAsMUnit(60.0) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + MayAsMUnit(50.0) * vtDir;
		curEle.ptGe[1] = ptS;
		curEle.ptGe[2] = ptS;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE - MayAsMUnit(50.0) * vtDir;
		curEle.ptGe[1] = ptS;
		curEle.ptGe[2] = ptS;
		cplCurve.append(curEle);
		return TRUE;
	}	
	
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();		
	AcGePoint3d arPoint[4], arPointIn[4];
	arPoint[0] = ptStart - dStartWidth * vt / 2.0;
	arPoint[1] = ptStart + dStartWidth * vt / 2.0;
	arPoint[2] = ptEnd + dEndWidth * vt / 2.0;
	arPoint[3] = ptEnd - dEndWidth * vt / 2.0;
	arPointIn[0] = arPoint[0] - dPlusEdge * vtSect;
	arPointIn[1] = arPoint[1] - dPlusEdge * vtSect;
	arPointIn[2] = arPoint[2] + dPlusEdge * vtSect;
	arPointIn[3] = arPoint[3] + dPlusEdge * vtSect;

	if (1 == nType)			// 内部线
	{
		curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
		curEle.ptGe[1] = arPointIn[2];
		curEle.ptGe[2] = arPointIn[2];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
		curEle.ptGe[1] = arPointIn[3];
		curEle.ptGe[2] = arPointIn[3];
		cplCurve.append(curEle);

		if (bHasBaseLine)
		{
			curEle.idSubLay = m_idCenterLayer;		// 基线图层
			curEle.dWidth = GetCentLineWidth();
			curEle.ptGe[0] = ptStart;
			curEle.ptGe[1] = ptStart - dPlusEdge * vtSect;
			curEle.ptGe[2] = ptStart - dPlusEdge * vtSect;
			cplCurve.append(curEle);
			
			curEle.ptGe[0] = ptStart - dPlusEdge * vtSect;
			curEle.ptGe[1] = ptEnd + dPlusEdge * vtSect;
			curEle.ptGe[2] = ptEnd + dPlusEdge * vtSect;
			cplCurve.append(curEle);
			
			curEle.ptGe[0] = ptEnd + dPlusEdge * vtSect;
			curEle.ptGe[1] = ptEnd;
			curEle.ptGe[2] = ptEnd;
			cplCurve.append(curEle);
		}
	}
	else if (0 == nType)	// 外边线
	{	
		curEle.dWidth = GetEdgeLineWidth();
		curEle.ptGe[0] = arPoint[1];
		curEle.ptGe[1] = arPointIn[1];
		curEle.ptGe[2] = arPointIn[1];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPoint[0];
		curEle.ptGe[1] = arPointIn[0];
		curEle.ptGe[2] = arPointIn[0];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[1];
		curEle.ptGe[1] = arPointIn[2];
		curEle.ptGe[2] = arPointIn[2];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[0];
		curEle.ptGe[1] = arPointIn[3];
		curEle.ptGe[2] = arPointIn[3];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[2];
		curEle.ptGe[1] = arPoint[2];
		curEle.ptGe[2] = arPoint[2];
		cplCurve.append(curEle);
		
		curEle.ptGe[0] = arPointIn[3];
		curEle.ptGe[1] = arPoint[3];
		curEle.ptGe[2] = arPoint[3];
		cplCurve.append(curEle);
		
		curEle.idSubLay = idEndLayer;		// 两端图层
		curEle.dWidth = GetEndLineWidth();
		curEle.ptGe[0] = arPoint[0];
		curEle.ptGe[1] = arPoint[1];
		curEle.ptGe[2] = arPoint[1];
		cplCurve.append(curEle);			
		
		curEle.ptGe[0] = arPoint[2];
		curEle.ptGe[1] = arPoint[3];
		curEle.ptGe[2] = arPoint[3];
		cplCurve.append(curEle);			
	}
	
	return TRUE;
}

// 绘制三维图形（圆对方）
void ImpHvacReducer::ExplodeCir2Rect3d(AcGiDraw& mode) const
{
	ExplodeRect2Cir3d(mode, TRUE);
}

// 构建二维图形（圆对方）
BOOL ImpHvacReducer::MakeCir2Rect2DCurves(AecComplexCurve& cplCurve, int &nType) const
{
	return MakeRect2Cir2DCurves(cplCurve, nType, TRUE);
}

// 绘制三维图形（圆对圆）
void ImpHvacReducer::ExplodeCir2Cir3d(AcGiDraw& mode) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dPlusEdge = GetPlusEdge();
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);		
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	
	AcGeVector3d vtSect = GetSectNormal();
	double dMinDiffAng = PI / 12.0;	// 圆弧分割的角度
	//GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinDiffAng);
	m_pXDataMap->GetAt(KEY_MINDIFFANG, dMinDiffAng);
	int nSect = int(2.0 * PI / dMinDiffAng) + 1;
	dMinDiffAng = 2.0 * PI / nSect;
	
	// 起始端圆分割点
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();		
	AcGePoint3dArray arCirPtStart;
	AcGePoint3d ptCir;
	ptCir = ptStart + vt * dStartWidth / 2.0;
	arCirPtStart.append(ptCir);
	for (int i = 1; i < nSect; i++)
	{
		ptCir.rotateBy(dMinDiffAng, vtSect, ptStart);
		arCirPtStart.append(ptCir);
	}
	arCirPtStart.append(ptStart + vt * dStartWidth / 2.0);	// 最后一个封闭，可消除计算误差
	
	// 终止端端圆分割点
	AcGePoint3dArray arCirPtEnd;
	ptCir = ptEnd + vt * dEndWidth / 2.0;
	arCirPtEnd.append(ptCir);
	for (i = 1; i < nSect; i++)
	{
		ptCir.rotateBy(dMinDiffAng, vtSect, ptEnd);
		arCirPtEnd.append(ptCir);
	}
	arCirPtEnd.append(ptEnd + vt * dEndWidth / 2.0);
	
	// nSect+1行2列网格点
	AcGePoint3dArray arPoint;
	for (i = 0; i < nSect + 1; i++)
	{
		arPoint.append(arCirPtStart.at(i));
		arPoint.append(arCirPtStart.at(i) - dPlusEdge * vtSect);
		arPoint.append(arCirPtEnd.at(i) + dPlusEdge * vtSect);
		arPoint.append(arCirPtEnd.at(i));		
	}
	DrawMesh(mode,nSect + 1, 4, arPoint.asArrayPtr());
}

// 构建二维图形（圆对圆）
BOOL ImpHvacReducer::MakeCir2Cir2DCurves(AecComplexCurve& cplCurve, int &nType) const
{
	return MakeRect2Rect2DCurves(cplCurve, nType);
}

// 获得外轮廓点
void ImpHvacReducer::GetOutVertex(AcGePoint3dArray& arPoint, ESection eStart, ESection eEnd) const
{
	double dStartWidth = MayAsMUnit(200.0), dStartThick = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dEndThick = MayAsMUnit(400.0);
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	if (eStart == eRect) 
		m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
	else
		dStartThick = dStartWidth;				// 圆形取厚度为宽
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	if (eStart == eRect) 
		m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
	else
		dEndThick = dEndWidth;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);

	// 计算8顶点（圆形近似为方形计算）
	AcGeVector3d vtSect = AcGeVector3d::kZAxis;
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();	
	AcGePoint3dArray arStartPt;
	arStartPt.append(ptStart + dStartWidth * vt / 2.0 + dStartThick * vtNormal / 2.0);
	arStartPt.append(arStartPt.at(0) - dStartWidth * vt);
	arStartPt.append(arStartPt.at(1) - dStartThick * vtNormal);
	arStartPt.append(arStartPt.at(0) - dStartThick * vtNormal);
	AcGePoint3dArray arEndPt;		
	arEndPt.append(ptEnd + dEndWidth * vt / 2.0 + dEndThick * vtNormal / 2.0);
	arEndPt.append(arEndPt.at(0) - dEndWidth * vt);
	arEndPt.append(arEndPt.at(1) - dEndThick * vtNormal);
	arEndPt.append(arEndPt.at(0) - dEndThick * vtNormal);

	// 边旋转到与x，y轴平行
	double dAngle = vtNormal.angleTo(AcGeVector3d::kXAxis);
	for (int i = 0; i < 4; i++)
	{
		arStartPt.at(i).rotateBy(dAngle, vtSect, ptStart);
		arEndPt.at(i).rotateBy(dAngle, vtSect, ptStart);
	}

	// 寻找外轮廓点
	if (arStartPt.at(0).x < arEndPt.at(0).x)
	{
		arPoint.append(arEndPt.at(0));
		arPoint.append(arEndPt.at(1));
		if (arStartPt.at(1).y < arEndPt.at(1).y)	
		{
			arPoint.append(arEndPt.at(2));
			if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
			{
				arPoint.append(arStartPt.at(2));
				arPoint.append(arStartPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 左，下偏出
				{
					arPoint.append(arStartPt.at(0));
				}
				else										// 左偏出
				{
					arPoint.append(arEndPt.at(3));
				}
			}
			else
			{
				arPoint.append(arEndPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 下偏出
				{
					arPoint.append(arStartPt.at(3));
					arPoint.append(arStartPt.at(0));
				}
				else										// 全在里面
				{					
				}
			}
		}
		else		// 上偏
		{
			arPoint.append(arStartPt.at(1));
			arPoint.append(arStartPt.at(2));
			if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
			{
				arPoint.append(arStartPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 上，左，下偏出
				{
					arPoint.append(arStartPt.at(0));
				}
				else										// 上，左偏出
				{
					arPoint.append(arEndPt.at(3));
				}
			}
			else
			{
				arPoint.append(arEndPt.at(2));
				arPoint.append(arEndPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 上，下偏出
				{
					arPoint.append(arStartPt.at(3));
					arPoint.append(arStartPt.at(0));
				}
				else										// 上偏出
				{					
				}
			}
		}
	}
	else	// 右偏
	{
		arPoint.append(arStartPt.at(0));
		arPoint.append(arStartPt.at(1));
		if (arStartPt.at(1).y < arEndPt.at(1).y)	
		{
			arPoint.append(arEndPt.at(1));
			arPoint.append(arEndPt.at(2));
			if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
			{
				arPoint.append(arStartPt.at(2));
				arPoint.append(arStartPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 右，左，下偏出
				{
				}
				else										// 右，左偏出
				{
					arPoint.append(arEndPt.at(3));
					arPoint.append(arEndPt.at(0));
				}
			}
			else
			{
				arPoint.append(arEndPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 右，下偏出
				{
					arPoint.append(arStartPt.at(3));
				}
				else										// 右偏出
				{
					arPoint.append(arEndPt.at(0));
				}
			}
		}
		else		// 上偏
		{
			arPoint.append(arStartPt.at(2));
			if (arStartPt.at(2).x < arEndPt.at(2).x)// 左偏
			{
				arPoint.append(arStartPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 右，上，左，下偏出
				{
				}
				else										// 右，上，左偏出
				{
					arPoint.append(arEndPt.at(3));
					arPoint.append(arEndPt.at(0));
				}
			}
			else
			{
				arPoint.append(arEndPt.at(2));
				arPoint.append(arEndPt.at(3));
				if (arStartPt.at(3).y < arEndPt.at(3).y)	// 右，上，下偏出
				{
					arPoint.append(arStartPt.at(3));
				}
				else										// 右，上偏出
				{		
					arPoint.append(arEndPt.at(0));
				}
			}
		}
	}	

	// 恢复点的原位置
	for (i = 0; i < arPoint.length(); i++)
	{
		arPoint.at(i).rotateBy(-dAngle, vtSect, ptStart);
	}
}

/*
2______________________1
|						|
|			0			|
|						|
3______________________4|
*/
// bGetStartVertex 真:取起点截面周围顶点,假:取终点截面周围顶点
// 矩形截面,执行此函数后6个点,圆形界面26个点,顺序,中心点,逆时针24个点,逆时针起点终点重复一个点
void ImpHvacReducer::GetOutVertex2(AcGePoint3dArray& arPoint, bool bGetStartVertex) const
{
	ASSERT(NULL != m_pXDataMap);

	// 竖直放置时的外轮廓
	if (IsVertAlignment())
	{
		AcGeVector3d vtSect, vtNor;
		m_pXDataMap->GetAt(HRED_StartDir, vtSect);
		m_pXDataMap->GetAt(HVAC_Normal, vtNor);

		AcGePoint3d ptCenter, ptTmp;
		double dWidth(0.0), dThick(0.0);
		ESection eSect(eRect);
		if (bGetStartVertex)
		{
			m_pXDataMap->GetAt(HRED_StartPoint, ptCenter);
			m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSect);
			m_pXDataMap->GetAt(HRED_StartWidth, dWidth);
			m_pXDataMap->GetAt(HRED_StartThick, dThick);
		}
		else
		{
			m_pXDataMap->GetAt(HRED_EndPoint, ptCenter);
			m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSect);
			m_pXDataMap->GetAt(HRED_EndWidth, dWidth);
			m_pXDataMap->GetAt(HRED_EndThick, dThick);
		}

		AcGeVector3d vtDir = vtNor.crossProduct(vtSect);
		AcGeVector3d vtDirV = vtDir.normalize();
		vtDirV.rotateBy(PI*0.5, vtSect);

		// 0
		arPoint.append(ptCenter);
		if (eRect == eSect)
		{
			ptTmp = ptCenter + vtDir * dWidth * 0.5;
			ptTmp = ptTmp + vtDirV * dThick * 0.5;
			arPoint.append(ptTmp);//1
			ptTmp = arPoint[1] - vtDir * dWidth;
			arPoint.append(ptTmp);//2
			ptTmp = arPoint[2] - vtDirV * dThick;
			arPoint.append(ptTmp);//3
			ptTmp = arPoint[1] - vtDirV * dThick;
			arPoint.append(ptTmp);//4
			// 为闭合,增加1点为重复点
			arPoint.append(arPoint[1]);
		}
		else if (eCircle == eSect)
		{
			// 把圆按照最小分度角,分成几部分,取圆上点
			double dMixAngle = TAuxTools::GetMinDiffAngle();
			int nPart = 24;
			dMixAngle = PI*2.0 / nPart;

			ptTmp = ptCenter + vtDir * dWidth * 0.5;
			arPoint.append(ptTmp);	
			for (int i = 0; i < nPart; i++)
			{
				ptTmp.rotateBy(dMixAngle, vtSect, ptCenter);
				arPoint.append(ptTmp);
			}
		}
	}
}

BOOL ImpHvacReducer::MakeRect2Rect2DCurvesVer(AecComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);
	
	AcGePoint3dArray arSta, arEnd;
	GetOutVertex2(arSta, true);
	GetOutVertex2(arEnd, false);
	if (arSta.length() != arEnd.length()
		|| arSta.length() != 6)
		return FALSE;

	double dEndWidht = GetEndLineWidth();
	double dEdgeWidth = GetEdgeLineWidth();
	AcDbObjectId idEndLayer;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);

	AecCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	curEle.idSubLay = m_idDoubleLayer;

	{
		curEle.idSubLay = idEndLayer;
 		curEle.dWidth = dEndWidht;
		// 起点截面边线
		int i = 0;
		for (i = 1; i < arSta.length()-1; i++)
		{
			curEle.ptGe[0] = arSta[i];
			curEle.ptGe[1] = arSta[i+1];
			curEle.ptGe[2] = arSta[i+1];
			cplCurve.append(curEle);
		}
		// 终点截面边线
		for (i = 1; i < arSta.length()-1; i++)
		{
			curEle.ptGe[0] = arEnd[i];
			curEle.ptGe[1] = arEnd[i+1];
			curEle.ptGe[2] = arEnd[i+1];
			cplCurve.append(curEle);
		}

		// 绘制两个截面顶点之间的连线
		curEle.idSubLay.setNull();
		curEle.dWidth = dEdgeWidth;
		for (i = 1; i <= 4; i++)
		{
			curEle.ptGe[0] = arSta[i];
			curEle.ptGe[1] = arEnd[i];
			curEle.ptGe[2] = arEnd[i];
			cplCurve.append(curEle);
		}
	}

	return TRUE;
}

// 垂直构建二维图形（方对圆）
BOOL ImpHvacReducer::MakeRect2Cir2DCurvesVer(AecComplexCurve& cplCurve, int &nType, BOOL bStartIsRound) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartDia = MayAsMUnit(200.0), dEndWidth = MayAsMUnit(400.0), dEndThick = MayAsMUnit(400.0);
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	if (bStartIsRound)
	{
		m_pXDataMap->GetAt(HRED_StartDiameter, dStartDia);
		m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	}
	else
	{
		m_pXDataMap->GetAt(HRED_EndDiameter, dStartDia);
		m_pXDataMap->GetAt(HRED_StartWidth, dEndWidth);
		m_pXDataMap->GetAt(HRED_StartThick, dEndThick);
		m_pXDataMap->GetAt(HRED_EndPoint, ptStart);
		m_pXDataMap->GetAt(HRED_StartPoint, ptEnd);
	}
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);	
	
	AcDbObjectId idEndLayer;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
	
	// 计算顶点
	AcGeVector3d vtSect = GetSectNormal();
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();
	AcGePoint3dArray arStartPt;
	AcGePoint3d ptCir = ptStart + dStartDia * vt / 2.0;
	arStartPt.append(ptCir);
	for (int i = 1; i < 8; i++)
	{
		ptCir.rotateBy(PI / 4.0, vtSect, ptStart);
		arStartPt.append(ptCir);
	}
	arStartPt.append(ptStart + dStartDia * vt / 2.0);
	AcGePoint3dArray arEndPt;		
	arEndPt.append(ptEnd + dEndWidth * vt / 2.0 - dEndThick * vtNormal / 2.0);
	arEndPt.append(arEndPt.at(0) + dEndThick * vtNormal);
	arEndPt.append(arEndPt.at(1) - dEndWidth * vt);
	arEndPt.append(arEndPt.at(0) - dEndWidth * vt);
	arEndPt.append(arEndPt.at(0));
	
	AecCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	curEle.idSubLay = m_idDoubleLayer;
//	if (0 == nType)
	{
		curEle.dWidth = GetEdgeLineWidth();
		for (i = 0; i < 4; i++)
		{
			curEle.ptGe[0] = arStartPt.at(2 * i);
			curEle.ptGe[1] = arEndPt.at(i);
			curEle.ptGe[2] = arEndPt.at(i);
			cplCurve.append(curEle);
			curEle.ptGe[0] = arStartPt.at(2 * i);
			curEle.ptGe[1] = arEndPt.at(i + 1);
			curEle.ptGe[2] = arEndPt.at(i + 1);
			cplCurve.append(curEle);
		}
		
		curEle.idSubLay = idEndLayer;		// 两端图层
		curEle.dWidth = GetEndLineWidth();
		for (i = 0; i < 4; i++)
		{
			curEle.ptGe[0] = arStartPt.at(2 * i);
			curEle.ptGe[1] = arStartPt.at(2 * i + 1);
			curEle.ptGe[2] = arStartPt.at(2 * i + 2);
			cplCurve.append(curEle);
			curEle.ptGe[0] = arEndPt.at(i);
			curEle.ptGe[1] = arEndPt.at(i + 1);
			curEle.ptGe[2] = arEndPt.at(i + 1);
			cplCurve.append(curEle);
		}
	}

	return TRUE;
}

// 垂直构建二维图形（圆对方）
BOOL ImpHvacReducer::MakeCir2Rect2DCurvesVer(AecComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);
	
	MakeRect2Cir2DCurvesVer(cplCurve, nType, TRUE);
	return TRUE;
}

// 垂直构建二维图形（圆对圆）
BOOL ImpHvacReducer::MakeCir2Cir2DCurvesVer(AecComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartDia = MayAsMUnit(200.0), dEndDia = MayAsMUnit(400.0);
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(HRED_StartDiameter, dStartDia);
	m_pXDataMap->GetAt(HRED_EndDiameter, dEndDia);
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);	
	AcDbObjectId idEndLayer;
	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
	
	// 计算顶点
	AcGeVector3d vtSect = GetSectNormal();
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, vtNormal);
	vt.normalize();		
	AcGePoint3dArray arStartPt;	
	AcGePoint3d ptCir = ptStart + dStartDia * vt / 2.0;
	arStartPt.append(ptCir);
	for (int i = 1; i < 8; i++)
	{
		ptCir.rotateBy(PI / 4.0, vtSect, ptStart);
		arStartPt.append(ptCir);
	}
	arStartPt.append(ptStart + dStartDia * vt / 2.0);
	AcGePoint3dArray arEndPt;
	ptCir = ptEnd + dEndDia * vt / 2.0;
	arEndPt.append(ptCir);
	for (i = 1; i < 8; i++)
	{
		ptCir.rotateBy(PI / 4.0, vtSect, ptEnd);
		arEndPt.append(ptCir);
	}
	arEndPt.append(ptEnd + dEndDia * vt / 2.0);
	
	AecCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	curEle.idSubLay = m_idDoubleLayer;

	if (0 == nType)
	{
		curEle.idSubLay = idEndLayer;		// 两端图层
		curEle.dWidth = GetEndLineWidth();
		for (i = 0; i < 4; i++)
		{
			curEle.ptGe[0] = arStartPt.at(2 * i);
			curEle.ptGe[1] = arStartPt.at(2 * i + 1);
			curEle.ptGe[2] = arStartPt.at(2 * i + 2);
			cplCurve.append(curEle);
			curEle.ptGe[0] = arEndPt.at(2 * i);
			curEle.ptGe[1] = arEndPt.at(2 * i + 1);
			curEle.ptGe[2] = arEndPt.at(2 * i + 2);
			cplCurve.append(curEle);
		}
	}
	return TRUE;
}

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

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

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

double ImpHvacReducer::GetPlusEdge() const
{
	return 0.0;
}

AcGePoint3d ImpHvacReducer::GetEndPtAuto()
{	
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtEnd, vtOffset;
	double dPlus(0.0);

	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_StartDir, vtEnd);
	m_pXDataMap->GetAt(HRED_Offset, vtOffset);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus);
	vtEnd *= -1;

	double dSizeSub = GetMaxSizeSub();
	double dHoriLen = dSizeSub * 1.5 + MayAsMUnit(100);

	if (dHoriLen < MayAsMUnit(200.0))
		dHoriLen = MayAsMUnit(200.0);

	ptEnd = ptStart + (dHoriLen + dPlus * 2) * vtEnd;
	ptEnd += vtOffset;

	return ptEnd;
}

// 不支持既不同心又没有一边对其情况心情况
AcGePoint3d ImpHvacReducer::GetEndPtByangle()
{	
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtEnd, vtOffset;
	double dSizeSub(0.0), dPlus(0.0), dAngle(0.0);

	m_pXDataMap->GetAt(HRED_Angle, dAngle);
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_StartDir, vtEnd);
	m_pXDataMap->GetAt(HRED_Offset, vtOffset);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus);
	dSizeSub = GetMaxSizeSub();
	vtEnd *= -1;

	double dHoriLen(0.0);
	if (vtOffset.length() < 1e-3)	// 同心
		dHoriLen = dSizeSub * 0.5 / tan(dAngle*0.5);
	else
		dHoriLen = dSizeSub / tan(dAngle);

	double dAllDist = dHoriLen + dPlus * 2;
	if (dAllDist < MayAsMUnit(200))	// 避免天圆地方是看不出来
		dAllDist = MayAsMUnit(200);

	ptEnd = ptStart + dAllDist * vtEnd;
	ptEnd += vtOffset;

	return ptEnd;
}

AcGePoint3d ImpHvacReducer::GetEndPtByLen()
{	
	ASSERT(NULL != m_pXDataMap);

	double dLen(0.0);
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtEnd, vtOffset;

	m_pXDataMap->GetAt(HRED_Length, dLen);
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HRED_StartDir, vtEnd);
	vtEnd *= -1;
	
	if (dLen < MayAsMUnit(200))
		dLen = MayAsMUnit(200);
	
	vtOffset = ptEnd - ptStart;
	vtOffset = vtOffset.orthoProject(vtEnd);

	ptEnd = ptStart + dLen * vtEnd;
	ptEnd += vtOffset;

	return ptEnd;
}

double ImpHvacReducer::GetMaxSizeSub()
{
	ESection eStartSect = eRect;
	ESection eEndSect = eRect;
	double dStartWidth(0.0), dEndWidth(0.0), dStartThick(0.0), dEndThick(0.0), 
		dMaxSizeSub(0.0);

	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSect);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSect);
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
	m_pXDataMap->GetAt(HRED_EndThick, dEndThick);

	if (eStartSect == eEndSect)
	{
		double dWidthSub = fabs(dStartWidth - dEndWidth);
		if (eStartSect == eRect)
		{
			double dThickSub = fabs(dStartThick - dEndThick);
			dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
		}
		else
		{
			dMaxSizeSub = dWidthSub;
		}
	}
	else
	{
		if (eStartSect == eRect)
		{
			double dWidthSub = fabs(dStartWidth - dEndWidth);
			double dThickSub = fabs(dStartThick - dEndWidth);
			dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
		}
		else
		{
			double dWidthSub = fabs(dStartWidth - dEndWidth);
			double dThickSub = fabs(dStartWidth - dEndThick);
			dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
		}
	}
	return dMaxSizeSub;
}

AcGeVector3d ImpHvacReducer::normal() const
{
	return AcGeVector3d::kZAxis;
}

BOOL ImpHvacReducer::GetInterfaceSizeData(int nIndex, AecInterface& inf) const
{
	if(NULL == m_pXDataMap)
		return FALSE;

	// 获取截面类型
	ESection eSectType = eRect;

	// 获取接口截面、宽度、厚度数据key值
	LPCTSTR pszWidthKey, pszThickKey;
	switch (nIndex)
	{
	case 0:
		m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectType);
		pszWidthKey = ((eCircle == eSectType) ? HRED_StartDiameter : HRED_StartWidth);
		pszThickKey = HRED_StartThick;
		break;
	case 1:
		m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSectType);
		pszWidthKey = ((eCircle == eSectType) ? HRED_EndDiameter : HRED_EndWidth);
		pszThickKey = HRED_EndThick;
		break;
	default:
		return FALSE;
	}

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

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

	return TRUE;
}

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

	// 获取变径各点位置
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);

	// 求两端方向
	AcGeVector3d vtStart = GetSectNormal();
	AcGeVector3d vtEnd = -vtStart;

	AecInterface inf;
	inf.idOwner = m_pOwnerEnt->objectId();
	for (int nIndex = 0;nIndex < 2;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;
			}
		default:
			break;
		}
		arInfs.append(inf);
	}
	return true;
}