envi-code/SourceCode/Code2026/tg_shs/shs_pipebase/THImpHvacFlange.cpp

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

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

using namespace TDb;


THImpHvacFlange::THImpHvacFlange()
{
}

THImpHvacFlange::~THImpHvacFlange()
{
}

Acad::ErrorStatus THImpHvacFlange::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 THImpHvacFlange::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
{
	ASSERT(NULL != pszName && NULL != pInfo && NULL != m_pXDataMap);

	// 暖通基本参数设置
	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::eFlange);
		}

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

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HVAC_SectType))
	{
		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, HVAC_HasBaseLine))
	{
		pInfo->bVisible = FALSE;
		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);

	// 法兰参数数据设置
	if (0 == _tcsicmp(pszName, HFLN_Type))
	{
		pInfo->bVisible = TRUE;

		// 单线也允许切换，更新位置及连接实体， mcl 09.11.20
		//	pInfo->bEditable = (!bSingleLine && TDb::eSingleLine != eType);
		pInfo->bEditable = TRUE;

		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("单线"));
			pInfo->parlValues->Add(TDb::eSingleLine);
			pInfo->parsValues->Add(_T("双线开口"));
			pInfo->parlValues->Add(TDb::eOpenDbLine);
			pInfo->parsValues->Add(_T("双线封口"));
			pInfo->parlValues->Add(TDb::eCloseDbLine);
			pInfo->parsValues->Add(_T("三线封口"));
			pInfo->parlValues->Add(TDb::eCloseTrLine);
		}

		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 获取各点位置
			AcGePoint3d ptStart, ptEnd, ptMid;
			m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
			m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
			Midpoint(ptStart, ptEnd, ptMid);

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

			// 原来法兰样式和新样式比较,当单线、非单线之间转换时，进行位置及连接件更新
			TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
			m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
			TDb::HvacFlangeType eFlangeNewType = (HvacFlangeType)pInfo->pXData->nVal;
			m_pXDataMap->SetAt(HFLN_Type, eFlangeNewType);

			if (eFlangeType == TDb::eSingleLine && eFlangeNewType != TDb::eSingleLine
				|| eFlangeType != TDb::eSingleLine && eFlangeNewType == TDb::eSingleLine)
			{
				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, KEY_StartSectType) || 0 == _tcsicmp(pszName, KEY_EndSectType))
	{
		pInfo->bVisible = FALSE;
		pInfo->bEditable = FALSE;

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

	// 尺寸计算方式 为了注册列表名，保证其他管件能用到此参数
	if (0 == _tcsicmp(pszName, HRED_ComputeType))
	{
		pInfo->bVisible = FALSE;
		pInfo->bEditable = FALSE;

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

	if (0 == _tcsicmp(pszName, HFLN_SkirtSize))
	{
		pInfo->bEditable = TRUE;
		pInfo->bVisible = !bSingleLine;
		TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);

		return TRUE;
	}

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

		return TRUE;
	}

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

		return TRUE;
	}

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

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

		return TRUE;
	}

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

		// 整体移动
		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 改变顶点变换行为
			AcGePoint3d ptStart;
			m_pXDataMap->GetAt(HFLN_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, HELB_EndPoint))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 整体移动
		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 改变顶点变换行为
			AcGePoint3d ptEnd;
			m_pXDataMap->GetAt(HELB_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 THImpHvacFlange::GetTips(CMapStringToString& mapLable2Tip) const
{
}

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

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

	// 截面类型
	HvacSectType eSectType = eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	switch (eSectType)
	{
	case TDb::eRectangular:	acutPrintf(_T("\n\t\t\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\t\t   截面：圆形"));	break;
	case TDb::eOblate:		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t   截面：扁圆形"));	break;
	}

	// 外围宽
	double dSkirtSize = 0.0;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
    dSkirtSize *= dPScale/100;
	//
	acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t出头量：%.2f"), dSkirtSize);

	// 圆型截面显示直径
	if (TDb::eCircular == eSectType)
	{
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HFLN_Diameter, 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(HFLN_Width, dWidth);
		m_pXDataMap->GetAt(HFLN_Thick, dThick);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t宽度：%.2f\t  厚度：%.2f"), dWidth, dThick);
	}

	// 起点
	AcGePoint3d pt;
	m_pXDataMap->GetAt(HFLN_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(HFLN_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 THImpHvacFlange::IsHorzAlignment() const
{
	// 获得法向量
//	AcGePoint3d ptStart, ptEnd;
//	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
//	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
//	AcGeVector3d vtNormal = ptStart - ptEnd;
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);

	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	AcGeTol tolTmp;
	tolTmp.setEqualPoint(1);
	tolTmp.setEqualVector(/*1*/0.001);//Lixlmodify
	return vtNormal.isParallelTo(vtZAxis, tolTmp);
}

BOOL THImpHvacFlange::IsVertAlignment() const
{
	// 获得方向向量
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	AcGeVector3d vtDir = ptEnd - ptStart;
	
	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);

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

	// 立法兰法向量垂直于Z轴,方向向量平行于Z轴
	return vtNormal.isPerpendicularTo(vtZAxis) && vtDir.isParallelTo(vtZAxis);
}

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

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

	return bSingleLine;
}

void THImpHvacFlange::GetKindName(CString& sName)
{
	sName = _T("TCH_HFLANGE");
}

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

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

	// 获取截面类型
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	// 获取接口截面、宽度、厚度数据key值
	LPCTSTR pszWidthKey, pszThickKey;
	switch (nIndex)
	{
	case 0:
		pszWidthKey = ((TDb::eCircular == eSectType) ? HFLN_Diameter : HFLN_Width);
		pszThickKey = HFLN_Thick;
		break;
	case 1:
		pszWidthKey = ((TDb::eCircular == eSectType) ? HFLN_Diameter : HFLN_Width);
		pszThickKey = HFLN_Thick;
		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 THImpHvacFlange::GetInterface(int nIndex, TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

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

	// 求两端方向
	AcGeVector3d vtStart = ptStart - ptEnd;
	AcGeVector3d vtEnd = ptEnd - ptStart;

	// 单线法兰取中点,不再使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = vtEnd;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * FLANGWIDTH_SINGLE*0.5;
// 		ptEnd = ptTmp + vtDir * FLANGWIDTH_SINGLE*0.5;
// 	}

	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 THImpHvacFlange::GetInterface(const AcGePoint3d& ptConnect,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

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

	// 求两端方向
	AcGeVector3d vtStart = ptStart - ptEnd;

	// 单线法兰取中点，不再使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = -vtStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * FLANGWIDTH_SINGLE*0.5;
// 		ptEnd = ptTmp + vtDir * FLANGWIDTH_SINGLE*0.5;
// 	}

	// 计算测试点到始末点的距离
	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, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(1, pipeInterface);
			return TRUE;
		}
		// 如果末尾接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(1, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtStart);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptEnd);
		GetInterfaceSizeData(1, pipeInterface);
		return TRUE;
	}

	return FALSE;
}

BOOL THImpHvacFlange::HasInterface(const AcGePoint3d& ptConnect,const AcGeVector3d& vtDir)
{
	if (NULL == m_pXDataMap)
		return FALSE;

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

	// 求两端方向
	AcGeVector3d vtStart = ptStart - ptEnd;

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

	// 单线法兰取中点,没有在使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = -vtStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * 0.005;
// 		ptEnd = ptTmp + vtDir * 0.005;
//	}

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

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

	return FALSE;
}

BOOL THImpHvacFlange::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	if ( !idConnect.isValid() )
		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(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);

	// 求两端方向
	AcGeVector3d vtStart = ptStart - ptEnd;

	// 单线法兰取中点，不再使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = -vtStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * FLANGWIDTH_SINGLE*0.5;
// 		ptEnd = ptTmp + vtDir * FLANGWIDTH_SINGLE*0.5;
// 	}

	// 计算测试点到始末点的距离
	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, vtStart))
	{
		m_pXDataMap->SetAt(KEY_IDCNT2, idConnect);
		pEnt->close();
		return TRUE;
	}

	pEnt->close();

	return FALSE;
}

BOOL THImpHvacFlange::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect1,const AcDbObjectId& idConnect2)
{
	if (NULL == m_pXDataMap)
		return FALSE;

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

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

	// 打开对象2
	AcDbEntity* pEnt2;
	if (Acad::eOk != acdbOpenObject(pEnt2, idConnect2, AcDb::kForRead))
	{
		pEnt1->close();
		return FALSE;
	}

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

	// 获取法兰各点位置
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);

	// 求两端方向
	AcGeVector3d vtStart = ptStart - ptEnd;

	// 单线法兰取中点，不再使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = -vtStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * FLANGWIDTH_SINGLE*0.5;
// 		ptEnd = ptTmp + vtDir * FLANGWIDTH_SINGLE*0.5;
// 	}

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

	// 基类指针
	TDbInterfacesObj* pInterfaceObj1 = TDbInterfacesObj::cast(pEnt1);
	TDbInterfacesObj* pInterfaceObj2 = TDbInterfacesObj::cast(pEnt2);
	ASSERT(NULL != pInterfaceObj1 && NULL != pInterfaceObj2);

	// 连接两个对象
	if (dDist1 < 1.e-3 && pInterfaceObj1->HasInterface(ptStart, vtStart)
		&& dDist2 < 1.e-3 && pInterfaceObj2->HasInterface(ptEnd, vtStart))
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, idConnect1);
		m_pXDataMap->SetAt(KEY_IDCNT2, idConnect2);
		pEnt1->close();
		pEnt2->close();
		return TRUE;
	}

	// 连接两个对象
	if (dDist2 < 1.e-3 && pInterfaceObj1->HasInterface(ptEnd, vtStart)
		&& dDist1 < 1.e-3 && pInterfaceObj2->HasInterface(ptStart, vtStart))
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, idConnect2);
		m_pXDataMap->SetAt(KEY_IDCNT2, idConnect1);
		pEnt1->close();
		pEnt2->close();
		return TRUE;
	}

	pEnt1->close();
	pEnt2->close();

	return FALSE;
}

BOOL THImpHvacFlange::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 THImpHvacFlange::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 THImpHvacFlange::ExplodeOrDraw3d(XExplodeDraw &mode) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotImplementedYet;
	
	/*
	// 变径类型
	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 iSectType = 2;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);

	switch (iSectType)
	{
	case TDb::eRectangular:		// 矩形口
		MakeRectangle3D(mode);
		break;
	case TDb::eCircular:		// 圆形口
		MakeCircle3D(mode);
		break;
	case TDb::eOblate:			
		break;
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacFlange::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}
	
	TComplexCurve cplCurve;
	MakeCurves(cplCurve);
	
	TDbExtentsEdge edage;
	edage.SetEdage(cplCurve);
	
	BOOL bWeight = FALSE;
	// 	m_pXDataMap->GetAt(KEY_EDAGEWEIGHT,bWeight);
	
	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* THImpHvacFlange::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);
	*/

	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
	if (IsHorzAlignment())
	{
		switch (eFlangeType)
		{
		case TDb::eSingleLine:		//单线
 			{
 				return MakeSingleLinePolyCurve();
 			}
		case TDb::eOpenDbLine:		//双线开口			
		case TDb::eCloseDbLine:		//双线封口			
		case TDb::eCloseTrLine:		//三线
			{
				return MakeMultiLinePolyCurve();
			}
		default:
			break;
		}			
	}
	else if (IsVertAlignment())
	{
		//立面安装不支持单线遮挡
		if (IsSingleLine())
		{
			return NULL;
		}

		int iSectType = 2;
		m_pXDataMap->GetAt(HVAC_SectType, iSectType);
		switch (iSectType)
		{
		case TDb::eRectangular:		//矩形
			{
				return MakeRectanglePolyCurve();				
			}
		case TDb::eCircular:		//圆形
			{
				return MakeCirclePolyCurve();
			}
		case TDb::eOblate:			//扁圆形
			{
				break;
			}
		default:
			break;
		}		
	}
	//任意角度
	else
	{
		AcDbDatabase* pDb = acdbCurDwg();
		AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));

		AcDbPolyline * pPline = new AcDbPolyline;
		if (NULL == pPline)
			return NULL;
		AcGePoint3dArray arpts,arpts1;
		if(!GetAnyAnglePts(arpts, arpts1))
			return NULL;
		double dEl(0.0);
		AcGePoint3d ptS,ptStart,ptEnd;
		m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
		m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
		ptS = ptStart;
// 		if (ptEnd.z > ptStart.z)
// 		{
// 			ptS = ptEnd;
// 		}

		AcGePoint3d pt1,pt2,pt3;
		pt1 = arpts[0];
		pt2 = arpts[1];
		pt3 = arpts[2];
		pt1.z = ptS.z;
		pt2.z = ptS.z;
		pt3.z = ptS.z;
		AcGePlane plan = GetHidePlane(pt1, pt2, pt3, vtZAxis, dEl);
		int iSectType = 2;
		m_pXDataMap->GetAt(HVAC_SectType, iSectType);
		if (iSectType == TDb::eRectangular)
		{
			if (arpts.length() > 6)
			{
				pPline->addVertexAt(0,arpts[0].convert2d(plan));
				pPline->addVertexAt(1,arpts[5].convert2d(plan));
				pPline->addVertexAt(2,arpts[4].convert2d(plan));
				pPline->addVertexAt(3,arpts[3].convert2d(plan));
			}
			else
			{
				pPline->addVertexAt(0,arpts[0].convert2d(plan));
				pPline->addVertexAt(1,arpts[1].convert2d(plan));
				pPline->addVertexAt(2,arpts[2].convert2d(plan));
				pPline->addVertexAt(3,arpts[3].convert2d(plan));
			}
		}
		else
		{
// Begin---Lixl---Modify---2011-11-22-----倾斜法兰PolyCurve修改
			// 获取绘图数据
 			double dDiameter = 0.0;
 			AcGeVector3d vtDir = AcGeVector3d::kIdentity;
 			m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
 			vtDir = ptEnd - ptStart;
 			vtDir.normalize();

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

			AcGePoint3d ptMid;
			Midpoint(ptStart, ptEnd, ptMid);
			plan.set(ptMid, vtZAxis);

			pt1 = AcGePoint3d::kOrigin.orthoProject(plan);
			plan.set(pt1, vtZAxis);
			dEl = pt1.asVector().length();
			if (!pt1.asVector().isCodirectionalTo(vtZAxis))
			{
				dEl *= -1;
			}

			if (TDb::eSingleLine == eFlangeType)
			{
				// 单线法兰,只画一条
				TAuxTools::GetEllipseFromCircle(ptMid, dDiameter, vtDir, vtZAxis, *pPline);
			}
			else
			{
				AcDbPolyline PStrLine;
				AcDbPolyline PEndLine;
				AcDbPolyline PInSideLine;
				int iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, -vtDir, vtZAxis, PStrLine, -vtDir);
				TAuxTools::GetEllipseFromCircle(ptEnd, dDiameter, vtDir, vtZAxis, PEndLine, vtDir);
				if (ptStart.z > ptEnd.z)
				{
					TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, vtDir, vtZAxis, PInSideLine, vtDir);
				}
				else
				{
					TAuxTools::GetEllipseFromCircle(ptEnd, dDiameter, vtDir, vtZAxis, PInSideLine, -vtDir);
				}

				AcGePoint3d ptNow;
				double dBulge(0.0);
				for (int i = 0; i < (int)PEndLine.numVerts(); i++)
				{
					PEndLine.getBulgeAt(i, dBulge);
					PEndLine.getPointAt(i, ptNow);
					pPline->addVertexAt(i, ptNow.convert2d(plan), dBulge);
				}

				int nNowMax = i;
				int nStartNum = PStrLine.numVerts();	
				for (i = nStartNum - 1; i > -1; i--)
				{
					PStrLine.getBulgeAt(nStartNum - 1 - i, dBulge);
					PStrLine.getPointAt(i, ptNow);
					pPline->addVertexAt(nStartNum - 1 - i + nNowMax , ptNow.convert2d(plan), -dBulge);
				}

				PEndLine.getPointAt(0, ptNow);
				pPline->addVertexAt(pPline->numVerts(), ptNow.convert2d(plan));
				AcDbPolyline pLine;

				if (ptStart.z > ptEnd.z)
				{
					PStrLine.getPointAt(0, ptNow);
					pPline->addVertexAt(pPline->numVerts(), ptNow.convert2d(plan));

					TAuxTools::MergerPline(pPline, &PInSideLine);
				}
				else
				{
					TAuxTools::MergerPline(pPline, &PInSideLine);
				}
			}
// End---------------------------------------------------------------------
		}
		pPline->setNormal(vtZAxis);
		pPline->setElevation(dEl);
