#include "stdafx.h"
#include "StdArx.h"

#include "THImpHvacReducer.h"
#include "TDbInterfaceRecord.h"
#include "TDbXDataMap.h"
#include "TDbInterfaceMsgWrite.h"
#include "math.h"
#include "dbxutil.h"
#include "dbsymutl.h"



using namespace TDb;

THImpHvacReducer::THImpHvacReducer()
{
}

THImpHvacReducer::~THImpHvacReducer()
{
}

Acad::ErrorStatus THImpHvacReducer::getClassID(CLSID* pClsid) const
{
// #if (ADS < 16)
// 	// {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E5}
// 	CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE5 }};
// #endif
// 
// #if (ADS == 16)
// 	// {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E5}
// 	CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE6 }};
// #endif
// 
// #if (ADS == 17)
// 	// {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E7}
// 	CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE7 }};
// #endif
// 
// #if (ADS == 18)
// 	CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
// #endif
// 
// #if (ADS == 19)
// 	CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
// #endif

	return Acad::eOk;
}

BOOL THImpHvacReducer::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
{
	ASSERT(NULL != pszName && NULL != pInfo);

	// 暖通基本参数设置
	if (0 == _tcsicmp(pszName, KEY_RUNTIME))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("变径"));
			pInfo->parlValues->Add(TDb::eReduce);
		}

		// 全局属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				pInfo->pXData->nVt = TXINT;
				pInfo->pXData->nVal = TDb::eReduce;
			}
			// 设置数据
			else
			{
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Type))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			HvacSectType eStartSect(TDb::eRectangular);
			HvacSectType eEndSect = eStartSect;
			m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSect);
			m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSect);
			if (eStartSect == eEndSect)
			{
				pInfo->parsValues->Add(_T("变径"));
				pInfo->parlValues->Add(0);
			}
			else
			{
				pInfo->parsValues->Add(_T("天圆地方"));
				pInfo->parlValues->Add(0);
			}
		}
		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HVAC_HasBaseLine))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("隐藏"));
			pInfo->parlValues->Add(0);
			pInfo->parsValues->Add(_T("显示"));
			pInfo->parlValues->Add(1);
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HVAC_IsSingleLine))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("双线"));
			pInfo->parlValues->Add(0);
			pInfo->parsValues->Add(_T("单线"));
			pInfo->parlValues->Add(1);
		}
		TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);

		return TRUE;
	}

	// 获得单线状态，当状态为单线时不显示
	BOOL bSingleLine = FALSE;
	m_pXDataMap->GetAt(HVAC_IsSingleLine, bSingleLine);

	// 变径参数数据设置
	// HRED_StartSectType和HVAC_SectType定义相同，为同一个值
	// 为区分显示名称，借用未被使用的KEY_StartSectType值来表达
	if (0 == _tcsicmp(pszName, KEY_StartSectType))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("矩形"));
			pInfo->parlValues->Add(TDb::eRectangular);
			pInfo->parsValues->Add(_T("圆形"));
			pInfo->parlValues->Add(TDb::eCircular);
		}

		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(HRED_StartSectType, *pInfo->pXData);
			}
			// 设置数据
			else
			{
				m_pXDataMap->SetAt(HRED_StartSectType, *pInfo->pXData);
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_EndSectType))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("矩形"));
			pInfo->parlValues->Add(TDb::eRectangular);
			pInfo->parsValues->Add(_T("圆形"));
			pInfo->parlValues->Add(TDb::eCircular);
		}

		return TRUE;
	}
	
	// 尺寸计算方式
	if (0 == _tcsicmp(pszName, HRED_ComputeType))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("自动计算"));
			pInfo->parlValues->Add(TDb::eAuto);
			pInfo->parsValues->Add(_T("角度"));
			pInfo->parlValues->Add(TDb::eAngle);
			pInfo->parsValues->Add(_T("长度"));
			pInfo->parlValues->Add(TDb::eLength);
		}
		return TRUE;
	}

	// 具体设置角度或长度
	HvacReduComType eComTyep = TDb::eAuto;
	m_pXDataMap->GetAt(HRED_ComputeType, (int&)eComTyep);
	if (0 == _tcsicmp(pszName, HRED_Angle) && eComTyep == TDb::eAngle
		|| 0 == _tcsicmp(pszName, HRED_Length) && eComTyep == TDb::eLength)
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{		
				if (0 == _tcsicmp(pszName, HRED_Angle) && eComTyep == TDb::eAngle)
				{
					m_pXDataMap->GetAt(HRED_Angle, *pInfo->pXData);
					pInfo->pXData->dVal[0] *= 180/PI;
				}
			}
			else	// 设置数据
			{					
				if (0 == _tcsicmp(pszName, HRED_Angle) && eComTyep == TDb::eAngle)
					m_pXDataMap->SetAt(HRED_Angle, pInfo->pXData->dVal[0] * PI / 180);
				else
					m_pXDataMap->SetAt(HRED_Length, pInfo->pXData->dVal[0]);		

				// 先记录更新前信息
				AcGePoint3dArray ptArrOrig;
				AcDbObjectIdArray idArr;
				TAuxTools::GetInterfacePoint(this, ptArrOrig);
				TAuxTools::GetInterfaceId(this, idArr);
			
				IsValid(NULL);

				// 更新连接实体
				if (NULL != m_pOwnerEnt)
				{
					AcGePoint3dArray ptArrNew;
					TAuxTools::GetInterfacePoint(this, ptArrNew);
					TAuxTools::DealWithConEnt(idArr, ptArrOrig, ptArrNew, m_pOwnerEnt->objectId());

					m_pOwnerEnt->close();
					acedPostCommand(_T("redraw\n"));	
				}	
			
				pInfo->pXData->nVt = 0;
			}
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_StartWidth))
	{
		// 获得截面，当截面不为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular != eSectType);
		pInfo->bEditable = pInfo->bVisible;
		TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_StartThick))
	{
		// 获得截面，当截面不为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular != eSectType);
		pInfo->bEditable = pInfo->bVisible;

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_EndWidth))
	{
		// 获得截面，当截面不为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular != eSectType);
		pInfo->bEditable = pInfo->bVisible;
		TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_EndThick))
	{
		// 获得截面，当截面不为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular != eSectType);
		pInfo->bEditable = pInfo->bVisible;

		return TRUE;
	}

	// HRED_StartDiameter和HRED_StartWidth定义相同，为同一个值
	// 为区分显示名称，借用未被使用的KEY_StartDiameter值来表达
	if (0 == _tcsicmp(pszName, KEY_StartDiameter))
	{
		// 获得截面，当截面为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular == eSectType);
		pInfo->bEditable = pInfo->bVisible;

		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(HRED_StartDiameter, *pInfo->pXData);
			}
			// 设置数据
			else
			{
				TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, HRED_StartDiameter, pInfo);
			}
		}

		return TRUE;
	}

	// HRED_EndDiameter和HRED_EndWidth定义相同，为同一个值
	// 为区分显示名称，借用未被使用的KEY_EndDiameter值来表达
	if (0 == _tcsicmp(pszName, KEY_EndDiameter))
	{
		// 获得截面，当截面为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular == eSectType);
		pInfo->bEditable = pInfo->bVisible;

		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(HRED_EndDiameter, *pInfo->pXData);
			}
			// 设置数据
			else
			{
				TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, HRED_EndDiameter, pInfo);
			}
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_StartPoint))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 整体移动
		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 改变顶点变换行为
			AcGePoint3d ptStart;
			m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
			AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - ptStart;

			AcGeMatrix3d mat;
			mat.setToTranslation(offset);
			transformBy(mat);
//			pInfo->pXData->nVt = 0;	// 设置处理完成标识
			TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HRED_EndPoint))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 整体移动
		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 改变顶点变换行为
			AcGePoint3d ptEnd;
			m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
			AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - ptEnd;

			AcGeMatrix3d mat;
			mat.setToTranslation(offset);
			transformBy(mat);
//			pInfo->pXData->nVt = 0;	// 设置处理完成标识
			TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);
		}

		return TRUE;
	}

	return FALSE;
}

void THImpHvacReducer::GetTips(CMapStringToString& mapLable2Tip) const
{
}

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

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

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

// 	double dOffset = 0.0;
// 	m_pXDataMap->GetAt(HRED_Offset, dOffset);
// 	acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t偏心距离：%.2f"), dOffset);

	// 圆型截面显示直径
	if (TDb::eCircular == 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 (TDb::eCircular == 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 THImpHvacReducer::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 THImpHvacReducer::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 THImpHvacReducer::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 THImpHvacReducer::IsSingleLine() const
{
	ASSERT(NULL != m_pXDataMap);

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

	return bSingleLine;
}

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

	AcGeVector3d vtSta;
	m_pXDataMap->GetAt(HRED_StartDir, vtSta);
	if (!vtSta.isParallelTo(TAuxTools::GetUcsZvt()))
	{
		// Lixl变径为倾斜方向时（不平行Z轴，不垂直Z轴）返回map里面的方向，不向XY平面投影
		if (!vtSta.isPerpendicularTo(TAuxTools::GetUcsZvt()))
			return vtSta;
		else
			vtSta = vtSta.orthoProject(TAuxTools::GetUcsZvt());
	}	
	return vtSta;

// 获取变径各点位置
// 	double dOffsetH = 0.0;
// 	AcGePoint3d ptStart, ptEnd;
// 	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
// 	m_pXDataMap->GetAt(HRED_Offset, dOffsetH);
// 	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
// 	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
// 	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
// 
// 	// 计算起始侧面法向量
// 	AcGePlane plan;
// 	plan.set(ptStart, vtNormal);
// 	ptEnd = ptEnd.orthoProject(plan);
// 	AcGeVector3d vtStart = ptStart - ptEnd;
// 	double dAngle = asin(dOffsetH / ptStart.distanceTo(ptEnd));
// 	vtStart.rotateBy(-dAngle, vtNormal);
// 	return vtStart.normalize();
}

void THImpHvacReducer::GetKindName(CString& sName)
{
	sName = _T("TCH_HREDUCER");
}

int THImpHvacReducer::GetInterfaceCount() const
{
	// 返回接口个数
	return 2;
}

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

	// 获取截面类型
	TDb::HvacSectType eSectType = TDb::eRectangular;

	// 获取接口截面、宽度、厚度数据key值
	LPCTSTR pszWidthKey, pszThickKey;
	switch (nIndex)
	{
	case 0:
		m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectType);
		pszWidthKey = ((TDb::eCircular == eSectType) ? HRED_StartDiameter : HRED_StartWidth);
		pszThickKey = HRED_StartThick;
		break;
	case 1:
		m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSectType);
		pszWidthKey = ((TDb::eCircular == 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);

	// 设置接口数据
	pipeInterface.SetType(eSectType);
	pipeInterface.SetSize(dWidth, dThick);

	return TRUE;
}

BOOL THImpHvacReducer::GetInterface(int nIndex, TInterface& pipeInterface) 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;

	AcDbObjectId id;
	switch(nIndex)
	{
	case 0:
		// 如果起始接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(nIndex, pipeInterface);
			return TRUE;
		}
		// 如果起始接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(nIndex, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtStart);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptStart);
		GetInterfaceSizeData(nIndex, pipeInterface);
		return TRUE;
	case 1:
		// 如果末尾接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(nIndex, pipeInterface);
			return TRUE;
		}
		// 如果末尾接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(nIndex, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtEnd);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptEnd);
		GetInterfaceSizeData(nIndex, pipeInterface);
		return TRUE;
	}

	return FALSE;
}

BOOL THImpHvacReducer::GetInterface(const AcGePoint3d& ptConnect,TInterface& pipeInterface) 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;

	// 计算测试点到始末点的距离
	double dDist1 = ptConnect.distanceTo(ptStart);
	double dDist2 = ptConnect.distanceTo(ptEnd);
	AcDbObjectId id;

	// 位于起始点
	if (dDist1 < 1.e-3)
	{
		// 如果起始接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(0, pipeInterface);
			return TRUE;
		}
		// 如果起始接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(0, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtStart);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptStart);
		GetInterfaceSizeData(0, pipeInterface);
		return TRUE;
	}

	// 位于末尾点
	if (dDist2 < 1.e-3)
	{
		// 如果末尾接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(1, pipeInterface);
			return TRUE;
		}
		// 如果末尾接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(1, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtEnd);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptEnd);
		GetInterfaceSizeData(1, pipeInterface);
		return TRUE;
	}

	return FALSE;
}

BOOL THImpHvacReducer::HasInterface(const AcGePoint3d& ptConnect,const AcGeVector3d& vtDir)
{
	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;

	// 计算测试点到始末点的距离
	double dDist1 = ptConnect.distanceTo(ptStart);
	double dDist2 = ptConnect.distanceTo(ptEnd);

	// 位于起始点
	if (dDist1 < 1.e-3)
		return (vtDir.isParallelTo(vtStart));

	// 位于末尾点
	if (dDist2 < 1.e-3)
		return (vtDir.isParallelTo(vtEnd));

	return FALSE;
}

