#include "stdafx.h"
#include "ImpHvacOffset.h"
#include "AuxTools.h"
#include "AecDbEntityBase.h"

using namespace AecEqui;

extern void GetEndPointIndex(const AcGePoint3dArray &ptArr, int &nIndex1, int &nIndex2, AcGeVector3d* pRangeDir = NULL);

// 获取标准基准投影面，２Ｄ相关绘制不在此面上的点都投影到此面上
AcGePlane GetStdPrjPlan( const AcGePoint3d &ptOnPlan )
{
	AcGeVector3d vtZAxis(TAuxTools::GetUcsZvt());
	AcGePlane planStd(ptOnPlan, vtZAxis);
	AcGePoint3d ptPrj = AcGePoint3d::kOrigin.orthoProject(planStd);
	planStd.set(ptPrj, vtZAxis);

	return planStd;
}

// 辅助添加点函数,减少程序行数
int AutoAppendPt( AecComplexCurve &cplCurve, AecCurveElement &cplEle, 
						   const AcGePoint3d &ptS, const AcGePoint3d &ptMid, const AcGePoint3d &ptE ) 
{
	cplEle.ptGe[0] = ptS;
	cplEle.ptGe[1] = ptMid;
	cplEle.ptGe[2] = ptE;

	return cplCurve.append(cplEle);
}

ImpHvacOffset::ImpHvacOffset()
{
	m_pXDataMap = NULL;
	m_pOwnerEnt = NULL;
}

ImpHvacOffset::~ImpHvacOffset()
{

}

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

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

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

	// 圆型截面显示直径
	if ( eCircle == eSectType)
	{
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HOFF_Diameter, dDiameter);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t直径：%.2f"), dDiameter);
	}
	// 非圆型截面显示宽度和厚度
	else
	{
		double dStartWidth = 0.0, dEndWidth = 0.0, dThick = 0.0;
		m_pXDataMap->GetAt(HOFF_StartWidth, dStartWidth);
		m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth);
		m_pXDataMap->GetAt(HOFF_Thick, dThick);
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t始端宽度：%.2f  末端宽度：%.2f  厚度：%.2f"), dStartWidth, dEndWidth, dThick);
	}

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

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

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

	// 变换点位置
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	ptStart.transformBy(xform);
	ptEnd.transformBy(xform);

	// 变换向量
	AcGeVector3d vtSta(StartVect()), vtEnd(EndVect());
	vtSta.transformBy(xform);
	vtEnd.transformBy(xform);
	vtSta.normalize();
	vtEnd.normalize();

	// 更新点
	m_pXDataMap->SetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->SetAt(HOFF_EndPoint, ptEnd);

	// 更新向量
	m_pXDataMap->SetAt(HOFF_StartDir, vtSta);
	m_pXDataMap->SetAt(HOFF_EndDir, vtEnd);

	// 设置尺寸
	double dScale = xform.scale();
	double dStaWidth(0.0), dEndWidth(0.), dHeigh(0.0);
	m_pXDataMap->GetAt(HOFF_StartWidth, dStaWidth);
	m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth);
	m_pXDataMap->GetAt(HOFF_Thick, dHeigh);

	dStaWidth *= dScale;
	dEndWidth *= dScale;
	dHeigh *= dScale;
	m_pXDataMap->SetAt(HOFF_StartWidth, dStaWidth);
	m_pXDataMap->SetAt(HOFF_EndWidth, dEndWidth);
	m_pXDataMap->SetAt(HOFF_Thick, dHeigh);

	return Acad::eOk;
}

AcGeVector3d ImpHvacOffset::StartVect() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtSta(AcGeVector3d::kIdentity);
	if (NULL != m_pXDataMap)
		m_pXDataMap->GetAt(HOFF_StartDir, vtSta);

	return vtSta;
}

AcGeVector3d ImpHvacOffset::EndVect() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtEnd(AcGeVector3d::kIdentity);
	if (NULL != m_pXDataMap)
		m_pXDataMap->GetAt(HOFF_EndDir, vtEnd);

	return vtEnd;	
}

AcGeVector3d ImpHvacOffset::normal() const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	AcGeVector3d  vtEnd(EndVect());
	AcGeVector3d vtDirect = ptEnd- ptStart;
	AcGeVector3d vtNormal = vtDirect.crossProduct(vtEnd);
	vtNormal.normalize();

	return vtNormal;
}

BOOL ImpHvacOffset::IsHorzAlignment() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	AcGeVector3d vtUserZAxis = TAuxTools::GetUcsZvt();
	AcGeVector3d vtSub = ptEnd - ptStart;

	return vtSub.isPerpendicularTo(vtUserZAxis);
}

BOOL ImpHvacOffset::IsSideVertAlignment() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtUserZAxis = TAuxTools::GetUcsZvt();
	return StartVect().isParallelTo(vtUserZAxis);	
}

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

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	AcGeVector3d vtSub = ptEnd - ptStart;
	AcGeVector3d vtSta;
	m_pXDataMap->GetAt(HOFF_StartDir, vtSta);
	AcGeVector3d vtUserZAxis = TAuxTools::GetUcsZvt();
	AcGeVector3d vtSubPrj = vtSub.orthoProject(TAuxTools::GetUcsZvt());
	AcGeVector3d vtStaPrj = vtSta.orthoProject(TAuxTools::GetUcsZvt());

	return vtSubPrj.isParallelTo(vtStaPrj);
}

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

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

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

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

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

	if (!IsCanDraw())
		return Acad::eNotImplementedYet;

	AecHvac::HvacOffsetType eType =AecHvac::eArcuateLink;
	ESection eSectType = eRect;
	m_pXDataMap->GetAt(HOFF_Type, (int&)eType);
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

	if (eType ==AecHvac::eArcuateLink)
	{
		if (eSectType == eRect)
			return DrawRectArcuate3d(mode);
		else if (eSectType ==eCircle)
			return DrawCircleArcuate3d(mode);
	}
	else if (eType ==AecHvac::eLinearLink)
	{
		if (eSectType == eRect)
			return DrawRectLinear3d(mode);
		else if (eSectType ==eCircle)
			return DrawCircleLinear3d(mode);
	}

	return Acad::eNotImplementedYet;
}

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

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

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

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

			nV3 = nV2 + 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	AecComplexCurve cplCurve;
	MakeCurves(cplCurve);
	
	AecComplexCurveDraw edage;
	edage.SetEdage(cplCurve);
	
	AcDbObjectId idReal = m_idDoubleLayer;
	AcDbObjectId idDash = m_idDashLayer;
	AcDbObjectId idCent = m_idCenterLayer;

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

	AecComplexCurve cplCen;
	GetCurvesInSide(cplCen);

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

	return Acad::eOk;
}

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

	if (!IsSingleLine() && !IsCanDraw())
		return FALSE;

	if (IsHorzAlignment())
	{
		AecHvac::HvacOffsetType eType =AecHvac::eArcuateLink;
		m_pXDataMap->GetAt(HOFF_Type, (int&)eType);
	
		if (eType ==AecHvac::eArcuateLink)
			return MakeHorizArcuate2DCurves(compCurve, 0);
		else if (eType ==AecHvac::eLinearLink)
			return MakeHorizLinear2DCurves(compCurve, 0);
	}
	else if (IsSideVertAlignment())
	{
		ESection eSectType = eRect;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

		if (eSectType == eRect)
			return MakeSideVertRect2DCurves(compCurve, 0);
		else if (eSectType ==eCircle)
			return MakeSideVertCircle2DCurves(compCurve, 0);
	}
	else if (IsFaceVertAlignment())
	{
		return MakeFaceVert2DCurves(compCurve, 0);
	}
	return FALSE;	
}

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

	if (!IsSingleLine() && !IsCanDraw())
		return FALSE;

	if (IsHorzAlignment())
	{
		AecHvac::HvacOffsetType eType = AecHvac::eArcuateLink;
		m_pXDataMap->GetAt(HOFF_Type, (int&)eType);

		if (eType == AecHvac::eArcuateLink)
			return MakeHorizArcuate2DCurves(compCurve, 1);
		else if (eType == AecHvac::eLinearLink)
			return MakeHorizLinear2DCurves(compCurve, 1);
	}
	else if (IsSideVertAlignment())
	{
		ESection eSectType = eRect;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);

		if (eSectType == eRect)
			return MakeSideVertRect2DCurves(compCurve, 1);
		else if (eSectType == eCircle)
			return MakeSideVertCircle2DCurves(compCurve, 1);
	}
	else if (IsFaceVertAlignment())
	{
		return MakeFaceVert2DCurves(compCurve, 1);
	}

	return FALSE;	
}