//		pPline->setClosed(Adesk::kTrue);
		return pPline;
	}
	return NULL;
}

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

	// 法兰类型
	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
	m_pXDataMap->GetAt(HFLN_Type,(int&) eFlangeType);

	//////////////////////////////////////////////////////////////////////////
	//lm 08.11.10	
	if (IsHorzAlignment())
	{
		switch (eFlangeType)
		{
		case TDb::eSingleLine:		//单线
			{
				return MakeHSingleLine2D(cplCurve);
			}
		case TDb::eOpenDbLine:		//双线开口
			{
				return MakeHOpenDbLine2D(cplCurve);
			}
		case TDb::eCloseDbLine:		//双线封口
			{
				return MakeHCloseDbLine2D(cplCurve);
			}
		case TDb::eCloseTrLine:		//三线
			{
				return MakeHCloseTrLine2D(cplCurve);
			}
		default:
			break;
		}	
			
	}
	else if (IsVertAlignment())
	{
		int iSectType = 2;
		m_pXDataMap->GetAt(HVAC_SectType, iSectType);
		switch (iSectType)
		{
		case TDb::eRectangular:		//矩形
			{
				return MakeRectangle2D(cplCurve);				
			}
		case TDb::eCircular:		//圆形
			{
				return MakeCircle2D(cplCurve);
			}
		case TDb::eOblate:			//扁圆形
			{
				break;
			}
		default:
			break;
		}		
	}
	else
	{
		return MakeCirInclineLine2D(cplCurve);
//		return MakeAnyAngle2D(cplCurve);
	}
	return FALSE;
}

BOOL THImpHvacFlange::GetCurvesInSide(TComplexCurve& compCurve) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	if (IsHorzAlignment())
	{
		// 变径类型
		TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
		m_pXDataMap->GetAt(HFLN_Type,(int&) eFlangeType);

		//二维三线
		ASSERT(NULL != m_pXDataMap);
		// 获取绘图数据
		AcGePoint3d ptBase, ptS, ptE;
		double dSkirtSize = 0.0;
		double dBoardThick = 0.0;
		double dThick = 0.0;
		double dDiameter = 0.0;
		double dWidth = 0.0;
		AcGeVector3d vtDir = AcGeVector3d::kIdentity;
		AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
		int iSectType = 2;
		m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dSkirtSize *= dPScale/100;
		//
		m_pXDataMap->GetAt(HFLN_Thick, dThick);
		m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
		m_pXDataMap->GetAt(HFLN_Width, dWidth);
		
		// 计算方向向量
		AcGePoint3d ptStart, ptEnd;
		m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
			m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);

		if(eFlangeType == TDb::eCloseTrLine)
		{			
			dBoardThick = ptStart.distanceTo(ptEnd);
			vtDir = ptEnd - ptStart;
			vtDir = vtDir.normalize();
			ptBase = ptStart + vtDir * dBoardThick / 2.0;
			m_pXDataMap->GetAt(HVAC_SectType, iSectType);
			m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
			vtDir.rotateBy(PI / 2.0, vtNormal);
			
			// 根据矩形口与圆口的不同情况计算
			if (TDb::eRectangular == iSectType)
			{
				ptS = ptBase + vtDir * (dWidth / 2.0 + dSkirtSize);
				ptE = ptBase - vtDir * (dWidth / 2.0 + dSkirtSize);
			}
			else if (TDb::eCircular == iSectType)
			{
				ptS = ptBase + vtDir * (dDiameter / 2.0 + dSkirtSize);
				ptE = ptBase - vtDir * (dDiameter / 2.0 + dSkirtSize);
			}
			
			// 添加边
			TDb::TCurveElement el;
			memset(&el, 0, sizeof(TDb::TCurveElement));
			double dEdgeWidth = GetEdgeLineWidth();
			el.dWidth = dEdgeWidth;
			if (!IsSingleLine())
			{
				el.ptGe[0] = ptS;
				el.ptGe[1] = ptE;
				el.ptGe[2] = ptE;
				compCurve.append(el);
			}			
		}

		if (IsSingleLine())
		{
			// 添加边
			TDb::TCurveElement el;
			memset(&el, 0, sizeof(TDb::TCurveElement));
			double dEdgeWidth = GetEdgeLineWidth();					
			el.dWidth = dEdgeWidth;
			el.ptGe[0] = ptStart;
			el.ptGe[1] = ptEnd;
			el.ptGe[2] = ptEnd;
			compCurve.append(el);
		}
	}
	else if (IsVertAlignment())
	{
		return FALSE;
	}
	else
	{
//		MakeAnyAngle2D(compCurve, 1);
		MakeCirInclineLine2D(compCurve, 1);
	}
	return compCurve.length() > 0;
}

// mcl 重新启用 2010.03.30
BOOL THImpHvacFlange::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);
	*/
	HvacSectType eSectType = TDb::eOblate;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);

	AcGePoint3d ptS, ptE;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptS);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptE);
	double dDiameter(300.0);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	
	if (IsHorzAlignment())
	{
		switch (eFlangeType)
		{
		case TDb::eSingleLine:		// 单线
				return MakeSigleLineFaces(arFaces);
		case TDb::eOpenDbLine:
		case TDb::eCloseDbLine:
		case TDb::eCloseTrLine:		// 多线
			return MakeMultiLineFaces(arFaces);
		default:
			break;
		}
	}
	else if (IsVertAlignment())
	{
		//立面安装不支持单线遮挡
		if (IsSingleLine())
		{
			return NULL;
		}
		switch (eSectType)
		{
		case TDb::eRectangular:		// 矩形口
			return MakeRectangleFaces(arFaces);
		case TDb::eCircular:		// 圆形口
			return MakeCircleFaces(arFaces);
		case TDb::eOblate:
			break;
		default:
			break;
		}
	}
	//任意角度
	else
	{
		AcDbDatabase* pDb = acdbCurDwg();
		AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
		
		AcDbFace * pFace;
		AcGePoint3dArray arpts,arpts1;
		if(!GetAnyAnglePts(arpts, arpts1))
//		if(!GetInclineAnglePts(arpts, arpts1))
			return FALSE;
		
		if (eSectType == TDb::eRectangular)
		{
			if (arpts.length() > 6)
			{
				pFace = new AcDbFace;
				pFace->setVertexAt(0, arpts[0]);
				pFace->setVertexAt(1, arpts[5]);
				pFace->setVertexAt(2, arpts[4]);
				pFace->setVertexAt(3, arpts[3]);
				arFaces.append(pFace);
			}
			else
			{
				pFace = new AcDbFace;
				pFace->setVertexAt(0, arpts[0]);
				pFace->setVertexAt(1, arpts[1]);
				pFace->setVertexAt(2, arpts[2]);
				pFace->setVertexAt(3, arpts[3]);
				arFaces.append(pFace);
			}
		}
		else if (eSectType == TDb::eCircular)
		{

// 			AcGeCircArc3d circle(arpts[0],arpts[1],arpts[2]);
// 			AcGePoint3d pt = arpts[0];
// 			double dangle = circle.endAng() - circle.startAng();
// 			if (dangle < 0)
// 			{
// 				dangle = -dangle;
// 			}
// 			double dMinDiffAng = PI/12;
// 			GetGlobalContext()->GetAt(KEY_MINDIFFANG,dMinDiffAng);
// 			int nSeg = dangle / dMinDiffAng;
// 			for (int i = 0; i < -2; i++)

// 			{
// 				pFace = new AcDbFace;
// 				pFace->setVertexAt(0, circle.center());
// 				pFace->setVertexAt(1, pt);
// 				pt.rotateBy(dMinDiffAng,AcGeVector3d::kZAxis,circle.center());
// 				pFace->setVertexAt(2, pt);
// 				pFace->setVertexAt(3, circle.center());
// 				arFaces.append(pFace);
// 			}

			// Begin---Lixl---Modify---2011-12-15----倾斜法兰,重新计算消隐面
// 			//粗略计算的Face
//  			int nSize = arpts.length();
// 			if (nSize < 10)
// 			{
// 				return FALSE;
// 			}
// 			AcGePoint3d ptCen = TAuxTools::Mid(arpts[3], arpts[9]);
// 			for (int i = 0; i < nSize - 1; i++)
// 			{
// 				pFace = new AcDbFace;
// 				pFace->setVertexAt(0, ptCen);
// 				pFace->setVertexAt(1, arpts[i]);
// 				pFace->setVertexAt(2, arpts[i + 1]);
// 				pFace->setVertexAt(3, ptCen);
// 				arFaces.append(pFace);
// 			}
// 			pFace = new AcDbFace;
// 			pFace->setVertexAt(0, ptCen);
// 			pFace->setVertexAt(1, arpts[0]);
// 			pFace->setVertexAt(2, arpts[nSize - 1]);
// 			pFace->setVertexAt(3, ptCen);
// 			arFaces.append(pFace);

			AcGePoint3d ptMid;
			Midpoint(ptS, ptE, ptMid);
			AcGePlane planStd(ptMid, vtZAxis);
// 			ptTemp = AcGePoint3d::kOrigin.orthoProject(planStd);
// 			planStd.set(ptTemp, vtZAxis);

			// 两端半圆
			AcGePoint3d ptSS = ptS.orthoProject(planStd);
			AcGePoint3d ptEE = ptE.orthoProject(planStd);
			AcGeVector3d vtStaEvery, vtEndEvery, vtDirect;
			vtDirect = ptEE - ptSS;
			vtDirect.normalize();
			AcGeVector3d vtSide = AcGeVector3d::kZAxis;
			vtSide.rotateBy(-PI * 0.5, vtDirect);

			double dMinAngle(TAuxTools::GetMinDiffAngle());
			int nPartNum = int(PI / dMinAngle) + 1;
			dMinAngle = PI / nPartNum;

			AcGePoint3dArray ptArrSta, ptArrEnd;
			vtDirect = ptE - ptS;
			vtDirect.normalize();

			vtStaEvery = vtDirect.crossProduct(vtZAxis);
			AcGePoint3d ptStaNow, ptEndNow;
			ptStaNow = ptS + vtStaEvery.normalize() * dDiameter * 0.5;
			ptEndNow = ptE + vtStaEvery * dDiameter * 0.5;
			if (TDb::eSingleLine == eFlangeType)
			{
				ptStaNow = ptMid + vtStaEvery * dDiameter * 0.5;
				ptEndNow = ptMid + vtStaEvery * dDiameter * 0.5;
				ptS = ptMid;
				ptE = ptMid;
			}

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

				if (ptS.z > ptE.z)
				{
					ptStaNow.rotateBy(-dMinAngle, -vtDirect, ptS);
					ptEndNow.rotateBy(dMinAngle, -vtDirect, ptE);
				}
				else
				{
					ptStaNow.rotateBy(-dMinAngle, vtDirect, ptS);
					ptEndNow.rotateBy(dMinAngle, vtDirect, ptE);
				}

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

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

			if (TDb::eSingleLine != eFlangeType)
			{
				// 中间矩形区域
				ptArrSta.setLogicalLength(0);
				GetFourKeyPoints(ptArrSta);
				if (4 == ptArrSta.length())
				{
					AcDbFace* pMidFace = new AcDbFace;
					pMidFace->setVertexAt(0, ptArrSta.at(0).orthoProject(planStd));
					pMidFace->setVertexAt(1, ptArrSta.at(1).orthoProject(planStd));
					pMidFace->setVertexAt(2, ptArrSta.at(2).orthoProject(planStd));
					pMidFace->setVertexAt(3, ptArrSta.at(3).orthoProject(planStd));
					arFaces.append(pMidFace);
				}
			}
			// End---------------------------------------------------------------------
		}
		return TRUE;
	}
	return FALSE;
}

double THImpHvacFlange::GetEdgeLineWidth() const
{
	BOOL bShow(FALSE);
	// delete by dyc on 2013-12-12 法兰不应该加粗
	//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 THImpHvacFlange::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;
}

Acad::ErrorStatus THImpHvacFlange::transformBy(const AcGeMatrix3d& xform)
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	
	AcGeVector3d vtOff = xform.translation();
	BOOL bMoveInDuct = IsMovedWithInDuct(vtOff);

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

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

	// 更新点
	m_pXDataMap->SetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->SetAt(HFLN_EndPoint, ptEnd);

	// 原竖向法向不支持旋转带非竖向
	AcGeVector3d vtNormal = normal();
	if (!vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))
	{
		vtNormal.transformBy(xform);
		vtNormal.normalize();
		m_pXDataMap->SetAt(KEY_NORMAL, vtNormal);
	}

	// 设置尺寸
	double dScale = xform.scale();
	double dWidth(0.0), dThick(0.0), dSkitSize(0.0);
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkitSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
//	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
//	if (dPScale < 1.e-3) dPScale = 1.0;
//	dSkitSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	m_pXDataMap->GetAt(HFLN_Thick, dThick);

	dWidth *= dScale;
	dThick *= dScale;
	dSkitSize *= dScale;
	m_pXDataMap->SetAt(HFLN_SkirtSize, dSkitSize);
	m_pXDataMap->SetAt(HFLN_Width, dWidth);
	m_pXDataMap->SetAt(HFLN_Thick, dThick);

	// 传递消息
	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())
		{
			BOOL bAutoCon(FALSE);
			GetGlobalContext(HVAC_AUTOCONNECT, bAutoCon);
			if (bAutoCon)
			{
				TInterfaceModifyMsg iMsg;
				TDbInterfaceMsgWrite msgWrite;
//				if (bMoveInDuct)
//				{
					// 写入接口更改消息
					iMsg.SetInterfaceOper(TDb::eTransformBy);
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetTransform(xform);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
					msgWrite.WriteInterfaceMsg(iMsg);
//				}
				
				if (!bMoveInDuct && TAuxTools::IsAutoWorkConnect())
				{
					// 写入自动融合或断开新管 更改消息
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetTransform(xform.translation());
					iMsg.SetTransform(xform);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
					iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
					msgWrite.WriteInterfaceMsg(iMsg);			
				}
			}

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

	return Acad::eOk;
}

TDb::Position THImpHvacFlange::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 THImpHvacFlange::getStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

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

	// 单线法兰取中点
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = ptEnd - ptStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * 0.005;
// 		ptEnd = ptTmp + vtDir * 0.005;
// 	}

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

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

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

	AcGeVector3d vtStart = ptStart - ptEnd;
	vtStart.normalize();

	// 单线法兰取中点,不再使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = -vtStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * 0.005;
// 		ptEnd = ptTmp + vtDir * 0.005;
// 	}

	// 增加夹点
	gripPoints.append(ptStart);	
	gripPoints.append(ptEnd);

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

	gripPoints.append(ptGeCmd1);
	gripPoints.append(ptGeCmd2);

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacFlange::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(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);

	// 单线法兰取中点，不再使用
// 	TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
// 	m_pXDataMap->GetAt(HFLN_Type, (int &)eFlangeType);
// 	if (TDb::eSingleLine == eFlangeType)
// 	{
// 		AcGePoint3d ptTmp;
// 		Midpoint(ptStart, ptEnd, ptTmp);
// 		AcGeVector3d vtDir = ptEnd - ptStart;
// 		vtDir.normalize();
// 		ptStart = ptTmp - vtDir * 0.005;
// 		ptEnd = ptTmp + vtDir * 0.005;
// 	}

	// 根据捕捉模式处理
	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 THImpHvacFlange::moveStretchPointsAt(const AcDbIntArray& indices,
													  const AcGeVector3d& offset)
{
	if (indices.length() < 2)
		return Acad::eNotImplementedYet;

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
 
	ptStart += offset;
 	ptEnd += offset;
 
	m_pXDataMap->SetAt(HFLN_StartPoint, ptStart);
 	m_pXDataMap->SetAt(HFLN_EndPoint, ptEnd);
 
	if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
 	{
 		//更新自身模型空间的扩展字典的接口信息
 		UpdateInterfaceRec(m_pOwnerEnt->objectId(), offset);
		return Acad::eOk;
	}

	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus THImpHvacFlange::moveGripPointsAt(const AcDbIntArray& indices,
												   const AcGeVector3d& offset)
{
	return OnCHorEqualRMoveGripPointsAt(indices,offset);
}

Acad::ErrorStatus THImpHvacFlange::OnCHorEqualRMoveGripPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);

	// 如果有多个点，则去除命令点后，有多个点时作为移动，单个点时使用该点类型
	TDb::Position ePos;
	if (indices.length() == 1)
	{
		// 单个夹点
		ePos = ExplainGripIndex(indices[0]);
	}
	else
	{
		// 多个夹点
		int iCount = 0;
		TDb::Position eTemp;
		int iPos = indices.length();
		while ((--iPos) >= 0 && iCount < 2)
		{
			eTemp = ExplainGripIndex(indices[iPos]);
			switch (eTemp)
			{
			case TDb::eStart:
			case TDb::eEnd:
				ePos = eTemp;
				iCount++;
				break;
			}
		}

		// 多个命令夹点不处理
		if (iCount == 0)
			return Acad::eOk;

		// 多个非命令夹点，移动整体
		if (iCount > 1)
		{
			// 法兰夹点只是移动操作，移动最后一个夹点
		}
	}

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

	switch(ePos)
	{
	case TDb::eStart:
	case TDb::eEnd:
//		MoveGripRandom(ePos, offset);
//		break;
 		{
			BOOL bMoveInDuct = IsMovedWithInDuct(offset);
 			AcGePoint3d ptNewStart = ptStart + offset;
 			AcGePoint3d ptNewEnd = ptEnd + offset;
 			
 			m_pXDataMap->SetAt(HFLN_StartPoint, ptNewStart);
 			m_pXDataMap->SetAt(HFLN_EndPoint, ptNewEnd);
 

 			if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
 			{
				BOOL bAutoCon(FALSE);
				GetGlobalContext(HVAC_AUTOCONNECT, bAutoCon);
				if (bAutoCon)
				{
  					TInterfaceModifyMsg iMsg;
					if (bMoveInDuct)
					{
						// 创建接口更改消息
 						iMsg.SetMsgPoint(ePos == TDb::eStart ? ptNewStart : ptNewEnd);
 						iMsg.SetGripPosition(ePos);
 						iMsg.SetMoveGripOffset(offset);
 						iMsg.SetMsgValidate(TRUE);
 						iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
 						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
					}
					else if (TAuxTools::IsAutoWorkConnect())
					{
						// 写入自动融合或断开新管 更改消息
						iMsg.SetMsgValidate(TRUE);
						AcGeMatrix3d mat;
						mat.setTranslation(offset);
						iMsg.SetTransform(offset);
						iMsg.SetTransform(mat);
						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
						iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
					}
 					
 					// 写入接口更改消息
 					TDbInterfaceMsgWrite msgWrite;
 					msgWrite.WriteInterfaceMsg(iMsg);
				}

 				//更新自身模型空间的扩展字典的接口信息
 				UpdateInterfaceRec(m_pOwnerEnt->objectId(), offset);
 			}
 		}
		break;

	case TDb::eCommand0:
	case TDb::eCommand1:
		{
			// 获得夹点命令
			CString sCmdStr;
			GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
			if (sCmdStr.IsEmpty())
				return Acad::eNotApplicable;

			// 创建接口更改消息
			TInterfaceModifyMsg iMsg;
			iMsg.SetMsgPoint(ePos == TDb::eCommand0 ? ptStart : ptEnd);
			iMsg.SetGripPosition(ePos);
			iMsg.SetMoveGripOffset(offset);
			iMsg.SetMsgValidate(TRUE);
			iMsg.SetInterfaceOper(TDb::eNewCommand);
			iMsg.SetPreviewObjToCreate(TDb::ePipe, 0);

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

			// 发送消息
			acedPostCommand(_T("\33"));
			acedPostCommand(sCmdStr + _T("\n"));
		}

		break;
	default:
		break;
	}

	return Acad::eOk;
}