BOOL THImpHvacReducer::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;

	// 打开对象
	AcDbEntity* pEnt;
	if (Acad::eOk != acdbOpenObject(pEnt, idConnect, AcDb::kForRead))
		return FALSE;

	// 检查对象类型，是否是暖通管件
	if (!(pEnt->isKindOf(TDbHvacDuct::desc()) || pEnt->isKindOf(TDbHvacFitting::desc())
		|| pEnt->isKindOf(TDbHvacEquipment::desc())))
	{
		pEnt->close();
		return FALSE;
	}

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

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

	// 计算测试点到始末点的距离
	double dDist1 = ptConnect.distanceTo(ptStart);
	double dDist2 = ptConnect.distanceTo(ptEnd);

	// 基类指针
	TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
	ASSERT(NULL != pInterfaceObj);

	// 位于起始点
	if (dDist1 < 1.e-3 && pInterfaceObj->HasInterface(ptStart, vtStart))
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, idConnect);
		pEnt->close();
		return TRUE;
	}

	// 位于末尾点
	if (dDist2 < 1.e-3 && pInterfaceObj->HasInterface(ptEnd, vtEnd))
	{
		m_pXDataMap->SetAt(KEY_IDCNT2, idConnect);
		pEnt->close();
		return TRUE;
	}

	pEnt->close();

	return FALSE;
}

BOOL THImpHvacReducer::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;

	// 浅层次删除; 命名字典中的关系,需要外面移除关系,只移除内部关系
	AcDbObjectId id;
	m_pXDataMap->GetAt(KEY_IDCNT1, id);
	if (id == idConnect)
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, AcDbObjectId::kNull);
		return TRUE;
	}

	m_pXDataMap->GetAt(KEY_IDCNT2, id);
	if (id == idConnect)
	{
		m_pXDataMap->SetAt(KEY_IDCNT2, AcDbObjectId::kNull);
		return TRUE;
	}

	return FALSE;
}

BOOL THImpHvacReducer::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
{
	if (NULL == m_pXDataMap)
		return FALSE;

	// 获得消息传递设置, 确定是否传递消息
	CString sDispatch = _T("0");
	GetGlobalContext(KEY_DISPATCHMSG, sDispatch);
	BOOL bDispatch = (_ttoi(sDispatch) != 0);

	BOOL bMsgTranslate = FALSE;
	// 获得消息类型, 根据消息类型处理
	TDb::InterfaceOper eOper = iModiMsg.GetInterfaceOper();
	switch (eOper)
	{
	case TDb::eMoveGripPoint:
		// 夹点移动消息处理
		bMsgTranslate =	OnMoveGripPointMsgNotify(iModiMsg, iModiMsgs);
		break;
	case TDb::eTransformBy:
		// 对象移动消息处理
		bMsgTranslate =	OnTransformMsgNotify(iModiMsg, iModiMsgs);
		break;
	case TDb::eSize:
		// 尺寸调整消息处理
		bMsgTranslate = OnSizeMsgNotify(iModiMsg, iModiMsgs);
		break;
	default:
		return bMsgTranslate;
	}

	// 记录修改标识
	if (m_pOwnerEnt != NULL)
		m_pOwnerEnt->recordGraphicsModified();

	return bMsgTranslate;
}

Acad::ErrorStatus THImpHvacReducer::ExplodeOrDraw3d(XExplodeDraw& mode) const
{
	if (NULL == m_pXDataMap)
		return Acad::eOk;
	
	// 变径类型
	TDb::HvacSectType eStartSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

	// 始端截面
	switch (eStartSectType)
	{
	case TDb::eRectangular:		// 矩形
		// 末端截面
		switch (eEndSectType)
		{
		case TDb::eRectangular:	// 矩形
			ExplodeRect2Rect3d(mode);
			break;
		case TDb::eCircular:	// 园形
			ExplodeRect2Cir3d(mode);
			break;
		case TDb::eOblate:		// 扁圆形
			break;
		}
		break;

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

	case TDb::eOblate:			// 扁圆形
		// 末端截面
		switch (eEndSectType)
		{
		case TDb::eRectangular:	// 矩形
			break;
		case TDb::eCircular:	// 园形
			break;
		case TDb::eOblate:		// 扁圆形
			break;
		}
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacReducer::ExplodeOrDraw2d(XExplodeDraw& mode) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}
	
	TComplexCurve cplCurve;
	MakeCurves(cplCurve);
	
	TDbExtentsEdge edage;
	edage.SetEdage(cplCurve);
	
	BOOL bWeight = FALSE;
		
	AcDbObjectId idReal = ((TDbInterfacesObj*)m_pOwnerEnt)->layerId();
	AcDbObjectId idDash = ((TDbInterfacesObj*)m_pOwnerEnt)->DashLayer();
	AcDbObjectId idCent = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
	
	edage.ExplodeOrDraw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);	

	return Acad::eOk;
}

AcDbPolyline* THImpHvacReducer::MakePolyCurve() const
{
	if (NULL == m_pXDataMap)
		return NULL;

	// 变径类型
	TDb::HvacSectType eStartSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType,(int&) eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

	if (IsHorzAlignment())		// 水平
	{
		switch (eStartSectType)
		{
		case TDb::eRectangular:		// 矩形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeRect2RectPolyCurve();
				break;
			case TDb::eCircular:	// 园形
				return MakeRect2CirPolyCurve();
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eCircular:		// 园形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeCir2RectPolyCurve();
				break;
			case TDb::eCircular:	// 园形
				return MakeCir2CirPolyCurve();
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eOblate:			// 扁圆形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				break;
			case TDb::eCircular:	// 园形
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if(IsVertAlignment())	// 立管
	{
		switch (eStartSectType)
		{
		case TDb::eRectangular:		// 矩形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeRect2RectPolyCurveVer();
				break;
			case TDb::eCircular:	// 园形
				return MakeRect2CirPolyCurveVer();
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;			
		case TDb::eCircular:		// 园形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeCir2RectPolyCurveVer();
				break;
			case TDb::eCircular:	// 园形
				return MakeCir2CirPolyCurveVer();
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;			
		case TDb::eOblate:			// 扁圆形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				break;
			case TDb::eCircular:	// 园形
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if (IsInclineAlignment())
	{
		switch (eStartSectType)
		{
		case TDb::eRectangular:
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 方对方
				return MakeRect2RectPolyCurve();
				break;
			case TDb::eCircular:	// 方对圆
				return MakeRect2CirPolyCurve();
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eCircular:
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 圆对方
				return MakeCir2RectPolyCurve();
				break;
			case TDb::eCircular:	// 圆对圆
				return MakeIncCir2CirPolyCurve();
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		}
	}

	return NULL;
}

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

	// 变径类型
	TDb::HvacSectType eStartSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

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

	return FALSE;
}

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

	// 变径类型
	TDb::HvacSectType eStartSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

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

	return FALSE;
}

BOOL THImpHvacReducer::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 变径类型
	TDb::HvacSectType eStartSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType,(int&) eStartSectType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSectType);

	if (IsHorzAlignment())			// 水平
	{
		switch (eStartSectType)
		{
		case TDb::eRectangular:		// 矩形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeRect2RectPolyCurveFaces(arFaces);
				break;
			case TDb::eCircular:	// 园形
				return MakeRect2CirPolyCurveFaces(arFaces);
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eCircular:		// 园形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeCir2RectPolyCurveFaces(arFaces);
				break;
			case TDb::eCircular:	// 园形
				return MakeCir2CirPolyCurveFaces(arFaces);
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eOblate:			// 扁圆形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				break;
			case TDb::eCircular:	// 园形
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		}
	}
	else if(IsVertAlignment())	// 立管
	{
		switch (eStartSectType)
		{
		case TDb::eRectangular:		// 矩形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeRect2RectPolyCurveFacesVer(arFaces);
				break;
			case TDb::eCircular:	// 园形
				return MakeRect2CirPolyCurveFacesVer(arFaces);
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eCircular:		// 园形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeCir2RectPolyCurveFacesVer(arFaces);
				break;
			case TDb::eCircular:	// 园形
				return MakeCir2CirPolyCurveFacesVer(arFaces);
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		case TDb::eOblate:			// 扁圆形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				break;
			case TDb::eCircular:	// 园形
				break;
			case TDb::eOblate:		// 扁圆形
				break;
			}
			break;
		}//倾斜变径二维先按水平画Lixl
	}
	else if (IsInclineAlignment())
	{
		switch (eStartSectType)
		{
		case TDb::eRectangular:		// 矩形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeRect2RectPolyCurveFaces(arFaces);
				break;
			case TDb::eCircular:	// 园形
				return MakeRect2CirPolyCurveFaces(arFaces);
				break;
			}
			break;
		case TDb::eCircular:		// 园形
			switch (eEndSectType)
			{
			case TDb::eRectangular:	// 矩形
				return MakeCir2RectPolyCurveFaces(arFaces);
				break;
			case TDb::eCircular:	// 园形
				return MakeIncCir2CirPolyCurveFaces(arFaces);
				break;
			}
			break;
		}
	}

	return FALSE;
}

Acad::ErrorStatus THImpHvacReducer::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);

	// 传递消息
	if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
	{
		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		AcDbDatabase* pDb = m_pOwnerEnt->database();
		if (pDb == NULL) pDb = acdbCurDwg();

		AcDbObjectId idModel;
		AcDbBlockTable* pTable = NULL;
		pDb->getBlockTable(pTable, AcDb::kForRead);
		if (pTable != NULL)
		{
			pTable->getAt(ACDB_MODEL_SPACE, idModel);
			pTable->close();
		}
		
		if (idModel == m_pOwnerEnt->blockId())
		{
			// 写入接口更改消息
			TInterfaceModifyMsg iMsg;
			iMsg.SetInterfaceOper(TDb::eTransformBy);
			iMsg.SetMsgValidate(TRUE);
			iMsg.SetTransform(xform);
			iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

			TDbInterfaceMsgWrite msgWrite;
			msgWrite.WriteInterfaceMsg(iMsg);

			//更新接口记录接口信息
			UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
		}
	}

	return Acad::eOk;
}

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

	return ePos;
}

Acad::ErrorStatus THImpHvacReducer::getStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

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

	stretchPoints.append(ptStart);
	stretchPoints.append(ptEnd);
	
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacReducer::getGripPoints(AcGePoint3dArray& gripPoints,
													AcDbIntArray& osnapModes,
													AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

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

	//夹点
	gripPoints.append(ptStart); //STA
	gripPoints.append(ptEnd); //END

	AcGeVector3d vtStart = GetSectNormal();
	vtStart.normalize();

	//增加2个命令夹点
	AcGePoint3d ptGeCmd1,ptGeCmd2;	//按 10 个像素点
//	double dCmd = PixelToWcs(10);
	ptGeCmd1 = ptStart + g_dCmdOff * vtStart;
	ptGeCmd2 = ptEnd - g_dCmdOff * vtStart;
	gripPoints.append(ptGeCmd1); //cmd1
	gripPoints.append(ptGeCmd2); //cmd2

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacReducer::getOsnapPoints(AcDb::OsnapMode osnapMode,
												 INT_PTR gsSelectionMark,
												 const AcGePoint3d& pickPoint,
												 const AcGePoint3d& lastPoint,
												 const AcGeMatrix3d& viewXform,
												 AcGePoint3dArray& snapPoints,
												 AcDbIntArray& geomIds) const	
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

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

	// 根据捕捉模式处理
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		snapPoints.append(ptStart);
		snapPoints.append(ptEnd);
		break;
	case AcDb::kOsModeMid:
		break;
	case AcDb::kOsModeCen:
		break;
	case AcDb::kOsModePerp:
		break;
	case AcDb::kOsModeNear:
		break;
	}

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacReducer::moveStretchPointsAt(const AcDbIntArray& indices,
													  const AcGeVector3d& offset)
{
	if (indices.length() < 2)
		return Acad::eNotImplementedYet;

	AcGePoint3d ptStart, ptEnd, ptMsg;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	ptStart += offset;
	ptEnd += offset;				
	m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);

	if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
	{
		//更新接口记录接口信息
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), offset);
		return Acad::eOk;
	}

	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus THImpHvacReducer::moveGripPointsAt(const AcDbIntArray& indices,
												   const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);
	int nSize = indices.length();
	if (nSize > 0) 
	{
		// 取得位置点
		AcGePoint3d ptStart, ptEnd, ptMsg;
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
		
		int nIndex = indices.first();	// 选择多个夹点,以first为准
		TDb::Position ePos = ExplainGripIndex(nIndex);
		
		TInterfaceModifyMsg iMsg;
		TDbInterfaceMsgWrite msgWrite;
		AcDbSoftPointerId idOwner;
		m_pXDataMap->GetAt(KEY_THISID, idOwner);		
		switch(ePos)
		{
		case TDb::eStart:
		case TDb::eEnd:
			MoveGripRandom(ePos, offset);
			break;
/*			{
				ptStart += offset;
				ptEnd += offset;				
				m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
				m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);

				// 写入接口更改消息
				iMsg.SetMsgPoint(ptStart);//new pos
				iMsg.SetGripPosition(ePos);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
				iMsg.SetMsgOperateOn(idOwner);
				msgWrite.WriteInterfaceMsg(iMsg);
				
				//更新接口记录接口信息
				AcGeMatrix3d xform;
				xform.setToTranslation(offset);
				UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);				
				break;
			}
		case TDb::eEnd:
			{
				ptStart += offset;
				ptEnd += offset;				
				m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
				m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);

				// 写入接口更改消息
				iMsg.SetMsgPoint(ptEnd);//new pos
				iMsg.SetGripPosition(ePos);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
				iMsg.SetMsgOperateOn(idOwner);
				msgWrite.WriteInterfaceMsg(iMsg);
				
				//更新接口记录接口信息
				AcGeMatrix3d xform;
				xform.setToTranslation(offset);
				UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
				break;
			}
*/		case TDb::eCommand0:
			{
				// 写入接口更改消息
				iMsg.SetMsgPoint(ptStart);
				iMsg.SetGripPosition(ePos);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::ePipe, 0);				
				iMsg.SetMsgOperateOn(idOwner);
				msgWrite.WriteInterfaceMsg(iMsg);				
				
				acedPostCommand(_T("\33"));
				CString csCmd;
				GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, csCmd);
				if (!csCmd.IsEmpty())
				{
					csCmd += _T("\n");
					acedPostCommand(csCmd);
				}
				break;
			}			
		case TDb::eCommand1:
			{
				// 写入接口更改消息
				iMsg.SetMsgPoint(ptEnd);
				iMsg.SetGripPosition(ePos);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::ePipe, 0);
				iMsg.SetMsgOperateOn(idOwner);				
				msgWrite.WriteInterfaceMsg(iMsg);				
				
				acedPostCommand(_T("\33"));
				CString csCmd;
				GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, csCmd);
				if (!csCmd.IsEmpty())
				{
					csCmd += _T("\n");
					acedPostCommand(csCmd);
				}
				break;
			}			
		default:
			break;
		}
	}
	return Acad::eOk;
}