Acad::ErrorStatus ImpHvacOffset::DrawRectArcuate3d( AcGiDraw &mode ) const
{
	AcGePoint3dArray ptLeftArr, ptRightArr;
	GetAllMinAnglePt(ptLeftArr, ptRightArr);

	if (ptLeftArr.length() != ptRightArr.length() || 7 > ptLeftArr.length())
		return Acad::eNotImplementedYet;

	double dHalfThick(0.0);
	m_pXDataMap->GetAt(HOFF_Thick, dHalfThick);
	dHalfThick *= 0.5;
	
	AcGeVector3d vtNormal = normal();
	AcGeVector3d vtOff = dHalfThick * vtNormal;

	AcGePoint3dArray ptMeshArr;
	int i(0);
	for (i = 0; i < ptLeftArr.length(); i++)
	{
		ptMeshArr.append(ptLeftArr[i] + vtOff);
		ptMeshArr.append(ptRightArr[i] + vtOff);
		ptMeshArr.append(ptRightArr[i] - vtOff);
		ptMeshArr.append(ptLeftArr[i] - vtOff);
		ptMeshArr.append(ptLeftArr[i] + vtOff);
	}

	DrawMesh(mode,ptLeftArr.length(), 5, ptMeshArr.asArrayPtr());
	return Acad::eOk;
}

Acad::ErrorStatus ImpHvacOffset::DrawRectLinear3d( AcGiDraw &mode ) const
{
	AcGePoint3dArray ptUpArr, ptDownArr;
	if (!GetTwoSideKeyPoints(ptUpArr, ptDownArr))
		return Acad::eNotImplementedYet;
	
	if (8 != ptDownArr.length() || 8 != ptUpArr.length())
		return Acad::eNotImplementedYet;

	AcGePoint3dArray ptMeshArr;
	ptMeshArr.append(ptUpArr[1]);
	ptMeshArr.append(ptUpArr[0]);
	ptMeshArr.append(ptDownArr[0]);
	ptMeshArr.append(ptDownArr[1]);
	ptMeshArr.append(ptUpArr[1]);

	ptMeshArr.append(ptUpArr[2]);
	ptMeshArr.append(ptUpArr[7]);
	ptMeshArr.append(ptDownArr[7]);
	ptMeshArr.append(ptDownArr[2]);
	ptMeshArr.append(ptUpArr[2]);

	ptMeshArr.append(ptUpArr[3]);
	ptMeshArr.append(ptUpArr[6]);
	ptMeshArr.append(ptDownArr[6]);
	ptMeshArr.append(ptDownArr[3]);
	ptMeshArr.append(ptUpArr[3]);

	ptMeshArr.append(ptUpArr[4]);
	ptMeshArr.append(ptUpArr[5]);
	ptMeshArr.append(ptDownArr[5]);
	ptMeshArr.append(ptDownArr[4]);
	ptMeshArr.append(ptUpArr[4]);
	DrawMesh(mode,4, 5, ptMeshArr.asArrayPtr());

	return Acad::eOk;
}

// 先找出左右两侧弧所有最小分度角点，然后循环求出每段圆中各分度角点
Acad::ErrorStatus ImpHvacOffset::DrawCircleArcuate3d( AcGiDraw &mode ) const
{
	AcGePoint3dArray ptLeftArr, ptRightArr;
	GetAllMinAnglePt(ptLeftArr, ptRightArr);

	if (ptLeftArr.length() != ptRightArr.length() || 7 > ptLeftArr.length())
		return Acad::eNotImplementedYet;

	double dMinAngle(TAuxTools::GetMinDiffAngle());
	double dCircleMinAngle(0.0);
	int nCirclePart = (int)(PI*2 / dMinAngle) + 1;
	dCircleMinAngle = PI*2 / nCirclePart;

	// 每段圆左/右侧点,循环点, 每段圆心点
	AcGePoint3d ptLeft, ptRight, ptNow, ptCenter;	

	// 每段相切、垂直向量， 法向
	AcGeVector3d vtTangEvery, vtPerlEvery, vtNormal(normal());
	AcGePoint3dArray ptArrMesh;

	int i(0), j(0);
	for (i = 0; i < ptLeftArr.length(); i++)
	{
		vtPerlEvery = ptLeftArr[i] - ptRightArr[i];
		vtTangEvery = vtPerlEvery.crossProduct(vtNormal);
		ptCenter = TAuxTools::Mid(ptLeftArr[i], ptRightArr[i]);
		ptNow = ptLeftArr[i];

		for (j = 0; j < nCirclePart; j++)
		{
			ptArrMesh.append(ptNow);
			ptNow.rotateBy(dCircleMinAngle, vtTangEvery, ptCenter);
		}
		ptArrMesh.append(ptLeftArr[i]);
	}
	DrawMesh(mode,ptLeftArr.length(), nCirclePart + 1, ptArrMesh.asArrayPtr());

	return Acad::eOk;	
}

Acad::ErrorStatus ImpHvacOffset::DrawCircleLinear3d( AcGiDraw &mode ) const
{
	double dRadius(0.0), dPluse(0.0);
	m_pXDataMap->GetAt(HOFF_Diameter, dRadius);
	dRadius *= 0.5;
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPluse);
	
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	AcGeVector3d vtStart(StartVect());
	AcGeVector3d vtDirect = (ptEnd + dPluse * vtStart) - (ptStart - dPluse * vtStart);
	AcGeVector3d vtNormal = normal();

	double dMinAngle(TAuxTools::GetMinDiffAngle());
	int nPart = (int)(PI*2 / dMinAngle) + 1;
	dMinAngle = PI*2 / nPart;

	AcGePoint3dArray ptMeshArr;
	AcGePoint3d ptStartFirst = ptStart + dRadius * vtNormal;
	AcGePoint3d ptStartNow = ptStartFirst;
	AcGePoint3d ptNext;
	int i(0);
	for (i = 0; i < nPart + 1; i++)
	{
		ptMeshArr.append(ptStartNow);
		ptNext = ptStartNow - dPluse * vtStart;
		ptMeshArr.append(ptNext);
		ptNext += vtDirect;
		ptMeshArr.append(ptNext);
		ptNext -= dPluse * vtStart;
		ptMeshArr.append(ptNext);
		ptStartNow.rotateBy(dMinAngle, vtStart, ptStart);
	}
	
	DrawMesh(mode,nPart + 1, 4, ptMeshArr.asArrayPtr());

	return Acad::eOk;	
}