// 拖拽管件，支持转向等操作
Acad::ErrorStatus THImpHvacFlange::MoveGripRandom(TDb::Position ePos, const AcGeVector3d& offset )
{	
	AcGePoint3d ptDrag;
	if (ePos == eStart)
		m_pXDataMap->GetAt(HFLN_StartPoint, ptDrag);
	else
		m_pXDataMap->GetAt(HFLN_EndPoint, ptDrag);
	
	TInterfaceModifyMsg iMsg;
	iMsg.SetMsgPoint(ptDrag);
	iMsg.SetGripPosition(ePos);
	iMsg.SetMoveGripOffset(offset);
	iMsg.SetMsgValidate(TRUE);
	iMsg.SetInterfaceOper(eNewCommand);
	iMsg.SetPreviewObjToCreate(eFlange, 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 THImpHvacFlange::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, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint,ptStart);
	m_pXDataMap->GetAt(HFLN_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 = ptStart - ptEnd;
		AcGeVector3d vtEnd = -vtSta;
		
		ptStart += vtOffset;
		ptEnd += vtOffset;
		m_pXDataMap->SetAt(HELB_StartPoint,ptStart);
		m_pXDataMap->SetAt(HELB_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 THImpHvacFlange::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();
	
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint,ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint,ptEnd);
	AcGePoint3d ptGeSOld = ptStart;
	AcGePoint3d ptGeEOld = ptEnd;
	AcGeVector3d vtSta = ptStart - ptEnd;
	AcGeVector3d vtEnd = -vtSta;
	
	ptStart.transformBy(mtTrans);
	ptEnd.transformBy(mtTrans);
	m_pXDataMap->SetAt(HELB_StartPoint,ptStart);
	m_pXDataMap->SetAt(HELB_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;	
	return FALSE;
}

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

	AcGePoint3d ptOrigStart, ptOrigEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptOrigStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptOrigEnd);

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

		// 判断是否是空间连接或导致宽高互换
		if (vtHeighDir.isParallelTo(vtNormal))
			iModiMsg.GetSize(dNewWidth, dNewHeigh);
		else
			iModiMsg.GetSize(dNewHeigh, dNewWidth);
	}
	else if (eSect == TDb::eCircular)
	{
		iModiMsg.GetSize(dNewWidth, dNewHeigh);
		dNewHeigh = dNewWidth;
	}
	
	AcGeVector3d vtOff = iModiMsg.GetMoveGripOffset();
	AcGePoint3d ptNewStart = ptOrigStart + vtOff;
	AcGePoint3d ptNewEnd = ptOrigEnd + vtOff;

	m_pXDataMap->SetAt(HFLN_Width, dNewWidth);
	m_pXDataMap->SetAt(HFLN_Thick, dNewHeigh);
	m_pXDataMap->SetAt(HFLN_StartPoint, ptNewStart);
	m_pXDataMap->SetAt(HFLN_EndPoint, ptNewEnd);

	// 消息传递	
	AcGeVector3d vtLine = ptOrigEnd - ptOrigStart;
	AcDbObjectId idFind;
	if (FindConnect(ptOrigStart, -vtLine, m_pOwnerEnt->objectId(), idFind)) // sta 点的接口
	{
		TInterfaceModifyMsg iMsg = iModiMsg;
		iMsg.SetMsgOperateOn(idFind);
		iMsg.SetMsgPoint(ptOrigStart);
		iModiMsgs.append(iMsg);
	}

	if (FindConnect(ptOrigEnd, vtLine, m_pOwnerEnt->objectId(), idFind)) // End 点的接口
	{
		TInterfaceModifyMsg iMsg = iModiMsg;
		iMsg.SetMsgOperateOn(idFind);
		iMsg.SetMsgPoint(ptOrigEnd);
		iModiMsgs.append(iMsg);
	}

	if (!ptOrigStart.isEqualTo(ptNewStart, g_globalTol))
		((TDbInterfacesObj*)m_pOwnerEnt)->UpdateInterfaceRec(ptOrigStart, ptNewStart);
	if (!ptOrigEnd.isEqualTo(ptNewEnd, g_globalTol))
		((TDbInterfacesObj*)m_pOwnerEnt)->UpdateInterfaceRec(ptOrigEnd, ptNewEnd);

	return TRUE;
}

BOOL THImpHvacFlange::MakeRectangle2D(TComplexCurve& cplCurve) const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取绘图数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dThick = 0.0;
	double dWidth = 0.0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	ptBase = ptEnd.z > ptStart.z ? ptEnd:ptStart;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);

	// 计算方向向量
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtXDir = vtNormal;
	AcGeVector3d vtYDir = vtXDir;
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	vtYDir.rotateBy(PI / 2.0, vtZAxis);	
	vtXDir = vtXDir.normalize();
	vtYDir = vtYDir.normalize();

	// 获取矩形端点
	ptS = ptBase + vtXDir * (dThick / 2.0 + dSkirtSize);
	ptE = ptBase - vtXDir * (dThick / 2.0 + dSkirtSize);
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS + vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptS2 = ptS - vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptE1 = ptE + vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptE2 = ptE - vtYDir * (dWidth / 2.0 + dSkirtSize);
	
	// 添加矩形边
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;

	if (IsSingleLine())
	{
		el.ptGe[0] = ptStart;
		el.ptGe[1] = ptEnd;
		el.ptGe[2] = ptEnd;
		cplCurve.append(el);
		return TRUE;
	}
	el.ptGe[0] = ptS1;
	el.ptGe[1] = ptE1;
	el.ptGe[2] = ptE1;
	cplCurve.append(el);

	el.ptGe[0] = ptE1;
	el.ptGe[1] = ptE2;
	el.ptGe[2] = ptE2;
	cplCurve.append(el);

	el.ptGe[0] = ptE2;
	el.ptGe[1] = ptS2;
	el.ptGe[2] = ptS2;
	cplCurve.append(el);

	el.ptGe[0] = ptS2;
	el.ptGe[1] = ptS1;
	el.ptGe[2] = ptS1;
	cplCurve.append(el);

// 	ptS = ptBase + vtXDir * dThick / 2.0;
// 	ptE = ptBase - vtXDir * dThick / 2.0;
// 	ptS1 = ptS + vtYDir * dWidth / 2.0;
// 	ptS2 = ptS - vtYDir * dWidth / 2.0;
// 	ptE1 = ptE + vtYDir * dWidth / 2.0;
// 	ptE2 = ptE - vtYDir * dWidth / 2.0;
// 
// 	el.ptGe[0] = ptS1;
// 	el.ptGe[1] = ptE1;
// 	el.ptGe[2] = ptE1;
// 	cplCurve.append(el);
// 	
// 	el.ptGe[0] = ptE1;
// 	el.ptGe[1] = ptE2;
// 	el.ptGe[2] = ptE2;
// 	cplCurve.append(el);
// 	
// 	el.ptGe[0] = ptE2;
// 	el.ptGe[1] = ptS2;
// 	el.ptGe[2] = ptS2;
// 	cplCurve.append(el);
// 	
// 	el.ptGe[0] = ptS2;
// 	el.ptGe[1] = ptS1;
// 	el.ptGe[2] = ptS1;
// 	cplCurve.append(el);

	return cplCurve.length() > 0;
}

BOOL THImpHvacFlange::MakeCircle2D(TComplexCurve& cplCurve) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取绘图数据
	AcGePoint3d ptBase, ptArcH1, ptArcH2, ptArcV1, ptArcV2;
	double dSkirtSize = 0.0;
	double dDiameter = 0.0;	
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	ptBase = ptEnd.z > ptStart.z ? ptEnd:ptStart;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);	

	// 计算方向向量
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtXDir = vtNormal;
	AcGeVector3d vtYDir = vtXDir;
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	vtYDir.rotateBy(PI / 2.0, vtZAxis);	
	vtXDir = vtXDir.normalize();
	vtYDir = vtYDir.normalize();
	
	// 计算圆上的点
	ptArcH1 = ptBase + vtYDir * (dDiameter / 2.0 + dSkirtSize);
	ptArcH2 = ptBase - vtYDir * (dDiameter / 2.0 + dSkirtSize);
	ptArcV1 = ptBase + vtXDir * (dDiameter / 2.0 + dSkirtSize);
	ptArcV2 = ptBase - vtXDir * (dDiameter / 2.0 + dSkirtSize);

	// 添加两段圆弧（两个半圆组成一个园）
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;
	el.ptGe[0] = ptArcH1;
	el.ptGe[1] = ptArcV1;
	el.ptGe[2] = ptArcH2;
	cplCurve.append(el);

	el.ptGe[0] = ptArcH1;
	el.ptGe[1] = ptArcV2;
	el.ptGe[2] = ptArcH2;
	cplCurve.append(el);

// 	ptArcH1 = ptBase + vtYDir * dDiameter / 2.0;
// 	ptArcH2 = ptBase - vtYDir * dDiameter / 2.0;
// 	ptArcV1 = ptBase + vtXDir * dDiameter / 2.0;
// 	ptArcV2 = ptBase - vtXDir * dDiameter / 2.0;
// 
// 	el.ptGe[0] = ptArcH1;
// 	el.ptGe[1] = ptArcV1;
// 	el.ptGe[2] = ptArcH2;
// 	cplCurve.append(el);
// 	
// 	el.ptGe[0] = ptArcH1;
// 	el.ptGe[1] = ptArcV2;
// 	el.ptGe[2] = ptArcH2;
// 	cplCurve.append(el);

	return cplCurve.length() > 0;
}

// mcl,修正单线长度问题 2010.03.29
BOOL THImpHvacFlange::MakeHSingleLine2D(TComplexCurve& cplCurve) const
{	
	//二维单线
	ASSERT(NULL != m_pXDataMap);
	
	// 获取绘图数据
	int iSectType = 2;
	AcGePoint3d ptStart, ptEnd, ptBase;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	ptBase = TAuxTools::Mid(ptStart, ptEnd);
	
	// 计算方向向量
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	vtDir.rotateBy(PI / 2.0, vtNormal);

	double dSkirtSize = 0.0;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//

	// 添加边
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;
	if (!IsSingleLine())
	{
		if (TDb::eRectangular == iSectType)
		{
			double dWidth = 0.0;
			m_pXDataMap->GetAt(HFLN_Width, dWidth);
			dWidth *= 0.5;
			el.ptGe[0] = ptBase - vtDir * (dWidth + dSkirtSize);
			el.ptGe[1] = ptBase + vtDir * (dWidth + dSkirtSize);
			el.ptGe[2] = el.ptGe[1];
			cplCurve.append(el);
		}
		else if (TDb::eCircular == iSectType)
		{
			double dDiameter = 0.0;
			m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
			dDiameter *= 0.5;
			el.ptGe[0] = ptBase - vtDir * (dDiameter + dSkirtSize);
			el.ptGe[1] = ptBase + vtDir * (dDiameter + dSkirtSize);
			el.ptGe[2] = el.ptGe[1];
			cplCurve.append(el);
		}
	}
	else
	{
		el.ptGe[0] = ptStart;
		el.ptGe[1] = ptEnd;
		el.ptGe[2] = ptEnd;
		cplCurve.append(el);
	}

	return cplCurve.length() > 0;
}

BOOL THImpHvacFlange::MakeHOpenDbLine2D(TComplexCurve& cplCurve) const
{	
	// 二维双线开口
	ASSERT(NULL != m_pXDataMap);
	
	// 获取绘图数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dWidth = 0.0;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	int iSectType = 2;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);

	// 计算方向向量
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	ptBase = ptStart + vtDir * dBoardThick / 2.0;	
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtDir.rotateBy(PI / 2.0, vtNormal);

	// 根据矩形口与圆口的不同情况计算
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptBase + vtDir * (dWidth / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dWidth / 2.0 + dSkirtSize);
	}
	else if (TDb::eCircular == iSectType)
	{
		ptS = ptBase + vtDir * (dDiameter / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dDiameter / 2.0 + dSkirtSize);
	}
	else
	{
		return FALSE;
	}

	// 计算图形端点
	AcGeVector3d vtPDir = vtDir;
	vtPDir.rotateBy(PI / 2.0, vtNormal);
	vtPDir = vtPDir.normalize();
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS + vtPDir * dBoardThick / 2.0;
	ptS2 = ptS - vtPDir * dBoardThick / 2.0;
	ptE1 = ptE + vtPDir * dBoardThick / 2.0;
	ptE2 = ptE - vtPDir * dBoardThick / 2.0;

	// 添加边
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;
	if (!IsSingleLine())
	{
		el.ptGe[0] = ptS1;
		el.ptGe[1] = ptE1;
		el.ptGe[2] = ptE1;
		cplCurve.append(el);
		
		el.ptGe[0] = ptS2;
		el.ptGe[1] = ptE2;
		el.ptGe[2] = ptE2;
		cplCurve.append(el);
	}
	else
	{
		el.ptGe[0] = ptStart;
		el.ptGe[1] = ptEnd;
		el.ptGe[2] = ptEnd;
		cplCurve.append(el);
	}
	

	return cplCurve.length() > 0;
}

BOOL THImpHvacFlange::MakeHCloseDbLine2D(TComplexCurve& cplCurve) const
{	
	// 二维双线封闭
	ASSERT(NULL != m_pXDataMap);

	// 获取绘图数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dWidth = 0.0;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	int iSectType = 2;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);

	// 计算方向向量
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	ptBase = ptStart + vtDir * dBoardThick / 2.0;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtDir.rotateBy(PI / 2.0, vtNormal);
	
	// 根据矩形口与圆口的不同情况计算
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptBase + vtDir * (dWidth / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dWidth / 2.0 + dSkirtSize);
	}
	else if (TDb::eCircular == iSectType)
	{
		ptS = ptBase + vtDir * (dDiameter / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dDiameter / 2.0 + dSkirtSize);
	}
	else
	{
		return FALSE;
	}

	// 计算图形端点
	AcGeVector3d vtPDir = vtDir;
	vtPDir.rotateBy(PI / 2.0, vtNormal);
	vtPDir = vtPDir.normalize();
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;

	ptS1 = ptS + vtPDir * (dBoardThick / 2.0);
	ptS2 = ptS - vtPDir * (dBoardThick / 2.0);
	ptE1 = ptE + vtPDir * (dBoardThick / 2.0);
	ptE2 = ptE - vtPDir * (dBoardThick / 2.0);

	// 添加边
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;
	if (!IsSingleLine())
	{
		el.ptGe[0] = ptS1;
		el.ptGe[1] = ptE1;
		el.ptGe[2] = ptE1;
		cplCurve.append(el);
		
		el.ptGe[0] = ptS2;
		el.ptGe[1] = ptE2;
		el.ptGe[2] = ptE2;
		cplCurve.append(el);
		
		el.ptGe[0] = ptS1;
		el.ptGe[1] = ptS2;
		el.ptGe[2] = ptS2;
		cplCurve.append(el);
		
		el.ptGe[0] = ptE1;
		el.ptGe[1] = ptE2;
		el.ptGe[2] = ptE2;
		cplCurve.append(el);
	}
	else
	{
		el.ptGe[0] = ptStart;
		el.ptGe[1] = ptEnd;
		el.ptGe[2] = ptEnd;
		cplCurve.append(el);
	}
	
	
	return cplCurve.length() > 0;
}