// 拖拽管件，支持转向等操作
Acad::ErrorStatus THImpHvacReducer::MoveGripRandom(TDb::Position ePos, const AcGeVector3d& offset )
{	
	AcGePoint3d ptDrag;
	if (ePos == eStart)
		m_pXDataMap->GetAt(HRED_StartPoint, ptDrag);
	else if (ePos == eEnd)
		m_pXDataMap->GetAt(HRED_EndPoint, ptDrag);
	
	TInterfaceModifyMsg iMsg;
	iMsg.SetMsgPoint(ptDrag);
	iMsg.SetGripPosition(ePos);
	iMsg.SetMoveGripOffset(offset);
	iMsg.SetMsgValidate(TRUE);
	iMsg.SetInterfaceOper(eNewCommand);
	iMsg.SetPreviewObjToCreate(eReduce, 0);

	// 写入接口更改消息
	AcDbSoftPointerId idOwner;
	m_pXDataMap->GetAt(KEY_THISID, idOwner);
	iMsg.SetMsgOperateOn(idOwner);
	TDbInterfaceMsgWrite msgWrite;
	msgWrite.WriteInterfaceMsg(iMsg);

	// 发送消息
	acedPostCommand(_T("\33"));
	acedPostCommand(_T("znyd\n"));
 
	return Acad::eOk;
}

BOOL THImpHvacReducer::OnMoveGripPointMsgNotify(const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs)
{
	if (!TAuxTools::IsAutoWorkOffset())
		return FALSE;

	ASSERT(NULL != m_pXDataMap);
	
	BOOL bMsgTranslate = FALSE;
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
		return FALSE;
	
	AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
	if (vtOffset.isZeroLength()) 
		return FALSE;
	
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	AcGePoint3d ptGeSOld = ptStart;
	AcGePoint3d ptGeEOld = ptEnd;
	
	int nPos = iModiMsg.GetGripPosition();
	if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
	{
		AcGeVector3d vtSta, vtEnd;
		m_pXDataMap->GetAt(HRED_StartDir, vtSta);
		vtEnd = -vtSta;
		
		ptStart += vtOffset;
		ptEnd += vtOffset;
		m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
		m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);
				
		// 构造接口消息传递 开始端检查
		AcDbObjectId idT;
		if (FindConnect(ptGeSOld, vtSta, m_pOwnerEnt->objectId(), idT)) // sta 点的接口
		{
			TInterfaceModifyMsg msg;
			msg.SetMsgPoint(ptGeSOld);
			msg.SetMoveGripOffset(vtOffset);
			msg.SetMsgOperateOn(idT);
			msg.SetGripPosition(eStart);
			iModiMsgs.append(msg);
			bMsgTranslate = TRUE;
		}
		
		// 构造接口消息传递 末端检查
		if (FindConnect(ptGeEOld, vtEnd, m_pOwnerEnt->objectId(), idT)) // end 点的接口
		{
			TInterfaceModifyMsg msg;
			msg.SetMsgPoint(ptGeEOld);
			msg.SetMoveGripOffset(vtOffset);
			msg.SetMsgOperateOn(idT);
			msg.SetGripPosition(eEnd);
			iModiMsgs.append(msg);
			bMsgTranslate = TRUE;
		}
		
		// 更新模型空间的扩展字典的注册的接口数据
		AcGeMatrix3d xform;
		xform.setToTranslation(vtOffset);
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
	}
				
	return bMsgTranslate;}

BOOL THImpHvacReducer::OnTransformMsgNotify(const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs)
{
	if (!TAuxTools::IsAutoWorkOffset())
		return FALSE;

	ASSERT(NULL != m_pXDataMap);

	BOOL bMsgTranslate = FALSE;
	
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
		return FALSE;
	
	AcGeMatrix3d mtTrans = iModiMsg.GetTransform();
	AcGeVector3d vtSta, vtEnd;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HRED_StartDir, vtSta);
	vtEnd = -vtSta;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	AcGePoint3d ptGeSOld = ptStart;
	AcGePoint3d ptGeEOld = ptEnd;
	
	ptStart.transformBy(mtTrans);
	ptEnd.transformBy(mtTrans);
	m_pXDataMap->SetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);
		
	// 构造接口消息传递 开始端检查
	AcDbObjectId idT;
	if (FindConnect(ptGeSOld, vtSta, m_pOwnerEnt->objectId(), idT)) // sta 点的接口
	{
		TInterfaceModifyMsg msg;
		msg.SetMsgPoint(ptGeSOld);
		msg.SetTransform(mtTrans);
		msg.SetMsgOperateOn(idT);
		iModiMsgs.append(msg);
		bMsgTranslate = TRUE;
	}
	
	// 构造接口消息传递 末端检查
	if (FindConnect(ptGeEOld, vtEnd, m_pOwnerEnt->objectId(), idT)) // end 点的接口
	{
		TInterfaceModifyMsg msg;
		msg.SetMsgPoint(ptGeEOld);
		msg.SetTransform(mtTrans);
		msg.SetMsgOperateOn(idT);
		iModiMsgs.append(msg);
		bMsgTranslate = TRUE;
	}
	
	// 更新模型空间的扩展字典的注册的接口数据
	UpdateInterfaceRec(m_pOwnerEnt->objectId(), mtTrans);
	
	return bMsgTranslate;
}

BOOL THImpHvacReducer::OnSizeMsgNotify(const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs)
{
	ASSERT(NULL != m_pXDataMap);

	BOOL bSizeChanged = FALSE;
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
		return FALSE;

	// 获取消息发送方截面类型,暂未实现
	HvacSectType eChangedSect = (HvacSectType)-1;
	// ...

	AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
	AcGePoint3d ptOrigStart, ptOrigEnd, ptMsg;
	m_pXDataMap->GetAt(HRED_StartPoint, ptOrigStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptOrigEnd);
	ptMsg = iModiMsg.GetMsgPoint();

	// 先检查接口是否真实连接了实体
	BOOL bStartCon(FALSE), bEndCon(FALSE);
	AcDbObjectId idStart(AcDbObjectId::kNull), idEnd(AcDbObjectId::kNull);
	m_pXDataMap->GetAt(KEY_IDCNT1, idStart);
	m_pXDataMap->GetAt(KEY_IDCNT2, idEnd);

	OPENOBJ_BEGIN(idStart, AcDb::kForRead, TDbInterfacesObj, pIfObj);
	if (NULL != pIfObj)
	{
		AcGePoint3d ptFind = ptOrigStart;
		if (ptMsg.distanceTo(ptOrigStart) < 1)
			ptFind += vtOffset;

		if (pIfObj->GetInterface(ptFind, TInterface()))
			bStartCon = TRUE;
	}
	OPENOBJ_END();

	OPENOBJ_BEGIN(idEnd, AcDb::kForRead, TDbInterfacesObj, pIfObj);
	if (NULL != pIfObj)
	{
		AcGePoint3d ptFind = ptOrigEnd;
		if (ptMsg.distanceTo(ptOrigEnd) < 1)
			ptFind += vtOffset;

		if (pIfObj->GetInterface(ptFind, TInterface()))
			bEndCon = TRUE;		
	}
	OPENOBJ_END();

	HvacReduComType eComType = TDb::eAuto;
	HvacSectType eSect = TDb::eRectangular;
 	m_pXDataMap->GetAt(HRED_ComputeType, (int&)eComType);
 	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);

	// 设置各接口新尺寸
	double dNewWidth, dNewHeigh(0.0);
	AcGeVector3d vtNormal = normal();
	if (eSect == TDb::eRectangular)
	{
		AcGeVector3d vtWidthDir, vtHeighDir;
		iModiMsg.GetSizeDir(vtWidthDir, vtHeighDir);

		// 判断是否是空间连接或导致宽高互换
		if (vtHeighDir.isParallelTo(vtNormal))
			iModiMsg.GetSize(dNewWidth, dNewHeigh);
		else
			iModiMsg.GetSize(dNewHeigh, dNewWidth);
	}
	else
	{
		iModiMsg.GetSize(dNewWidth, dNewHeigh);
		dNewHeigh = dNewWidth;
	}

	// 看哪个接口方向修改了尺寸，修改相应接口尺寸
	int nModifyFrom(0);	// 修改方向， 0：首，1：尾
	if (ptMsg.distanceTo(ptOrigStart) < 1)
	{
		if (eChangedSect == -1)
			m_pXDataMap->GetAt(HRED_StartSectType, (int&)eChangedSect);
		else
			m_pXDataMap->SetAt(HRED_StartSectType, eChangedSect);
	
		AcGePoint3d ptNewStart = ptOrigStart + vtOffset;
		m_pXDataMap->SetAt(HRED_StartPoint, ptNewStart);
		if (eChangedSect == TDb::eRectangular)
		{
			m_pXDataMap->SetAt(HRED_StartWidth, dNewWidth);
			m_pXDataMap->SetAt(HRED_StartThick, dNewHeigh);
		}
		else if (eChangedSect == TDb::eCircular)
		{
			m_pXDataMap->SetAt(HRED_StartDiameter, dNewWidth);
		}

		AcGeVector3d vtFitOff;
		m_pXDataMap->GetAt(HRED_Offset, vtFitOff);
		vtFitOff -= vtOffset;
		m_pXDataMap->SetAt(HRED_Offset, vtFitOff);

		bSizeChanged = TRUE;
		nModifyFrom = 0;
	}
	else if (ptMsg.distanceTo(ptOrigEnd) < 1)
	{
		if (eChangedSect == -1)
			m_pXDataMap->GetAt(HRED_EndSectType, (int&)eChangedSect);
		else
			m_pXDataMap->SetAt(HRED_EndSectType, eChangedSect);
	
		AcGePoint3d ptNewEnd = ptOrigEnd + vtOffset;
		m_pXDataMap->SetAt(HRED_EndPoint, ptNewEnd);
		if (eChangedSect == TDb::eRectangular)
		{
			m_pXDataMap->SetAt(HRED_EndWidth, dNewWidth);
			m_pXDataMap->SetAt(HRED_EndThick, dNewHeigh);
		}
		else if (eChangedSect == TDb::eCircular)
		{
			m_pXDataMap->SetAt(HRED_EndDiameter, dNewWidth);
		}

		AcGeVector3d vtFitOff;
		m_pXDataMap->GetAt(HRED_Offset, vtFitOff);
		vtFitOff += vtOffset;
		m_pXDataMap->SetAt(HRED_Offset, vtFitOff);

		bSizeChanged = TRUE;
		nModifyFrom = 1;	
	}	

	// 由于尺寸变化，调用内部校正函数，接口点必须沿各向量方向校正
	IsValid(NULL);
	AcGePoint3d ptNewStart, ptNewEnd;
	m_pXDataMap->GetAt(HRED_StartPoint, ptNewStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptNewEnd);

	// 根据最终位移向量，处理接口端连接实体位置
 	AcGeVector3d vtStartOff = ptNewStart - ptOrigStart;
 	AcGeVector3d vtEndOff = ptNewEnd - ptOrigEnd;
 	if (vtStartOff.length() > 1e-6)
		UpdateInterfaceRec(id, ptOrigStart, ptNewStart);
 	if (vtEndOff.length() > 1e-6)
		UpdateInterfaceRec(id, ptOrigEnd, ptNewEnd);

	// 纠正由于风管边壁偏移导致的向量差
 	AcGeVector3d vtStart;
 	m_pXDataMap->GetAt(HRED_StartDir, vtStart);
	AcGePoint3d ptFixedStart(ptOrigStart), ptFixedEnd(ptOrigEnd);
	if (nModifyFrom == 0)
	{
		ptFixedStart += vtOffset;

		double dAngle = vtStartOff.angleTo(vtStart);
		double dLen = vtStartOff.length() * cos(dAngle);
		vtStartOff.setToProduct(vtStart, dLen);
	}
	else if (nModifyFrom == 1)
	{
		ptFixedEnd += vtOffset;
	
		double dAngle = vtEndOff.angleTo(-vtStart);
		double dLen = vtEndOff.length() * cos(dAngle);
		vtEndOff.setToProduct(-vtStart, dLen);
	}

 	if (vtStartOff.length() > 1e-6 && bStartCon)
 		TAuxTools::DealWithConEnt(idStart, vtStartOff, id, ptFixedStart);
 	if (vtEndOff.length() > 1e-6 && bEndCon)
 		TAuxTools::DealWithConEnt(idEnd, vtEndOff, id, ptFixedEnd);
 
	return bSizeChanged;
}


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

	double dStartWidth = 200.0, dStartThick = 200.0, dEndWidth = 400.0, 
		dEndThick = 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));		
	}
	
	mode.DrawMesh(5, 4, arPoint.asArrayPtr());
}