// 按两个弯头连接，有变径时在起始端半部变
BOOL ImpHvacOffset::MakeHorizArcuate2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	double dEdgeWidth(GetEdgeLineWidth());
	if (IsSingleLine() || (IsBaseLine() && nOutOrIn == 1))
	{
		AcGePoint3dArray ptBaseArr;
		if (!GetArcBaseKeyPt(ptBaseArr) || ptBaseArr.length() != 7)
			return FALSE;	

		if (IsSingleLine())
			tCurveEle.dWidth = dEdgeWidth;
		else
		{
			tCurveEle.dWidth = GetCentLineWidth();
			tCurveEle.idSubLay = GetBaseLayerId();
		}

		AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[0], ptBaseArr[1], ptBaseArr[1]);
		AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[1], ptBaseArr[2], ptBaseArr[3]);
		AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[3], ptBaseArr[4], ptBaseArr[5]);
		AutoAppendPt(cplCurve, tCurveEle, ptBaseArr[5], ptBaseArr[6], ptBaseArr[6]);
	}
	else if (nOutOrIn == 0)
	{
		AcGePoint3dArray ptLeftArr, ptRightArr;
		if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr))
			return FALSE;

		if (7 != ptLeftArr.length() || 7 != ptRightArr.length())
			return FALSE;

		tCurveEle.dWidth = dEdgeWidth;
		AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[0], ptLeftArr[1], ptLeftArr[1]);
		AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[1], ptLeftArr[2], ptLeftArr[3]);
		AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[3], ptLeftArr[4], ptLeftArr[5]);
		AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[5], ptLeftArr[6], ptLeftArr[6]);		

		AutoAppendPt(cplCurve, tCurveEle, ptRightArr[0], ptRightArr[1], ptRightArr[1]);
 		AutoAppendPt(cplCurve, tCurveEle, ptRightArr[1], ptRightArr[2], ptRightArr[3]);
		AutoAppendPt(cplCurve, tCurveEle, ptRightArr[3], ptRightArr[4], ptRightArr[5]);
		AutoAppendPt(cplCurve, tCurveEle, ptRightArr[5], ptRightArr[6], ptRightArr[6]);		

		tCurveEle.dWidth = GetEndLineWidth();
		m_pXDataMap->GetAt(HVAC_EndLayer, tCurveEle.idSubLay);
		AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[0], ptRightArr[0], ptRightArr[0]);		
		AutoAppendPt(cplCurve, tCurveEle, ptLeftArr[6], ptRightArr[6], ptRightArr[6]);		
	}
	return TRUE;	
}

BOOL ImpHvacOffset::MakeHorizLinear2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	double dEdgeWidth(GetEdgeLineWidth());
	if (IsSingleLine() || (IsBaseLine() && nOutOrIn == 1))
	{
		AcGePoint3d ptStart, ptEnd;
		m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
		m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

		double dPlus(0.0);
		m_pXDataMap->GetAt(HVAC_PlusEdge, dPlus);
		AcGeVector3d vtSta(StartVect()), vtEnd(EndVect());
		AcGePoint3d ptStaPlus = ptStart - dPlus * vtSta;
		AcGePoint3d ptEndPlus = ptEnd - dPlus * vtEnd;

		if (IsSingleLine())
			tCurveEle.dWidth = dEdgeWidth;
		else
		{
			tCurveEle.dWidth = GetCentLineWidth();
			tCurveEle.idSubLay = GetBaseLayerId();
		}
	
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptStaPlus, ptStaPlus);
		AutoAppendPt(cplCurve, tCurveEle, ptStaPlus, ptEndPlus, ptEndPlus);
		AutoAppendPt(cplCurve, tCurveEle, ptEndPlus, ptEnd, ptEnd);
	
		return TRUE;
	}
	else if (nOutOrIn == 0)
	{
		AcGePoint3dArray ptArr;
		GetMidKeyPoints(ptArr);
		int i(0);
		for (i = 0; i < ptArr.length() - 1; i++)
		{
			if (i == 0 || i == 4)
			{
				tCurveEle.dWidth = GetEndLineWidth();
				m_pXDataMap->GetAt(HVAC_EndLayer, tCurveEle.idSubLay);
			}
			else
			{
				tCurveEle.dWidth = dEdgeWidth;
				tCurveEle.idSubLay.setNull();
			}
			AutoAppendPt(cplCurve, tCurveEle, ptArr[i], ptArr[i+1], ptArr[i+1]);
		}

		AutoAppendPt(cplCurve, tCurveEle, ptArr[i], ptArr[0], ptArr[0]);
	}
	return TRUE;
}

BOOL ImpHvacOffset::MakeSideVertRect2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;

	tCurveEle.gsMark = 0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd);
	AcGePlane planStd = GetStdPrjPlan(ptMid);

	double dEdgeWidth(GetEdgeLineWidth()), dCentWidth(GetCentLineWidth());
	if (IsSingleLine())
	{
		tCurveEle.dWidth = dEdgeWidth;
		tCurveEle.idSubLay = m_idCenterLayer;
		AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), 
								ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd));	
		return TRUE;
	}

	AcGePoint3dArray ptUpArr, ptDownArr;
	GetTwoSideKeyPoints(ptUpArr, ptDownArr);
	if (8 != ptUpArr.length() || 8 != ptDownArr.length())
		return FALSE;
	
	int nEnd1(0), nEnd2(0);
	GetEndPointIndex(ptUpArr, nEnd1, nEnd2);

	if(nOutOrIn == 1)
	{
		tCurveEle.dWidth = dEdgeWidth;
		int i(0);
		for (i = 0; i < ptUpArr.length(); i++)
		{
			if (i == nEnd1 || i == nEnd2)
				continue;

			AutoAppendPt(cplCurve, tCurveEle, ptDownArr[i].orthoProject(planStd), 
							ptUpArr[i].orthoProject(planStd), ptUpArr[i].orthoProject(planStd));	
		}

		if (IsBaseLine())
		{
			tCurveEle.dWidth = dCentWidth;
			tCurveEle.idSubLay = m_idCenterLayer;
			AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), 
								ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd));	
		}
	}
	else if (nOutOrIn == 0)
	{
		tCurveEle.dWidth = dEdgeWidth;
		// 端点两边
		AutoAppendPt(cplCurve, tCurveEle, ptDownArr[nEnd1].orthoProject(planStd), 
							ptUpArr[nEnd1].orthoProject(planStd), ptUpArr[nEnd1].orthoProject(planStd));	
		AutoAppendPt(cplCurve, tCurveEle, ptDownArr[nEnd2].orthoProject(planStd), 
							ptUpArr[nEnd2].orthoProject(planStd), ptUpArr[nEnd2].orthoProject(planStd));	
	
		// 侧部两边
		AutoAppendPt(cplCurve, tCurveEle, ptDownArr[nEnd1].orthoProject(planStd), 
							ptDownArr[nEnd2].orthoProject(planStd), ptDownArr[nEnd2].orthoProject(planStd));	
		AutoAppendPt(cplCurve, tCurveEle, ptUpArr[nEnd1].orthoProject(planStd), 
							ptUpArr[nEnd2].orthoProject(planStd), ptUpArr[nEnd2].orthoProject(planStd));	
	}
	return Acad::eOk;	
}