BOOL THImpHvacFlange::MakeAnyAngle2D(TComplexCurve& cplCurve, int nType) const
{	
	// 二维双线封闭
	ASSERT(NULL != m_pXDataMap);
	//arpts是外轮廓线点数组，arpts1是内轮廓线点数组，
	AcGePoint3dArray arpts, arpts1;
	if(!GetAnyAnglePts(arpts, arpts1))
		return FALSE;
	// 获取绘图数据

	int iSectType = 2;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	// 添加边
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;
	// 根据矩形口与圆口的不同情况计算
	if (TDb::eRectangular == iSectType)
	{
		//外轮廓
		if (nType == 0)
		{
			for (int i = 1; i < arpts.length();i++)
			{
				el.ptGe[0] = arpts[i - 1];
				el.ptGe[1] = arpts[i];
				el.ptGe[2] = arpts[i];
				cplCurve.append(el);
			}
		}
		//内部线
		else if (nType == 1)
		{
			for (int i = 1; i < arpts1.length();i++)
			{
				el.ptGe[0] = arpts1[i - 1];
				el.ptGe[1] = arpts1[i];
				el.ptGe[2] = arpts1[i];
				cplCurve.append(el);
			}
		}
		
	}
	else if (TDb::eCircular == iSectType)
	{
		// 获取绘图数据
		AcGePoint3d ptSU, ptSD, ptEU,ptED;
		double dSkirtSize = 0.0;
		double dBoardThick = 0.0;
		double dThick = 0.0;
		double dDiameter = 0.0;
		double dWidth = 0.0;
		AcGeVector3d vtDir = AcGeVector3d::kIdentity;
		AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
		int iSectType = 2;
		m_pXDataMap->GetAt(HVAC_SectType, iSectType);
		m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dSkirtSize *= dPScale/100;
		//
		m_pXDataMap->GetAt(HFLN_Thick, dThick);
		m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
		m_pXDataMap->GetAt(HFLN_Width, dWidth);
		
		// 计算方向向量
		AcGePoint3d ptStart, ptEnd;
		m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
		m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
		dBoardThick = ptStart.distanceTo(ptEnd);
		vtDir = ptEnd - ptStart;
		vtDir = vtDir.normalize();
		m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
		vtNormal.normalize();
		AcGeVector3d vtCross = vtNormal.crossProduct(vtDir);
		vtCross.normalize();
		dWidth *= 0.5;
		dThick *=0.5;

		// 获得UCS坐标Z向量
		AcDbDatabase* pDb = acdbCurDwg();
		AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
		AcGeVector3d vtX = vtCross;
		vtX.rotateBy(PI * 0.5, vtZAxis);
		BOOL bDrawinside = FALSE;
		//开始点和终止点互换
		if (ptEnd.z > ptStart.z)
		{
			vtX *= -1;
			bDrawinside = TRUE;
		}
		AcDbPolyline pPolyLine, pPolyLine1, pPolyLine2, pPolyLine3, pPolyLine4;
		AcGePoint3dArray arPtsEll;
		int iRes = -1;
		double dBigCir = dDiameter + dSkirtSize * 2;

		//内部线
		if (nType == 1)
		{
			//如果法兰向上将绘制内部线，向下将不绘制内部线
			if (bDrawinside)
			{
				return 0;
			}
			//Star小圆
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, vtDir, vtZAxis, pPolyLine1,-vtX);
			if (iRes == 2)
			{
				arPtsEll.setLogicalLength(0);
				TAuxTools::GetArcPoint(pPolyLine1, arPtsEll);//Lixl add 2011-11-23
				for(int i = 0; i < arPtsEll.length()-1; i++)
				{
					el.ptGe[0] = arPtsEll[i];
					el.ptGe[1] = arPtsEll[i+1];
					el.ptGe[2] = arPtsEll[i+1];
					cplCurve.append(el);				
				}
// 				el.ptGe[0] = arPtsEll[0];
// 				el.ptGe[1] = arPtsEll[1];
// 				el.ptGe[2] = arPtsEll[2];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[2];				
// 				el.ptGe[1] = arPtsEll[3];
// 				el.ptGe[2] = arPtsEll[4];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[4];
// 				el.ptGe[1] = arPtsEll[5];
// 				el.ptGe[2] = arPtsEll[6];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[0];
// 				el.ptGe[1] = arPtsEll[3] - vtCross * dDiameter;
// 				el.ptGe[2] = arPtsEll[6];
// 				cplCurve.append(el);
			}
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, vtDir, vtZAxis, pPolyLine2,vtX);
			if (iRes == 2)
			{
				arPtsEll.setLogicalLength(0);
				TAuxTools::GetArcPoint(pPolyLine2, arPtsEll);//Lixl add 2011-11-23
				for(int i = 0; i < arPtsEll.length()-1; i++)
				{
					el.ptGe[0] = arPtsEll[i];
					el.ptGe[1] = arPtsEll[i+1];
					el.ptGe[2] = arPtsEll[i+1];
					cplCurve.append(el);				
				}
// 				el.ptGe[0] = arPtsEll[0];
// 				el.ptGe[1] = arPtsEll[1];
// 				el.ptGe[2] = arPtsEll[2];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[2];				
// 				el.ptGe[1] = arPtsEll[3];
// 				el.ptGe[2] = arPtsEll[4];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[4];
// 				el.ptGe[1] = arPtsEll[5];
// 				el.ptGe[2] = arPtsEll[6];
// 				cplCurve.append(el);
			}
			/*
			//Star大圆如果显示真实宽度 iRes = 2
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dBigCir, vtDir, vtZAxis, pPolyLine3,vtX);
			if (iRes == 3)
			{
				arPtsEll.setLogicalLength(0);
				TAuxTools::GetArcPoint(pPolyLine3, arPtsEll);
				el.ptGe[0] = arPtsEll[0];
				el.ptGe[1] = arPtsEll[1];
				el.ptGe[2] = arPtsEll[2];
				cplCurve.append(el);
				el.ptGe[0] = arPtsEll[2];				
				el.ptGe[1] = arPtsEll[3];
				el.ptGe[2] = arPtsEll[4];
				cplCurve.append(el);
				el.ptGe[0] = arPtsEll[4];
				el.ptGe[1] = arPtsEll[5];
				el.ptGe[2] = arPtsEll[6];
				cplCurve.append(el);
			}
			*/
		}
		//外轮廓
		if (nType == 0)
		{
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dBigCir, vtDir, vtZAxis, pPolyLine4,-vtX);
			if (iRes == 2)
			{
				arPtsEll.setLogicalLength(0);
				TAuxTools::GetArcPoint(pPolyLine4, arPtsEll);//Lixl add 2011-11-23
				for(int i = 0; i < arPtsEll.length()-1; i++)
				{
					el.ptGe[0] = arPtsEll[i];
					el.ptGe[1] = arPtsEll[i+1];
					el.ptGe[2] = arPtsEll[i+1];
					cplCurve.append(el);				
				}
// 				el.ptGe[0] = arPtsEll[0];
// 				el.ptGe[1] = arPtsEll[1];
// 				el.ptGe[2] = arPtsEll[2];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[2];				
// 				el.ptGe[1] = arPtsEll[3];
// 				el.ptGe[2] = arPtsEll[4];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[4];
// 				el.ptGe[1] = arPtsEll[5];
// 				el.ptGe[2] = arPtsEll[6];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[6];
// 				el.ptGe[1] = arPtsEll[3] + vtCross * dBigCir;
// 				el.ptGe[2] = arPtsEll[0];
// 				cplCurve.append(el);
// 				ptSU = arPtsEll[0];
// 				ptSD = arPtsEll[6];
			}
////////////////////////////////////////////////////////////////////
			//Star大圆如果显示真实宽度 iRes = 3
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dBigCir, vtDir, vtZAxis, pPolyLine3,vtX);
			if (iRes == 2)
			{
				arPtsEll.setLogicalLength(0);
				TAuxTools::GetArcPoint(pPolyLine3, arPtsEll);//Lixl add 2011-11-23
				for(int i = 0; i < arPtsEll.length()-1; i++)
				{
					el.ptGe[0] = arPtsEll[i];
					el.ptGe[1] = arPtsEll[i+1];
					el.ptGe[2] = arPtsEll[i+1];
					cplCurve.append(el);				
				}
// 				el.ptGe[0] = arPtsEll[6];
// 				el.ptGe[1] = arPtsEll[5];
// 				el.ptGe[2] = arPtsEll[4];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[4];				
// 				el.ptGe[1] = arPtsEll[3];
// 				el.ptGe[2] = arPtsEll[2];
// 				cplCurve.append(el);
// 				el.ptGe[0] = arPtsEll[2];
// 				el.ptGe[1] = arPtsEll[1];
// 				el.ptGe[2] = arPtsEll[0];
// 				cplCurve.append(el);
			}
			/*
			//End大圆如果显示真实宽度 iRes = 2
			iRes = TAuxTools::GetEllipseFromCircle(ptEnd, dBigCir, vtDir, vtZAxis, pPolyLine,vtX);
			if (iRes == 3)
			{
				arPtsEll.setLogicalLength(0);
				TAuxTools::GetArcPoint(pPolyLine, arPtsEll);
				el.ptGe[0] = arPtsEll[0];
				el.ptGe[1] = arPtsEll[1];
				el.ptGe[2] = arPtsEll[2];
				cplCurve.append(el);
				el.ptGe[0] = arPtsEll[2];				
				el.ptGe[1] = arPtsEll[3];
				el.ptGe[2] = arPtsEll[4];
				cplCurve.append(el);
				el.ptGe[0] = arPtsEll[4];
				el.ptGe[1] = arPtsEll[5];
				el.ptGe[2] = arPtsEll[6];
				cplCurve.append(el);
				ptEU = arPtsEll[6];
				ptED = arPtsEll[0];

				el.ptGe[0] = ptSU;
				el.ptGe[1] = ptEU;
				el.ptGe[2] = ptEU;
				cplCurve.append(el);
				el.ptGe[0] = ptSD;				
				el.ptGe[1] = ptED;
				el.ptGe[2] = ptED;
				cplCurve.append(el);
			}
			*/
		}
	}
	return cplCurve.length() > 0;
}

void GetArcPoint(AcDbPolyline &polyLine, AcGePoint3dArray &ptArcArr)
{
	if (polyLine.numVerts() != 4)
		return;

	double dPara1(0.0), dPara2(0.0);
	double dPar1, dPar2;
	AcGePoint3d pt0, pt1, pt2, pt3, ptMid;

	polyLine.getPointAt(0, pt0);
	polyLine.getPointAt(1, pt1);
	polyLine.getPointAt(2, pt2);
	polyLine.getPointAt(3, pt3);

	polyLine.getParamAtPoint(pt0, dPar1);
	polyLine.getParamAtPoint(pt1, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
	ptArcArr.append(pt0);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt1);

	polyLine.getParamAtPoint(pt1, dPar1);
	polyLine.getParamAtPoint(pt2, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt2);

	polyLine.getParamAtPoint(pt2, dPar1);
	polyLine.getParamAtPoint(pt3, dPar2);
	polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
	ptArcArr.append(ptMid);
	ptArcArr.append(pt3);

	if (polyLine.isClosed())
	{
		polyLine.getParamAtPoint(pt3, dPar1);
		polyLine.getEndParam(dPar2);
		polyLine.getPointAtParam((dPar1 + dPar2)*0.5, ptMid);
		ptArcArr.append(ptMid);
		ptArcArr.append(pt0);
	}
}

// LixlAdd绘制倾斜法兰二维图形
BOOL THImpHvacFlange::MakeCirInclineLine2D(TComplexCurve& cplCurve, int nType/* = 0*/) const
{
	ASSERT(NULL != m_pXDataMap);

	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	HvacFlangeType eFlType = TDb::eSingleLine;
	m_pXDataMap->GetAt(HFLN_Type, (int&)eFlType);
	double dDiameter(200.0);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	if (TDb::eRectangular == eSectType)
	{
//		MakeAnyAngle2D(cplCurve, nType);
		TDb::HvacFlangeType eFlangeType = TDb::eSingleLine;
		m_pXDataMap->GetAt(HFLN_Type,(int&) eFlangeType);
		switch (eFlangeType)
		{
		case TDb::eSingleLine:		//单线
			{
				return MakeHSingleLine2D(cplCurve);
			}
		case TDb::eOpenDbLine:		//双线开口
			{
				return MakeHOpenDbLine2D(cplCurve);
			}
		case TDb::eCloseDbLine:		//双线封口
			{
				return MakeHCloseDbLine2D(cplCurve);
			}
		case TDb::eCloseTrLine:		//三线
			{
				return MakeHCloseTrLine2D(cplCurve);
			}
		default:
			break;
		}	
	}
	else if (TDb::eCircular == eSectType && 1 == nType)
	{
		//arpts是ptStart法兰面数组，arpts1是ptEnd面数组
		AcGePoint3dArray arpts, arpts1;
	
		// 添加边
		TDb::TCurveElement el;
		memset(&el, 0, sizeof(TDb::TCurveElement));
		double dEdgeWidth = GetEdgeLineWidth();
		el.dWidth = dEdgeWidth;
		int i = 0;
		AcGePoint3d ptStart, ptEnd;
		m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
		m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
		if (0 == nType)
		{
			AcGeVector3d vtDir = ptEnd - ptStart;
			vtDir.normalize();
			AcGeVector3d vtZAxis = TAuxTools::GetUcsZvt();
			AcDbPolyline *pPolyLine = new AcDbPolyline;
			if (NULL == pPolyLine)
				return FALSE;
			int iRes(0);
			
			if (TDb::eSingleLine == eFlType)
			{
				// 单线法兰,只画一条
				AcGePoint3d ptMid;
				Midpoint(ptStart, ptEnd, ptMid);
				
				iRes = TAuxTools::GetEllipseFromCircle(ptMid, dDiameter, vtDir, vtZAxis, *pPolyLine);
				if (iRes == 2)
				{
					arpts.setLogicalLength(0);
					TAuxTools::GetArcPoint(*pPolyLine, arpts);
					for (i = 0; i < arpts.length()-1; i++)
					{
						el.ptGe[0] = arpts[i];
						el.ptGe[1] = arpts[i+1];
						el.ptGe[2] = arpts[i+1];
						cplCurve.append(el);
					}
				}
			}
			else
			{
				// 两条边
				GetFourKeyPoints(arpts);
				if (arpts.length() > 0)
				{
					el.ptGe[0] = arpts[0];
					el.ptGe[1] = arpts[1];
					el.ptGe[2] = arpts[1];
					cplCurve.append(el);

					el.ptGe[0] = arpts[2];
					el.ptGe[1] = arpts[3];
					el.ptGe[2] = arpts[3];
					cplCurve.append(el);
				}

				//ptEnd圆末端半个椭圆(向外)
				iRes = TAuxTools::GetEllipseFromCircle(ptEnd, dDiameter, vtDir, vtZAxis, *pPolyLine, vtDir);
				if (iRes == 2)
				{
					arpts.setLogicalLength(0);
					TAuxTools::GetArcPoint(*pPolyLine, arpts);

	// 				for (i = 0; i < arpts.length(); i++)
	// 				{
	// 					if (i > 1 && i%2 == 0)
	// 					{
	// 						el.ptGe[0] = arpts[i-2];
	// 						el.ptGe[1] = arpts[i-1];
	// 						el.ptGe[2] = arpts[i];
	// 						cplCurve.append(el);
	// 					}
	// 				}
					for (i = 0; i < arpts.length()-1; i++)
					{
						el.ptGe[0] = arpts[i];
						el.ptGe[1] = arpts[i+1];
						el.ptGe[2] = arpts[i+1];
						cplCurve.append(el);
					}
				}

				pPolyLine->reset(Adesk::kFalse, i);

				//ptStart截面,半个椭圆(向外)
				iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, -vtDir, vtZAxis, *pPolyLine, -vtDir);
				if (iRes == 2)
				{
					arpts1.setLogicalLength(0);
					TAuxTools::GetArcPoint(*pPolyLine, arpts1);
					for (i = 0; i < arpts1.length()-1; i++)
					{
						el.ptGe[0] = arpts1[i];
						el.ptGe[1] = arpts1[i+1];
						el.ptGe[2] = arpts1[i+1];
						cplCurve.append(el);
					}
				}

				pPolyLine->reset(Adesk::kFalse, i);

				// 根据高度,画ptStart或者ptEnd截面中,向内的半个类似椭圆的多段线
				arpts1.setLogicalLength(0);
				if (ptStart.z > ptEnd.z)
				{
					iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, vtDir, vtZAxis, *pPolyLine, vtDir);
					if (iRes == 2)
					{
						TAuxTools::GetArcPoint(*pPolyLine, arpts1);
						for (i = 0; i < arpts1.length()-1; i++)
						{
							el.ptGe[0] = arpts1[i];
							el.ptGe[1] = arpts1[i+1];
							el.ptGe[2] = arpts1[i+1];
							cplCurve.append(el);
						}
					}
				}
				else									
				{
					iRes = TAuxTools::GetEllipseFromCircle(ptEnd, dDiameter, vtDir, vtZAxis, *pPolyLine, -vtDir);
					if (iRes == 2)
					{
						TAuxTools::GetArcPoint(*pPolyLine, arpts);
						for (i = 0; i < arpts.length()-1; i++)
						{
							el.ptGe[0] = arpts[i];
							el.ptGe[1] = arpts[i+1];
							el.ptGe[2] = arpts[i+1];
							cplCurve.append(el);
						}
					}
				}
			}

			if (NULL != pPolyLine)
				delete pPolyLine;
		}
	}
	return cplCurve.length() > 0;
}