// 构建外轮廓（方对方）
AcDbPolyline* THImpHvacReducer::MakeRect2RectPolyCurve() const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = 200.0, dEndWidth = 400.0, dPlusEdge = GetPlusEdge();
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	TDb::HvacSectType eSectTypeStart = TDb::eRectangular, eSectTypeEnd = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectTypeStart);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSectTypeEnd);
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);		
	if (!vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))
	{	
		if (eSectTypeStart == TDb::eRectangular) 
			m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
		if (eSectTypeEnd == TDb::eRectangular) 
			m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);
	}
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);	
	
	AcGeVector3d vtSect = GetSectNormal();
	AcGeVector3d vt = vtSect;
	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;
	
	// mcl changed, 2010.03.17. GetHidePlane()求的可能是个斜面，改为以首点为基准
	//	AcGePlane plan = GetHidePlane(arPoint[0], arPoint[1], arPoint[2], TAuxTools::GetUcsZvt(), dEle);	
	AcGePlane plan = GetStdPrjPlan(arPoint[0]);	
	double dEle = TAuxTools::GetPlaneEle(plan);
	
	AcDbPolyline* pPolyLine = new AcDbPolyline;	
	pPolyLine->addVertexAt(0, arPoint[0].convert2d(plan));
	pPolyLine->addVertexAt(1, arPoint[1].convert2d(plan));
	pPolyLine->addVertexAt(2, arPointIn[1].convert2d(plan));
	pPolyLine->addVertexAt(3, arPointIn[2].convert2d(plan));
	pPolyLine->addVertexAt(4, arPoint[2].convert2d(plan));
	pPolyLine->addVertexAt(5, arPoint[3].convert2d(plan));
	pPolyLine->addVertexAt(6, arPointIn[3].convert2d(plan));
	pPolyLine->addVertexAt(7, arPointIn[0].convert2d(plan));
	pPolyLine->setNormal(TAuxTools::GetUcsZvt());
	pPolyLine->setElevation(dEle);
	pPolyLine->setClosed(Adesk::kTrue);
	
	return pPolyLine;
}

// 构建二维图形（方对方）
BOOL THImpHvacReducer::MakeRect2Rect2DCurves(TComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = 200.0, dEndWidth = 400.0, dPlusEdge = GetPlusEdge();
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectType);
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	if ((eSectType == TDb::eRectangular) && !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);

	TDbFittingBase* pFit = TDbFittingBase::cast(m_pOwnerEnt);
	if (NULL != pFit)
		idBaseLayer = pFit->CenterLayer();
				
	BOOL bHasBaseLine = FALSE;
	m_pXDataMap->GetAt(HVAC_HasBaseLine, bHasBaseLine);
	
	TDb::TCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	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) > 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 = 20.0, dE = 50.0;
		if (dStartWidth > dEndWidth)
		{
			dS = 50.0;
			dE = 20.0;
		}	
		curEle.ptGe[0] = ptS + (dS + 10.0) * vtDir;
		curEle.ptGe[1] = ptS - (dS + 10.0) * vtDir;
		curEle.ptGe[2] = ptS - (dS + 10.0) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + (dE + 10.0) * vtDir;
		curEle.ptGe[1] = ptE - (dE + 10.0) * vtDir;
		curEle.ptGe[2] = ptE - (dE + 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 = idBaseLayer;		// 基线图层
			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 THImpHvacReducer::MakeIncCir2Cir2DCurves(TComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartWidth = 200.0, dEndWidth = 400.0, dPlusEdge = 0.0;
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	TDb::HvacSectType eStaSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	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 == TDb::eRectangular) && !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);
	TDbFittingBase* pFit = TDbFittingBase::cast(m_pOwnerEnt);
	if (NULL != pFit)
		idBaseLayer = pFit->CenterLayer();

	TDb::TCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	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) > 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 = 20.0, dE = 50.0;
		if (dStartWidth > dEndWidth)
		{
			dS = 50.0;
			dE = 20.0;
		}	
		curEle.ptGe[0] = ptS + (dS + 10.0) * vtDir;
		curEle.ptGe[1] = ptS - (dS + 10.0) * vtDir;
		curEle.ptGe[2] = ptS - (dS + 10.0) * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + (dE + 10.0) * vtDir;
		curEle.ptGe[1] = ptE - (dE + 10.0) * vtDir;
		curEle.ptGe[2] = ptE - (dE + 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 == TDb::eCircular)
		{
			nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptEnd, dEndWidth, vt, TAuxTools::GetUcsZvt(), *pLine, vt);
			if (-1 != nRet)
			{
// 				for (i = 0; i < arPtsCir.length(); i++)
// 				{
// 					if (i > 1 && i%2 == 0)
// 					{
// 						curEle.ptGe[0] = arPtsCir[i-2];
// 						curEle.ptGe[1] = arPtsCir[i-1];
// 						curEle.ptGe[2] = arPtsCir[i];
// 						cplCurve.append(curEle);
// 					}
// 				}
				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 == TDb::eCircular)
		{
			nRet = TAuxTools::GetEllipsePtsFromCircle(arPtsCir, ptStart, dStartWidth, -vt, TAuxTools::GetUcsZvt(), *pLine, -vt);
			if (-1 != nRet)
			{
// 				for (i = 0; i < arPtsCir.length(); i++)
// 				{
// 					if (i > 1 && i%2 == 0)
// 					{
// 						curEle.ptGe[0] = arPtsCir[i-2];
// 						curEle.ptGe[1] = arPtsCir[i-1];
// 						curEle.ptGe[2] = arPtsCir[i];
// 						cplCurve.append(curEle);
// 					}
// 				}
				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 * 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 = idBaseLayer;		// 基线图层
			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(); i++)
// 				{
// 					if (i > 1 && i%2 == 0)
// 					{
// 						curEle.ptGe[0] = arPtsCir[i-2];
// 						curEle.ptGe[1] = arPtsCir[i-1];
// 						curEle.ptGe[2] = arPtsCir[i];
// 						cplCurve.append(curEle);
// 					}
// 				}
				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(); i++)
// 				{
// 					if (i > 1 && i%2 == 0)
// 					{
// 						curEle.ptGe[0] = arPtsCir[i-2];
// 						curEle.ptGe[1] = arPtsCir[i-1];
// 						curEle.ptGe[2] = arPtsCir[i];
// 						cplCurve.append(curEle);
// 					}
// 				}
				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;
}

// 构建倾斜变径 圆对圆轮廓线
AcDbPolyline* THImpHvacReducer::MakeIncCir2CirPolyCurve() const
{
	ASSERT(NULL != m_pXDataMap);

	AcDbPolyline* pPolyCurve = new AcDbPolyline;
	if (NULL == pPolyCurve)
		return pPolyCurve;
	double dStartWidth = 200.0, dEndWidth = 400.0, dPlusEdge = 0.0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);	
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	TDb::HvacSectType eStaSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	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 == TDb::eRectangular) && !vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 取厚
	{
		m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);	
	}

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

	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;

	AcGePlane plan(TAuxTools::Mid(ptStart, ptEnd), TAuxTools::GetUcsZvt());
	AcGePoint3d ptOrg = AcGePoint3d::kOrigin.orthoProject(plan);
	double dEl = ptOrg.asVector().length();
	if (!ptOrg.asVector().isCodirectionalTo(plan.normal()))
	{
		dEl *= -1.0;
	}
	plan.set(ptOrg, TAuxTools::GetUcsZvt());
	
	// 边线
	pPolyCurve->addVertexAt(0, arPoint[1].convert2d(plan));
	pPolyCurve->addVertexAt(1, arPoint[2].convert2d(plan));

	// 终点椭圆端线
	vt = ptEnd - ptStart;
	nRet = TAuxTools::GetEllipseFromCircle(ptEnd, dEndWidth, vt, TAuxTools::GetUcsZvt(), *pCirLine, vt);
	if (-1 != nRet)
	{
		TAuxTools::MergerPline(pPolyCurve, pCirLine);
	}

	// 边线
	pPolyCurve->addVertexAt(pPolyCurve->numVerts(), arPoint[3].convert2d(plan));
	pPolyCurve->addVertexAt(pPolyCurve->numVerts(), arPoint[0].convert2d(plan));

	// 起点椭圆边线
	pCirLine->reset(Adesk::kFalse, i);
	if (eStaSectType == TDb::eCircular)
	{
		nRet = TAuxTools::GetEllipseFromCircle(ptStart, dStartWidth, -vt, TAuxTools::GetUcsZvt(), *pCirLine, -vt);
		if (-1 != nRet)
			TAuxTools::MergerPline(pPolyCurve, pCirLine);
	} 

	if (NULL != pCirLine)
		delete pCirLine;

	pPolyCurve->setElevation(dEl);
	pPolyCurve->setNormal(plan.normal());
	pPolyCurve->setClosed(Adesk::kTrue);

	return pPolyCurve;
}
BOOL THImpHvacReducer::MakeIncCir2CirPolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);

	double dStartWidth = 200.0, dEndWidth = 400.0;
	AcGePoint3d ptStart, ptEnd;	
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	TDb::HvacSectType eStaSectType = TDb::eRectangular;
	TDb::HvacSectType eEndSectType = TDb::eRectangular;
	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(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	if ((eStaSectType == TDb::eRectangular) && !vtNormal.isParallelTo(TAuxTools::GetUcsZvt())) // 取厚
	{
		m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
		m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);	
	}

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

	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;

	AcGePlane plan(TAuxTools::Mid(ptStart, ptEnd), TAuxTools::GetUcsZvt());
	AcGePoint3d ptOrg = AcGePoint3d::kOrigin.orthoProject(plan);
	plan.set(ptOrg, TAuxTools::GetUcsZvt());

	// 中心的矩形平面
	AcDbFace* pCenFace = new AcDbFace;
	pCenFace->setVertexAt(0, arPoint[0].orthoProject(plan));
	pCenFace->setVertexAt(1, arPoint[1].orthoProject(plan));
	pCenFace->setVertexAt(2, arPoint[2].orthoProject(plan));
	pCenFace->setVertexAt(3, arPoint[3].orthoProject(plan));
	arFaces.append(pCenFace);

	// 终点端半个椭圆面和起点半个椭圆面
	double dMinAngle(TAuxTools::GetMinDiffAngle() * 0.5);
	int nPartNum = int(PI / dMinAngle) + 1;
	dMinAngle = PI / nPartNum;

	AcGePoint3dArray ptArrSta, ptArrEnd;
	AcGePoint3d ptStaNow = arPoint[0];
	AcGePoint3d ptEndNow = arPoint[3];

	vt = ptEnd - ptStart;
	vt.normalize();

	for (i = 0; i < nPartNum + 1; i++)
	{
		ptArrSta.append(ptStaNow.orthoProject(plan));
		ptArrEnd.append(ptEndNow.orthoProject(plan));

		if (ptStart.z > ptEnd.z)
		{
			ptStaNow.rotateBy(-dMinAngle, -vt, ptStart);
			ptEndNow.rotateBy(dMinAngle, -vt, ptEnd);
		}
		else
		{
			ptStaNow.rotateBy(-dMinAngle, vt, ptStart);
			ptEndNow.rotateBy(dMinAngle, vt, ptEnd);
		}

		if (i > 0)
		{
			AcDbFace* pStaFace = new AcDbFace;
			pStaFace->setVertexAt(0, ptStart.orthoProject(plan));
			pStaFace->setVertexAt(1, ptArrSta[i]);
			pStaFace->setVertexAt(2, ptArrSta[i-1]);
			pStaFace->setVertexAt(3, ptStart.orthoProject(plan));
			arFaces.append(pStaFace);

			AcDbFace* pEndFace = new AcDbFace;
			pEndFace->setVertexAt(0, ptEnd.orthoProject(plan));
			pEndFace->setVertexAt(1, ptArrEnd[i]);
			pEndFace->setVertexAt(2, ptArrEnd[i-1]);
			pEndFace->setVertexAt(3, ptEnd.orthoProject(plan));
			arFaces.append(pEndFace);
		}
	}

	return arFaces.length() > 0;
}