BOOL ImpHvacOffset::MakeSideVertCircle2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;
	tCurveEle.gsMark = 0;

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	double dRadius(0.0);
	m_pXDataMap->GetAt(HOFF_Diameter, dRadius);
	dRadius *= 0.5;

	AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd);
	AcGePlane planStd = GetStdPrjPlan(ptMid);
	ptStart = ptStart.orthoProject(planStd);
	ptEnd = ptEnd.orthoProject(planStd);

	double dEdgeWidth(GetEdgeLineWidth()), dCentWidth(GetCentLineWidth());
	if (IsSingleLine())
	{
		tCurveEle.dWidth = dEdgeWidth;
		AutoAppendPt(cplCurve, tCurveEle, ptStart, ptEnd, ptEnd);	
		return TRUE;
	}
	
	AcGeVector3d vtNormal = normal();
	AcGeVector3d vtDirect = ptEnd - ptStart;
	vtDirect.normalize();

	
	AcGePoint3d ptStartCirSta, ptStartCirMid, ptStartCirEnd;	// 起始半圆各点
	AcGePoint3d ptEndCirSta, ptEndCirMid, ptEndCirEnd;			// 末半圆各点
	ptStartCirSta = ptStart + dRadius * vtNormal;
	ptStartCirEnd = ptStart - dRadius * vtNormal;
	ptEndCirSta = ptEnd + dRadius * vtNormal;
	ptEndCirEnd = ptEnd - dRadius * vtNormal;

	if(nOutOrIn == 1)
	{
		tCurveEle.dWidth = dEdgeWidth;
		// 起始端半圆
		ptStartCirMid = ptStart + dRadius * vtDirect;
		AutoAppendPt(cplCurve, tCurveEle, ptStartCirSta, ptStartCirMid, ptStartCirEnd);	

		// 末端半圆
		ptEndCirMid = ptEnd - dRadius * vtDirect;
		AutoAppendPt(cplCurve, tCurveEle, ptEndCirSta, ptEndCirMid, ptEndCirEnd);	
	
		if (IsBaseLine())
		{
			tCurveEle.dWidth = dCentWidth;
			tCurveEle.idSubLay = GetBaseLayerId();
			AutoAppendPt(cplCurve, tCurveEle, ptStart, ptEnd, ptEnd);	
		}
	}
	else if (nOutOrIn == 0)
	{
		tCurveEle.dWidth = dEdgeWidth;
		// 两边
		AutoAppendPt(cplCurve, tCurveEle, ptStartCirSta, ptEndCirSta, ptEndCirSta);	
		AutoAppendPt(cplCurve, tCurveEle, ptStartCirEnd, ptEndCirEnd, ptEndCirEnd);	

		// 两半圆	
		ptStartCirMid = ptStart - dRadius * vtDirect;
		AutoAppendPt(cplCurve, tCurveEle, ptStartCirSta, ptStartCirMid, ptStartCirEnd);	

		ptEndCirMid = ptEnd + dRadius * vtDirect;
		AutoAppendPt(cplCurve, tCurveEle, ptEndCirSta, ptEndCirMid, ptEndCirEnd);	
	}
	return TRUE;
}