// 倾斜法兰绘制方法和风管统一,即利用画风管方法画法兰Lixl
void THImpHvacFlange::GetFourKeyPoints( AcGePoint3dArray &ptArr ) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获得法兰数据
	AcGePoint3d ptS, ptE;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptS);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptE);

	AcGeVector3d vtNormal, vtZAxis(TAuxTools::GetUcsZvt());
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	if (vtNormal.length() < 1E-9)
		return;

	HvacSectType eSectType = eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	double dWidth(0.0), dHeigh(0.0);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	m_pXDataMap->GetAt(HFLN_Thick, dHeigh);

	// 不同截面,不同处理,暂时只处理倾斜圆管,后续需要,自定添加
	if (TDb::eRectangular == eSectType)
	{
	}
	else if (TDb::eCircular == eSectType)
	{
		double dHalfWidth = dWidth * 0.5;

		AcGePoint3d ptMid;
		Midpoint(ptS, ptE, ptMid);
		AcGePlane plan(ptMid, vtZAxis);

		if (!IsHorzAlignment())
		{
			AcGePoint3d ptSOnPlan = ptS.orthoProject(plan);
			AcGePoint3d ptEOnPlan = ptE.orthoProject(plan);
			AcGeVector3d vtDirOnPlan = ptEOnPlan - ptSOnPlan;
			vtDirOnPlan.normalize();

			// vtSide是垂直于法向和法兰方向的向量,用于求沿法兰方向的中心截面的四个点
			AcGeVector3d vtSide = vtZAxis;
			vtSide.rotateBy(-PI * 0.5, vtDirOnPlan);

			ptArr.append(ptS - dHalfWidth * vtSide);
			ptArr.append(ptE - dHalfWidth * vtSide);
			ptArr.append(ptE + dHalfWidth * vtSide);
			ptArr.append(ptS + dHalfWidth * vtSide);
		}
	}
}

BOOL THImpHvacFlange::GetInclineAnglePts(AcGePoint3dArray &arpts, AcGePoint3dArray &arpts1) const
{	
	ASSERT(NULL != m_pXDataMap);
	arpts1.setLogicalLength(0);
	arpts.setLogicalLength(0);

	// 获取绘图数据
	AcGePoint3d pt, ptS, ptE;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dWidth = 0.0;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	int iSectType = 2;
	TDb::HvacFlangeType eFlType = TDb::eSingleLine;
	m_pXDataMap->GetAt(HFLN_Type, (int&)eFlType);
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);

	// 计算方向向量
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtNormal.normalize();
	AcGeVector3d vtCross = vtNormal.crossProduct(vtDir);
	vtCross.normalize();

	dWidth *= 0.5;
	dThick *=0.5;
	// 根据矩形口与圆口的不同情况计算
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptStart;
		pt = ptS + vtCross * (dWidth + dSkirtSize);
		arpts.append(pt + vtNormal * (dThick + dSkirtSize));
		arpts.append(pt - vtNormal * (dThick + dSkirtSize));

		pt = ptS - vtCross * (dWidth + dSkirtSize);
		arpts.append(pt - vtNormal * (dThick + dSkirtSize));
		arpts.append(pt + vtNormal * (dThick + dSkirtSize));

		arpts.append(arpts[0]);
		//算内部线的点
		arpts1.setLogicalLength(0);
		pt = ptS + vtCross * dWidth;
		arpts1.append(pt + vtNormal * dThick);
		arpts1.append(pt - vtNormal * dThick);

		pt = ptS - vtCross * dWidth;
		arpts1.append(pt - vtNormal * dThick);
		arpts1.append(pt + vtNormal * dThick);
		arpts1.append(arpts1[0]);
	}
	else if (TDb::eCircular == iSectType)
	{
		AcGeVector3d vtZAxis = TAuxTools::GetUcsZvt();
		AcDbPolyline *pPolyLine = new AcDbPolyline;
		int iRes(0);
		AcGePoint3d ptBase;
		Midpoint(ptStart, ptEnd, ptBase);
		if (ptStart.z > ptEnd.z) // 起点高,取起点外面半个椭圆曲线,构造pline线
		{
			//ptStart圆
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, -vtDir, vtZAxis, *pPolyLine, -vtDir);
			if (iRes == 2)
			{
				TAuxTools::GetArcPoint(*pPolyLine, arpts);
			}
		}
		else
		{
			iRes = TAuxTools::GetEllipseFromCircle(ptStart, dDiameter, vtDir, vtZAxis, *pPolyLine, -vtDir);
			if (iRes == 2)
			{
				TAuxTools::GetArcPoint(*pPolyLine, arpts);
			}
		}
		if (NULL != pPolyLine)
			delete pPolyLine;
	}
	
	return arpts.length() > 0;
}

BOOL THImpHvacFlange::GetAnyAnglePts(AcGePoint3dArray &arpts, AcGePoint3dArray &arpts1) const
{	
	// 二维双线封闭
	ASSERT(NULL != m_pXDataMap);
	arpts1.setLogicalLength(0);
	arpts.setLogicalLength(0);
	
	// 获取绘图数据
	AcGePoint3d pt, ptS, ptE, ptMid;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dWidth = 0.0;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	int iSectType = 2;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	
	// 计算方向向量
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtNormal.normalize();
	AcGeVector3d vtCross = vtNormal.crossProduct(vtDir);
	vtCross.normalize();
	dWidth *= 0.5;
	dThick *=0.5;
	// 根据矩形口与圆口的不同情况计算
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptStart;
// 		if (ptEnd.z > ptStart.z)
// 		{
// 			ptS = ptEnd;
// 		}

		pt = ptS + vtCross * (dWidth + dSkirtSize);
		arpts.append(pt + vtNormal * (dThick + dSkirtSize));
		arpts.append(pt - vtNormal * (dThick + dSkirtSize));

		pt = ptS - vtCross * (dWidth + dSkirtSize);
		arpts.append(pt - vtNormal * (dThick + dSkirtSize));
		arpts.append(pt + vtNormal * (dThick + dSkirtSize));

		arpts.append(arpts[0]);
		//是否真实显示宽度
		// 		AcGeMatrix3d mat;
		// 		vtDir *= dBoardThick;
		// 		if (ptEnd.z > ptStart.z)
		// 		{
		// 			vtDir *= -1;
		// 		}
		// 		mat.setToTranslation(vtDir);
		// 		for (int i = 0; i < arpts.length();i++)
		// 		{
		// 			pt = arpts[i];
		// 			pt.transformBy(mat);
		// 			arpts1.append(pt);
		// 		}
		// 		arpts.append(arpts1[2]);
		// 		arpts.append(arpts1[1]);
		//		arpts.append(arpts[0]);
		// 		arpts.append(arpts[3]);
		//算内部线的点
		arpts1.setLogicalLength(0);
// 		if (ptEnd.z > ptStart.z)
// 		{
// 			ptS = ptEnd;
// 		}
		pt = ptS + vtCross * dWidth;
		arpts1.append(pt + vtNormal * dThick);
		arpts1.append(pt - vtNormal * dThick);
		
		pt = ptS - vtCross * dWidth;
		arpts1.append(pt - vtNormal * dThick);
		arpts1.append(pt + vtNormal * dThick);
		arpts1.append(arpts1[0]);
	}
	else if (TDb::eCircular == iSectType)
	{
		// 获得UCS坐标Z向量
		AcDbDatabase* pDb = acdbCurDwg();
		AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
		AcGeVector3d vtX = vtCross;
		vtX.rotateBy(PI * 0.5, vtZAxis);
		//开始点和终止点互换
		if (ptEnd.z > ptStart.z)
		{
// 			AcGePoint3d ptTemp = ptStart;
// 			ptStart = ptEnd;
// 			ptEnd = ptTemp;
			vtX *= -1;
		}
		AcDbPolyline pPolyLine, pPolyLine1;
		AcGePoint3dArray arPtsEll;
		//Star大圆
		double dBigCir = dDiameter/* + dSkirtSize * 2*/;
		int iRes = TAuxTools::GetEllipseFromCircle(ptStart, dBigCir, vtDir, vtZAxis, pPolyLine,-vtX);
		if (iRes == 2)
		{
			arPtsEll.setLogicalLength(0);
			TAuxTools::GetArcPoint(pPolyLine, arPtsEll);
			arpts.append(arPtsEll);
		}
// 		//大圆
		iRes = TAuxTools::GetEllipseFromCircle(ptStart, dBigCir, vtDir, vtZAxis, pPolyLine1,vtX);
		if (iRes == 2)
		{
			arPtsEll.setLogicalLength(0);
			TAuxTools::GetArcPoint(pPolyLine1, arPtsEll);
			for (int i = 1; i < arPtsEll.length() - 1; i++)
			{
				arpts.append(arPtsEll[i]);
			}
		}
	}
	ptS = ptStart;
// 	if (ptEnd.z > ptStart.z)
// 	{
// 		ptS = ptEnd;
// 	}
	Midpoint(ptStart, ptEnd, ptMid);
	for (int i = 0; i < arpts.length(); i++)
	{
		arpts[i].z = ptMid.z;
	}
	return arpts.length() > 0;
}

BOOL THImpHvacFlange::MakeHCloseTrLine2D(TComplexCurve& cplCurve) const
{
	//二维三线
	ASSERT(NULL != m_pXDataMap);

	// 获取绘图数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dWidth = 0.0;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	int iSectType = 2;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);

	// 计算方向向量
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	ptBase = ptStart + vtDir * dBoardThick / 2.0;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtDir.rotateBy(PI / 2.0, vtNormal);

	// 根据矩形口与圆口的不同情况计算
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptBase + vtDir * (dWidth / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dWidth / 2.0 + dSkirtSize);
	}
	else if (TDb::eCircular == iSectType)
	{
		ptS = ptBase + vtDir * (dDiameter / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dDiameter / 2.0 + dSkirtSize);
	}
	else
	{
		return FALSE;
	}

	// 计算图形端点
	AcGeVector3d vtPDir = vtDir;
	vtPDir.rotateBy(PI / 2.0, vtNormal);
	vtPDir = vtPDir.normalize();
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS + vtPDir * dBoardThick / 2.0;
	ptS2 = ptS - vtPDir * dBoardThick / 2.0;
	ptE1 = ptE + vtPDir * dBoardThick / 2.0;
	ptE2 = ptE - vtPDir * dBoardThick / 2.0;

	// 添加边
	TDb::TCurveElement el;
	memset(&el, 0, sizeof(TDb::TCurveElement));
	double dEdgeWidth = GetEdgeLineWidth();
	el.dWidth = dEdgeWidth;
	if (!IsSingleLine())
	{
		el.ptGe[0] = ptS1;
		el.ptGe[1] = ptE1;
		el.ptGe[2] = ptE1;
		cplCurve.append(el);
		
		el.ptGe[0] = ptS2;
		el.ptGe[1] = ptE2;
		el.ptGe[2] = ptE2;
		cplCurve.append(el);
		
		el.ptGe[0] = ptS1;
		el.ptGe[1] = ptS2;
		el.ptGe[2] = ptS2;
		cplCurve.append(el);
		
		el.ptGe[0] = ptE1;
		el.ptGe[1] = ptE2;
		el.ptGe[2] = ptE2;
		cplCurve.append(el);
		
// 		el.ptGe[0] = ptS;
// 		el.ptGe[1] = ptE;
// 		el.ptGe[2] = ptE;
// 		cplCurve.append(el);
	}
	else
	{
		el.ptGe[0] = ptStart;
		el.ptGe[1] = ptEnd;
		el.ptGe[2] = ptEnd;
		cplCurve.append(el);
	}
	
	
	return cplCurve.length() > 0;
}

// 矩形口三维绘制
/*
			↑默认法向

起始端	 6━━━━━4		侧壁面	 1━━3━━━5━━7━━9  
		┃	        ┃				┃	  ┃	┃	  ┃ 
		┃
		┃	起始端  ┃				┃	  ┃	┃	  ┃ 
		┃
		 8	        ┃				┃	  ┃	┃	  ┃ 
		 0━━━━━2				 0━━2━━━4━━6━━8
 */