// 构建外轮廓所围平面的3DFace组（方对方）
BOOL THImpHvacReducer::MakeRect2RectPolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);
	
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);	

	// mcl, add.各点都投影到以首点为基准的标准面上
	AcGePlane planStd = GetStdPrjPlan(ptStart);
	ptEnd = ptEnd.orthoProject(planStd);

	AcGeVector3d vtSect = GetSectNormal();
	AcGeVector3d vt = vtSect;
	vt.rotateBy(PI / 2.0, TAuxTools::GetUcsZvt());
	vt.normalize();		
	AcDbFace* pFace = NULL;
	if (IsSingleLine())
	{
		double dHideWidth = 0.0;
		GetGlobalContext()->GetAt(KEY_HIDEWIDTH, dHideWidth);

		AcGePoint3d arPoint[4];
		arPoint[0] = ptStart - dHideWidth * vt / 2.0;
		arPoint[1] = ptStart + dHideWidth * vt / 2.0;
		arPoint[2] = ptEnd + dHideWidth * vt / 2.0;
		arPoint[3] = ptEnd - dHideWidth * vt / 2.0;

		pFace = new AcDbFace;
		pFace->setVertexAt(0, arPoint[0]);
		pFace->setVertexAt(1, arPoint[1]);
		pFace->setVertexAt(2, arPoint[2]);
		pFace->setVertexAt(3, arPoint[3]);
		arFaces.append(pFace);
	}
	else
	{
		double dStartWidth = 200.0, dEndWidth = 400.0, dPlusEdge = GetPlusEdge();
		AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
		m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
		TDb::HvacSectType eSectTypeStart = TDb::eRectangular, eSectTypeEnd = TDb::eRectangular;
		m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSectTypeStart);
		m_pXDataMap->GetAt(HRED_EndSectType, (int&)eSectTypeEnd);
		m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
		m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);		
		if (!vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))
		{	
			if (eSectTypeStart == TDb::eRectangular) 
				m_pXDataMap->GetAt(HRED_StartThick, dStartWidth);
			if (eSectTypeEnd == TDb::eRectangular) 
				m_pXDataMap->GetAt(HRED_EndThick, dEndWidth);
		}
		
		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 (dPlusEdge > 1.0e-6)
		{
			pFace = new AcDbFace;
			pFace->setVertexAt(0, arPoint[0]);
			pFace->setVertexAt(1, arPoint[1]);
			pFace->setVertexAt(2, arPointIn[1]);
			pFace->setVertexAt(3, arPointIn[0]);
			arFaces.append(pFace);
		}	
		pFace = new AcDbFace;
		pFace->setVertexAt(0, arPointIn[0]);
		pFace->setVertexAt(1, arPointIn[1]);
		pFace->setVertexAt(2, arPointIn[2]);
		pFace->setVertexAt(3, arPointIn[3]);
		arFaces.append(pFace);
		if (dPlusEdge > 1.0e-6)
		{
			pFace = new AcDbFace;
			pFace->setVertexAt(0, arPointIn[3]);
			pFace->setVertexAt(1, arPointIn[2]);
			pFace->setVertexAt(2, arPoint[2]);
			pFace->setVertexAt(3, arPoint[3]);
			arFaces.append(pFace);
		}
	}
	
	return TRUE;
}

// 绘制三维图形（方对圆）
void THImpHvacReducer::ExplodeRect2Cir3d(XExplodeDraw& mode, BOOL bStartIsRound) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = 200.0, dStartThick = 200.0, dEndWidth = 400.0, 
		dEndThick = 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);
	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));	
	
	mode.DrawMesh(4 * (nSect + 1) + 1, 4, arPoint.asArrayPtr());
}
// 构建外轮廓（方对圆）
AcDbPolyline* THImpHvacReducer::MakeRect2CirPolyCurve() const
{
	return MakeRect2RectPolyCurve();
}
// 构建二维图形（方对圆）
BOOL THImpHvacReducer::MakeRect2Cir2DCurves(TComplexCurve& cplCurve, int &nType, BOOL bStartIsRound) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = 200.0, dEndWidth = 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);
	
	TDb::TCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;

	// 绘单线
	if (IsSingleLine())
	{
		AcGeVector3d vtDir = ptStart - ptEnd;
		AcGePoint3d ptS, ptM, ptE;
		vtDir.normalize();
		ptM = ptEnd + vtDir * ptStart.distanceTo(ptEnd) / 2.0;
		if (ptStart.distanceTo(ptEnd) > 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.0, TAuxTools::GetUcsZvt());		
		curEle.ptGe[0] = ptS + 10.0 * vtDir;		// ptS是圆断面
		curEle.ptGe[1] = ptS - 10.0 * vtDir;
		curEle.ptGe[2] = ptS - 10.0 * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + 60.0 * vtDir;
		curEle.ptGe[1] = ptE - 60.0 * vtDir;
		curEle.ptGe[2] = ptE - 60.0 * vtDir;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE + 50.0 * vtDir;
		curEle.ptGe[1] = ptS;
		curEle.ptGe[2] = ptS;
		cplCurve.append(curEle);
		curEle.ptGe[0] = ptE - 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 = idBaseLayer;		// 基线图层
			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;
}
// 构建外轮廓所围平面的3DFace组（方对圆）
BOOL THImpHvacReducer::MakeRect2CirPolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	return MakeRect2RectPolyCurveFaces(arFaces);
}

// 绘制三维图形（圆对方）
void THImpHvacReducer::ExplodeCir2Rect3d(XExplodeDraw& mode) const
{
	ExplodeRect2Cir3d(mode, TRUE);
}
// 构建外轮廓（圆对方）
AcDbPolyline* THImpHvacReducer::MakeCir2RectPolyCurve() const
{
	return MakeRect2RectPolyCurve();
}
// 构建二维图形（圆对方）
BOOL THImpHvacReducer::MakeCir2Rect2DCurves(TComplexCurve& cplCurve, int &nType) const
{
	return MakeRect2Cir2DCurves(cplCurve, nType, TRUE);
}
// 构建外轮廓所围平面的3DFace组（圆对方）
BOOL THImpHvacReducer::MakeCir2RectPolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	return MakeRect2RectPolyCurveFaces(arFaces);
}

// 绘制三维图形（圆对圆）
void THImpHvacReducer::ExplodeCir2Cir3d(XExplodeDraw& mode) const
{
	ASSERT(NULL != m_pXDataMap);
	
	double dStartWidth = 200.0, dEndWidth = 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);
	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));		
	}
	mode.DrawMesh(nSect + 1, 4, arPoint.asArrayPtr());
}
// 构建外轮廓（圆对圆）
AcDbPolyline* THImpHvacReducer::MakeCir2CirPolyCurve() const
{
	return MakeRect2RectPolyCurve();
}
// 构建二维图形（圆对圆）
BOOL THImpHvacReducer::MakeCir2Cir2DCurves(TComplexCurve& cplCurve, int &nType) const
{
	return MakeRect2Rect2DCurves(cplCurve, nType);
}
// 构建外轮廓所围平面的3DFace组（圆对圆）
BOOL THImpHvacReducer::MakeCir2CirPolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	return MakeRect2RectPolyCurveFaces(arFaces);
}

// 获得外轮廓点
void THImpHvacReducer::GetOutVertex(AcGePoint3dArray& arPoint, TDb::HvacSectType eStart, TDb::HvacSectType eEnd) const
{
	double dStartWidth = 200.0, dStartThick = 200.0, dEndWidth = 400.0, dEndThick = 400.0;
	AcGePoint3d ptStart, ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
	if (eStart == TDb::eRectangular) 
		m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
	else
		dStartThick = dStartWidth;				// 圆形取厚度为宽
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	if (eStart == TDb::eRectangular) 
		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 THImpHvacReducer::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);
		TDb::HvacSectType eSect(TDb::eRectangular);
		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 (TDb::eRectangular == 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 (TDb::eCircular == 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);
			}
		}
	}
}

// 垂直构建外轮廓
AcDbPolyline* THImpHvacReducer::MakePolyCurveVer() const
{
// 	TDb::HvacSectType eStartType = TDb::eRectangular;
// 	TDb::HvacSectType eEndType = TDb::eRectangular;
// 	m_pXDataMap->GetAt(HRED_StartSectType,(int&)eStartType);
// 	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndType);	
// 	AcGePoint3dArray arPoint;
// 	GetOutVertex(arPoint, eStartType, eEndType);
// 	
// 	double dStartWidth = 200.0, dStartThick = 200.0;
// 	AcGePoint3d ptStart;
// 	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
// 	m_pXDataMap->GetAt(HRED_StartWidth, dStartWidth);
// 	if (eStartType == TDb::eRectangular) 
// 		m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
// 	else
// 		dStartThick = dStartWidth;				// 圆形取厚度为宽	
// 	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
// 	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
// 	AcGeVector3d vtSect = GetSectNormal();
// 	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);
// 	
//  	AcGePlane plan = GetStdPrjPlan(arStartPt.at(0));	
// 	double dEle = TAuxTools::GetPlaneEle(plan);
// 
// 	AcDbPolyline* pPolyLine = new AcDbPolyline;
// 	for (int i = 0; i < arPoint.length(); i++)
// 	{
// 		pPolyLine->addVertexAt(i, arPoint.at(i).convert2d(plan));
// 	}
// 	pPolyLine->setNormal(TAuxTools::GetUcsZvt());
// 	pPolyLine->setElevation(dEle);
// 	pPolyLine->setClosed(Adesk::kTrue);	

	// 换个方法Lixl modify 2012-5-21
	TDb::HvacSectType eStartSect, eEndSect, eSect;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eStartSect);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndSect);

	double dStaWidth, dStaThick, dEndWidth, dEndThick;
	m_pXDataMap->GetAt(HRED_StartWidth, dStaWidth);
	m_pXDataMap->GetAt(HRED_StartThick, dStaThick);
	m_pXDataMap->GetAt(HRED_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HRED_EndThick, dEndThick);
	
	double dStartArea, dEndArea;
	if (TDb::eRectangular == eStartSect)
		dStartArea = dStaWidth * dStaThick;
	else
		dStartArea = dStaWidth * dStaWidth;
	if (TDb::eRectangular == eEndSect)
		dEndArea = dEndWidth * dEndThick;
	else
		dEndArea = dEndWidth * dEndWidth;

	bool bStart(true);
	eSect = eStartSect;
	if (UP_ZERO(dEndArea - dStartArea))
	{
		bStart = false;
		eSect = eEndSect;
	}

	AcGePoint3dArray arPoint;
	GetOutVertex2(arPoint, bStart);
	if (arPoint.length() < 6)
		return NULL;

	AcGePlane plan = GetStdPrjPlan(arPoint[0]);	
	double dEle = TAuxTools::GetPlaneEle(plan);

	AcDbPolyline* pPolyLine = new AcDbPolyline;
	if (eSect == TDb::eRectangular)	// 方形截面
	{
		pPolyLine->addVertexAt(0, arPoint[1].convert2d(plan));
		pPolyLine->addVertexAt(1, arPoint[2].convert2d(plan));
		pPolyLine->addVertexAt(2, arPoint[3].convert2d(plan));
		pPolyLine->addVertexAt(3, arPoint[4].convert2d(plan));
	}
	else
	{
		// 圆截面时,arPoint第一个元素是中心点,最后一个元素与逆时针起点重复,舍去
		int nVer(0);
		for (int i = 1; i < arPoint.length()-1; i++)
		{
			pPolyLine->addVertexAt(nVer++, arPoint[i].convert2d(plan));
		}
	}
	pPolyLine->setNormal(TAuxTools::GetUcsZvt());
	pPolyLine->setElevation(dEle);
	pPolyLine->setClosed(Adesk::kTrue);
	return pPolyLine;
}
void THImpHvacReducer::MakePolyCurveFacesVer(AcDbVoidPtrArray& arFaces)
{
// 	TDb::HvacSectType eStartType = TDb::eRectangular;
// 	TDb::HvacSectType eEndType = TDb::eRectangular;
// 	m_pXDataMap->GetAt(HRED_StartSectType,(int&)eStartType);
// 	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndType);	
// 	AcGePoint3dArray arPoint;
// 	GetOutVertex(arPoint, eStartType, eEndType);
// 
// 	AcDbFace* pFace = NULL;
// 	for (int i = 1; i < arPoint.length() - 1; i++)
// 	{
// 		pFace = new AcDbFace;
// 		pFace->setVertexAt(0, arPoint.at(0));
// 		pFace->setVertexAt(1, arPoint.at(i));
// 		pFace->setVertexAt(2, arPoint.at(i + 1));
// 		arFaces.append(pFace);
// 	}	

	// Lixl modify 2012-5-21
	TDb::HvacSectType eStartType = TDb::eRectangular;
	TDb::HvacSectType eEndType = TDb::eRectangular;
	m_pXDataMap->GetAt(HRED_StartSectType,(int&)eStartType);
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eEndType);	
	AcGePoint3dArray arSra, arEnd;
	GetOutVertex2(arSra, true);
	GetOutVertex2(arEnd, false);
	if (arSra.length() < 0 || arEnd.length() < 0)
		return ;

	AcDbFace* pFace = NULL;
	if (TDb::eRectangular == eStartType)
	{
		pFace = new AcDbFace;
		pFace->setVertexAt(0, arSra.at(1));
		pFace->setVertexAt(1, arSra.at(2));
		pFace->setVertexAt(2, arSra.at(3));
		pFace->setVertexAt(3, arSra.at(4));
		arFaces.append(pFace);
	}
	else
	{
		for (int i = 0; i <= arSra.length()-2; i++)
		{
			pFace = new AcDbFace;
			pFace->setVertexAt(0, arSra[0]);
			pFace->setVertexAt(1, arSra[i]);
			pFace->setVertexAt(2, arSra[i + 1]);
			pFace->setVertexAt(3, arSra[0]);
			arFaces.append(pFace);
		}
	}

	if (TDb::eRectangular == eEndType)
	{
		pFace = new AcDbFace;
		pFace->setVertexAt(0, arEnd.at(1));
		pFace->setVertexAt(1, arEnd.at(2));
		pFace->setVertexAt(2, arEnd.at(3));
		pFace->setVertexAt(3, arEnd.at(4));
		arFaces.append(pFace);
	}
	else
	{
		for (int i = 0; i <= arEnd.length() - 2; i++)
		{
			pFace = new AcDbFace;
			pFace->setVertexAt(0, arEnd[0]);
			pFace->setVertexAt(1, arEnd[i]);
			pFace->setVertexAt(2, arEnd[i + 1]);
			pFace->setVertexAt(3, arEnd[0]);
			arFaces.append(pFace);
		}
	}
}