BOOL ImpHvacOffset::MakeFaceVert2DCurves( AecComplexCurve& cplCurve, const int &nOutOrIn ) const
{
	AecCurveElement tCurveEle;
	memset(&tCurveEle, 0, sizeof(AecCurveElement));
	tCurveEle.bHided = FALSE;
	tCurveEle.dWidth = 0.0;

	tCurveEle.gsMark = 0;
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	AcGePoint3d ptMid = TAuxTools::Mid(ptStart, ptEnd);
	AcGePlane planStd = GetStdPrjPlan(ptMid);

	AcGePoint3dArray ptUpArr, ptDownArr;
	GetTwoSideKeyPoints(ptUpArr, ptDownArr);
	if (8 != ptUpArr.length() || 8 != ptDownArr.length())
		return FALSE;

	double dEdgeWidth(GetEdgeLineWidth()), dCentWidth(GetCentLineWidth());
	if (IsSingleLine())
	{
		tCurveEle.dWidth = dEdgeWidth;
		tCurveEle.idSubLay = m_idCenterLayer;
		AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), 
								ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd));	

		return Acad::eOk;
	}

	if (nOutOrIn == 1)
	{
		if (IsBaseLine())
		{
			tCurveEle.dWidth = dCentWidth;
			tCurveEle.idSubLay = m_idCenterLayer;
			AutoAppendPt(cplCurve, tCurveEle, ptStart.orthoProject(planStd), 
									ptEnd.orthoProject(planStd), ptEnd.orthoProject(planStd));	
		}
	}
	else if (nOutOrIn == 0)
	{	
		tCurveEle.dWidth = dEdgeWidth;
		AutoAppendPt(cplCurve, tCurveEle, ptUpArr[1].orthoProject(planStd), 
			ptUpArr[4].orthoProject(planStd), ptUpArr[4].orthoProject(planStd));
	
		AutoAppendPt(cplCurve, tCurveEle, ptDownArr[4].orthoProject(planStd), 
			ptDownArr[1].orthoProject(planStd), ptDownArr[1].orthoProject(planStd));
	
		tCurveEle.dWidth = GetEndLineWidth();
		m_pXDataMap->GetAt(HVAC_EndLayer, tCurveEle.idSubLay);
		AutoAppendPt(cplCurve, tCurveEle, ptDownArr[1].orthoProject(planStd), 
			ptUpArr[1].orthoProject(planStd), ptUpArr[1].orthoProject(planStd));
		AutoAppendPt(cplCurve, tCurveEle, ptUpArr[4].orthoProject(planStd), 
			ptDownArr[4].orthoProject(planStd), ptDownArr[4].orthoProject(planStd));
		
		// 中间加箭头标示，上升（下降）摇手弯，及气流方向
		// 长度为乙子弯长度1/2,三条线均分宽度
		// 箭头7.5度
		/*
		0━━━━━━1		高标高			
					  \					
					   \					
		Start			\				 4		End
						 \			  	  \				
						  \				   \		
						   2━━━━━━━━3											
					   低标高
		*/
		int nDrawMode(0);
		m_pXDataMap->GetAt(HOFF_VertDrawStyle, nDrawMode);
		if (1 == nDrawMode)
		{
			int nFlowDir(0);
			m_pXDataMap->GetAt(HVAC_FlowDirect, nFlowDir);
			
			AcGePoint3d ptArrorArr[5], ptRectArr[4];
			ptRectArr[0] = ptDownArr[1].orthoProject(planStd);
			ptRectArr[1] = ptUpArr[1].orthoProject(planStd);
			ptRectArr[2] = ptUpArr[4].orthoProject(planStd);
			ptRectArr[3] = ptDownArr[4].orthoProject(planStd);
			
			double dLen = ptRectArr[0].distanceTo(ptRectArr[3]);
			double dWidth = ptRectArr[0].distanceTo(ptRectArr[1]);
			AcGeVector3d vtLen, vtWidth;
			vtLen = (ptRectArr[3] - ptRectArr[0]).normalize();
			vtWidth = (ptRectArr[1] - ptRectArr[0]).normalize();
			AcGeVector3d vtHook = vtWidth;
			double dHookOff = dLen/12 * tan(7.5/180.0*PI);
			if (dHookOff > dWidth/3)
				dHookOff = dWidth/3;
			
			if (nFlowDir == 0)	// 起始点流向终点
			{
				// 注：乙字弯的流向在外部没有使用，所以暂未考虑逆向的画法
				AcGeVector3d vecTmp = ptEnd - ptStart;
				if(vecTmp.angleTo(TAuxTools::GetUcsXvt()) - PI * 0.5 < 1E-6)
				{
					ptArrorArr[0] = ptRectArr[0] + vtWidth * dWidth/3 + vtLen * dLen/4; 
					ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; 
					ptArrorArr[3] = ptRectArr[2] - vtWidth * dWidth/3 - vtLen * dLen/4;  
					ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6;  
					ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12;

					// 纠正末尾钩子方向
					AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0];
					vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt());
					if (vtHook.angleTo(vtDirect) > PI*0.5)
						vtHook *= -1;

					ptArrorArr[4] += vtHook * dHookOff;
				}
				else
				{
					ptArrorArr[0] = ptRectArr[1] - vtWidth * dWidth/3 + vtLen * dLen/4;  
					ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6;
					ptArrorArr[3] = ptRectArr[3] + vtWidth * dWidth/3 - vtLen * dLen/4; 
					ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6; 
					ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12;  

					AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0];
					vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt());
					if (vtHook.angleTo(vtDirect) < PI*0.5)
						vtHook *= -1;
					ptArrorArr[4] += vtHook * dHookOff;
				}
			}
			else
			{
				vtLen *= -1;
				ptArrorArr[0] = ptRectArr[3] + vtWidth * dWidth/3 + vtLen * dLen/4; 
				ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; 
				ptArrorArr[3] = ptRectArr[1] - vtWidth * dWidth/3 - vtLen * dLen/4;  
				ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6;  
				ptArrorArr[4] = ptArrorArr[3] - vtLen * dLen/12;  
				
				AcGeVector3d vtDirect = ptArrorArr[3] - ptArrorArr[0];
				vtDirect.rotateBy(PI*0.5, TAuxTools::GetUcsZvt());
				if (vtHook.angleTo(vtDirect) > PI*0.5)
					vtHook *= -1;
				ptArrorArr[4] += vtHook * dHookOff;
			}
			
			tCurveEle.dWidth = dEdgeWidth;
			tCurveEle.idSubLay.setNull();
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[0], ptArrorArr[1], ptArrorArr[1]);
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[1], ptArrorArr[2], ptArrorArr[2]);
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[2], ptArrorArr[3], ptArrorArr[3]);
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[3], ptArrorArr[4], ptArrorArr[4]);
		}
		else if (2 == nDrawMode)
		{
			int nFlowDir(0);
			m_pXDataMap->GetAt(HVAC_FlowDirect, nFlowDir);

			AcGePoint3d ptArrorArr[5], ptRectArr[4];
			ptRectArr[0] = ptDownArr[1].orthoProject(planStd);
			ptRectArr[1] = ptUpArr[1].orthoProject(planStd);
			ptRectArr[2] = ptUpArr[4].orthoProject(planStd);
			ptRectArr[3] = ptDownArr[4].orthoProject(planStd);

			double dLen = ptRectArr[0].distanceTo(ptRectArr[3]);
			double dWidth = ptRectArr[0].distanceTo(ptRectArr[1]);
			AcGeVector3d vtLen, vtWidth;
			vtLen = (ptRectArr[3] - ptRectArr[0]).normalize();
			vtWidth = (ptRectArr[1] - ptRectArr[0]).normalize();
			AcGeVector3d vtHook = vtWidth;
			double dHookOff = dLen/12 * tan(7.5/180.0*PI);
			if (dHookOff > dWidth/3)
				dHookOff = dWidth/3;

			if (nFlowDir == 0)	// 起始点流向终点
			{
				// 注：乙字弯的流向在外部没有使用，所以暂未考虑逆向的画法
				AcGeVector3d vecTmp = ptEnd - ptStart;
				if(vecTmp.angleTo(TAuxTools::GetUcsXvt()) - PI * 0.5 < 1E-6)
				{
					ptArrorArr[0] = ptRectArr[0] + vtWidth * dWidth/3 + vtLen * dLen/4;
					ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; 
					ptArrorArr[3] = ptRectArr[2] - vtWidth * dWidth/3 - vtLen * dLen/4;
					ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6;  
				}
				else
				{
					ptArrorArr[0] = ptRectArr[1] - vtWidth * dWidth/3 + vtLen * dLen/4;
					ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6;
					ptArrorArr[3] = ptRectArr[3] + vtWidth * dWidth/3 - vtLen * dLen/4;
					ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6;
				}
			}
			else
			{
				vtLen *= -1;
				ptArrorArr[0] = ptRectArr[3] + vtWidth * dWidth/3 + vtLen * dLen/4;
				ptArrorArr[1] = ptArrorArr[0] + vtLen * dLen/6; 
				ptArrorArr[3] = ptRectArr[1] - vtWidth * dWidth/3 - vtLen * dLen/4;
				ptArrorArr[2] = ptArrorArr[3] - vtLen * dLen/6;  
			}

			tCurveEle.dWidth = dEdgeWidth;
			tCurveEle.idSubLay.setNull();
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[0], ptArrorArr[1], ptArrorArr[1]);
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[1], ptArrorArr[2], ptArrorArr[2]);
			AutoAppendPt(cplCurve, tCurveEle, ptArrorArr[2], ptArrorArr[3], ptArrorArr[3]);
		}
	}
	return Acad::eOk;	
}

/*
	    0━7				
		┃	\				
		┃	 \				
	S	┃	  \				
		┃	   \			
		┃	    \			
		1━2 	6━ 5		
	       \		┃		
	        \		┃		
	         \		┃		
		      \		┃   E	
		       \	┃		
	   		    3━4		
							
*/