void THImpHvacFlange::MakeRectangle3D(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取绘图数据
	AcGePoint3d ptBase;
	AcGeVector3d vtMain,vtMainv;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);

	// 计算方向向量
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);	
	vtMain = ptEnd - ptStart;
	vtMainv = vtMain;
	vtMainv.rotateBy(PI / 2.0, vtNormal);	
	vtMain.normalize();
	vtMainv.normalize();
	vtNormal.normalize();
	AcGePoint3dArray arPts, arptSides;
	//左方块
	ptBase = ptStart + vtNormal	* dThick * 0.5;	
	ptBase = ptBase - vtMainv * (dWidth * 0.5 + dSkirtSize);
	//0
	arPts.append(ptBase);
	//1
	arPts.append(arPts[0] + vtMain * dBoardThick);
	//2
	arPts.append(arPts[1] + vtMainv * (dWidth + dSkirtSize * 2));
	//3
	arPts.append(arPts[0] + vtMainv * (dWidth + dSkirtSize * 2));

	arptSides.append(arPts[0] + vtNormal * dSkirtSize );
	arptSides.append(arPts[3] + vtNormal * dSkirtSize );
	arptSides.append(arPts[3]);
	arptSides.append(arPts[0]);
	arptSides.append(arPts[0] + vtNormal * dSkirtSize );

	arptSides.append(arPts[1] + vtNormal * dSkirtSize );
	arptSides.append(arPts[2] + vtNormal * dSkirtSize );
	arptSides.append(arPts[2]);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[1] + vtNormal * dSkirtSize );
	mode.DrawMesh(2, 5, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] + vtNormal * dSkirtSize);
	arptSides.append(arPts[0] );
	arptSides.append(arPts[3] + vtNormal * dSkirtSize);
	arptSides.append(arPts[3]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[1] + vtNormal * dSkirtSize);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[2] + vtNormal * dSkirtSize);
	arptSides.append(arPts[2]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());

	//右方块
	ptBase = ptStart - vtNormal	* dThick * 0.5;	
	ptBase = ptBase - vtMainv * (dWidth * 0.5 + dSkirtSize);
	arPts.setLogicalLength(0);
	//0
	arPts.append(ptBase);
	//1
	arPts.append(arPts[0] + vtMain * dBoardThick);
	//2
	arPts.append(arPts[1] + vtMainv * (dWidth + dSkirtSize * 2));
	//3
	arPts.append(arPts[0] + vtMainv * (dWidth + dSkirtSize * 2));
	
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] - vtNormal * dSkirtSize );
	arptSides.append(arPts[3] - vtNormal * dSkirtSize );
	arptSides.append(arPts[3]);
	arptSides.append(arPts[0]);
	arptSides.append(arPts[0] - vtNormal * dSkirtSize );
	
	arptSides.append(arPts[1] - vtNormal * dSkirtSize );
	arptSides.append(arPts[2] - vtNormal * dSkirtSize );
	arptSides.append(arPts[2]);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[1] - vtNormal * dSkirtSize );
	mode.DrawMesh(2, 5, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] - vtNormal * dSkirtSize);
	arptSides.append(arPts[0] );
	arptSides.append(arPts[3] - vtNormal * dSkirtSize);
	arptSides.append(arPts[3]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[1] - vtNormal * dSkirtSize);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[2] - vtNormal * dSkirtSize);
	arptSides.append(arPts[2]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());

	//下方块
	ptBase = ptStart + vtNormal	* dThick * 0.5;	
	ptBase = ptBase - vtMainv * (dWidth * 0.5 + dSkirtSize);
	arPts.setLogicalLength(0);
	//0
	arPts.append(ptBase);
	//1
	arPts.append(arPts[0] + vtMain * dBoardThick);
	//2
	arPts.append(arPts[1] + vtMainv * (dSkirtSize));
	//3
	arPts.append(arPts[0] + vtMainv * (dSkirtSize));
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] - vtNormal * dThick );
	arptSides.append(arPts[3] - vtNormal * dThick );
	arptSides.append(arPts[3]);
	arptSides.append(arPts[0]);
	arptSides.append(arPts[0] - vtNormal * dThick );
	
	arptSides.append(arPts[1] - vtNormal * dThick );
	arptSides.append(arPts[2] - vtNormal * dThick );
	arptSides.append(arPts[2]);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[1] - vtNormal * dThick );
	mode.DrawMesh(2, 5, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] - vtNormal * dThick);
	arptSides.append(arPts[0] );
	arptSides.append(arPts[3] - vtNormal * dThick);
	arptSides.append(arPts[3]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[1] - vtNormal * dThick);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[2] - vtNormal * dThick);
	arptSides.append(arPts[2]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());


	//上方块
	ptBase = ptStart + vtNormal	* dThick * 0.5;	
	ptBase = ptBase + vtMainv * (dWidth * 0.5);
	arPts.setLogicalLength(0);
	//0
	arPts.append(ptBase);
	//1
	arPts.append(arPts[0] + vtMain * dBoardThick);
	//2
	arPts.append(arPts[1] + vtMainv * (dSkirtSize));
	//3
	arPts.append(arPts[0] + vtMainv * (dSkirtSize));
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] - vtNormal * dThick );
	arptSides.append(arPts[3] - vtNormal * dThick );
	arptSides.append(arPts[3]);
	arptSides.append(arPts[0]);
	arptSides.append(arPts[0] - vtNormal * dThick );
	
	arptSides.append(arPts[1] - vtNormal * dThick );
	arptSides.append(arPts[2] - vtNormal * dThick );
	arptSides.append(arPts[2]);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[1] - vtNormal * dThick );
	mode.DrawMesh(2, 5, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[0] - vtNormal * dThick);
	arptSides.append(arPts[0] );
	arptSides.append(arPts[3] - vtNormal * dThick);
	arptSides.append(arPts[3]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());
	arptSides.setLogicalLength(0);
	arptSides.append(arPts[1] - vtNormal * dThick);
	arptSides.append(arPts[1]);
	arptSides.append(arPts[2] - vtNormal * dThick);
	arptSides.append(arPts[2]);
	mode.DrawMesh(2, 2, arptSides.asArrayPtr());
	
	/*
	vtFlangeDir = ptEnd - ptStart;
	vtFlangeDir = vtFlangeDir.normalize();
	ptBase = ptStart + vtFlangeDir * dBoardThick / 2.0;	
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);	
	vtFlangeDir.rotateBy(PI / 2.0, vtNormal);	
	AcGeVector3d vtYDir = vtFlangeDir;
	AcGeVector3d vtXDir = vtFlangeDir;
	vtXDir.rotateBy(PI / 2.0, vtNormal);	
	vtYDir = vtYDir.normalize();
	vtXDir = vtXDir.normalize();
	vtNormal = vtNormal.normalize();	// 5 X 2 顶点
	AcGePoint3d ptArrSide[5*2];
	ptArrSide[0] = ptBase - vtNormal * (dThick / 2.0 + dSkirtSize) + vtYDir * (dWidth / 2.0 + dSkirtSize) - vtXDir * dBoardThick / 2.0;
	ptArrSide[2] = ptArrSide[0] - vtYDir * (dWidth + dSkirtSize * 2.0);
	ptArrSide[4] = ptArrSide[2] + vtNormal * (dThick + dSkirtSize * 2.0);
	ptArrSide[6] = ptArrSide[0] + vtNormal * (dThick + dSkirtSize * 2.0);
	ptArrSide[8] = ptArrSide[0];

	ptArrSide[1] = ptArrSide[0] + vtXDir * dBoardThick;
	ptArrSide[3] = ptArrSide[2] + vtXDir * dBoardThick;
	ptArrSide[5] = ptArrSide[4] + vtXDir * dBoardThick;
	ptArrSide[7] = ptArrSide[6] + vtXDir * dBoardThick;
	ptArrSide[9] = ptArrSide[1];
	
	mode.DrawMesh(5, 2, ptArrSide);

	AcGePoint3dArray arPtSides;
	arPtSides.append(ptArrSide[0]);
	arPtSides.append(ptArrSide[2]);
	arPtSides.append(ptArrSide[6]);
	arPtSides.append(ptArrSide[4]);
// 	ptArrSide[0] = ptBase - vtNormal * dThick / 2.0 + vtYDir * dWidth / 2.0 - vtXDir * dBoardThick / 2.0;
// 	ptArrSide[2] = ptArrSide[0] - vtYDir * dWidth;
// 	ptArrSide[4] = ptArrSide[2] + vtNormal * dThick;
// 	ptArrSide[6] = ptArrSide[0] + vtNormal * dThick;
// 	ptArrSide[8] = ptArrSide[0];
// 	
// 	ptArrSide[1] = ptArrSide[0] + vtXDir * dBoardThick;
// 	ptArrSide[3] = ptArrSide[2] + vtXDir * dBoardThick;
// 	ptArrSide[5] = ptArrSide[4] + vtXDir * dBoardThick;
// 	ptArrSide[7] = ptArrSide[6] + vtXDir * dBoardThick;
// 	ptArrSide[9] = ptArrSide[1];
	mode.DrawMesh(2, 2, arPtSides.asArrayPtr());

	arPtSides.setLogicalLength(0);
	arPtSides.append(ptArrSide[1]);
	arPtSides.append(ptArrSide[3]);
	arPtSides.append(ptArrSide[7]);
	arPtSides.append(ptArrSide[5]);
	mode.DrawMesh(2, 2, arPtSides.asArrayPtr());
	*/
	
}

// 圆形口三维绘制
/*
			↑默认法向
			┏━8━┓
起始端	  10		6		侧壁面	 1━━3━━━5━━7━━9...
		  ┃		┃				┃	  ┃	┃	  ┃ 
		  12 起始端	 4				┃	  ┃	┃	  ┃ 
		  ┃	    ┃				┃	  ┃	┃	  ┃   ┃
		   14		2				 0━━2━━━4━━6━━8...
			┗━0━┛			 	
*/
void THImpHvacFlange::MakeCircle3D(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);	

	// 获取绘图数据
	AcGePoint3d ptBase;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dDiameter = 0.0;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	AcGeVector3d vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	ptBase = ptStart + vtDir * dBoardThick / 2.0;
	
	// 计算方向向量
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtFlangeDir = AcGeVector3d::kIdentity;
	vtFlangeDir = vtDir.rotateBy(PI / 2.0, vtNormal);	
	vtFlangeDir = vtFlangeDir.normalize();
	AcGeVector3d vtXDir = vtFlangeDir;
	vtXDir.rotateBy(PI / 2.0, vtNormal);
	vtNormal = vtNormal.normalize();
	vtXDir = vtXDir.normalize();
	
	// 计算圆的分割精度
	double dMinAngle(PI / 12);
	GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinAngle);
	int nPartNum = int(PI * 2 / dMinAngle) + 1;
	dMinAngle = PI * 2 / nPartNum;

	// 计算三维端点
	AcGePoint3dArray ptArr;
	AcGeVector3d vtNow = vtNormal * -1;	// 每组顶点法向
	int i(0);
	for (i = 0; i < nPartNum * 2; i += 2)
	{
		ptArr.append(ptBase + (dDiameter / 2.0 + dSkirtSize) * vtNow - vtXDir * dBoardThick / 2.0);
		ptArr.append(ptBase + (dDiameter / 2.0 + dSkirtSize) * vtNow + vtXDir * dBoardThick / 2.0);
		vtNow.rotateBy(dMinAngle, vtXDir);
	}	
	ptArr.append(ptArr.at(0));
	ptArr.append(ptArr.at(1));	
	mode.DrawMesh(nPartNum + 1, 2, ptArr.asArrayPtr());

	vtNow = vtNormal * -1;
	AcGePoint3dArray ptArr1;
	//ptArr.setLogicalLength(0);
	for (i = 0; i < nPartNum * 2; i += 2)
	{
		ptArr1.append(ptBase + (dDiameter / 2.0) * vtNow - vtXDir * dBoardThick / 2.0);
		ptArr1.append(ptBase + (dDiameter / 2.0) * vtNow + vtXDir * dBoardThick / 2.0);
		vtNow.rotateBy(dMinAngle, vtXDir);
	}
	ptArr1.append(ptArr1.at(0));
	ptArr1.append(ptArr1.at(1));	
	mode.DrawMesh(nPartNum + 1, 2, ptArr1.asArrayPtr());

	for (i = 0; i < ptArr.length() - 3; i += 2)
	{
		AcGePoint3dArray arPtSide;
		arPtSide.append(ptArr[i]);
		arPtSide.append(ptArr[i + 2]);
		arPtSide.append(ptArr1[i]);
		arPtSide.append(ptArr1[i + 2]);
		mode.DrawMesh(2, 2, arPtSide.asArrayPtr());
		
		arPtSide.setLogicalLength(0);
		arPtSide.append(ptArr[i + 1]);
		arPtSide.append(ptArr[i + 3]);
		arPtSide.append(ptArr1[i + 1]);
		arPtSide.append(ptArr1[i + 3]);
		mode.DrawMesh(2, 2, arPtSide.asArrayPtr());
	}
}

BOOL THImpHvacFlange::MakeRectangleFaces(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);

	// 获取数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dThick = 0.0;
	double dWidth = 0.0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	ptBase = ptEnd.z > ptStart.z ? ptEnd:ptStart;	
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtXDir = vtNormal;
	AcGeVector3d vtYDir = vtXDir;
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	vtYDir.rotateBy(PI / 2.0, vtZAxis);
	vtXDir = vtXDir.normalize();
	vtYDir = vtYDir.normalize();

	// 计算面端点
	ptS = ptBase + vtXDir * (dThick / 2.0 + dSkirtSize);
	ptE = ptBase - vtXDir * (dThick / 2.0 + dSkirtSize);
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS + vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptS2 = ptS - vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptE1 = ptE + vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptE2 = ptE - vtYDir * (dWidth / 2.0 + dSkirtSize);

	// 生成面
	AcDbFace *pFace = new AcDbFace;
	pFace->setVertexAt(0, ptS1);
	pFace->setVertexAt(1, ptE1);
	pFace->setVertexAt(2, ptE2);
	pFace->setVertexAt(3, ptS2);
	arFaces.append(pFace);

	return arFaces.length() > 0;
}

BOOL THImpHvacFlange::MakeCircleFaces(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);

	// 获取数据
	AcGePoint3d ptBase;
	double dSkirtSize = 0.0;
	double dDiameter = 0.0;	
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	ptBase = ptEnd.z > ptStart.z ? ptEnd:ptStart;	
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);	
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);	
	vtNormal = vtNormal.normalize();
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));	

	// 计算圆的分割精度
	double dMinAngle(PI / 12);
	GetGlobalContext()->GetAt(KEY_MINDIFFANG, dMinAngle);
	int nPartNum = int(PI * 2 / dMinAngle) + 1;
	dMinAngle = PI * 2 / nPartNum;

	// 计算面端点并生成面
	AcGePoint3d ptF = AcGePoint3d::kOrigin;
	AcGePoint3d ptL = AcGePoint3d::kOrigin;
	AcGeVector3d vtNow = vtNormal * -1;	// 每组顶点法向
	int i(0);
	for (i = 0; i < nPartNum; i ++)
	{
		ptF = ptBase + (dDiameter / 2.0 + dSkirtSize) * vtNow;
		vtNow.rotateBy(dMinAngle, vtZAxis);
		ptL = ptBase + (dDiameter / 2.0 + dSkirtSize) * vtNow;		
		
		AcDbFace* pFace = new AcDbFace;
		pFace->setVertexAt(0, ptBase);
		pFace->setVertexAt(1, ptF);
		pFace->setVertexAt(2, ptL);
		pFace->setVertexAt(3, ptBase);
		arFaces.append(pFace);
	}
	
	return arFaces.length() > 0;
}

BOOL THImpHvacFlange::MakeSigleLineFaces(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);

	// 获取数据
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	AcGePoint3d ptBase = TAuxTools::Mid(ptStart, ptEnd);
	
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtNormal.normalize();
	vtDir.rotateBy(PI / 2.0, vtNormal);
	vtDir.normalize();
	
	double dHideWidth(0);
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	
	// 单线遮挡处理
	if (IsSingleLine())
	{
		GetGlobalContext()->GetAt(KEY_HIDEWIDTH,  dHideWidth);
		dHideWidth *= 0.5;
		vtDir *= dHideWidth;
		ptS1 = ptStart + vtDir;
		ptS2 = ptStart - vtDir;
		ptE1 = ptEnd + vtDir;
		ptE2 = ptEnd - vtDir;
	}
	else
	{
		double dSkirtSize = 0.0;
		m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dSkirtSize *= dPScale/100;
		//
		double dWidth = 0.0;
		
		TDb::HvacSectType eSect = TDb::eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
		if (eSect == TDb::eRectangular)
		{
			m_pXDataMap->GetAt(HFLN_Width, dWidth);
		}
		else if (eSect == TDb::eCircular)
		{
			m_pXDataMap->GetAt(HFLN_Diameter, dWidth);
		}
		
		dHideWidth = dWidth*0.5 + dSkirtSize;
		vtDir *= dHideWidth;
		ptS1 = ptBase + vtDir;
		ptS2 = ptS1;
		ptE1 = ptBase - vtDir;
		ptE2 = ptE1;
	}
	
	// 生成Face面
	AcDbFace *pFace = new AcDbFace;
	pFace->setVertexAt(0, ptS1);
	pFace->setVertexAt(1, ptE1);
	pFace->setVertexAt(2, ptE2);
	pFace->setVertexAt(3, ptS2);
	arFaces.append(pFace);
	
	return arFaces.length() > 0;
}

BOOL THImpHvacFlange::MakeMultiLineFaces(AcDbVoidPtrArray& arFaces)
{
	ASSERT(NULL != m_pXDataMap);

	// 获取数据
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGePoint3d ptBase = AcGePoint3d::kOrigin;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dWidth = 0.0;
	int iSectType = 2;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	ptBase = ptStart + vtDir * dBoardThick / 2.0;
	vtDir.rotateBy(PI / 2.0, vtNormal);
	
	// 根据矩形与圆形的不同情况计算面端点
	AcGePoint3d ptS, ptE;
	// 单线遮挡处理
	if (IsSingleLine())
	{
		double dHalfStartWidth(0);
		GetGlobalContext()->GetAt(KEY_HIDEWIDTH,  dHalfStartWidth);
		ptS = ptBase + vtDir * dHalfStartWidth * 0.5;
		ptE = ptBase - vtDir * dHalfStartWidth * 0.5;
		AcGeVector3d vtPDir = vtDir;
		vtPDir.rotateBy(PI / 2.0, vtNormal);
		vtPDir = vtPDir.normalize();
		
		AcGePoint3d ptS1, ptS2, ptE1, ptE2;
		ptS1 = ptS + vtPDir * dBoardThick / 2.0;
		ptS2 = ptS - vtPDir * dBoardThick / 2.0;
		ptE1 = ptE + vtPDir * dBoardThick / 2.0;
		ptE2 = ptE - vtPDir * dBoardThick / 2.0;
		/*
		ptS1.z += 1;
		ptS2.z += 1;
		ptE1.z += 1;
		ptE2.z += 1;
		*/
		AcDbFace *pFace = new AcDbFace;
		pFace->setVertexAt(0, ptS1);
		pFace->setVertexAt(1, ptE1);
		pFace->setVertexAt(2, ptE2);
		pFace->setVertexAt(3, ptS2);
		arFaces.append(pFace);
		
		return arFaces.length() > 0;
	}

	
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptBase + vtDir * (dWidth / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dWidth / 2.0 + dSkirtSize);
	}
	else if (TDb::eCircular == iSectType)
	{
		ptS = ptBase + vtDir * (dDiameter / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dDiameter / 2.0 + dSkirtSize);
	}
	else
	{
		return FALSE;
	}
	
	// 生成矩形
	AcGeVector3d vtPDir = vtDir;
	vtPDir.rotateBy(PI / 2.0, vtNormal);
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS - vtPDir * dBoardThick / 2.0;
	ptS2 = ptS + vtPDir * dBoardThick / 2.0;
	ptE1 = ptE - vtPDir * dBoardThick / 2.0;
	ptE2 = ptE + vtPDir * dBoardThick / 2.0;
	/*
	ptS1.z += 1;
	ptS2.z += 1;
	ptE1.z += 1;
	ptE2.z += 1;
	*/
	AcDbFace *pFace = new AcDbFace;
	pFace->setVertexAt(0, ptS1);
	pFace->setVertexAt(1, ptE1);
	pFace->setVertexAt(2, ptE2);
	pFace->setVertexAt(3, ptS2);
	arFaces.append(pFace);

	return arFaces.length() > 0;
}