// 垂直构建外轮廓（方对方）
AcDbPolyline* THImpHvacReducer::MakeRect2RectPolyCurveVer() const
{	
	return MakePolyCurveVer();
}
// 垂直构建二维图形（方对方）
BOOL THImpHvacReducer::MakeRect2Rect2DCurvesVer(TComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);
	
//	double dStartWidth = 200.0, dStartThick = 200.0, dEndWidth = 400.0, dEndThick = 400.0;
// 	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);
// 	AcDbObjectId idEndLayer;
// 	m_pXDataMap->GetAt(HVAC_EndLayer, idEndLayer);
// 	
// 	// 计算顶点
// 	AcGeVector3d vt = AcGeVector3d::kZAxis;
// 	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);
// 	
// 	TDb::TCurveElement curEle;
// 	curEle.bHided = FALSE;
// 	curEle.dWidth = 0.0;
// 	curEle.gsMark = 0;
// 	if (0 == nType)
// 	{
// 		curEle.dWidth = GetEdgeLineWidth();
// 		for (int i = 0; i < 4; i++)
// 		{
// 			curEle.ptGe[0] = arStartPt.at(i);
// 			curEle.ptGe[1] = arEndPt.at(i);
// 			curEle.ptGe[2] = arEndPt.at(i);
// 			cplCurve.append(curEle);
// 		}
// 
// 		curEle.idSubLay = idEndLayer;		// 两端图层
// 		curEle.dWidth = GetEndLineWidth();
// 		for (i = 0; i < 3; i++)
// 		{
// 			curEle.ptGe[0] = arStartPt.at(i);
// 			curEle.ptGe[1] = arStartPt.at(i + 1);
// 			curEle.ptGe[2] = arStartPt.at(i + 1);
// 			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);
// 		}
// 		curEle.ptGe[0] = arStartPt.at(0);
// 		curEle.ptGe[1] = arStartPt.at(3);
// 		curEle.ptGe[2] = arStartPt.at(3);
// 		cplCurve.append(curEle);		
// 		curEle.ptGe[0] = arEndPt.at(0);
// 		curEle.ptGe[1] = arEndPt.at(3);
// 		curEle.ptGe[2] = arEndPt.at(3);
// 		cplCurve.append(curEle);	
// 	}
	
	// Lixl modify 2012-5-21
	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);

	TDb::TCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	{
		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;
}
// 垂直构建外轮廓所围平面的3DFace组（方对方）
BOOL THImpHvacReducer::MakeRect2RectPolyCurveFacesVer(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);

	MakePolyCurveFacesVer(arFaces);
	return TRUE;
}

// 垂直构建外轮廓（方对圆）
AcDbPolyline* THImpHvacReducer::MakeRect2CirPolyCurveVer() const
{
	return MakePolyCurveVer();
}
// 垂直构建二维图形（方对圆）
BOOL THImpHvacReducer::MakeRect2Cir2DCurvesVer(TComplexCurve& cplCurve, int &nType, BOOL bStartIsRound) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartDia = 200.0, dEndWidth = 400.0, dEndThick = 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));
	
	TDb::TCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
//	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;
}
// 垂直构建外轮廓所围平面的3DFace组（方对圆）
BOOL THImpHvacReducer::MakeRect2CirPolyCurveFacesVer(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);
	
	MakePolyCurveFacesVer(arFaces);
	return TRUE;
}

// 垂直构建外轮廓（圆对方）
AcDbPolyline* THImpHvacReducer::MakeCir2RectPolyCurveVer() const
{
	return MakePolyCurveVer();
}
// 垂直构建二维图形（圆对方）
BOOL THImpHvacReducer::MakeCir2Rect2DCurvesVer(TComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);
	
	MakeRect2Cir2DCurvesVer(cplCurve, nType, TRUE);
	return TRUE;
}
// 垂直构建外轮廓所围平面的3DFace组（圆对方）
BOOL THImpHvacReducer::MakeCir2RectPolyCurveFacesVer(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);
	
	MakePolyCurveFacesVer(arFaces);
	return TRUE;
}

// 垂直构建外轮廓（圆对圆）
AcDbPolyline* THImpHvacReducer::MakeCir2CirPolyCurveVer() const
{
	return MakePolyCurveVer();
}
// 垂直构建二维图形（圆对圆）
BOOL THImpHvacReducer::MakeCir2Cir2DCurvesVer(TComplexCurve& cplCurve, int &nType) const
{
	ASSERT(NULL != m_pXDataMap);

	double dStartDia = 200.0, dEndDia = 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);
	
	TDb::TCurveElement curEle;
	curEle.bHided = FALSE;
	curEle.dWidth = 0.0;
	curEle.gsMark = 0;
	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;
}
// 垂直构建外轮廓所围平面的3DFace组（圆对圆）
BOOL THImpHvacReducer::MakeCir2CirPolyCurveFacesVer(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);
	
	MakePolyCurveFacesVer(arFaces);
	return TRUE;
}

// mcl commented, 2010.03.17. GetHidePlane()求的可能是个斜面，改为以首点为基准
// AcGePlane THImpHvacReducer::GetHidePlane(AcGePoint3d pt1, AcGePoint3d pt2, AcGePoint3d pt3,  
// 									  const AcGeVector3d vtNormal, double &dEle) const
// {
// 	AcGePlane plan(pt1, pt2, pt3);
// 	AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
// 	plan.set(ptOrth, vtNormal);
// 	
// 	dEle = ptOrth.asVector().length();
// 	if (!ptOrth.asVector().isCodirectionalTo(vtNormal))
// 		dEle *= -1.0;
// 	
// 	return plan;
// }

AcGePlane THImpHvacReducer::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;
}


// 注意：pXMap == NULL表示不想得到返回值，只是判断数据是否合理
// 先取出m_pXDataMap中数据进行判断是否合理，返回判断结果
// 如果pXMap不为NULL，则将有效参数填入pXMap
BOOL THImpHvacReducer::IsValid(TDbXDataMap* pXMap)
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptEnd;
	HvacReduComType eType = TDb::eAuto;
	m_pXDataMap->GetAt(HRED_ComputeType, (int&)eType);
	if (TDb::eAngle == eType)
		ptEnd = GetEndPtByangle();
	else if (TDb::eLength == eType)
		ptEnd = GetEndPtByLen();
	else
		ptEnd = GetEndPtAuto();

	AcGePoint3d ptOrigEnd;
	m_pXDataMap->GetAt(HRED_EndPoint, ptOrigEnd);

	m_pXDataMap->SetAt(HRED_EndPoint, ptEnd);
	if (NULL != m_pOwnerEnt)
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), ptOrigEnd, ptEnd);

	if (NULL != pXMap)
		pXMap->SetAt(HRED_EndPoint, ptEnd);

	return TRUE;
}

double THImpHvacReducer::GetEdgeLineWidth() const
{
	BOOL bShow(FALSE);
	GetGlobalContext( HVAC_SHOWWIDTH, bShow);
	// add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响
	TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow);

	if (!bShow)
		return 0.0;
	
	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);
	
	return dWidth;
}

double THImpHvacReducer::GetCentLineWidth() const
{
	BOOL bShow(FALSE);
	GetGlobalContext( HVAC_SHOWWIDTH, bShow);
	// add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响
	TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow);

	if (!bShow)
		return 0.0;
	
	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HVAC_CentWidth, dWidth);
	
	return dWidth;
}

double THImpHvacReducer::GetEndLineWidth() const
{
	BOOL bShow(FALSE);
	GetGlobalContext( HVAC_SHOWWIDTH, bShow);
	// add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响
	TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow);

	if (!bShow)
		return 0.0;
	
	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HVAC_EndWidth, dWidth);
	
	return dWidth;
}

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

int THImpHvacReducer::GetXBaseShell(TXShell& xShell)
{
	int nRet = 0;
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	HvacSectType eSSectType;
	m_pXDataMap->GetAt(HRED_StartSectType, (int&)eSSectType);
	HvacSectType eESectType;
	m_pXDataMap->GetAt(HRED_EndSectType, (int&)eESectType);
	if (TDb::eRectangular == eSSectType && TDb::eRectangular == eESectType)
	{
		// 获得参数
		double dSWidth = 0.0;
		m_pXDataMap->GetAt(HRED_StartWidth, dSWidth);
		double dEWidth = 0.0;
		m_pXDataMap->GetAt(HRED_EndWidth, dEWidth);
		double dSThick = 0.0;
		m_pXDataMap->GetAt(HRED_StartThick, dSThick);
		double dEThick = 0.0;
		m_pXDataMap->GetAt(HRED_EndThick, dEThick);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGeVector3d vtSide;
		m_pXDataMap->GetAt(HRED_StartDir, vtSide);
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		AcGePoint3d ptEnd;
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
		
		// 构造碰撞实体
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dSWidth, dSThick, dEWidth, dEThick, xShell, &vtSide, &vtSide);
		nRet = 1;
	}
	else if (TDb::eCircular == eSSectType && TDb::eCircular == eESectType)
	{
		// 获得参数
		double dSDiameter = 0.0;
		m_pXDataMap->GetAt(HRED_StartDiameter, dSDiameter);
		double dEDiameter = 0.0;
		m_pXDataMap->GetAt(HRED_EndDiameter, dEDiameter);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		AcGeVector3d vtSide;
		m_pXDataMap->GetAt(HRED_StartDir, vtSide);
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		AcGePoint3d ptEnd;
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
		
		// 构造碰撞实体
		TAuxTools::BuildCirDuct(ptStart, ptEnd, dSDiameter, dEDiameter, xShell, &vtSide, &vtSide);

		nRet = 1;
	}
	else if ((TDb::eCircular == eSSectType && TDb::eRectangular == eESectType))
	{
		// 获得参数
		double dSDiameter = 0.0;
		m_pXDataMap->GetAt(HRED_StartDiameter, dSDiameter);
		double dEWidth = 0.0;
		m_pXDataMap->GetAt(HRED_EndWidth, dEWidth);
		double dEThick = 0.0;
		m_pXDataMap->GetAt(HRED_EndThick, dEThick);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		AcGeVector3d vtStart;
		m_pXDataMap->GetAt(HRED_StartDir, vtStart);
		AcGeVector3d vtSide = vtStart;
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		AcGePoint3d ptEnd;
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
		
		// 构造碰撞实体
		TAuxTools::BuildCir2RectDuct(ptStart, ptEnd, vtNormal, dSDiameter, dEWidth, dEThick, xShell, &vtSide, &vtStart);
		nRet = 1;
	}
	else if (TDb::eRectangular == eSSectType && TDb::eCircular == eESectType)
	{
		// 获得参数
		double dEDiameter = 0.0;
		m_pXDataMap->GetAt(HRED_EndDiameter, dEDiameter);
		double dSWidth = 0.0;
		m_pXDataMap->GetAt(HRED_StartWidth, dSWidth);
		double dSThick = 0.0;
		m_pXDataMap->GetAt(HRED_StartThick, dSThick);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		AcGeVector3d vtStart;
		m_pXDataMap->GetAt(HRED_StartDir, vtStart);
		AcGeVector3d vtEnd = -vtStart;
		AcGeVector3d vtSide = vtEnd;
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
		AcGePoint3d ptEnd;
		m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
		
		// 构造碰撞实体
		TAuxTools::BuildCir2RectDuct(ptEnd, ptStart, vtNormal, dEDiameter, dSWidth, dSThick, xShell, &vtSide, &vtEnd);
		nRet = 1;
	}
	else
	{
		// 不做处理
	}
	
	return nRet;
}