void ImpHvacOffset::GetMidKeyPoints( AcGePoint3dArray &ptArr, BOOL bSingleLine /*= FALSE*/ ) const
{
	ASSERT(NULL != m_pXDataMap);

	AcGePoint3d ptS, ptE;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptS);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptE);

	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect());
	AcGeVector3d vtStaSide(vtStart), vtEndSide(vtEnd);
	AcGeVector3d vtPerl = normal();

	vtStaSide.rotateBy(PI*0.5, vtPerl);
	vtEndSide.rotateBy(PI*0.5, vtPerl);
	
	double dStaWidth(0.0), dEndWidth(0.0), dHeigh(0.0), dPluse(0);
	m_pXDataMap->GetAt(HOFF_Thick, dHeigh);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPluse);

	if (bSingleLine)
	{
		m_pXDataMap->GetAt(KEY_HIDEWIDTH,  dStaWidth);	// 遮挡宽度
		dEndWidth = dStaWidth;
	}
	else
	{
		m_pXDataMap->GetAt(HOFF_StartWidth, dStaWidth);
		m_pXDataMap->GetAt(HOFF_EndWidth, dEndWidth);
		ESection eSectType = eRect;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		if (eSectType ==eCircle)
			dEndWidth = dStaWidth;
	}
	
	AcGePoint3d ptTempArr[8];
	ptTempArr[0] = ptS - dStaWidth * 0.5 * vtStaSide;
	ptTempArr[1] = ptTempArr[0] + dStaWidth * vtStaSide;
	ptTempArr[4] = ptE - dEndWidth * 0.5 * vtEndSide;
	ptTempArr[5] = ptTempArr[4] + dEndWidth * vtEndSide;

	ptTempArr[2] = ptTempArr[1] - dPluse * vtStart;
	ptTempArr[7] = ptTempArr[0] - dPluse * vtStart;
	ptTempArr[3] = ptTempArr[4] - dPluse * vtEnd;
	ptTempArr[6] = ptTempArr[5] - dPluse * vtEnd;

	int i(0);
	for (i = 0; i < 8; i++)
	{
		ptArr.append(ptTempArr[i]);
	}
}

BOOL ImpHvacOffset::GetTwoSideKeyPoints( AcGePoint3dArray &ptUpArr, AcGePoint3dArray &ptDownArr, 
													BOOL bSingleLine /*= FALSE*/ ) const
{
	GetMidKeyPoints(ptUpArr, bSingleLine);
	if (ptUpArr.length() < 1)
		return FALSE;

	AcGeVector3d vtPerl = normal();

	double dThick(0.0);
	m_pXDataMap->GetAt(HOFF_Thick, dThick);

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

	if (eSect ==eCircle)
		m_pXDataMap->GetAt(HOFF_Diameter, dThick);

	AcGeVector3d vtOffSet = dThick * vtPerl * 0.5;

	int i(0);
	for (i = 0; i < ptUpArr.length(); i++)
	{
		ptDownArr.append(ptUpArr[i] - vtOffSet);
		ptUpArr[i] += vtOffSet;
	}

	return TRUE;
}

BOOL ImpHvacOffset::GetArcBaseKeyPt( AcGePoint3dArray &ptKeyArr ) const
{
	AcGePoint3d ptStart, ptEnd, ptMid;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	ptMid = TAuxTools::Mid(ptStart, ptEnd);

	AcGeVector3d vtUserZAixs = normal();
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect());

	double dPluse(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dPluse);

	AcGePoint3d ptStartArc = ptStart - dPluse * vtStart;	// 起始端弧开始点
	AcGePoint3d ptEndArc = ptEnd - dPluse * vtEnd;			//末端弧开始点
	
	// 起始端弧
	AcGeVector3d vtStartPer(vtStart);
	vtStartPer.rotateBy(PI * 0.5, vtUserZAixs);

	AcGeLine3d lineStaPer(ptStartArc, ptStartArc + 100 * vtStartPer);
	AcGePoint3d ptStaMid = TAuxTools::Mid(ptStartArc, ptMid);

	AcGeVector3d vtMidPer = ptEndArc - ptStartArc;
	vtMidPer.rotateBy(PI * 0.5, vtUserZAixs);
	vtMidPer.normalize();

	AcGeLine3d lineStartMidPer(ptStaMid, ptStaMid + 100 * vtMidPer);
	AcGePoint3d ptStaCenter;	// 起始端弧圆心
	if (lineStaPer.intersectWith(lineStartMidPer, ptStaCenter) != Adesk::kTrue)	
		return FALSE;

	AcGeVector3d vtStartArc = ptStaMid - ptStaCenter;
	if (vtStartArc.angleTo(vtStart) < PI * 0.5)
		vtStartArc *= -1;

	vtStartArc.normalize();
	double dStartRadius = ptStartArc.distanceTo(ptStaCenter);
	AcGePoint3d ptStarArcMid = ptStaCenter + dStartRadius * vtStartArc;	// 起始端弧中点

	// 末端弧
	AcGeVector3d vtEndPer(vtEnd);
	vtEndPer.rotateBy(PI * 0.5, vtUserZAixs);

	AcGeLine3d lineEndPer(ptEndArc, ptEndArc + 100 * vtEndPer);
	AcGePoint3d ptEndMid = TAuxTools::Mid(ptEndArc, ptMid);
	AcGeLine3d lineEndMidPer(ptEndMid, ptEndMid + 100 * vtMidPer);
	AcGePoint3d ptEndCenter;	// 末端弧圆心
	if (lineEndPer.intersectWith(lineEndMidPer, ptEndCenter) != Adesk::kTrue)	
		return FALSE;

	AcGeVector3d vtEndArc = ptEndMid - ptEndCenter;
	if (vtEndArc.angleTo(vtEnd) < PI * 0.5)
		vtEndArc *= -1;

	vtEndArc.normalize();
	double dEndRadius = ptEndArc.distanceTo(ptEndCenter);
	AcGePoint3d ptEndArcMid = ptEndCenter + dEndRadius * vtEndArc;	// 末端弧中点

	ptKeyArr.append(ptStart);
	ptKeyArr.append(ptStartArc);
	ptKeyArr.append(ptStarArcMid);
	ptKeyArr.append(ptMid);
	ptKeyArr.append(ptEndArcMid);
	ptKeyArr.append(ptEndArc);
	ptKeyArr.append(ptEnd);

	return TRUE;
}