AcDbPolyline* THImpHvacFlange::MakeRectanglePolyCurve() const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dThick = 0.0;
	double dWidth = 0.0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	ptBase = ptEnd.z > ptStart.z ? ptEnd:ptStart;	
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtXDir = vtNormal;
	AcGeVector3d vtYDir = vtXDir;
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	vtYDir.rotateBy(PI / 2.0, vtZAxis);
	vtXDir = vtXDir.normalize();
	vtYDir = vtYDir.normalize();

	// 计算顶点
	ptS = ptBase + vtXDir * (dThick / 2.0 + dSkirtSize);
	ptE = ptBase - vtXDir * (dThick / 2.0 + dSkirtSize);
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS + vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptS2 = ptS - vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptE1 = ptE + vtYDir * (dWidth / 2.0 + dSkirtSize);
	ptE2 = ptE - vtYDir * (dWidth / 2.0 + dSkirtSize);

	// 生成pline线
	double dEl(0.0);
	AcGePlane plan = GetHidePlane(ptS1, ptE1, ptE2, vtZAxis, dEl);
	AcDbPolyline *pPolyline = new AcDbPolyline;
	pPolyline->addVertexAt(0, ptS1.convert2d(plan));
	pPolyline->addVertexAt(1, ptE1.convert2d(plan));
	pPolyline->addVertexAt(2, ptE2.convert2d(plan));
	pPolyline->addVertexAt(3, ptS2.convert2d(plan));
	pPolyline->setNormal(vtZAxis);
	pPolyline->setElevation(dEl);
	pPolyline->setClosed(Adesk::kTrue);

	return pPolyline;	
}

AcDbPolyline* THImpHvacFlange::MakeCirclePolyCurve() const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取数据
	AcGePoint3d ptBase, ptArcH1, ptArcH2, ptArcV1;
	double dSkirtSize = 0.0;
	double dDiameter = 0.0;	
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	ptBase = ptEnd.z > ptStart.z ? ptEnd:ptStart;	
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	AcGeVector3d vtXDir = vtNormal;
	AcGeVector3d vtYDir = vtXDir;
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	vtYDir.rotateBy(PI / 2.0, vtZAxis);
	vtXDir = vtXDir.normalize();
	vtYDir = vtYDir.normalize();

	// 计算顶点
	ptArcH1 = ptBase + vtYDir * (dDiameter / 2.0 + dSkirtSize);
	ptArcH2 = ptBase - vtYDir * (dDiameter / 2.0 + dSkirtSize);
	ptArcV1 = ptBase + vtXDir * (dDiameter / 2.0 + dSkirtSize);
	
	// 生成pline线
	double dEl(0.0);
	AcGePlane plan = GetHidePlane(ptArcH1, ptBase, ptArcV1, vtZAxis, dEl);		
	AcDbPolyline* pPolyline = new AcDbPolyline;
	pPolyline->addVertexAt(0, ptArcH1.convert2d(plan), 1);
	pPolyline->addVertexAt(1, ptArcH2.convert2d(plan), 1);
	pPolyline->setNormal(vtZAxis);
	pPolyline->setElevation(dEl);
	pPolyline->setClosed(Adesk::kTrue);

	return pPolyline;
}

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

// mcl 重新启用 2010.03.30
AcDbPolyline* THImpHvacFlange::MakeSingleLinePolyCurve() const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取数据
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	AcGePoint3d ptBase = TAuxTools::Mid(ptStart, ptEnd);

	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();

	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtNormal.normalize();
	vtDir.rotateBy(PI / 2.0, vtNormal);
	vtDir.normalize();

	double dHideWidth(0);
	AcGePoint3d ptS1, ptS2, ptE1, ptE2;

	// 单线遮挡处理
	if (IsSingleLine())
	{
		GetGlobalContext()->GetAt(KEY_HIDEWIDTH,  dHideWidth);
		dHideWidth *= 0.5;
		vtDir *= dHideWidth;
		ptS1 = ptStart + vtDir;
		ptS2 = ptStart - vtDir;
		ptE1 = ptEnd + vtDir;
		ptE2 = ptEnd - vtDir;
	}
	else
	{
		double dSkirtSize = 0.0;
		m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dSkirtSize *= dPScale/100;
		//
		double dWidth = 0.0;
	
		TDb::HvacSectType eSect = TDb::eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
		if (eSect == TDb::eRectangular)
		{
			m_pXDataMap->GetAt(HFLN_Width, dWidth);
		}
		else if (eSect == TDb::eCircular)
		{
			m_pXDataMap->GetAt(HFLN_Diameter, dWidth);
		}

		dHideWidth = dWidth*0.5 + dSkirtSize;
		vtDir *= dHideWidth;
		ptS1 = ptBase + vtDir;
		ptS2 = ptS1;
		ptE1 = ptBase - vtDir;
		ptE2 = ptE1;
	}

	// 生成pline线
	AcGePlane plan = GetStdPrjPlan(ptS1);
	double dEl = TAuxTools::GetPlaneEle(plan);

	AcDbPolyline *pPolyline = new AcDbPolyline;
	pPolyline->addVertexAt(0, ptS1.convert2d(plan));
	pPolyline->addVertexAt(1, ptE1.convert2d(plan));
	pPolyline->addVertexAt(2, ptE2.convert2d(plan));
	pPolyline->addVertexAt(3, ptS2.convert2d(plan));
	pPolyline->setNormal(vtNormal);

	pPolyline->setElevation(dEl);
	pPolyline->setClosed(Adesk::kTrue);

	return pPolyline;
}

AcDbPolyline* THImpHvacFlange::MakeMultiLinePolyCurve() const
{
	ASSERT(NULL != m_pXDataMap);

	// 获取数据
	AcGePoint3d ptBase, ptS, ptE;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dDiameter = 0.0;
	double dWidth = 0.0;
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	int iSectType = 2;
	AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	dBoardThick = ptStart.distanceTo(ptEnd);
	vtDir = ptEnd - ptStart;
	vtDir = vtDir.normalize();
	ptBase = ptStart + vtDir * dBoardThick / 2.0;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
	vtNormal.normalize();
	vtDir.rotateBy(PI / 2.0, vtNormal);
	vtDir.normalize();

	// 单线遮挡处理
	if (IsSingleLine())
	{
		double dHalfStartWidth(0);
		GetGlobalContext()->GetAt(KEY_HIDEWIDTH,  dHalfStartWidth);
		ptS = ptBase + vtDir * dHalfStartWidth * 0.5;
		ptE = ptBase - vtDir * dHalfStartWidth * 0.5;
		AcGeVector3d vtPDir = vtDir;
		vtPDir.rotateBy(PI / 2.0, vtNormal);
		vtPDir = vtPDir.normalize();
		
		AcGePoint3d ptS1, ptS2, ptE1, ptE2;
		ptS1 = ptS + vtPDir * dBoardThick / 2.0;
		ptS2 = ptS - vtPDir * dBoardThick / 2.0;
		ptE1 = ptE + vtPDir * dBoardThick / 2.0;
		ptE2 = ptE - vtPDir * dBoardThick / 2.0;
		// 生成pline线
		double dEl(0.0);
		AcGePlane plan = GetHidePlane(ptS1, ptE1, ptE2, vtNormal, dEl);
		AcDbPolyline *pPolyline = new AcDbPolyline;
		pPolyline->addVertexAt(0, ptS1.convert2d(plan));
		pPolyline->addVertexAt(1, ptE1.convert2d(plan));
		pPolyline->addVertexAt(2, ptE2.convert2d(plan));
		pPolyline->addVertexAt(3, ptS2.convert2d(plan));
		pPolyline->setNormal(vtNormal);
		//pPolyline->setElevation(dEl + 1.0);
		pPolyline->setElevation(dEl);
		pPolyline->setClosed(Adesk::kTrue);
		
		return pPolyline;
	}
	
	// 计算顶点
	if (TDb::eRectangular == iSectType)
	{
		ptS = ptBase + vtDir * (dWidth / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dWidth / 2.0 + dSkirtSize);
	}
	else if (TDb::eCircular == iSectType)
	{
		ptS = ptBase + vtDir * (dDiameter / 2.0 + dSkirtSize);
		ptE = ptBase - vtDir * (dDiameter / 2.0 + dSkirtSize);
	}
	else
	{
		return FALSE;
	}

	AcGeVector3d vtPDir = vtDir;
	vtPDir.rotateBy(PI / 2.0, vtNormal);
	vtPDir = vtPDir.normalize();

	AcGePoint3d ptS1, ptS2, ptE1, ptE2;
	ptS1 = ptS + vtPDir * dBoardThick / 2.0;
	ptS2 = ptS - vtPDir * dBoardThick / 2.0;
	ptE1 = ptE + vtPDir * dBoardThick / 2.0;
	ptE2 = ptE - vtPDir * dBoardThick / 2.0;

	// 生成pline线
	double dEl(0.0);
	AcGePlane plan = GetHidePlane(ptS1, ptE1, ptE2, vtNormal, dEl);
	AcDbPolyline *pPolyline = new AcDbPolyline;
	pPolyline->addVertexAt(0, ptS1.convert2d(plan));
	pPolyline->addVertexAt(1, ptE1.convert2d(plan));
	pPolyline->addVertexAt(2, ptE2.convert2d(plan));
	pPolyline->addVertexAt(3, ptS2.convert2d(plan));
	pPolyline->setNormal(vtNormal);
 	//pPolyline->setElevation(dEl + 1.0);
	pPolyline->setElevation(dEl);
	pPolyline->setClosed(Adesk::kTrue);

	return pPolyline;
}

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

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	AcGeVector3d vtOff = (ptEnd - ptStart).normalize();

	HvacFlangeType eType = TDb::eCloseDbLine;
	m_pXDataMap->GetAt(HFLN_Type, (int&)eType);

	// 如果发现空连接或连接风管或，则首先考虑移动该连接点
	BOOL bMoveStartPt(FALSE);
	AcGeVector3d vtStart = ptStart - ptEnd;
	AcDbObjectId idStart(AcDbObjectId::kNull);
	m_pXDataMap->GetAt(KEY_IDCNT1, idStart);

	// 验证位置关系
	OPENOBJ_BEGIN(idStart, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		if (!pObj->GetInterface(ptStart, TInterface()))
			idStart.setNull();
	}
	OPENOBJ_END();

	if (!idStart.isValid())
	{
		bMoveStartPt = TRUE;
	}
	else
	{
		AcDbObjectId idEnd(AcDbObjectId::kNull);
		m_pXDataMap->GetAt(KEY_IDCNT2, idEnd);

		// 验证位置关系
		OPENOBJ_BEGIN(idEnd, AcDb::kForRead, TDbInterfacesObj, pObj);
		if (NULL != pObj)
		{
			if (!pObj->GetInterface(ptEnd, TInterface()))
				idEnd.setNull();
		}
		OPENOBJ_END();
	
		if (!idEnd.isValid())
		{
			bMoveStartPt = FALSE;
		}
		else
		{
			OPENOBJ_BEGIN(idStart, AcDb::kForRead, TDbHvacDuct, pDuct);
			if (NULL != pDuct)
				bMoveStartPt = TRUE;
			else
				bMoveStartPt = FALSE;
			OPENOBJ_END();
		}
	}

	if (bMoveStartPt)
	{
		AcGePoint3d ptNewStart;
		if (eType == eSingleLine)
			ptNewStart = ptEnd - vtOff * FLANGWIDTH_SINGLE;
		else
			ptNewStart = ptEnd - vtOff * FLANGWIDTH_NORMAL;

		m_pXDataMap->SetAt(HFLN_StartPoint, ptNewStart);
	
		if (NULL != pXMap)
			pXMap->SetAt(HFLN_StartPoint, ptNewStart);

		if (NULL != m_pOwnerEnt)
			UpdateInterfaceRec(m_pOwnerEnt->objectId(), ptStart, ptNewStart);

	}
	else
	{
		AcGePoint3d ptNewEnd;
		if (eType == eSingleLine)
			ptNewEnd = ptStart + vtOff * FLANGWIDTH_SINGLE;
		else
			ptNewEnd = ptStart + vtOff * FLANGWIDTH_NORMAL;

		m_pXDataMap->SetAt(HFLN_EndPoint, ptNewEnd);
		if (NULL != pXMap)
			pXMap->SetAt(HFLN_EndPoint, ptNewEnd);

		if (NULL != m_pOwnerEnt)
			UpdateInterfaceRec(m_pOwnerEnt->objectId(), ptEnd, ptNewEnd);
	}

	return TRUE;
}

void THImpHvacFlange::OnSubErase( Adesk::Boolean erasing )
{
	if (erasing == Adesk::kTrue && 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 (TAuxTools::IsAutoWorkConnect() && idModel == m_pOwnerEnt->blockId())
		{
			// 写入接口更改消息
			TInterfaceModifyMsg iMsg;
			iMsg.SetMsgValidate(TRUE);
			iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
			iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
			
			TDbInterfaceMsgWrite msgWrite;
			msgWrite.WriteInterfaceMsg(iMsg);			
		}
	}		
}

BOOL THImpHvacFlange::IsMovedWithInDuct( const AcGeVector3d &vtOffset )
{
	ASSERT(NULL != m_pXDataMap);
	
	TInterface tIfSta, tIfEnd;
	GetInterface(0, tIfSta);
	GetInterface(1, tIfEnd);
	AcDbObjectId idStaCon = tIfSta.GetConnectObject();
	AcDbObjectId idEndCon = tIfEnd.GetConnectObject();
	
	// 先找出最远的两个点
	BOOL bStaDuct(FALSE);
	AcGePoint3d ptMin(AcGePoint3d::kOrigin), ptMax(AcGePoint3d::kOrigin);
	OPENOBJ_BEGIN(idStaCon, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		if (pObj->GetInterface(tIfSta.GetPosition(), TInterface()))
		{
			ObjectKind eKind(eCabletry);
			TDbXDataMap* pObjMap = pObj->GetSpecialtyDataReadOnly();
			if (NULL != pObjMap)
				pObjMap->GetAt(KEY_RUNTIME, (int&)eKind);

			if (eKind == ePipe)
			{
				TDbHvacDuct* pDuct = TDbHvacDuct::cast(pObj);
				if (NULL != pDuct)
				{
					ptMin = pDuct->StartPoint();
					ptMax = pDuct->EndPoint();
					bStaDuct = TRUE;
				}
			}	
		}
	}
	OPENOBJ_END();

	OPENOBJ_BEGIN(idEndCon, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		if (pObj->GetInterface(tIfEnd.GetPosition(), TInterface()))
		{
			ObjectKind eKind(eCabletry);
			TDbXDataMap* pObjMap = pObj->GetSpecialtyDataReadOnly();
			if (NULL != pObjMap)
				pObjMap->GetAt(KEY_RUNTIME, (int&)eKind);
			
			if (eKind == ePipe)
			{
				TDbHvacDuct* pDuct = TDbHvacDuct::cast(pObj);
				if (NULL != pDuct)
				{
					if (bStaDuct)
					{
						AcGePoint3d ptStart = pDuct->StartPoint();
						AcGePoint3d ptEnd = pDuct->EndPoint();
						double dDistSta = ptStart.distanceTo(ptMax);
						double dDistEnd = ptEnd.distanceTo(ptMax);
						AcGePoint3d ptNewMax = dDistEnd > dDistSta ? ptEnd:ptStart;
						
						dDistSta = ptMin.distanceTo(ptStart);
						dDistEnd = ptMax.distanceTo(ptStart);
						AcGePoint3d ptNewMin = dDistEnd > dDistSta ? ptMax:ptMin;
						
						ptMin = ptNewMin;
						ptMax = ptNewMax;
					}
					else
					{
						ptMin = pDuct->StartPoint();
						ptMax = pDuct->EndPoint();
					}
				}
			}
		}
	}
	OPENOBJ_END();

	if (ptMin.isEqualTo(ptMax, g_globalTol))	// 异常
		return FALSE;

	AcGePoint3d ptCenter, ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_StartPoint, ptEnd);
	ptCenter = TAuxTools::Mid(ptStart, ptEnd);

	AcGePoint3d ptNewCenter = ptCenter + vtOffset;
	AcDbLine lineHelp(ptMin, ptMax);
	double dTemp(0.0);
	if (lineHelp.getParamAtPoint(ptNewCenter, dTemp) == Acad::eOk)
	{
		// 距离管两端，不能小于半个法兰的宽度，否则算移出
		double dDistMin = ptNewCenter.distanceTo(ptMin);
		double dDistMax = ptNewCenter.distanceTo(ptMax);
		double dHalfFlang = ptStart.distanceTo(ptEnd) * 0.5;
		if (dDistMin > dHalfFlang && dDistMax > dHalfFlang)
			return TRUE;
	}

	return FALSE;
}

LRESULT THImpHvacFlange::UserCall( long i, LPVOID pData )
{
	ASSERT(NULL != m_pXDataMap);

	m_pXDataMap->SetAt(KEY_IDCNT1, NULL);
	m_pXDataMap->SetAt(KEY_IDCNT2, NULL);

	return 1l;	
}