int THImpHvacReducer::GetBodyBox(AcDbExtents& ext)
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	// 获得参数
	double dSWidth = 0.0;
	m_pXDataMap->GetAt(HRED_StartWidth, dSWidth);
	double dHalfSWidth = dSWidth / 2.0;
	double dSThick = 0.0;
	m_pXDataMap->GetAt(HRED_StartThick, dSThick);
	double dHalfSThick = dSThick / 2.0;
	HvacSectType eSSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSSectType);
	if (TDb::eCircular == eSSectType)
	{
		// 处理圆管数据
		dHalfSThick = dHalfSWidth;
	}

	double dEWidth = 0.0;
	m_pXDataMap->GetAt(HRED_EndWidth, dEWidth);
	double dHalfEWidth = dEWidth / 2.0;
	double dEThick = 0.0;
	m_pXDataMap->GetAt(HRED_EndThick, dEThick);
	double dHalfEThick = dEThick / 2.0;
	HvacSectType eESectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eESectType);
	if (TDb::eCircular == eESectType)
	{
		// 处理圆管数据
		dHalfEThick = dHalfEWidth;
	}
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	vtNormal.normalize();
	AcGeVector3d vtSide;
	m_pXDataMap->GetAt(HRED_StartDir, vtSide);
	vtSide.rotateBy(PI / 2.0, vtNormal);
	vtSide.normalize();
	AcGePoint3d ptStart;
	m_pXDataMap->GetAt(HRED_StartPoint, ptStart);
	AcGePoint3d ptEnd;
	m_pXDataMap->GetAt(HRED_EndPoint, ptEnd);
	
	// 计算端点
	AcGePoint3dArray arpt;
	arpt.append(ptStart + vtSide * dHalfSWidth + vtNormal * dHalfSThick);
	arpt.append(ptStart + vtSide * dHalfSWidth - vtNormal * dHalfSThick);
	arpt.append(ptStart - vtSide * dHalfSWidth - vtNormal * dHalfSThick);
	arpt.append(ptStart - vtSide * dHalfSWidth + vtNormal * dHalfSThick);
	arpt.append(ptEnd + vtSide * dHalfEWidth + vtNormal * dHalfEThick);
	arpt.append(ptEnd + vtSide * dHalfEWidth - vtNormal * dHalfEThick);
	arpt.append(ptEnd - vtSide * dHalfEWidth - vtNormal * dHalfEThick);
	arpt.append(ptEnd - vtSide * dHalfEWidth + vtNormal * dHalfEThick);
	
	// 构造最小包含体
	TAuxTools::BuildMinRectangle(arpt, ext);
	
	return 1;
}

AcGePoint3d THImpHvacReducer::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 + 100;

	if (dHoriLen < 200.0)
		dHoriLen = 200.0;

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

	return ptEnd;
}

// 不支持既不同心又没有一边对其情况心情况
AcGePoint3d THImpHvacReducer::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 < 200)	// 避免天圆地方是看不出来
		dAllDist = 200;

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

	return ptEnd;
}

AcGePoint3d THImpHvacReducer::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 < 200)
		dLen = 200;
	
	vtOffset = ptEnd - ptStart;
	vtOffset = vtOffset.orthoProject(vtEnd);

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

	return ptEnd;
}

double THImpHvacReducer::GetMaxSizeSub()
{
	HvacSectType eStartSect = TDb::eRectangular;
	HvacSectType eEndSect = TDb::eRectangular;
	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 == TDb::eRectangular)
		{
			double dThickSub = fabs(dStartThick - dEndThick);
			dMaxSizeSub = dWidthSub > dThickSub ? dWidthSub:dThickSub;
		}
		else
		{
			dMaxSizeSub = dWidthSub;
		}
	}
	else
	{
		if (eStartSect == TDb::eRectangular)
		{
			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;
}

// 导出XML
// CString THImpHvacReducer::GetXml() const
// {
// 	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
// 		return _T("");
// 
// 	int nValue(0);
// 	double dValue(0.0);
// 	int nSizePreci = 3; // 尺寸精度
// 	int nPtPreci = 6; // 位置精度
// 	int nWhPreci = 0; // 宽度、高度精度
// 
// 	TXmlTree xmlTree;
// 	CString csText;
// 	CString csX, csY, csZ;
// 	AcGePoint3d pt;
// 	AcGeVector3d vt;
// 	POSITION posRoot = xmlTree.Insert(_T("ATS_DBHFITTING"), NULL, NULL);
// 	{
// 		xmlTree.SetAttribute(posRoot, _T("name"), _T("变径"));
// 		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称，包含天圆地方"));
// 	}
// 
// 	POSITION posItemSectStr = xmlTree.Insert(_T("SectionType_start"), posRoot, NULL);
// 	{ 
// 		xmlTree.SetAttribute(posItemSectStr, _T("name"), _T("起始端截面类型"));
// 		xmlTree.SetAttribute(posItemSectStr, _T("comment"), _T("0:矩形,1:圆形"));
// 		m_pXDataMap->GetAt(HRED_StartSectType, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemSectStr, csText);
// 	}
// 
// 	POSITION posItemSectEnd = xmlTree.Insert(_T("SectionType_end"), posRoot, posItemSectStr);
// 	{ 
// 		xmlTree.SetAttribute(posItemSectEnd, _T("name"), _T("终止端截面类型"));
// 		xmlTree.SetAttribute(posItemSectEnd, _T("comment"), _T("0:矩形,1:圆形"));
// 		m_pXDataMap->GetAt(HRED_EndSectType, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemSectEnd, csText);
// 	}
// 
// 	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemSectEnd);
// 	{
// 		xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
// 		m_pXDataMap->GetAt(HVAC_Normal, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemNorDir, csText);
// 	}
// 
// 	POSITION posItemStartPt = xmlTree.Insert(_T("Start_point"), posRoot, posItemNorDir);
// 	{ 
// 		xmlTree.SetAttribute(posItemStartPt, _T("name"), _T("起点位置"));
// 		m_pXDataMap->GetAt(HRED_StartPoint, pt);
// 		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemStartPt, csText);
// 	}
// 
// 	POSITION posItemStartDir = xmlTree.Insert(_T("Start_direction"), posRoot, posItemStartPt);
// 	{ 
// 		xmlTree.SetAttribute(posItemStartDir, _T("name"), _T("起点方向"));
// 		m_pXDataMap->GetAt(HRED_StartDir, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemStartDir, csText);
// 	}
// 
// 	POSITION posItemEndPt = xmlTree.Insert(_T("End_point"), posRoot, posItemStartDir);
// 	{ 
// 		xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("终点位置"));
// 		m_pXDataMap->GetAt(HRED_EndPoint, pt);
// 		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemEndPt, csText);
// 	}
// 
// 	POSITION posItemWidthStr = xmlTree.Insert(_T("Width_Start"), posRoot, posItemEndPt);
// 	{ 
// 		xmlTree.SetAttribute(posItemWidthStr, _T("name"), _T("起始端宽度"));
// 		m_pXDataMap->GetAt(HRED_StartWidth, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemWidthStr, csText);
// 	}
// 
// 	POSITION posItemWidthEnd = xmlTree.Insert(_T("Width_End"), posRoot, posItemWidthStr);
// 	{ 
// 		xmlTree.SetAttribute(posItemWidthEnd, _T("name"), _T("终止端宽度"));
// 		m_pXDataMap->GetAt(HRED_EndWidth, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemWidthEnd, csText);
// 	}
// 
// 	POSITION posItemHghStr = xmlTree.Insert(_T("Height_Start"), posRoot, posItemWidthEnd);
// 	{ 
// 		xmlTree.SetAttribute(posItemHghStr, _T("name"), _T("起始端高度"));
// 		m_pXDataMap->GetAt(HRED_StartThick, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemHghStr, csText);
// 	}
// 
// 	POSITION posItemHghEnd = xmlTree.Insert(_T("Height_End"), posRoot, posItemHghStr);
// 	{ 
// 		xmlTree.SetAttribute(posItemHghEnd, _T("name"), _T("终止端高度"));
// 		m_pXDataMap->GetAt(HRED_EndThick, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemHghEnd, csText);
// 	}
// 
// 	POSITION posPlusEdge = xmlTree.Insert(_T("PlusEdge"), posRoot, posItemHghEnd);
// 	{
// 		xmlTree.SetAttribute(posPlusEdge, _T("name"),_T("咬口法兰翻边余量"));
// 		m_pXDataMap->GetAt(HVAC_PlusEdge, dValue);
// 		TAuxTools::DoubleToString(dValue, 1, csText);
// 		xmlTree.SetItemText(posPlusEdge, csText);
// 	}
// 
// 	POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posPlusEdge);
// 	{
// 		xmlTree.SetAttribute(posObjId, _T("name"),_T("ID"));
// 		xmlTree.SetAttribute(posObjId, _T("comment"),_T("变径ID"));
// 
// 		csText.Format(_T("%ld"), 0x7FFFFFFF & m_pOwnerEnt->objectId().asOldId());
// 		xmlTree.SetItemText(posObjId, csText);
// 	}
// 
// 	CString csXml = xmlTree.GetXml();
// 
// 	return csXml;
// }

CString THImpHvacReducer::GetXml(const AcGeMatrix3d& mat) const
{
	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
		return _T("");

	int nValue(0);
	double dValue(0.0);
	int nSizePreci = 3; // 尺寸精度
	int nPtPreci = 6; // 位置精度
	int nWhPreci = 0; // 宽度、高度精度

	TXmlTree xmlTree;
	CString csText;
	CString csX, csY, csZ;
	AcGePoint3d pt;
	AcGeVector3d vt;
	POSITION posRoot = xmlTree.Insert(_T("ATS_DBHFITTING"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("变径"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称，包含天圆地方"));
	}

	POSITION posItemSectStr = xmlTree.Insert(_T("SectionType_start"), posRoot, NULL);
	{ 
		xmlTree.SetAttribute(posItemSectStr, _T("name"), _T("起始端截面类型"));
		xmlTree.SetAttribute(posItemSectStr, _T("comment"), _T("0:矩形,1:圆形"));
		m_pXDataMap->GetAt(HRED_StartSectType, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemSectStr, csText);
	}

	POSITION posItemSectEnd = xmlTree.Insert(_T("SectionType_end"), posRoot, posItemSectStr);
	{ 
		xmlTree.SetAttribute(posItemSectEnd, _T("name"), _T("终止端截面类型"));
		xmlTree.SetAttribute(posItemSectEnd, _T("comment"), _T("0:矩形,1:圆形"));
		m_pXDataMap->GetAt(HRED_EndSectType, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemSectEnd, csText);
	}

	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemSectEnd);
	{
		xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
		m_pXDataMap->GetAt(HVAC_Normal, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemNorDir, csText);
	}

	POSITION posItemStartPt = xmlTree.Insert(_T("Start_point"), posRoot, posItemNorDir);
	{ 
		xmlTree.SetAttribute(posItemStartPt, _T("name"), _T("起点位置"));
		m_pXDataMap->GetAt(HRED_StartPoint, pt);
		pt.transformBy(mat);
		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemStartPt, csText);
	}

	POSITION posItemStartDir = xmlTree.Insert(_T("Start_direction"), posRoot, posItemStartPt);
	{ 
		xmlTree.SetAttribute(posItemStartDir, _T("name"), _T("起点方向"));
		m_pXDataMap->GetAt(HRED_StartDir, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemStartDir, csText);
	}

	POSITION posItemEndPt = xmlTree.Insert(_T("End_point"), posRoot, posItemStartDir);
	{ 
		xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("终点位置"));
		m_pXDataMap->GetAt(HRED_EndPoint, pt);
		pt.transformBy(mat);
		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemEndPt, csText);
	}

	POSITION posItemWidthStr = xmlTree.Insert(_T("Width_Start"), posRoot, posItemEndPt);
	{ 
		xmlTree.SetAttribute(posItemWidthStr, _T("name"), _T("起始端宽度"));
		m_pXDataMap->GetAt(HRED_StartWidth, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemWidthStr, csText);
	}

	POSITION posItemWidthEnd = xmlTree.Insert(_T("Width_End"), posRoot, posItemWidthStr);
	{ 
		xmlTree.SetAttribute(posItemWidthEnd, _T("name"), _T("终止端宽度"));
		m_pXDataMap->GetAt(HRED_EndWidth, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemWidthEnd, csText);
	}

	POSITION posItemHghStr = xmlTree.Insert(_T("Height_Start"), posRoot, posItemWidthEnd);
	{ 
		xmlTree.SetAttribute(posItemHghStr, _T("name"), _T("起始端高度"));
		m_pXDataMap->GetAt(HRED_StartThick, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemHghStr, csText);
	}

	POSITION posItemHghEnd = xmlTree.Insert(_T("Height_End"), posRoot, posItemHghStr);
	{ 
		xmlTree.SetAttribute(posItemHghEnd, _T("name"), _T("终止端高度"));
		m_pXDataMap->GetAt(HRED_EndThick, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemHghEnd, csText);
	}

	POSITION posPlusEdge = xmlTree.Insert(_T("PlusEdge"), posRoot, posItemHghEnd);
	{
		xmlTree.SetAttribute(posPlusEdge, _T("name"),_T("咬口法兰翻边余量"));
		m_pXDataMap->GetAt(HVAC_PlusEdge, dValue);
		TAuxTools::DoubleToString(dValue, 1, csText);
		xmlTree.SetItemText(posPlusEdge, csText);
	}

	POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posPlusEdge);
	{
		xmlTree.SetAttribute(posObjId, _T("name"),_T("ID"));
		xmlTree.SetAttribute(posObjId, _T("comment"),_T("变径ID"));

		csText.Format(_T("%ld"), 0x7FFFFFFF & m_pOwnerEnt->objectId().asOldId());
		xmlTree.SetItemText(posObjId, csText);
	}

	// begin
	// add by wc 13-12-13
	POSITION posSysName = xmlTree.Insert(_T("System"), posRoot, posObjId);
	{
		xmlTree.SetAttribute(posSysName, _T("name"), _T("管线类型"));
		xmlTree.SetAttribute(posSysName, _T("comment"), _T("回风/送风/通风..."));
		m_pXDataMap->GetAt(HVAC_System, csText);
		xmlTree.SetItemText(posSysName, csText);
	}

	POSITION posSingleLine = xmlTree.Insert(_T("IsSingleLine"), posRoot, posSysName);
	{
		xmlTree.SetAttribute(posSingleLine, _T("name"), _T("单线"));
		xmlTree.SetAttribute(posSingleLine, _T("comment"), _T("是否是单线: 1/是, 0/不是"));
		csText.Format(_T("%d"), (int)IsSingleLine());
		xmlTree.SetItemText(posSingleLine, csText);
	}

	POSITION posHasLiningLine = xmlTree.Insert(_T("HasLiningLine"), posRoot, posSingleLine);
	{
		xmlTree.SetAttribute(posHasLiningLine, _T("name"), _T("内衬线"));
		xmlTree.SetAttribute(posHasLiningLine, _T("comment"), _T("是否有内衬线:0/不是, 1/是"));
		if (!m_pXDataMap->GetAt(HVAC_HasLining, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posHasLiningLine, csText);
	}

	POSITION posLiningLineType = xmlTree.Insert(_T("LiningLineType"), posRoot, posHasLiningLine);
	{
		AcDbObjectId idType;
		AcDbObject	*pObjType = NULL;
		ACHAR *pChar = NULL;
		xmlTree.SetAttribute(posLiningLineType, _T("name"), _T("内衬线型"));
		xmlTree.SetAttribute(posLiningLineType, _T("comment"), _T("内衬线型的名称"));
		m_pXDataMap->GetAt(HVAC_LiningLine, idType);
		if (Acad::eOk != acdbOpenObject(pObjType, idType, AcDb::kForRead))
		{
		}
		if (NULL != pObjType)
		{
			AcDbLinetypeTableRecord *pRec = AcDbLinetypeTableRecord::cast(pObjType);
			pRec->getName(pChar);
			pRec->close();
			pObjType->close();
			csText.Format(_T("%s"), pChar);
			delete pChar;
		}
		else
			csText.Empty();
	}

	POSITION posIsEdgeWidth = xmlTree.Insert(_T("IsEdgeWidth"), posRoot, posLiningLineType);
	{
		xmlTree.SetAttribute(posIsEdgeWidth, _T("name"), _T("边线是否加粗"));
		xmlTree.SetAttribute(posIsEdgeWidth, _T("comment"), _T("0/不加粗, 1/加粗"));
		if (!m_pXDataMap->GetAt(HVAC_EdgeWeight, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posIsEdgeWidth, csText);
	}

	POSITION posIsCentWidth = xmlTree.Insert(_T("IsCentWidth"), posRoot, posIsEdgeWidth);
	{
		xmlTree.SetAttribute(posIsCentWidth, _T("name"), _T("中线是否加粗"));
		xmlTree.SetAttribute(posIsCentWidth, _T("comment"), _T("0/不加粗, 1/加粗"));
		if (!m_pXDataMap->GetAt(HVAC_CentWeight, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posIsCentWidth, csText);
	}

	POSITION posIsEndWidth = xmlTree.Insert(_T("IsEndWidth"), posRoot, posIsCentWidth);
	{
		xmlTree.SetAttribute(posIsEndWidth, _T("name"), _T("端线是否加粗"));
		xmlTree.SetAttribute(posIsEndWidth, _T("comment"), _T("0/不加粗, 1/加粗"));
		if (!m_pXDataMap->GetAt(HVAC_EndWeight, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posIsEndWidth, csText);
	}

	POSITION posEdgeWidth = xmlTree.Insert(_T("EdgeWidth"), posRoot, posIsEndWidth);
	{
		xmlTree.SetAttribute(posEdgeWidth, _T("name"), _T("边线加粗量"));
		xmlTree.SetAttribute(posEdgeWidth, _T("comment"), _T("边线加粗的数值"));
		m_pXDataMap->GetAt(HVAC_EdgeWidth, dValue);
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posEdgeWidth, csText);
	}

	POSITION posCentWidth = xmlTree.Insert(_T("CentWidth"), posRoot, posEdgeWidth);
	{
		xmlTree.SetAttribute(posCentWidth, _T("name"), _T("中线加粗量"));
		xmlTree.SetAttribute(posCentWidth, _T("comment"), _T("中线加粗的数值"));
		m_pXDataMap->GetAt(HVAC_CentWidth, dValue);
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posCentWidth, csText);
	}

	POSITION posEndWidth = xmlTree.Insert(_T("EndWidth"), posRoot, posCentWidth);
	{
		xmlTree.SetAttribute(posEndWidth, _T("name"), _T("端线加粗量"));
		xmlTree.SetAttribute(posEndWidth, _T("comment"), _T("端线加粗的数值"));
		m_pXDataMap->GetAt(HVAC_EndWidth, dValue);
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posEndWidth, csText);
	}
	// end

	CString csXml = xmlTree.GetXml();

	return csXml;
}