BOOL ImpHvacOffset::GetArcTwoSideKeyPt( AcGePoint3dArray &ptArrLeft, AcGePoint3dArray &ptArrRight, 
														BOOL bSingleLine /*= FALSE*/ ) const
{
	AcGePoint3dArray ptBaseArr;
	if (!GetArcBaseKeyPt(ptBaseArr))
		return FALSE;

	AcGePoint3d ptStart, ptEnd, ptMid;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	ptMid = TAuxTools::Mid(ptStart, ptEnd);

	double dHalfStartWidth(0.0), dHalfEndWidth(0.0);
	if (bSingleLine)
	{
		m_pXDataMap->GetAt(KEY_HIDEWIDTH,  dHalfStartWidth);	// 遮挡宽度
		dHalfEndWidth = dHalfStartWidth;
	}
	else
	{
		m_pXDataMap->GetAt(HOFF_StartWidth, dHalfStartWidth);
		m_pXDataMap->GetAt(HOFF_EndWidth, dHalfEndWidth);

		ESection eSectType = eRect;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		if (eSectType ==eCircle)
			m_pXDataMap->GetAt(HOFF_Diameter, dHalfEndWidth);
	}
	
	dHalfStartWidth *= 0.5;
	dHalfEndWidth *= 0.5;

	AcGeVector3d vtUserZAixs = normal();
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect());
	AcGeVector3d vtMidPer = ptEnd - ptStart;
	vtMidPer.rotateBy(PI * 0.5, vtUserZAixs);
	vtMidPer.normalize();

	AcGeVector3d vtStartPer(vtStart), vtEndPer(vtEnd);
	vtStartPer.rotateBy(PI * 0.5, vtUserZAixs);
	vtEndPer.rotateBy(PI * 0.5, vtUserZAixs);

	// 左边（从起始端法向方向 往末端法向看）
	double dEverWidth = (dHalfStartWidth + dHalfEndWidth) * 0.5;
	AcGeCircArc3d arc(ptBaseArr[1], ptBaseArr[2], ptBaseArr[3]);
	AcGePoint3d ptCenter = arc.center();
	AcGeVector3d vtMid = ptMid - ptCenter;
	vtMid.normalize();
	AcGeVector3d vtStartMid = ptBaseArr[2] - ptCenter;	// 起始端弧中点到圆心的向量
	vtStartMid.normalize();

	if (vtStartMid.angleTo(vtStartPer) > PI * 0.5)
	{
		vtStartMid *= -1;
		vtMid *= -1;
	}

	ptArrLeft.append(ptStart - dHalfStartWidth * vtStartPer);
	ptArrLeft.append(ptBaseArr[1] - dHalfStartWidth * vtStartPer);
	ptArrLeft.append(ptBaseArr[2] - dEverWidth * vtStartMid);
	ptArrLeft.append(ptMid - dHalfEndWidth * vtMid);

	arc.set(ptBaseArr[3], ptBaseArr[4], ptBaseArr[5]);
	ptCenter = arc.center();
	AcGeVector3d vtEndMid = ptBaseArr[4] - ptCenter;	// 末端弧中点到圆心的向量
	vtEndMid.normalize();

	if (vtEndMid.angleTo(vtEndPer) > PI * 0.5)
	{
		vtEndMid *= -1;
	}

	ptArrLeft.append(ptBaseArr[4] + dHalfEndWidth * vtEndMid);
	ptArrLeft.append(ptBaseArr[5] + dHalfEndWidth * vtEndPer); 
	ptArrLeft.append(ptEnd + dHalfEndWidth * vtEndPer); 

	// 右边
	vtStartMid *= -1;
	vtMid *= -1;
	vtEndMid *= -1;

	ptArrRight.append(ptStart + dHalfStartWidth * vtStartPer);
	ptArrRight.append(ptBaseArr[1] + dHalfStartWidth * vtStartPer);
	ptArrRight.append(ptBaseArr[2] - dEverWidth * vtStartMid);
	ptArrRight.append(ptMid - dHalfEndWidth * vtMid);

	ptArrRight.append(ptBaseArr[4] + dHalfEndWidth * vtEndMid);
	ptArrRight.append(ptBaseArr[5] - dHalfEndWidth * vtEndPer); 
	ptArrRight.append(ptEnd - dHalfEndWidth * vtEndPer); 

	return TRUE;
}

void ImpHvacOffset::GetAllMinAnglePt( AcGePoint3dArray &ptArrLeftPart, AcGePoint3dArray &ptArrRightPart, 
									   BOOL bSingleLine /*= FALSE*/ ) const
{
	AcGePoint3dArray ptLeftArr, ptRightArr;
	if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr, bSingleLine))
		return;

	if (7 != ptLeftArr.length() || 7 != ptRightArr.length())
		return;

	AcGeVector3d vtNormal = normal();
	double dMinAngle(TAuxTools::GetMinDiffAngle());
	
	// 首端法兰边直部分
	ptArrLeftPart.append(ptLeftArr[0]);
	ptArrLeftPart.append(ptLeftArr[1]);
	ptArrRightPart.append(ptRightArr[0]);
	ptArrRightPart.append(ptRightArr[1]);
	
	// 起始端左侧
	AcGeCircArc3d arcStartLeft(ptLeftArr[1], ptLeftArr[2], ptLeftArr[3]);
	AcGePoint3d ptStaLeftCent = arcStartLeft.center();
	double dStaLeftAngle = arcStartLeft.endAng() - arcStartLeft.startAng();
	int nStartLeftPartNum = int(dStaLeftAngle / dMinAngle) + 1;

	// 起始端右侧
	AcGeCircArc3d arcStartRight(ptRightArr[1], ptRightArr[2], ptRightArr[3]);
	AcGePoint3d ptStaRightCent = arcStartRight.center();
	double dStaRightAngle = arcStartRight.endAng() - arcStartRight.startAng();
	int nStartRightPartNum = int(dStaRightAngle / dMinAngle) + 1;

	// 按最大数目划分
	int nStartMaxNum = nStartLeftPartNum > nStartRightPartNum ? nStartLeftPartNum : nStartRightPartNum;
	double dStartLeftMinAngle = dStaLeftAngle / nStartMaxNum;
	DOUBLE dStartRightMinAngle = dStaRightAngle / nStartMaxNum;

	AcGePoint3d ptLeftNow, ptRightNow;
	ptLeftNow = ptLeftArr[1];
	ptRightNow = ptRightArr[1];
	int i(0);
	for (i = 0; i < nStartMaxNum - 1; i++)
	{
		ptLeftNow.rotateBy(dStartLeftMinAngle, -vtNormal, ptStaLeftCent);
		ptRightNow.rotateBy(dStartRightMinAngle, -vtNormal, ptStaRightCent);

		ptArrLeftPart.append(ptLeftNow);
		ptArrRightPart.append(ptRightNow);
	}

	ptArrLeftPart.append(ptLeftArr[3]);
	ptArrRightPart.append(ptRightArr[3]);


	// 末端左侧
	AcGeCircArc3d arcEndLeft(ptLeftArr[3], ptLeftArr[4], ptLeftArr[5]);
	AcGePoint3d ptEndLeftCent = arcEndLeft.center();
	double dEndLeftAngle = arcEndLeft.endAng() - arcEndLeft.startAng();
	int nEndLeftPartNum = int(dEndLeftAngle / dMinAngle) + 1;
	double dEndLeftMinAngle = dEndLeftAngle / nEndLeftPartNum;

	// 末端右侧
	AcGeCircArc3d arcEndRight(ptRightArr[3], ptRightArr[4], ptRightArr[5]);
	AcGePoint3d ptEndRightCent = arcEndRight.center();
	double dEndRightAngle = arcEndRight.endAng() - arcEndRight.startAng();
	int nEndRightPartNum = int(dEndRightAngle / dMinAngle) + 1;
	double dEndRightMinAngle = dEndRightAngle / nEndRightPartNum;

	// 按最大数目划分
	int nEndMaxNum = nEndLeftPartNum > nEndRightPartNum ? nEndLeftPartNum : nEndRightPartNum;
	dEndLeftMinAngle = dEndLeftAngle / nEndMaxNum;
	dEndRightMinAngle = dEndRightAngle / nEndMaxNum;
	ptLeftNow = ptLeftArr[3];
	ptRightNow = ptRightArr[3];
	for (i = 0; i < nEndMaxNum - 1; i++)
	{
		ptLeftNow.rotateBy(dEndLeftMinAngle, vtNormal, ptEndLeftCent);
		ptRightNow.rotateBy(dEndRightMinAngle, vtNormal, ptEndRightCent);

		ptArrLeftPart.append(ptLeftNow);
		ptArrRightPart.append(ptRightNow);
	}

	// 末端法兰部分
	ptArrLeftPart.append(ptLeftArr[5]);
	ptArrLeftPart.append(ptLeftArr[6]);
	ptArrRightPart.append(ptRightArr[5]);
	ptArrRightPart.append(ptRightArr[6]);
}