int THImpHvacFlange::GetXBaseShell(TXShell& xShell)
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	HvacSectType eSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (TDb::eRectangular == eSectType)
	{
		// 获得参数
		double dSkirt = 0.0;
		m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirt);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dSkirt *= dPScale/100;
		//
		double dWidth = 0.0;
		m_pXDataMap->GetAt(HFLN_Width, dWidth);
		dWidth += dSkirt * 2.0;
		double dThick = 0.0;
		m_pXDataMap->GetAt(HFLN_Thick, dThick);
		dThick += dSkirt * 2.0;
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
		AcGePoint3d ptEnd;
		m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
		
		// 构造碰撞实体
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);
	}
	else if (TDb::eCircular == eSectType)
	{
		// 获得参数
		double dSkirt = 0.0;
		m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirt);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dSkirt *= dPScale/100;
		//
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HFLN_Diameter, dDiameter);
		dDiameter += dSkirt * 2.0;
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
		AcGePoint3d ptEnd;
		m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
		
		// 构造碰撞实体
		TAuxTools::BuildCirDuct(ptStart, ptEnd, dDiameter, dDiameter, xShell);
	}
	else
	{
		// 不做处理
		;
	}
	
	return 1;
}

int THImpHvacFlange::GetBodyBox(AcDbExtents& ext)
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	// 获得参数
	double dSkirt = 0.0;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirt);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirt *= dPScale/100;
	//
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HFLN_Width, dWidth);
	dWidth += dSkirt * 2.0;
	double dHalfWidth = dWidth / 2.0;
	double dThick = 0.0;
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	dThick += dSkirt * 2.0;
	double dHalfThick = dThick / 2.0;
	HvacSectType eSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (TDb::eCircular == eSectType)
	{
		// 处理圆管数据
		dHalfThick = dHalfWidth;
	}
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	vtNormal.normalize();
	AcGePoint3d ptStart;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	AcGePoint3d ptEnd;
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	AcGeVector3d vtSide = ptEnd - ptStart;
	vtSide.rotateBy(PI / 2.0, vtNormal);
	vtSide.normalize();
	
	// 计算端点
	AcGePoint3dArray arpt;
	arpt.append(ptStart + vtSide * dHalfWidth + vtNormal * dHalfThick);
	arpt.append(ptStart + vtSide * dHalfWidth - vtNormal * dHalfThick);
	arpt.append(ptStart - vtSide * dHalfWidth - vtNormal * dHalfThick);
	arpt.append(ptStart - vtSide * dHalfWidth + vtNormal * dHalfThick);
	arpt.append(ptEnd + vtSide * dHalfWidth + vtNormal * dHalfThick);
	arpt.append(ptEnd + vtSide * dHalfWidth - vtNormal * dHalfThick);
	arpt.append(ptEnd - vtSide * dHalfWidth - vtNormal * dHalfThick);
	arpt.append(ptEnd - vtSide * dHalfWidth + vtNormal * dHalfThick);
	
	// 构造最小包含体
	TAuxTools::BuildMinRectangle(arpt, ext);
	
	return 1;
}

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

// 导出XML
// CString THImpHvacFlange::GetXml() const
// {
// 	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
// 		return _T("");
// 
// 	int nValue(0);
// 	double dValue(0.0);
// 	int nPtPreci = 6; // 位置精度
// 
// 	TXmlTree xmlTree;
// 	CString csText;
// 	CString csX, csY, csZ;
// 	AcGePoint3d pt;
// 	POSITION posRoot = xmlTree.Insert(_T("ATS_DBHFITTING"), NULL, NULL);
// 	{
// 		xmlTree.SetAttribute(posRoot, _T("name"), _T("法兰"));
// 		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
// 	}
// 
// 	POSITION posItemDrawStyle = xmlTree.Insert(_T("DrawStyle"), posRoot, NULL);
// 	{ 
// 		xmlTree.SetAttribute(posItemDrawStyle, _T("name"), _T("绘制样式"));
// 		xmlTree.SetAttribute(posItemDrawStyle, _T("comment"), _T("绘制表现形式1:单线,2:双线开口,3…"));
// 		m_pXDataMap->GetAt(HFLN_Type, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemDrawStyle, csText);
// 	}
// 
// 	POSITION posItemSect = xmlTree.Insert(_T("SectionType"), posRoot, posItemDrawStyle);
// 	{ 
// 		xmlTree.SetAttribute(posItemSect, _T("name"), _T("截面类型"));
// 		xmlTree.SetAttribute(posItemSect, _T("comment"), _T("截面的形状0:矩形,1:圆形"));
// 		m_pXDataMap->GetAt(HVAC_SectType, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemSect, csText);
// 	}
// 
// 	AcGeVector3d vt;
// 	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemSect);
// 	{
// 		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(HFLN_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 posItemEndPt = xmlTree.Insert(_T("End_point"), posRoot, posItemStartPt);
// 	{ 
// 		xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("终点位置"));
// 		m_pXDataMap->GetAt(HFLN_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 posItemSkirt = xmlTree.Insert(_T("SkirtSize"), posRoot, posItemEndPt);
// 	{ 
// 		xmlTree.SetAttribute(posItemSkirt, _T("name"), _T("出头量"));
// 		xmlTree.SetAttribute(posItemSkirt, _T("comment"), _T("超出风管尺寸部分"));
// 		m_pXDataMap->GetAt(HFLN_SkirtSize, dValue);
// 		TAuxTools::DoubleToString(dValue, 0, csText);
// 		xmlTree.SetItemText(posItemSkirt, csText);
// 	}
// 
// 	POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemSkirt);
// 	{ 
// 		xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
// 		m_pXDataMap->GetAt(HFLN_Width, dValue);
// 		TAuxTools::DoubleToString(dValue, 0, csText);
// 		xmlTree.SetItemText(posItemWidth, csText);
// 	}
// 
// 	POSITION posItemHeight = xmlTree.Insert(_T("Height"), posRoot, posItemWidth);
// 	{ 
// 		xmlTree.SetAttribute(posItemHeight, _T("name"), _T("高度"));
// 		m_pXDataMap->GetAt(HFLN_Thick, dValue);
// 		TAuxTools::DoubleToString(dValue, 0, csText);
// 		xmlTree.SetItemText(posItemHeight, csText);
// 	}
// 
// 	POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posItemHeight);
// 	{
// 		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 THImpHvacFlange::GetXml(const AcGeMatrix3d& mat) const
{
	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
		return _T("");

	int nValue(0);
	double dValue(0.0);
	int nPtPreci = 6; // 位置精度

	TXmlTree xmlTree;
	CString csText;
	CString csX, csY, csZ;
	AcGePoint3d pt;
	POSITION posRoot = xmlTree.Insert(_T("ATS_DBHFITTING"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("法兰"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	POSITION posItemDrawStyle = xmlTree.Insert(_T("DrawStyle"), posRoot, NULL);
	{ 
		xmlTree.SetAttribute(posItemDrawStyle, _T("name"), _T("绘制样式"));
		xmlTree.SetAttribute(posItemDrawStyle, _T("comment"), _T("绘制表现形式1:单线,2:双线开口,3…"));
		m_pXDataMap->GetAt(HFLN_Type, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemDrawStyle, csText);
	}

	POSITION posItemSect = xmlTree.Insert(_T("SectionType"), posRoot, posItemDrawStyle);
	{ 
		xmlTree.SetAttribute(posItemSect, _T("name"), _T("截面类型"));
		xmlTree.SetAttribute(posItemSect, _T("comment"), _T("截面的形状0:矩形,1:圆形"));
		m_pXDataMap->GetAt(HVAC_SectType, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemSect, csText);
	}

	AcGeVector3d vt;
	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemSect);
	{
		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(HFLN_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 posItemEndPt = xmlTree.Insert(_T("End_point"), posRoot, posItemStartPt);
	{ 
		xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("终点位置"));
		m_pXDataMap->GetAt(HFLN_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 posItemSkirt = xmlTree.Insert(_T("SkirtSize"), posRoot, posItemEndPt);
	{ 
		xmlTree.SetAttribute(posItemSkirt, _T("name"), _T("出头量"));
		xmlTree.SetAttribute(posItemSkirt, _T("comment"), _T("超出风管尺寸部分"));
		m_pXDataMap->GetAt(HFLN_SkirtSize, dValue);
		// add by zh 2013-5-20 根据出图比例计算出头长度
		double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
		if (dPScale < 1.e-3) dPScale = 1.0;
		dValue *= dPScale/100;
		//
		TAuxTools::DoubleToString(dValue, 0, csText);
		xmlTree.SetItemText(posItemSkirt, csText);
	}

	POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemSkirt);
	{ 
		xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
		m_pXDataMap->GetAt(HFLN_Width, dValue);
		TAuxTools::DoubleToString(dValue, 0, csText);
		xmlTree.SetItemText(posItemWidth, csText);
	}

	POSITION posItemHeight = xmlTree.Insert(_T("Height"), posRoot, posItemWidth);
	{ 
		xmlTree.SetAttribute(posItemHeight, _T("name"), _T("高度"));
		m_pXDataMap->GetAt(HFLN_Thick, dValue);
		TAuxTools::DoubleToString(dValue, 0, csText);
		xmlTree.SetItemText(posItemHeight, csText);
	}

	POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posItemHeight);
	{
		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);
	}

	CString csXml = xmlTree.GetXml();
	// end

	return csXml;
}

// 暂简化求出绕风管四壁的四个面,点对应图见工程目录下 关键点示意图.dwg
bool THImpHvacFlange::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);

	// 获取绘图数据
	HvacSectType eSect = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);

	AcGeVector3d vtMain,vtMainv;
	double dSkirtSize = 0.0;
	double dBoardThick = 0.0;
	double dThick = 0.0;
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	m_pXDataMap->GetAt(HFLN_Thick, dThick);
	m_pXDataMap->GetAt(HFLN_Width, dWidth);

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	dBoardThick = ptStart.distanceTo(ptEnd);
	
	// 计算方向向量
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);	
	vtMain = ptEnd - ptStart;
	vtMainv = vtMain;
	vtMainv.rotateBy(PI / 2.0, vtNormal);	
	vtMain.normalize();
	vtMainv.normalize();
	vtNormal.normalize();

	if (TDb::eRectangular == eSect)
	{
		AcGePoint3dArray ptUp4Arr, ptDown4Arr;
		AcGePoint3d ptTemp = ptStart;
		ptTemp += vtNormal * (dThick*0.5 + dSkirtSize) + vtMainv * (dWidth*0.5 + dSkirtSize);
		ptUp4Arr.append(ptTemp);
		
		ptTemp -= vtMainv * (dWidth + dSkirtSize*2);
		ptUp4Arr.append(ptTemp);
		
		ptTemp += vtMain * dBoardThick;
		ptUp4Arr.append(ptTemp);
		
		ptTemp += vtMainv * (dWidth + dSkirtSize*2);
		ptUp4Arr.append(ptTemp);
		
		ptDown4Arr = ptUp4Arr;
		double dOffset = dThick + dSkirtSize * 2;
		ptDown4Arr[0] -= vtNormal * dOffset;
		ptDown4Arr[1] -= vtNormal * dOffset;
		ptDown4Arr[2] -= vtNormal * dOffset;
		ptDown4Arr[3] -= vtNormal * dOffset;
		
		TGGePoly2D poly2d, poly2dOut;
		
		// 上面
		poly2d.AppendNode(ptUp4Arr[0]);
		poly2d.AppendNode(ptUp4Arr[1]);
		poly2d.AppendNode(ptUp4Arr[2]);
		poly2d.AppendNode(ptUp4Arr[3]);
		poly2d.SetClosed();
		
		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(ptDown4Arr[0]);
		poly2d.AppendNode(ptDown4Arr[1]);
		poly2d.AppendNode(ptDown4Arr[2]);
		poly2d.AppendNode(ptDown4Arr[3]);
		poly2d.SetClosed();
				
		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(ptUp4Arr[1]);
		poly2d.AppendNode(ptDown4Arr[1]);
		poly2d.AppendNode(ptDown4Arr[2]);
		poly2d.AppendNode(ptUp4Arr[2]);
		poly2d.SetClosed();	
		
		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(ptUp4Arr[0]);
		poly2d.AppendNode(ptDown4Arr[0]);
		poly2d.AppendNode(ptDown4Arr[3]);
		poly2d.AppendNode(ptUp4Arr[3]);
		poly2d.SetClosed();
		
		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));
	}
	else if (TDb::eCircular == eSect)
	{
		int nPartNum = int(PI * 2 / TAuxTools::GetMinDiffAngle());
		if(0 != nPartNum % 2)	// 边数要为偶数，才能和填充线准确接合
			nPartNum += 1;
		double dRotAngle = PI * 2 / nPartNum;
		
		AcGeVector3d vtNow = normal();
		if(!vtMain.isParallelTo(vtPlaneSecDir) && !vtNow.isParallelTo(vtPlaneSecDir))
			vtNow.rotateBy(PI / 2, vtMain);
		vtNow.normalize();
		vtNow *= (dWidth * 0.5 + dSkirtSize);

		int i = 0;
		AcGePoint3dArray arStrPts, arEndPts;
		for(i = 0; i < nPartNum; i++)
		{
			arStrPts.append(ptStart + vtNow);
			arEndPts.append(ptEnd + vtNow);
			vtNow.rotateBy(dRotAngle, vtMain);
		}

		TGGePoly2D poly2dF, poly2dS, poly2dOut;

		// 上面&下面
		for(i = 0; i <= nPartNum / 2; i++)
		{
			if(i < nPartNum / 4)
				poly2dF.AppendNode(arStrPts[(nPartNum / 4) * 3 + i]);
			else
				poly2dF.AppendNode(arStrPts[i - (nPartNum / 4)]);
			poly2dS.AppendNode(arStrPts[(nPartNum / 4) * 3 - i]);
		}
		for(i = 0; i <= nPartNum / 2; i++)
		{
			if(i <= nPartNum / 4)
				poly2dF.AppendNode(arEndPts[(nPartNum / 4) - i]);
			else
				poly2dF.AppendNode(arEndPts[nPartNum + (nPartNum / 4) - i]);
			poly2dS.AppendNode(arEndPts[(nPartNum / 4) + i]);
		}

		// 上
		poly2dF.SetClosed();
		poly2dOut.Reset();
		double dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2dF, poly2dOut);
		if(!!poly2dOut)
		{
			sectionRecord.push_back(TObjSectionRecord(idObj, idLayer,
				TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
		}

		// 下
		poly2dS.SetClosed();
		poly2dOut.Reset();
		dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2dS, poly2dOut);
		if(!!poly2dOut)
		{
			sectionRecord.push_back(TObjSectionRecord(idObj, idLayer,
				TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
		}

		// 前面&后面
		poly2dF.Reset();
		poly2dS.Reset();
		for(i = 0; i < nPartNum; i++)
		{
			poly2dF.AppendNode(arStrPts[i]);
			poly2dS.AppendNode(arEndPts[i]);
		}

		// 前
		poly2dF.SetClosed();
		poly2dOut.Reset();
		dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2dF, poly2dOut);
		if(!!poly2dOut)
		{
			sectionRecord.push_back(TObjSectionRecord(idObj, idLayer,
				TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
		}

		// 后
		poly2dS.SetClosed();
		poly2dOut.Reset();
		dMinDist = SectionUtility::Projection_poly2plane(section_pln, poly2dS, poly2dOut);
		if(!!poly2dOut)
		{
			sectionRecord.push_back(TObjSectionRecord(idObj, idLayer,
				TObjSectionRecord::eTCH_DBHFITTING, dMinDist, poly2dOut));
		}	
	}

	return true;
}

Acad::ErrorStatus THImpHvacFlange::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotImplementedYet;
	
	double dHalfheigh(0.0);
	HvacSectType eSect = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
	
	if (eSect == eRectangular)
		m_pXDataMap->GetAt(HFLN_Thick, dHalfheigh);
	else
		m_pXDataMap->GetAt(HFLN_Diameter, dHalfheigh);
	
	dHalfheigh *= 0.5;
	
	double dSkirtSize = 0.0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HFLN_StartPoint, ptStart);
	m_pXDataMap->GetAt(HFLN_EndPoint, ptEnd);
	m_pXDataMap->GetAt(HFLN_SkirtSize, dSkirtSize);
	// add by zh 2013-5-20 根据出图比例计算出头长度
	double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
	if (dPScale < 1.e-3) dPScale = 1.0;
	dSkirtSize *= dPScale/100;
	//
	AcGeVector3d vtNormal = normal();
	dHalfheigh += dSkirtSize;

	if (vtNormal.isParallelTo(TAuxTools::GetUcsZvt()))					// 常规法兰
	{
		ptLow = ptStart - vtNormal * dHalfheigh;
		ptUp = ptStart + vtNormal * dHalfheigh;
	}
	else /*if (vtNormal.isPerpendicularTo(TAuxTools::GetUcsZvt()))*/	// 立管上的法兰,暂不考虑斜管
	{
		if (ptStart.z < ptEnd.z)
		{
			ptLow = ptStart;
			ptUp = ptEnd;
		}
		else
		{
			ptLow = ptEnd;
			ptUp = ptStart;
		}
	}

	return Acad::eOk;	
}

// add by hh 2014-08-06 支持管件与水管遮挡
Acad::ErrorStatus THImpHvacFlange::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 THImpHvacFlange::IsMeClip() const
{
	return true;
}

bool THImpHvacFlange::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;
}