// 点对应图见工程目录下 关键点示意图.dwg
bool THImpHvacReducer::GetSection( const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir, 
								  std::vector<TObjSectionRecord> &sectionRecord, AcDbVoidPtrArray& arFillPtrs ) const
{
	if (NULL == m_pXDataMap)
		return false;

	AcDbObjectId idObj = m_pOwnerEnt->objectId();
	AcDbObjectId idLayer = m_pOwnerEnt->layerId();
	TGGeSectionPlane section_pln(face, vtPlaneSecDir);	

	AcGePoint3d ptStart, ptEnd;
	double dStartWidth(0.0), dStartThick(0.0), dEndWidth(0.0), dEndThick(0.0);
	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);
	
	// 计算开始4点
	AcGeVector3d vtSect = GetSectNormal();
	AcGeVector3d vtPerl = vtSect;
	vtPerl.rotateBy(PI / 2.0, vtNormal);
	vtPerl.normalize();		

	AcGePoint3dArray arPtS, arPtE;		
	arPtS.append(ptStart + dStartWidth * vtPerl*0.5 + dStartThick * vtNormal*0.5 );
	arPtS.append(arPtS.at(0) - dStartWidth * vtPerl);
	arPtS.append(arPtS.last() - dStartThick * vtNormal);
	arPtS.append(arPtS.at(0) - dStartThick * vtNormal);
	
	arPtE.append(ptEnd + dEndWidth * vtPerl*0.5 + dEndThick * vtNormal*0.5 );
	arPtE.append(arPtE.at(0) - dEndWidth * vtPerl);
	arPtE.append(arPtE.last() - dEndThick * vtNormal);
	arPtE.append(arPtE.at(0) - dEndThick * vtNormal);
	

	TGGePoly2D poly2d, poly2dOut;
	
	// 上面
	poly2d.AppendNode(arPtS[0]);
	poly2d.AppendNode(arPtS[1]);
	poly2d.AppendNode(arPtE[1]);
	poly2d.AppendNode(arPtE[0]);
	poly2d.AppendNode(*poly2d.Head());
	
	double dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2d, poly2dOut);
	if(!!poly2dOut) // add by hh 2011-03-11 增加投影后的Poly2D有效型判断
		sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
	
	// 下面
	poly2d.Reset();
	poly2d.AppendNode(arPtS[3]);
	poly2d.AppendNode(arPtS[2]);
	poly2d.AppendNode(arPtE[2]);
	poly2d.AppendNode(arPtE[3]);
	poly2d.AppendNode(*poly2d.Head());
	
	poly2dOut.Reset();
	dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2d, poly2dOut);
	if(!!poly2dOut) // add by hh 2011-03-11 增加投影后的Poly2D有效型判断
		sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
	
	// 前面
	poly2d.Reset();
	poly2d.AppendNode(arPtS[1]);
	poly2d.AppendNode(arPtS[2]);
	poly2d.AppendNode(arPtE[2]);
	poly2d.AppendNode(arPtE[1]);
	poly2d.AppendNode(*poly2d.Head());
			
	poly2dOut.Reset();
	dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2d, poly2dOut);
	if(!!poly2dOut) // add by hh 2011-03-11 增加投影后的Poly2D有效型判断
		sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
	
	// 后面
	poly2d.Reset();
	poly2d.AppendNode(arPtS[0]);
	poly2d.AppendNode(arPtS[3]);
	poly2d.AppendNode(arPtE[3]);
	poly2d.AppendNode(arPtE[0]);
	poly2d.AppendNode(*poly2d.Head());
	
	poly2dOut.Reset();
	dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2d, poly2dOut);
	if(!!poly2dOut) // add by hh 2011-03-11 增加投影后的Poly2D有效型判断
		sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));

	// 有圆形时，要绘制圆圈....
	// ....待细化

	return true;
}

Acad::ErrorStatus THImpHvacReducer::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotImplementedYet;
	

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	AcGeVector3d vtUcsZ = TAuxTools::GetUcsZvt();
	AcGeVector3d vtNormal = normal();
	if (vtNormal.isParallelTo(vtUcsZ))	//  立管上的变径
	{
		if (ptStart.z < ptEnd.z)
		{
			ptLow = ptStart;
			ptUp = ptEnd;
		}
		else
		{
			ptLow = ptEnd;
			ptUp = ptStart;
		}
	}
	else/* if (vtNormal.isPerpendicularTo(vtUcsZ))*/	// 水平管上的，暂不考虑斜管
	{
		double dStartThick(0.0), dEndthick(0.0);
		HvacSectType eSect = TDb::eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
		if (TDb::eRectangular == eSect)
		{
			m_pXDataMap->GetAt(HRED_StartThick, dStartThick);
			m_pXDataMap->GetAt(HRED_EndThick, dEndthick);
		}
		else
		{
			m_pXDataMap->GetAt(HRED_StartDiameter, dStartThick);
			m_pXDataMap->GetAt(HRED_EndDiameter, dEndthick);
		}

		dStartThick *= 0.5;
		dEndthick *= 0.5;
		
		AcGePoint3d ptStaUp = ptStart + vtNormal * dStartThick;
		AcGePoint3d ptStaDw = ptStart - vtNormal * dStartThick;
		AcGePoint3d ptEndUp = ptEnd + vtNormal * dEndthick;
		AcGePoint3d ptEndDw = ptEnd - vtNormal * dEndthick;

		if (ptStaUp.z > ptEndUp.z)
			ptUp = ptStaUp;
			else
			ptUp = ptEndUp;
	
		if (ptStaDw.z < ptEndDw.z)
			ptLow = ptStaDw;
		else
			ptLow = ptEndDw;
	}
	
	return Acad::eOk;		
}

// add by hh 2014-08-06 支持管件与水管遮挡
Acad::ErrorStatus THImpHvacReducer::GetClipBoundary(TGGePoly2D& poly)const
{
	AcDbPolyline* pLine = MakePolyCurve();
	if(NULL == pLine)
		return Acad::eNotImplementedYet;

	double dBrWidth = 0;
	if(!TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEHIDEWIDTH, dBrWidth))
		GetGlobalContext()->GetAt(HVAC_PIPEHIDEWIDTH, dBrWidth);
	if(EQUAL_ZERO(dBrWidth))
	{
		PolyConvert(*pLine, poly);
	}
	else
	{
		AcDbVoidPtrArray arPLines;
		pLine->getOffsetCurves(dBrWidth, arPLines);
		if(0 == arPLines.length())
		{
			PolyConvert(*pLine, poly);
		}
		else
		{
			PolyConvert(*((AcDbPolyline*)arPLines[0]), poly);
			for(int i = 0; i < arPLines.length(); i++)
			{
				if(NULL != arPLines[i])
					delete (AcDbEntity*)arPLines[i];
			}
		}
	}
	delete pLine;

	return Acad::eOk;
}

bool THImpHvacReducer::IsMeClip() const
{
	return true;
}

bool THImpHvacReducer::IsClipMe(const TEntityBase* pEnt)const//ok是否被裁剪
{
	if(NULL == pEnt)
		return false;

	//add by dyw 20150409 当图纸复杂时，遮挡的更改影响水管的绘制速度，暂时屏蔽掉
	return false;
	//add end

	CString sClassName = pEnt->GetMe()->isA()->name();
	if(0 == sClassName.Compare(_T("TDbPipe")))  // 水管
	{
		TInterfaceModifyMsg iMsg;
		iMsg.SetInterfaceOper(TDb::eUpdateCover);
		iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

		// 写入接口更改消息
		TDbInterfaceMsgWrite msgWrite;
		msgWrite.WriteInterfaceMsg(iMsg);

		return true;
	}
	return false;
}