BOOL ImpHvacOffset::IsCanDraw() const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	// 增加控制形态判断。2010.04.08
	if (!IsHorzAlignment() && !IsSideVertAlignment() && !IsFaceVertAlignment())
		return FALSE;

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	if (ptStart.distanceTo(ptEnd) < 1e-3)
		return FALSE;

	// 首尾法向量必须不同向平行
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect());
	if (!vtStart.isParallelTo(vtEnd) || vtStart.isCodirectionalTo(vtEnd))
		return FALSE;

	// 首尾点方向与首尾法向量判断
	AcGeVector3d vtDirect = ptEnd - ptStart;
	double dMaxAngle(PI * 0.5 - 0.1), dMinAngle(1e-3);
	if (vtDirect.angleTo(vtEnd) > dMaxAngle || vtDirect.angleTo(vtEnd) < dMinAngle)
		return FALSE;

	AecHvac::HvacOffsetType eType =AecHvac::eArcuateLink;
	m_pXDataMap->GetAt(HOFF_Type, (int&)eType);
	if (eType ==AecHvac::eArcuateLink)
	{
		AcGePoint3dArray ptLeftArr, ptRightArr;
		if (!GetArcTwoSideKeyPt(ptLeftArr, ptRightArr))
			return FALSE;

		double dSmallDist = ptLeftArr[3].distanceTo(ptStart);
		double dBigDist = ptLeftArr[4].distanceTo(ptStart);

		if (dBigDist < dSmallDist)
			return FALSE;

		// 因为起始端有可能有变径，右侧也判断一下
		dSmallDist = ptRightArr[1].distanceTo(ptStart);
		dBigDist = ptRightArr[2].distanceTo(ptStart);

		if (dBigDist < dSmallDist)
			return FALSE;
	}

	return TRUE;
}

AcDbObjectId ImpHvacOffset::GetBaseLayerId() const
{
	return m_idDoubleLayer;
}

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

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

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

double ImpHvacOffset::GetAngle() const
{
	ASSERT(NULL != m_pXDataMap);

	// 基本参数
	AecHvac::HvacOffsetType eType = AecHvac::eArcuateLink;
	m_pXDataMap->GetAt(HOFF_Type, (int&)eType);
	double dFlangPlus(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dFlangPlus);

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	AcGeVector3d vtStart, vtEnd, vtOffSet;
	m_pXDataMap->GetAt(HOFF_StartDir, vtStart);
	m_pXDataMap->GetAt(HOFF_EndDir, vtEnd);

	// 先反求角度，再根据角度求末点，角度不变
	AcGePoint3d ptArcStart = ptStart - vtStart * dFlangPlus;
	AcGePoint3d ptArcEnd = ptEnd - vtEnd * dFlangPlus;
	double dAngle = (ptArcEnd - ptArcStart).angleTo(vtEnd);
	if (dAngle > PI*0.5)
		dAngle = PI - dAngle;

	if (AecHvac::eArcuateLink == eType)
	{
		dAngle = PI*0.5 - dAngle;
		dAngle = PI - dAngle * 2;
	}
	return dAngle;
}

AcGePoint3d ImpHvacOffset::GetEndPointByAngle()
{
	ASSERT(NULL != m_pXDataMap);

	// 基本参数
	AecHvac::HvacOffsetType eType = AecHvac::eArcuateLink;
	m_pXDataMap->GetAt(HOFF_Type, (int&)eType);
	double dAngle(0.0), dFlangPlus(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dFlangPlus);
	m_pXDataMap->GetAt(HOFF_Angle, dAngle);

	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);
	AcGeVector3d vtStart, vtOffSet;
	m_pXDataMap->GetAt(HOFF_StartDir, vtStart);
	vtOffSet = ptEnd - ptStart;
	vtOffSet = vtOffSet.orthoProject(vtStart);
	
	// 求末点
	double dPerlDist = vtOffSet.length();				// 向下偏移的距离
	double dHorizLen(0.0);								// 水平偏移距离

	if (AecHvac::eArcuateLink == eType)					// 双弧Angle：表示弯头角度	
		dHorizLen = dPerlDist / tan(dAngle * 0.5);		// 水平偏移距离
	else if (AecHvac::eLinearLink == eType)				// 角接时，dAngle：表示倾斜角度
		dHorizLen = dPerlDist / tan(dAngle);			
	
	AcGePoint3d ptArcSta = ptStart - dFlangPlus * vtStart;// 弧开始点
	ptEnd = ptArcSta + vtOffSet - (dHorizLen + dFlangPlus) * vtStart;

	return ptEnd;
}

AcGePoint3d ImpHvacOffset::GetEndPtByLength()
{
	ASSERT(NULL != m_pXDataMap);

	// 基本参数
	AecHvac::HvacOffsetType eType = AecHvac::eArcuateLink;
	m_pXDataMap->GetAt(HOFF_Type, (int&)eType);
	double dLength(0.0), dOffset(0.0), dFlangPlus(0.0);
	m_pXDataMap->GetAt(HVAC_PlusEdge, dFlangPlus);
	m_pXDataMap->GetAt(HOFF_Length, dLength);
	m_pXDataMap->GetAt(HOFF_Offset, dOffset);

	double dOffsetArcLength = dLength - 2 * dFlangPlus;
	if (dOffsetArcLength > 0.1)
	{
		double dAngle = atan(dOffset / dOffsetArcLength);
		if (AecHvac::eArcuateLink == eType)
			dAngle *= 2;

		m_pXDataMap->SetAt(HOFF_Angle, dAngle);
		return GetEndPointByAngle();
	}
	return AcGePoint3d::kOrigin;
}


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

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

	// 获取接口截面、宽度、厚度数据key值
	LPCTSTR pszWidthKey, pszThickKey;
	switch (nIndex)
	{
	case 0:
		pszWidthKey = ((eCircle == eSectType) ? HOFF_Diameter : HOFF_StartWidth);
		pszThickKey = HOFF_Thick;
		break;
	case 1:
		pszWidthKey = ((eCircle == eSectType) ? HOFF_Diameter : HOFF_EndWidth);
		pszThickKey = HOFF_Thick;
		break;
	default:
		return FALSE;
	}

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

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

	return TRUE;
}

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

	// 获取各点位置
	AcGePoint3d ptStart, ptEnd;
	m_pXDataMap->GetAt(HOFF_StartPoint, ptStart);
	m_pXDataMap->GetAt(HOFF_EndPoint, ptEnd);

	// 求各端方向
	AcGeVector3d vtStart(StartVect()), vtEnd(EndVect());

	AecInterface inf;
	for (int nIndex = 0;nIndex < 2;nIndex++)
	{
		switch(nIndex)
		{
		case 0:
			{
				inf.vtDir = vtStart;
				inf.ptPos = ptStart;
				inf.idOwner = m_pOwnerEnt->objectId();
				GetInterfaceSizeData(nIndex, inf);
				break;
			}
		case 1:
			{
				inf.vtDir = vtEnd;
				inf.ptPos = ptEnd;
				inf.idOwner = m_pOwnerEnt->objectId();
				GetInterfaceSizeData(nIndex, inf);
				break;
			}
		}
		arInfs.append(inf);
	}
	return true;
}