#include "stdafx.h"
#include "AecDbEcFitting.h"
#include "dbgrip.h"
#include "AecGripCback.h"
#include "MFCDbDwgFiler.h"
#include "GiDrawUtility.h"
#include "AecComplexCurveDraw.h"
#include "KTCADUtilityEx.h"
#include "KTSetting.h"
#include "AecDbEwPipeBase.h"
#include "AecDbEarthWorm.h"
#include "AecDbECableTray.h"
#include "AcGiViewDraw.h"

#ifndef WCAP_END_HR
#define WCAP_END_HR 0.2541
#endif

#ifndef MESH_N
#define MESH_N 20
#endif

#define CAPENDRADIUS 0.254

static const Adesk::UInt16 kColorByBlock   = 0;
static const Adesk::UInt16 kRed            = 1;
static const Adesk::UInt16 kYellow         = 2;
static const Adesk::UInt16 kGreen          = 3;
static const Adesk::UInt16 kCyan           = 4;
static const Adesk::UInt16 kBlue           = 5;
static const Adesk::UInt16 kMagenta        = 6;
static const Adesk::UInt16 kWhite          = 7;
static const Adesk::UInt16 kColorByLayer   = 256;

extern CString IDCreate();
extern double PixelToWcs(int nPixel);
extern BOOL Is2DView();
extern AcGeVector3d GetUcsZvt();
extern AcDbCurve* FormatPolyline(AcDbCurve* pBaseCur);
extern void PushGripMessage(GripMessage&);

extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
extern AcDbArc* FormatArc(AcGePoint3d& ptGe1,AcGePoint3d& ptGe2,AcGePoint3d& ptGe3);
extern AcDbRegion* PolylineToRegion( AcDbPolyline* pPl);
extern AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
extern bool MakeBlockRefSet(AcDbVoidPtrArray &arEntPtrs, const AcDbObjectId &idLay, Adesk::Boolean bDoSubent, LPCTSTR pszName, AcDbDatabase *pDb = NULL);
extern AcDbCurve *GetMaxOffsetCurve(AcDbCurve *pPl, double dOff);

static void FreeBuffer(int n,AcDbVoidPtrArray& arEntPtrs)
{
	AcDbEntity* pEnt = NULL;
	while(arEntPtrs.length() > n )
	{
		pEnt = (AcDbEntity*)arEntPtrs.last();
		if (pEnt != NULL)
		{
			pEnt->erase();
			pEnt->close();
			arEntPtrs.removeLast();
			DELETE_PTR(pEnt);
		}
	}
}

static void MoveRegion(const AcGeVector3d& vt, AcDbRegion* pReg)
{
	if (pReg != NULL)
	{
		AcGeMatrix3d xm;
		xm.setTranslation(vt);
		pReg->transformBy(xm);
	}
}

static void TestPoint(AcGePoint3d *pptGe, int nCount, Adesk::Int16 nColor)
{
	AcDbPolyline *pPl = new AcDbPolyline;
	for (int i = 0; i < nCount; i++)
	{
		pPl->addVertexAt(i, pptGe[i].convert2d(AcGePlane::kXYPlane));
	}
	pPl->setColorIndex(nColor);
	AddToModelSpace(pPl);
}

static void OffsetPoint(AcGePoint3d& pt1,AcGePoint3d& pt2,double dThick)
{
	AcGeVector3d vt = pt2 - pt1;
	vt.normalize();

	pt1 += vt * dThick;
	pt2 -= vt * dThick;
}

static double AsDNUnit(double dVal)
{
	struct resbuf rb;
	acedGetVar(_T("INSUNITS"), &rb);
	if (rb.resval.rint == AcDb::kUnitsMeters)
	{
		dVal *= 0.001;
	}
	return dVal;
}

static double GetElbowL(AecHvac::DuctParam *pParam)
{
	double dL = 0.0;
	if (pParam->eType == eCircle)
		dL = pParam->dSize[0]; 

	double dD = __max(pParam->dSize[3], pParam->dSize[0]);

	double dRatio = pParam->m_dRatio;
	double dLx = (int)(dRatio * dD / 3.0 + 0.5);//默认50
	if (dLx > AsDNUnit(50.0))
		dLx = AsDNUnit(50.0);
	dL = dRatio * dD + dLx;
	return dL;
}

static double GetElbowLx(AecHvac::DuctParam *pParam)
{
	double dD = __max(pParam->dSize[3], pParam->dSize[0]);
	double dRatio = pParam->m_dRatio;
	double dLx = (int)(dRatio * dD / 3.0 + 0.5);//默认50
	if (dLx > AsDNUnit(50.0))
		dLx = AsDNUnit(50.0);

	if (pParam->eType == eCircle)
		dLx = AsDNUnit(50.0);

	return dLx;
}

static AcGePoint3d GetIntersectPt(AcGePoint3d &ptGe3, AcGeVector3d &vtMin, AcGePoint3d &ptGe5, AcGeVector3d &vtMaj)
{
	AcGePoint3d ptGe4 = MidPoint(ptGe3, ptGe5);
	AcGeLine3d ln3(ptGe3, vtMin);
	AcGeLine3d ln4(ptGe5, vtMaj);
	ln3.intersectWith(ln4, ptGe4);
	return ptGe4;
}

Adesk::UInt32 AecDbEcFitting::kCurrentVersionNumber = 2;//升级
ACRX_DXF_DEFINE_MEMBERS (AecDbEcFitting, AecDbEntityBase,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_DBECFIT,
						 "AecDbEcFitting"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")

AecDbEcFitting::AecDbEcFitting(void)
{
	m_nInfActive = -1;
	m_bActive = false;
	m_sGUID = IDCreate();
	m_pGripAppData = new AecGripData[GRIP_MAXNUM];
	m_mapSpecXData.SetAt(KEY_NO,m_sGUID);
}

AecDbEcFitting::~AecDbEcFitting(void)
{
	Clean3DBuffer();
	Clean2DBuffer();
	FreeBuffer(0,m_arDrawBuffer3d1);
	FreeBuffer(0,m_arDrawBuffer3d2);
	delete [] m_pGripAppData;
}

bool AecDbEcFitting::SetDuctParam(const AecHvac::DuctParam& data)
{
	assertWriteEnabled();

	double dL = 0.0,dW = 0.0,dt = 0.0;
	double dD = 0.0;
	m_mapSpecXData.SetAt(KEY_SECSHAPE,(int)data.eType);

	m_mapSpecXData.SetAt(KEY_APP, data.m_app);
	if (data.m_app == WPipe::eTrench)
	{
		m_mapSpecXData.SetAt(KEY_HIDESTART, 1);
		m_mapSpecXData.SetAt(KEY_HIDEEND, 1);
		m_mapSpecXData.SetAt(PIPE_DRAWDIR, WPipe::eID);

		//m_mapSpecXData.SetAt(PIPE_OD, data.dSize[0] + 2.0 * data.dSize[2]);
		//m_mapSpecXData.SetAt(PIPE_THICK, data.dSize[2]);
	}

	if (data.m_app == WPipe::eBridge)
	{
		double dL0 = 0, dW0 = 0;
		m_mapSpecXData.GetAt(KEY_SIZE1, dL0);
		m_mapSpecXData.GetAt(KEY_SIZE2, dW0);

		double dUse1 = 0, dUse2 = 0;
		m_mapSpecXData.GetAt(KEY_FILLUSED, dUse1);//0.55
		m_mapSpecXData.GetAt(KEY_FILLUSED, dUse2);//0.45

		BOOL bSpart = 0;
		m_mapSpecXData.GetAt(KEY_SPART, bSpart);

		if (dUse1 > 1.e-3 && !bSpart)//有填充率
		{
			double dAreaUsedOld = dUse1 * dL0 * dW0;
			double dAreaNewSet = dAreaUsedOld / (data.dSize[0] * data.dSize[1]);
			m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.55
		}
		else if (dUse1 > 1.e-3 && dUse2 > 1.e-3 && bSpart)
		{
			double dAreaUsedOld = dUse1 * dL0 * dW0 * 0.5;
			double dAreaNewSet = dAreaUsedOld / (data.dSize[0] * data.dSize[1] * 0.5);
			m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.55

			dAreaUsedOld = dUse2 * dL0 * dW0 * 0.5;
			dAreaNewSet = dAreaUsedOld / (data.dSize[0] * data.dSize[1] * 0.5);
			m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.45
		}
	}

	bool bSet = true;
	switch(data.eType)
	{
	case eRect:
		{
			dL = data.dSize[0];
			dW = data.dSize[1];
			dt = data.dSize[2];

			if (dL > 1.e-6 && dW > 1.e-6 && dt > 1.e-6)
			{
				m_mapSpecXData.SetAt(KEY_SIZE1,data.dSize[0]); //L
				m_mapSpecXData.SetAt(KEY_SIZE2,data.dSize[1]); //w
				m_mapSpecXData.SetAt(PIPE_THICK,data.dSize[2]);//t
				m_mapSpecXData.SetAt(KEY_SIZE3,data.dSize[3]);//w1,三通,变径用 分支
				m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
				m_mapSpecXData.SetAt(KEY_FACTORY,data.szFat);
				m_mapSpecXData.SetAt(KEY_CENNODRAW,!data.m_bCenDraw);//中心线
				m_mapSpecXData.SetAt(KEY_L,data.m_dL);
				m_mapSpecXData.SetAt(KEY_RRATIO,data.m_dRatio);
				m_mapSpecXData.SetAt(KEY_FULLPER,data.m_dFullPer);
				m_mapSpecXData.SetAt(KEY_SN,data.szNo);
				m_mapSpecXData.SetAt(KEY_TYPE,data.szType);
				m_mapSpecXData.SetAt(KEY_EXT,data.szExt);
				m_mapSpecXData.SetAt(KEY_COVER,data.m_bCover);
				m_mapSpecXData.SetAt(KEY_SPART,data.m_bSpart);
				m_mapSpecXData.SetAt(KEY_SYSSPLT, data.m_nSysSplit);
				m_mapSpecXData.SetAt(PIPE_SYS,data.szSys);
				m_mapSpecXData.SetAt(KEY_REM,data.szRem);

				bSet = true;
			}
			break;
		}
	case  eCircle:
		{
			dD = data.dSize[0];
			dt = data.dSize[1];

			if (dD > 1.e-6 && dt > 1.e-6)
			{
				m_mapSpecXData.SetAt(KEY_SIZE1,data.dSize[0]); //D
				m_mapSpecXData.SetAt(KEY_SIZE2,data.dSize[1]); //D
				m_mapSpecXData.SetAt(PIPE_THICK,data.dSize[2]);//t
				m_mapSpecXData.SetAt(KEY_SIZE3,data.dSize[3]);//w1,变径用
				m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
				m_mapSpecXData.SetAt(KEY_FACTORY,data.szFat);
				m_mapSpecXData.SetAt(KEY_CENNODRAW,!data.m_bCenDraw);//中心线
				m_mapSpecXData.SetAt(KEY_L,data.m_dL);
				m_mapSpecXData.SetAt(KEY_RRATIO,data.m_dRatio);
				m_mapSpecXData.SetAt(KEY_FULLPER,data.m_dFullPer);
				m_mapSpecXData.SetAt(KEY_SN,data.szNo);
				m_mapSpecXData.SetAt(KEY_TYPE,data.szType);
				m_mapSpecXData.SetAt(KEY_EXT,data.szExt);
				m_mapSpecXData.SetAt(KEY_COVER,data.m_bCover);
				m_mapSpecXData.SetAt(KEY_SPART,data.m_bSpart);
				m_mapSpecXData.SetAt(KEY_SYSSPLT, data.m_nSysSplit);
				m_mapSpecXData.SetAt(PIPE_SYS,data.szSys);
				m_mapSpecXData.SetAt(KEY_REM,data.szRem);

				bSet = true;
			}
			break;
		}
	default:
		break;
	}
	m_mapSpecXData.SetAt(KEY_WELLW, data.dSize[4]);

	//保存预留数据 电缆沟等用
	CString sKey;
	for (int i = 5; i < 33; i++)//
	{
		sKey.Format(_T("%s_%d"), KEY_SIZE, i);
		m_mapSpecXData.SetAt(sKey, data.dSize[i]);
	}

	return bSet;
}

void AecDbEcFitting::GetDuctParam(AecHvac::DuctParam& data) const
{
	assertReadEnabled();

	memset(&data,0,sizeof(AecHvac::DuctParam));

	int nType = 0;
	m_mapSpecXData.GetAt(KEY_SECSHAPE,nType);

	int nCenNDraw = 0;

	ESection eType = (ESection)nType;
	data.eType = eType;

	data.m_app = WPipe::eBridge;
	int nApp = 7;
	m_mapSpecXData.GetAt(KEY_APP, nApp);
	data.m_app = WPipe::EApp(nApp);
	if (nApp == 0)
		data.m_app = WPipe::eBridge;

	switch(eType)
	{
	case eRect:
		{
			m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //L
			m_mapSpecXData.GetAt(KEY_SIZE2,data.dSize[1]); //w
			m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
			m_mapSpecXData.GetAt(KEY_SIZE3,data.dSize[3]);//L2 支宽
			m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);//中心线
			data.m_bCenDraw = nCenNDraw ? FALSE : TRUE;
			data.eType = eRect;
			break;
		}
	case eCircle:
		{
			m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //D
			m_mapSpecXData.GetAt(KEY_SIZE2,data.dSize[1]); //D
			m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
			m_mapSpecXData.GetAt(KEY_SIZE3,data.dSize[3]);//L2 支宽
			m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);//中心线
			data.m_bCenDraw = nCenNDraw ? FALSE : TRUE;
			data.eType = eCircle;
			break;
		}
	default:
		break;
	}
	m_mapSpecXData.GetAt(KEY_WELLW, data.dSize[4]);
	m_mapSpecXData.GetAt(KEY_RRATIO,data.m_dRatio);

	m_mapSpecXData.GetAt(KEY_FULLPER, data.m_dFullPer);
	data.m_dFillUsed = 0;
	//m_mapSpecXData.GetAt(KEY_FILLUSED, data.m_dFillUsed);

	m_mapSpecXData.GetAt(KEY_FULLPER2, data.m_dFullPer2);
	data.m_dFillUsed2 = 0;
	//m_mapSpecXData.GetAt(KEY_FILLUSED2, data.m_dFillUsed2);

	m_mapSpecXData.GetAt(KEY_L,data.m_dL);//变径长 L

	data.m_vtNrom = GetNormal();
	data.m_nAlign = 1;//居中

	CString sTemp;
	m_mapSpecXData.GetAt(KEY_SN,sTemp);
	_tcscpy(data.szNo,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_TYPE,sTemp);
	_tcscpy(data.szType,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_EXT,sTemp);
	_tcscpy(data.szExt,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(PIPE_SYS,sTemp);
	_tcscpy(data.szSys,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_COVER,data.m_bCover);
	m_mapSpecXData.GetAt(KEY_SPART,data.m_bSpart);
	m_mapSpecXData.GetAt(KEY_SYSSPLT, data.m_nSysSplit);

	m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
	_tcscpy(data.szMat,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_FACTORY,sTemp);
	_tcscpy(data.szFat,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_REM,sTemp);
	_tcscpy(data.szRem,(LPCTSTR)sTemp);

	//提取预留数据 电缆沟等用
	CString sKey;
	for (int i = 5; i < 33; i++)//
	{
		sKey.Format(_T("%s_%d"), KEY_SIZE, i);
		m_mapSpecXData.GetAt(sKey, data.dSize[i]);
	}
}

bool AecDbEcFitting::GetDlgData(DlgData &data,BOOL bIsMajOrMin) const
{
	assertReadEnabled();

	AecHvac::DuctParam param;
	memset(&param, 0, sizeof(AecHvac::DuctParam));
	GetDuctParam(param);

	m_mapSpecXData.GetAt(KEY_KIND, data.m_sGKind);
	m_mapSpecXData.GetAt(KEY_RRATIO, data.m_dRatio);

	if (bIsMajOrMin == 0)//主
	{
		data.m_dTopEl = param.dSize[11];
		data.m_bHasCover = param.m_bCover;
		data.m_dW = param.dSize[4];
		data.m_dH = param.dSize[5];
		data.m_dt = param.dSize[6];
		data.m_db = param.dSize[7];
		data.m_dd = param.dSize[8];
		data.m_dh2 = param.dSize[9];
		data.m_dk = param.dSize[10];
	}
	else//支
	{
		data.m_dTopEl = param.dSize[11];
		data.m_bHasCover = param.m_bCover;
		data.m_dW = param.dSize[12];
		data.m_dH = param.dSize[13];
		data.m_dt = param.dSize[14];
		data.m_db = param.dSize[15];
		data.m_dd = param.dSize[16];
		data.m_dh2 = param.dSize[17];
		data.m_dk = param.dSize[18];

		if (data.m_dW < 1.e-1)//没有分支
		{
			data.m_dTopEl = param.dSize[11];
			data.m_bHasCover = param.m_bCover;
			data.m_dW = param.dSize[4];
			data.m_dH = param.dSize[5];
			data.m_dt = param.dSize[6];
			data.m_db = param.dSize[7];
			data.m_dd = param.dSize[8];
			data.m_dh2 = param.dSize[9];
			data.m_dk = param.dSize[10];
		}
	}
	return true;
}

bool AecDbEcFitting::SetXHolder(EAlign kPos, XHolder &xH)
{
	AssertWriteEnabled();

	switch (kPos)
	{
	case kLeft:
	{
		m_mapSpecXData.SetAt(KEY_LEFT, &xH, sizeof(XHolder));
		break;
	}
	case kRight:
	{
		m_mapSpecXData.SetAt(KEY_RIGHT, &xH, sizeof(XHolder));
		break;
	}
	default:
		break;
	}
	return false;
}

bool AecDbEcFitting::GetXHolder(EAlign kPos, XHolder &xH) const
{
	assertReadEnabled();

	int nSize1 = sizeof(XHolder);
	int nSize2 = 0;
	XHolder *pHolder = NULL;

	switch (kPos)
	{
	case kLeft:
	{
		if (!m_mapSpecXData.GetAt(KEY_LEFT, (void *&)pHolder, nSize2))
			return false;

		if (nSize2 == nSize1 && pHolder != NULL)
		{
			memcpy(&xH, pHolder, nSize1);
			delete pHolder;
			return true;
		}
		break;
	}
	case kRight:
	{
		if (!m_mapSpecXData.GetAt(KEY_RIGHT, (void *&)pHolder, nSize2))
			return false;

		if (nSize2 == nSize1 && pHolder != NULL)
		{
			memcpy(&xH, pHolder, nSize1);
			delete pHolder;
			return true;
		}
		break;
	}
	default:
		break;
	}
	return false;
}

void AecDbEcFitting::SetSingleLayer(AcDbObjectId& idLayer)
{
	AssertWriteEnabled();
	m_idSingleLayer = idLayer;
}

AcDbObjectId AecDbEcFitting::GetSingleLayer() const
{
	assertReadEnabled();
	return m_idSingleLayer;
}

void AecDbEcFitting::SetSingleLineType(AcDbObjectId& idLt)
{
	AssertWriteEnabled();
	m_idSingleLnType = idLt;
}

AcDbObjectId AecDbEcFitting::GetSingleLineType() const
{
	assertReadEnabled();
	return m_idSingleLnType;
}

void AecDbEcFitting::SetDoubleLayer(AcDbObjectId& idLayer)
{
	AssertWriteEnabled();
	m_idDoubleLayer = idLayer;
}

AcDbObjectId AecDbEcFitting::GetDoubleLayer() const
{
	assertReadEnabled();
	return m_idDoubleLayer;
}

void AecDbEcFitting::SetDoubleLineType(AcDbObjectId& idLt)
{
	AssertWriteEnabled();
	m_idDoubleLnType = idLt;
}

AcDbObjectId AecDbEcFitting::GetDoubleLineType() const
{
	assertReadEnabled();
	return m_idDoubleLnType;
}

void AecDbEcFitting::SetDashLayer(AcDbObjectId &idLayer)
{
	AssertWriteEnabled();
	m_idDashLayer = idLayer;
}

AcDbObjectId AecDbEcFitting::GetDashLayer() const
{
	assertReadEnabled();
	return m_idDashLayer;
}

void AecDbEcFitting::SetCenterLayer(AcDbObjectId& idLayer)
{
	assertWriteEnabled();
	m_idCenterLayer = idLayer;
}

AcDbObjectId AecDbEcFitting::GetCenterLayer() const
{	
	assertReadEnabled();
	return m_idCenterLayer;
}

void AecDbEcFitting::AssertWriteEnabled(Adesk::Boolean autoUndo,Adesk::Boolean recordModified )
{
	//if (objectId().isValid())
	{
		//FreeBuffer(0,m_ar2DDrableBufPtrs);
		//FreeBuffer(0,m_ar3DDrableBufPtrs);
		//m_ar3DDrableBufPtrs.removeAll();

		Clean3DBuffer();
		Clean2DBuffer();

		//m_ar2DDrableBufPtrs.removeAll();

		AecDbEntityBase::AssertWriteEnabled(autoUndo, recordModified);
		//assertWriteEnabled();
	}
}

Acad::ErrorStatus AecDbEcFitting::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgInFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be read first
	Adesk::UInt32 version =0 ;
	if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
		return (es) ;

	if ( version > AecDbEcFitting::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	m_mapSpecXData.dwgInFields(pFiler);

	pFiler->readInt16(&m_nInfActive);

	TCHAR* pszTmp = NULL;
	pFiler->readString(&pszTmp);
	if (pszTmp != NULL)
	{
		m_sGUID = pszTmp;
	}

	pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idSingleLayer);
	pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idSingleLnType);

	pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idDoubleLayer);
	pFiler->readSoftPointerId((AcDbSoftPointerId*)&m_idDoubleLnType);

	if (version > 1)
	{
		ReadUserInterface(pFiler);
	}

	return (pFiler->filerStatus());
}

Acad::ErrorStatus AecDbEcFitting::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgOutFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be saved first
	if ( (es =pFiler->writeUInt32 (AecDbEcFitting::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	m_mapSpecXData.dwgOutFields(pFiler);

	pFiler->writeInt16(m_nInfActive);
	pFiler->writeString((LPCTSTR)m_sGUID);

	pFiler->writeSoftPointerId(m_idSingleLayer);
	pFiler->writeSoftPointerId(m_idSingleLnType);

	pFiler->writeSoftPointerId(m_idDoubleLayer);
	pFiler->writeSoftPointerId(m_idDoubleLnType);

	WriteUserInterface(pFiler);

	return (pFiler->filerStatus());
}

Acad::ErrorStatus AecDbEcFitting::dxfInFields(AcDbDxfFiler* pFiler)
{
	AssertWriteEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	return Acad::eOk;
}

void AecDbEcFitting::SetActive(bool bActive)
{
	assertWriteEnabled();
	m_bActive = bActive;
}

bool AecDbEcFitting::IsActive() const
{
	assertReadEnabled();
	return m_bActive;
}

void AecDbEcFitting::NewGUID()
{
	assertWriteEnabled();
	m_sGUID = IDCreate();
}

void AecDbEcFitting::subList() const
{
	assertReadEnabled();
	AecDbEntityBase::subList();

	acutPrintf(_T("\n桥架连接件:"));
	AcArray<AecInterface> arInf;
	GetInterface(arInf);

	for (int i = 0;i < arInf.length();i++)
	{
		AecInterface &inf = arInf.at(i);
		acutPrintf(_T("\nInf%d : pt = (%.3f,%.3f,%.3f) size = %.3f,%.3f"), i + 1, inf.ptPos.x, inf.ptPos.y, inf.ptPos.z, inf.dSize1, inf.dSize2);
	}

	acutPrintf(_T("\n属性数据:"));
	m_mapSpecXData.List();
	acutPrintf(_T("\n"));
}

bool AecDbEcFitting::GetBimInfoTip(CString& sInfoTip) const
{
	assertReadEnabled();

	AecHvac::DuctParam data;
	memset(&data,0,sizeof(AecHvac::DuctParam));

	GetDuctParam(data);

	CString sField,sFmt;
	sField = _T("桥架:\n");
	sInfoTip += sField;

	MAKEFIELD(_T("类型"),_T("%s"),data.szType,sInfoTip);

	MAKEFIELD(_T("宽度"),_T("%d"),(int)(data.dSize[0]+0.5),sInfoTip);
	MAKEFIELD(_T("高度"),_T("%d"),(int)(data.dSize[1]+0.5),sInfoTip);

	MAKEFIELD(_T("板材厚度"),_T("%.1f"),data.dSize[2],sInfoTip);

	MAKEFIELD(_T("底标高"),_T("%.1f"),data.m_dEl - 0.5 * data.dSize[1],sInfoTip);

	MAKEFIELD(_T("系统"),_T("%s"),data.szSys,sInfoTip);

	MAKEFIELD(_T("材料"),_T("%s"),data.szMat,sInfoTip);

	MAKEFIELD(_T("厂家"),_T("%s"),data.szFat,sInfoTip);

	MAKEFIELD(_T("编号"),_T("%s"),data.szNo,sInfoTip);

	return true;
}

//设置 加 减 填充率
extern bool IsSameAsSysUse(LPCTSTR pszSys1, LPCTSTR pszSysD);
bool AecDbEcFitting::SendUserData(struct resbuf *pRb)
{
	//解析 是 int-sys-double
	if (pRb != NULL)
	{
		CString sSys;
		double dD = 0;
		int nAddOrSub = 1;

		struct resbuf *pRb1 = pRb->rbnext;
		struct resbuf *pRb2 = NULL;
		if (pRb1 != NULL)
		{
			pRb2 = pRb1->rbnext;
		}

		bool bYs = false;
		if (pRb1 != NULL && pRb2 != NULL)
		{
			if (pRb->restype == AcDb::kDxfXdInteger16)
			{
				nAddOrSub = pRb->resval.rint ? -1 : 1;
				bYs = true;
			}
			else
			{
				bYs = false;
			}

			if (pRb1->restype == kDxfXdAsciiString)
			{
				sSys = pRb1->resval.rstring;
				bYs = true;
			}
			else
			{
				bYs = false;
			}

			if (pRb2->restype == AcDb::kDxfReal)
			{
				dD = pRb2->resval.rreal;
				bYs = true;
			}
			else
			{
				bYs = false;
			}

			if (bYs)
			{
				double dFillUsed = 0.0, dThisUsed = 0;
				CString sSys2, sSysData = sSys;
				double dSCab = 0.25 * PI * dD * dD;

				struct resbuf rb;
				acedGetVar(_T("INSUNITS"), &rb);
				if (rb.resval.rint == AcDb::kUnitsMeters)
				{
					dSCab *= 1.e-6;
				}

				AecDbObjXDataMap *pDataMap = GetSpecialtyData(AcDb::kForWrite);

				DlgData dlgData;
				if (!GetDlgData(dlgData))
				{
					AecHvac::DuctParam param;
					GetDuctParam(param);

					if (param.m_bSpart)//有隔板
					{
						//隔板系统分类
						//param.m_nSysSplit;
						//判断 
						CString sSyss = param.szSys;
						sSyss.TrimRight();
						int nPos = sSyss.Find(_T('|'), 0);
						if (nPos != -1)
						{
							sSys = sSyss.Mid(0, nPos);
							if (nPos < sSyss.GetLength() - 1)
							{
								sSys2 = sSyss.Mid(nPos + 1);
							}

							if (IsSameAsSysUse(sSys, sSysData))
								//if (sSysData.Find(sSys) != -1)//走左侧层
							{
								//...
								dFillUsed = 0.0;
								pDataMap->GetAt(KEY_FILLUSED, dFillUsed);//0.65

								//面积 / 总面积 = 0.15
								dThisUsed = dSCab;
								dThisUsed /= (param.dSize[4]) * param.dSize[1];

								//ext.累加 0.45 + 0.15
								dFillUsed += dThisUsed * nAddOrSub;
								pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
							}
							//else if (sSysData.Find(sSys2) != -1)//走右侧层
							else if (IsSameAsSysUse(sSys2, sSysData))
							{
								//...
								dFillUsed = 0.0;
								pDataMap->GetAt(KEY_FILLUSED2, dFillUsed);

								//ext.面积 / 总面积 = 0.15
								dThisUsed = dSCab;
								dThisUsed /= (param.dSize[0] - param.dSize[4]) * param.dSize[1];

								//ext.累加 0.45 + 0.15
								dFillUsed += dThisUsed * nAddOrSub;
								pDataMap->SetAt(KEY_FILLUSED2, dFillUsed);
							}
							else//都没有找到,走单层
							{
								//...
								dFillUsed = 0.0;
								pDataMap->GetAt(KEY_FILLUSED, dFillUsed);

								//ext.面积 / 总面积 = 0.15
								dThisUsed = dSCab;
								dThisUsed /= param.dSize[0] * param.dSize[1];

								//ext.累加 0.45 + 0.15
								dFillUsed += dThisUsed * nAddOrSub;
								pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
							}
						}
						else//有隔板,没有分层系统,走单层
						{
							dFillUsed = 0.0;
							pDataMap->GetAt(KEY_FILLUSED, dFillUsed);

							//ext.面积 / 总面积 = 0.15
							dThisUsed = dSCab;
							dThisUsed /= param.dSize[0] * param.dSize[1];

							//ext.面积 / 总面积 = 0.15
							dFillUsed += dThisUsed * nAddOrSub;
							pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
						}
					}
					else
					{
						dFillUsed = 0.0;
						pDataMap->GetAt(KEY_FILLUSED, dFillUsed);

						//ext.面积 / 总面积 = 0.15
						dThisUsed = dSCab;
						dThisUsed /= param.dSize[0] * param.dSize[1];

						//ext.面积 / 总面积 = 0.15
						dFillUsed += dThisUsed * nAddOrSub;
						pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
					}
				}
			}
			return true;
		}
	}

	return false;
}

Acad::ErrorStatus AecDbEcFitting::copyFrom(const AcRxObject* pSrc)
{
	AssertWriteEnabled();

	AecDbEcFitting* pFit = AecDbEcFitting::cast(pSrc);
	if (pFit != NULL)
	{
		m_mapSpecXData.Empty();
		m_mapSpecXData.CopyFrom(&pFit->m_mapSpecXData);

		m_nInfActive = pFit->m_nInfActive;
		//m_sGUID = IDCreate();
		m_mapSpecXData.GetAt(KEY_NO,m_sGUID);
		m_bActive = pFit->m_bActive;

		m_idSingleLayer = pFit->m_idSingleLayer;
		m_idSingleLnType = pFit->m_idSingleLnType;

		m_idDoubleLayer = pFit->m_idDoubleLayer;
		m_idDoubleLnType = pFit->m_idDoubleLnType;

		this->m_arUserInfs.removeAll();
		this->m_arUserInfs.append(pFit->m_arUserInfs);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	AcGeVector3d vtMaj,vtMin;
	AcGePoint3d ptMid;
	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	vtMaj.transformBy(xform);
	vtMin.transformBy(xform);
	ptMid.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.SetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.SetAt(KEY_MID, ptMid);

	//用户接口联动
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		AecUserInterface &inf = m_arUserInfs.at(i);
		for (int j = 0; j < inf.nPoints; j++)
		{
			inf.ptGe[j].transformBy(xform);
			inf.vtDir.transformBy(xform);
		}
	}

	return Acad::eOk;
}

LPCTSTR	AecDbEcFitting::GetGripCmd() const
{
	assertReadEnabled();
	return _T("EL_cabtryadd");
}

SHJson::WValue &AecDbEcFitting::ToJson(bool bExprotGeo) const
{
	using namespace SHJson;
	assertReadEnabled();
	WValue &v = AecDbEntityBase::ToJson(bExprotGeo);
	addMember(v, _T("__nInfActive__"), m_nInfActive);
	addMember(v, _T("__sGUID__"), m_sGUID);
	addMember(v, _T("__bActive__"), m_bActive);
	return v;
}

bool AecDbEcFitting::ByJson(const SHJson::WValue &v)
{
	using namespace SHJson;
	AssertWriteEnabled();

	MCIt it1(v.FindMember(_T("__nInfActive__")))
		, it2(v.FindMember(_T("__sGUID__")))
		, it3(v.FindMember(_T("__bActive__")));
	if (it1 != v.MemberEnd() && it2 != v.MemberEnd() && it3 != v.MemberEnd())
	{
		m_nInfActive = it1->value.GetInt();
		m_sGUID = it2->value.GetString();
		m_bActive = it3->value.GetBool();
	}

	return AecDbEntityBase::ByJson(v);
}

#if ARX>16	
Acad::ErrorStatus AecDbEcFitting::subGetGripPoints(AcDbGripDataPtrArray& grips,
													 const double curViewUnitSize,
													 const int gripSize,
													 const AcGeVector3d& curViewDir,
													 const int bitflags) const
{
	assertReadEnabled();

	AcGePoint3dArray gripPoints;

	AcArray<AecInterface> arInfs;
	GetInterface(arInfs);
	
	AcGePoint3d ptMid;
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	CString sCmd = GetGripCmd();
	AcDbGripData* pGripData = NULL;

	EPosition ePos = eCommand0;
	int i(0);
	for (i = 0;i < arInfs.length();i++)
	{
		pGripData = new AcDbGripData;

		memset(&m_pGripAppData[i],0,sizeof(AecGripData));

		m_pGripAppData[i].nIndex = i;
		m_pGripAppData[i].ePos = ePos;
		m_pGripAppData[i].ptGrip = arInfs.at(i).ptPos;
		_tcscpy(m_pGripAppData[i].szTip,sCmd);
		m_pGripAppData[i].pOwner = (AcDbEntity*)this;
		m_pGripAppData[i].idHost = objectId();

		pGripData->setGripPoint(arInfs.at(i).ptPos);
		pGripData->setAppData((void*)&m_pGripAppData[i]);
		pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
		pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
		grips.append(pGripData);
	}

	pGripData = new AcDbGripData;
	memset(&m_pGripAppData[i],0,sizeof(AecGripData));
	m_pGripAppData[i].nIndex = i;
	m_pGripAppData[i].ePos = eMid;
	m_pGripAppData[i].ptGrip = ptMid;
	_tcscpy(m_pGripAppData[i].szTip,_T("位置夹点"));
	m_pGripAppData[i].pOwner = (AcDbEntity*)this;
	m_pGripAppData[i].idHost = objectId();

	pGripData->setGripPoint(ptMid);
	pGripData->setAppData((void*)&m_pGripAppData[i]);
	pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
	grips.append(pGripData);

	return  Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();

	AcGePoint3d ptMid;
	m_mapSpecXData.GetAt(KEY_MID, ptMid);
	stretchPoints.append(ptMid);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subMoveGripPointsAt(const AcDbVoidPtrArray& gripAppData, const AcGeVector3d& offset, const int bitflags)
{
	AssertWriteEnabled();

	AecGripData* pAppData = NULL;
	AcDbIntArray arIndex;

	if ( !gripAppData.isEmpty() )
	{
		pAppData = (AecGripData*)gripAppData.first();
		arIndex.append(pAppData->nIndex);
	}
	else
	{
		return Acad::eOk;
	}
	AcGeVector3d vtOffset = offset;
	if(Is2DView())
	{
		vtOffset = offset.orthoProject(GetUcsZvt());
	}

	AecInterface inf;
	GripMessage msg;
	memset(&msg,0,sizeof(GripMessage));
	//reset
	msg.nSegindex = -1;
	msg.nType = -1;
	msg.idHost.setNull();
	msg.pParam = 0;
	msg.nData = -1;
	_tcscpy(msg.szLockId, _T("0"));//锁定id,如果有
	msg.fData = 0;
	msg.nSegindex = 0;
	msg.nSubSegIndex = 0;
	msg.vtOffset.set(0,0,0);
	msg.ptGrip.set(0,0,0);

	AcGeMatrix3d xformM;
	xformM.setToTranslation(vtOffset);

	int nGripIndex = arIndex.first();
	if (nGripIndex < GetInterfaceCount())
	{
		msg.nType = eCommand0;
		msg.nData = nGripIndex;
		GetInterface(msg.nData,inf);
		msg.ptGrip = inf.ptPos;
		msg.idHost = pAppData->idHost;
		msg.vtOffset = vtOffset;

		PushGripMessage(msg);

		CString sCmd = GetGripCmd();
		if (!sCmd.IsEmpty())
		{
			acedPostCommand(_T("\x03"));
			sCmd += _T("\n");
			acedPostCommand(sCmd);
		}
	}
	else
	{
		TransformBy(xformM);

		//按接口关系更新相关联对象
		msg.nType = eMid;
		msg.nData = -1;
		msg.idHost = pAppData->idHost;
		msg.vtOffset = vtOffset;

		PushGripMessage(msg);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	AssertWriteEnabled();

	if (indices.length() > 0)
	{
		AcGePoint3d ptMid;
		m_mapSpecXData.GetAt(KEY_MID, ptMid);

		ptMid += offset;
		m_mapSpecXData.SetAt(KEY_MID,ptMid);
	}
	return Acad::eOk;
}

void AecDbEcFitting::GetGripText(int nPos, CString& sText)
{
	if (nPos < GetInterfaceCount())
	{
		sText = _T("拉伸命令夹点");
	}
	else
	{
		sText = _T("位置夹点");
	}
}

Acad::ErrorStatus AecDbEcFitting::subGetOsnapPoints(AcDb::OsnapMode     osnapMode,
													  INT_PTR             gsSelectionMark,
													  const AcGePoint3d&  pickPoint,
													  const AcGePoint3d&  lastPoint,
													  const AcGeMatrix3d& viewXform,
													  AcGePoint3dArray&   snapPoints,
													  AcDbIntArray&       geomIds) const
{
	if (Has2DBuffer())
	{
		AcDbEntity* pSubEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pSubEnt = (AcDbEntity*)ar2D.at(i);
			pSubEnt->getOsnapPoints(osnapMode,gsSelectionMark,pickPoint,lastPoint,viewXform,snapPoints,geomIds);
		}

		AcArray<AecInterface> arInfs;
		GetInterface(arInfs);

		for (int i = 0;i < arInfs.length();i++)
		{
			const AecInterface &inf = arInfs.at(i);
			snapPoints.append(inf.ptPos);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subGetGeomExtents(AcDbExtents& extents) const
{
	assertReadEnabled();

	AcDbExtents ext1;
	AcDbEntity* pEnt = NULL;
	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);
		pEnt->getGeomExtents(ext1);
		extents.addExt(ext1);
	}

	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	for (int j = 0;j < ar2D.length();j++)
	{
		pEnt = (AcDbEntity*)ar2D.at(j);
		pEnt->getGeomExtents(ext1);
		extents.addExt(ext1);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subIntersectWith(const AcDbEntity*	pEnt, 
													 AcDb::Intersect		intType, 
													 AcGePoint3dArray&	points, 
													 INT_PTR				thisGsMarker, 
													 INT_PTR				otherGsMarker) const
{
	assertReadEnabled();

	if (Has2DBuffer())
	{
		AcDbEntity* pSubEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pSubEnt = (AcDbEntity*)ar2D.at(i);
			pSubEnt->intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::subIntersectWith(const AcDbEntity*	pEnt,
													 AcDb::Intersect		intType,
													 const AcGePlane&	projPlane,
													 AcGePoint3dArray&	points,
													 INT_PTR				thisGsMarker,
													 INT_PTR				otherGsMarker) const
{
	assertReadEnabled();

	if (Has2DBuffer())
	{
		AcDbEntity* pSubEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pSubEnt = (AcDbEntity*)ar2D.at(i);
			pSubEnt->intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
		}
	}
	return Acad::eOk;
}

#endif

Acad::ErrorStatus AecDbEcFitting::ShowUsedFill(AcGiDraw &dc) const
{
	int nApp = 0;
	m_mapSpecXData.GetAt(KEY_APP, nApp);
	WPipe::EApp eApp = (WPipe::EApp)nApp;

	//显示已用填充率
	struct resbuf rb;
	rb.resval.rint = 0;
	acedGetVar(_T("useri3"), &rb);
	if (rb.resval.rint == 1395 && eApp == WPipe::eBridge)
	{
		CString sFill, sFill2, sText;
		//显示填充率
		double dFillUsed1 = 0.0;
		m_mapSpecXData.GetAt(KEY_FILLUSED, dFillUsed1);//0.65
		if (dFillUsed1 > 0.001)
		{
			sFill.Format(_T("已用填充率=%d%%"), (int)(dFillUsed1 * 100));
		}

		double dFillUsed2 = 0.0;
		m_mapSpecXData.GetAt(KEY_FILLUSED2, dFillUsed2);
		if (dFillUsed2 > 0.001)
		{
			sFill2.Format(_T("已用填充率2=%d%%"), (int)(dFillUsed2 * 100));
		}
		sText = sFill + sFill2;
		if (!sText.IsEmpty())
		{
			AcGeVector3d vtMaj;
			AcGePoint3d ptMid, ptE;
			m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
			m_mapSpecXData.GetAt(KEY_MID, ptMid);
			ptE = ptMid + vtMaj * 200.0;
			AcGePoint3d pt1 = ptMid;
			AcGePoint3d pt2 = ptE;
			AcGePoint3d pt3;
			Midpoint(pt1, pt2, pt3);
			double dH = 2.5;
			m_mapSpecXData.GetAt(KEY_SIZE1, dH);
			dH *= 0.25;
			dc.DrawTextFit(sText, pt3, pt2, dH, _T("Standard"));
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	//管线系统屏蔽掉
	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());
	//dc.SetSelectionMarker(1);

	int nCrBk = dc.GetColor();
	int nColor = nCrBk;
	if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
	{
		dc.SetColor(nColor);
	}

	if (Has2DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pEnt = (AcDbEntity*)ar2D.at(i);
			//pEnt->setColorIndex(nColor);
			dc.DrawEntity(*pEnt);
		}

		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);

		ShowUsedFill(dc);

		return Acad::eOk;
	}

	int nApp = 0;
	m_mapSpecXData.GetAt(KEY_APP, nApp);
	WPipe::EApp eApp = (WPipe::EApp)nApp;

	switch (eApp)
	{
		case WPipe::eTrench:
		{
			DrawTrech2D(dc);
			break;
		}
		case WPipe::eBridge:
		{
			DrawBridge2D(dc);
			break;
		}
		default:
			break;
	}

	DrawUserInf(dc);

	ShowUsedFill(dc);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawUserInf(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcGePoint3d ptGe[16], ptGe1,ptGe2, ptS, ptE;
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		const AecUserInterface &inf = m_arUserInfs.at(i);

		if (inf.nPoints == 2)
		{
			AcDbCircle *pCir = new AcDbCircle;
			pCir->setCenter(inf.ptGe[0]);
			pCir->setNormal(inf.vtDir);
			pCir->setRadius(inf.ptGe[1].distanceTo(inf.ptGe[0]));
			pCir->setLayer(layerId());

			if (inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
			{
				dc.DrawEntity(pCir);
				Add2DBuffer(pCir);
			}
			else
			{
				AcDbCurve *pCurve = NULL;
				pCir->getOrthoProjectedCurve(AcGePlane::kXYPlane, pCurve);
				if (pCurve != NULL)
				{
					dc.DrawEntity(pCurve);
					Add2DBuffer(pCurve);

					pCurve->getStartPoint(ptS);
					pCurve->getEndPoint(ptE);

					AcDbLine *pLn = NULL;

					ptGe1 = ptS + inf.vtDir;
					pLn = new AcDbLine(ptS, ptGe1);
					pLn->setLayer(layerId());
					dc.DrawEntity(pLn);
					Add2DBuffer(pLn);

					ptGe2 = ptE + inf.vtDir;
					pLn = new AcDbLine(ptE, ptGe2);
					pLn->setLayer(layerId());
					dc.DrawEntity(pLn);
					Add2DBuffer(pLn);

					pLn = new AcDbLine(ptGe1, ptGe2);
					pLn->setLayer(layerId());
					dc.DrawEntity(pLn);
					Add2DBuffer(pLn);
				}
				delete pCir;
			}
		}
		else if (inf.nPoints > 2)
		{
			//投影到XY
			AcGePoint3dArray arPts,arPts2;
			for (int j = 0; j < inf.nPoints; j++)
			{
				ptGe[j] = inf.ptGe[j].orthoProject(AcGePlane::kXYPlane);
				if (arPts.find(ptGe[j]) == -1)
					arPts.append(ptGe[j]);
			}

			AcDbLine *pLn = NULL;
			if (!inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
			{
				for (int j = 0; j < arPts.length(); j++)
				{
					ptGe2 = arPts.at(j) + inf.vtDir;
					arPts2.append(ptGe2);
					pLn = new AcDbLine(arPts.at(j), ptGe2);
					pLn->setLayer(layerId());
					dc.DrawEntity(pLn);
					Add2DBuffer(pLn);
				}

				for (int j = 0; j < arPts2.length() - 1; j++)
				{
					pLn = new AcDbLine(arPts2.at(j), arPts2.at(j + 1));
					pLn->setLayer(layerId());
					dc.DrawEntity(pLn);
					Add2DBuffer(pLn);
				}
			}
			else
			{
				arPts.removeAll();
				for (int j = 0; j < inf.nPoints; j++)
				{
					ptGe[j] = inf.ptGe[j].orthoProject(AcGePlane::kXYPlane);

					if (arPts.length() > 0)
					{
						pLn = new AcDbLine(arPts.last(), ptGe[j]);
						pLn->setLayer(layerId());
						dc.DrawEntity(pLn);
						Add2DBuffer(pLn);
					}
					arPts.append(ptGe[j]);
					if (j == inf.nPoints - 1)
					{
						pLn = new AcDbLine(arPts.first(), ptGe[j]);
						pLn->setLayer(layerId());
						dc.DrawEntity(pLn);
						Add2DBuffer(pLn);
					}
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawBridge2D(AcGiDraw &dc) const
{
	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
	EFittingType eType = (EFittingType)nType;

	switch (eType)
	{
	case eElbow:
		DrawElbow2d(dc);
		break;
	case eTee:
		DrawTee2d(dc);
		break;
	case eCross:
		DrawCross2d(dc);
		break;
	case eReduce:
		DrawReduce2d(dc);
		break;
	case eOffset:
		DrawOffset2d(dc);
		break;
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrech2D(AcGiDraw &dc) const
{
	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
	EFittingType eType = (EFittingType)nType;

	switch (eType)
	{
	case eElbow:
		DrawTrElbow2d(dc);
		break;
	case eTee:
		DrawTrTee2d(dc);
		break;
	case eCross:
		DrawTrCross2d(dc);
		break;
	case eReduce:
		DrawTrReduce2d(dc);
		break;
	case eOffset:
		DrawTrOffset2d(dc);
		break;
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawBridge3D(AcGiDraw &dc) const
{
	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
	EFittingType eType = (EFittingType)nType;

	switch (eType)
	{
	case eElbow:
		DrawElbow3d(dc);
		break;
	case eTee:
		DrawTee3d(dc);
		break;
	case eCross:
		DrawCross3d(dc);
		break;
	case eReduce:
		DrawReduce3d(dc);
		break;
	case eOffset:
		DrawOffset3d(dc);
		break;
	default:
		break;
	}
	return Acad::eOk;
}

extern bool FormatRect(AcGePoint3d *pptGe, double dw, double dt);
extern AcDbRegion *CreatePolygonRegionOnly(AcGePoint3d *pPoints, int nSize);
bool AecDbEcFitting::GetDlgRegionData(DlgData &data, AcArray<RegionAndEl> &arRegEl) const
{
	AcDbRegion *pRegion = NULL;

	//原始位置为原点
	//底板
	AcDbVoidPtrArray arLnPtrs;
	RegionAndEl rel;
	rel.pReg = NULL;
	_tcscpy(rel.m_szMat, _T("混凝土"));

	AcGePoint3d ptGe[5];

	FormatRect(ptGe, data.m_dd, data.m_db);

	pRegion = CreatePolygonRegionOnly(ptGe, 5);
	if (pRegion == NULL)
	{
		return false;
	}
	rel.m_dZ = data.m_dTopEl;
	rel.m_dZ -= data.m_dk;
	rel.m_dZ -= data.m_dH;
	rel.m_dZ -= 0.5 * data.m_db;
	rel.pReg = pRegion;
	rel.nType = 1;//板
	rel.m_dX = 0.0;//偏移
	rel.dSize[0] = data.m_dd;
	rel.dSize[1] = data.m_db;
	rel.dSize[2] = 0.0;
	arRegEl.append(rel);

	//侧面墙体
	FormatRect(ptGe, data.m_dt, (data.m_dH - data.m_dh2));
	pRegion = CreatePolygonRegionOnly(ptGe, 5);
	if (pRegion == NULL)
	{
		return false;
	}
	_tcscpy(rel.m_szMat, _T("砌砖墙体"));
	rel.m_dZ = data.m_dTopEl;
	rel.m_dZ -= data.m_dk;
	rel.m_dZ -= data.m_dh2;
	rel.m_dZ -= 0.5 * (data.m_dH - data.m_dh2);
	rel.m_dX = 0.0;
	rel.m_dX -= 0.5 * data.m_dW;
	rel.m_dX -= 0.5 * data.m_dt;
	rel.pReg = pRegion;
	rel.nType = 2;//墙

	rel.dSize[0] = data.m_dt;
	rel.dSize[1] = (data.m_dH - data.m_dh2);
	rel.dSize[2] = 0.0;

	arRegEl.append(rel);

	//侧面墙体2
	rel.m_dX += (data.m_dW + data.m_dt);
	rel.pReg = (AcDbRegion *)pRegion->clone();
	arRegEl.append(rel);

	//压顶
	FormatRect(ptGe, data.m_dt, data.m_dh2);
	pRegion = CreatePolygonRegionOnly(ptGe, 5);
	if (pRegion == NULL)
	{
		return false;
	}
	_tcscpy(rel.m_szMat, _T("混凝土"));
	rel.m_dZ = data.m_dTopEl;
	rel.m_dZ -= data.m_dk;
	rel.m_dZ -= 0.5 * data.m_dh2;
	rel.pReg = pRegion;
	rel.nType = 2;
	rel.m_dX = 0.0;
	rel.m_dX -= 0.5 * data.m_dW;
	rel.m_dX -= 0.5 * data.m_dt;

	rel.dSize[0] = data.m_dt;
	rel.dSize[1] = data.m_dh2;
	rel.dSize[2] = 0.0;

	arRegEl.append(rel);

	rel.m_dX += (data.m_dW + data.m_dt);
	rel.pReg = (AcDbRegion *)pRegion->clone();
	arRegEl.append(rel);

	//盖板
	if (data.m_bHasCover)
	{
		FormatRect(ptGe, data.m_dW + 2.0 * data.m_dt, data.m_dk);
		pRegion = CreatePolygonRegionOnly(ptGe, 5);
		if (pRegion == NULL)
		{
			return false;
		}

		_tcscpy(rel.m_szMat, _T("钢筋混凝土盖板"));
		rel.m_dZ = data.m_dTopEl;
		rel.m_dZ -= 0.5 * data.m_dk;
		rel.m_dX = 0.0;
		rel.nType = 1;// 板
		rel.pReg = pRegion;

		rel.dSize[0] = data.m_dW + 2.0 * data.m_dt;
		rel.dSize[1] = data.m_dk;
		rel.dSize[2] = 0.0;

		arRegEl.append(rel);
	}
	return true;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrech3D(AcGiDraw &dc) const
{
	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
	EFittingType eType = (EFittingType)nType;

	switch (eType)
	{
	case eElbow:
		DrawTrElbow3d(dc);
		break;
	case eTee:
		DrawTrTee3d(dc);
		break;
	case eCross:
		DrawTrCross3d(dc);
		break;
	case eReduce:
		DrawTrReduce3d(dc);
		break;
	case eOffset:
		DrawTrOffset3d(dc);
		break;
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawElbow2d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
	m_mapSpecXData.GetAt(HELB_Type, (int&)eElbowType);

	switch(eElbowType)
	{
	case AecHvac::eIncline://内斜线
		{
			DrawIncline2d(dc);
			break;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrElbow2d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
		//内外圆弧的方式2种
	AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
	m_mapSpecXData.GetAt(HELB_Type, (int &)eElbowType);

	switch (eElbowType)
	{
	case AecHvac::eIncline://内斜线
	{
		DrawTrIncline2d(dc);
		break;
	}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTee2d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
	m_mapSpecXData.GetAt(HTEE_Type, (int&)eTeeType);

	switch(eTeeType)
	{
	case AecHvac::eIncline2Branch://内斜线
		{
			DrawIncline2Tee2d(dc);
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrTee2d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
	m_mapSpecXData.GetAt(HTEE_Type, (int &)eTeeType);

	switch (eTeeType)
	{
	case AecHvac::eIncline2Branch://内斜线
	{
		DrawTrIncline2Tee2d(dc);
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

static void InsertL2Point(AcGePoint3d& ptX,AcGePoint3d& ptOrg,AcGePoint3d& ptY,double dLx,AcGePoint3dArray& arPts)
{
	AcGeVector3d vt = ptOrg - ptX;
	vt.normalize();

	AcGePoint3d pt = ptX + vt * dLx;
	arPts.append(pt);

	vt = ptOrg - ptY;
	vt.normalize();

	pt = ptY + vt * dLx;
	arPts.append(pt);
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d0(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L 
	dH = dParam.dSize[1];// H
	dDn2 = dParam.dSize[3];//分支宽度

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	double dL = dDn * dRatio;

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	AcGePoint3d ptGe[10];

	//如果是俯视图
	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平
	{
		AcGePoint3dArray arPts;
		ptGe[0] = ptMid;
		ptGe[0] -= vtMaj * (dL + dLx);
		ptGe[0] -= vtMin * dDn * 0.5;
		arPts.append(ptGe[0]);

		ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
		arPts.append(ptGe[1]);

		ptGe[2] = ptGe[1] + vtMin * dDn;
		arPts.append(ptGe[2]);

		ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
		ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);

		InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
		arPts.append(ptGe[4]);

		ptGe[5] = ptGe[4] - vtMaj * dDn2;
		arPts.append(ptGe[5]);

		ptGe[6] = ptGe[3] - vtMaj * dDn2;
		ptGe[7] = ptGe[0] + vtMin * dDn;
		InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
		arPts.append(ptGe[7]);

		ptGe[8] = ptGe[0];
		arPts.append(ptGe[8]);

		BOOL bHide = FALSE;
		m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

		AcDbPolyline *pPl = NULL;
		if (bHide)
		{
			AcDbVoidPtrArray arPls;
			AcGePoint3d *ptGe2 = arPts.asArrayPtr();
			pPl = FormatPolyline(ptGe2, 2);
			if (pPl != NULL)
				arPls.append(pPl);

			ptGe2 += 2;
			pPl = FormatPolyline(ptGe2, 4);
			if (pPl != NULL)
				arPls.append(pPl);

			ptGe2 += 4;
			pPl = FormatPolyline(ptGe2, 4);
			if (pPl != NULL)
				arPls.append(pPl);

			for (int k = 0; k < arPls.length(); k++)
			{
				pPl = (AcDbPolyline *)arPls.at(k);
				pPl->setLayer(layerId());
				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
		else
		{
			pPl = FormatPolyline(arPts.asArrayPtr(), arPts.length());
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}

		ptGe[0] = ptMid;
		ptGe[0] -= vtMaj * (dL + dLx);
		ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);

		if (nCenNDraw == FALSE)
		{
			pPl = FormatPolyline(ptGe, 2);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());
				pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}

		ptGe[0] = ptMid;
		ptGe[1] = ptMid + vtMin * (dL + dLx);

		if (nCenNDraw == FALSE)
		{
			pPl = FormatPolyline(ptGe, 2);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());
				pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
	}
	else
	{
		AcDbPolyline *pPl = NULL;
		AcGeLine3d ln3d;
		ln3d.set(AcGePoint3d::kOrigin, vtNorm);
		if (ln3d.isParallelTo(AcGePlane::kXYPlane))//竖放
		{
			// ___
			//  |
			ln3d.set(AcGePoint3d::kOrigin, vtMaj);
			if (ln3d.isParallelTo(AcGePlane::kXYPlane))//vtMaj // XY面
			{
				AcGeVector3d vtV = vtMaj;
				vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

				ptGe[0] = ptMid;
				ptGe[0] -= vtMaj * (dL + dLx);
				ptGe[0] -= vtV * 0.5 * dDn;

				ptGe[1] = ptGe[0] + vtV * dDn;
				ptGe[2] = ptGe[1] + vtMaj * 2.0 * (dL + dLx);
				ptGe[3] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
				ptGe[4] = ptGe[0];

				pPl = FormatPolyline(ptGe, 5);
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}

				//Section
				switch (dParam.eType)
				{
				case eRect:
				{
					//折边
					ptGe[0] += vtMaj * dLx;
					ptGe[1] += vtMaj * dLx;
					ptGe[2] -= vtMaj * dLx;
					ptGe[3] -= vtMaj * dLx;
					ptGe[4] = ptGe[0];

					pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						if (!vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
						{
							pPl->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
						}

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					ptGe[0] += vtMaj * (dL - 0.5 * dH);
					ptGe[1] += vtMaj * (dL - 0.5 * dH);
					ptGe[2] -= vtMaj * (dL - 0.5 * dH);
					ptGe[3] -= vtMaj * (dL - 0.5 * dH);
					ptGe[4] = ptGe[0];

					pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						if (!vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
						{
							pPl->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
						}

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
					break;
				}
				case eCircle:
				{
					AcDbCircle *pCir = new AcDbCircle;
					pCir->setCenter(ptMid);
					pCir->setRadius(dDn * 0.5);
					pCir->setNormal(AcGeVector3d::kZAxis);

					pCir->setLayer(m_idDoubleLayer);
					if (!vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						pCir->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
					}

					dc.DrawEntity(pCir);
					Add2DBuffer(pCir);

					break;
				}
				default:
					break;
				}

				//cen
				ptGe[0] = ptMid;
				ptGe[0] -= vtMaj * (dL + dLx);

				ptGe[1] = ptMid;
				ptGe[1] += vtMaj * (dL + dLx);

				if (nCenNDraw == FALSE)
				{
					pPl = FormatPolyline(ptGe, 2);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
			}

			//|-
			ln3d.set(AcGePoint3d::kOrigin, vtMin);
			if (ln3d.isParallelTo(AcGePlane::kXYPlane))//vtMin // XY面
			{
				AcGeVector3d vtV = vtMin;
				vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

				if (dParam.eType == eRect)
				{
					ptGe[0] = ptMid;
					ptGe[0] -= vtMin * 0.5 * dDn;
					ptGe[0] -= vtV * 0.5 * dDn;

					ptGe[1] = ptGe[0] + vtV * (dL + dLx + 0.5 * dDn);
					ptGe[2] = ptGe[1] + vtV * dDn;
					ptGe[3] = ptGe[0] + vtV * dDn;
					ptGe[4] = ptGe[0];

					pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
				else if (dParam.eType == eCircle)
				{
					ptGe[0] = ptMid;
					ptGe[0] -= vtV * 0.5 * dDn;

					ptGe[1] = ptGe[0] + vtV * (dL + dLx);
					ptGe[2] = ptGe[1] + vtV * dDn;
					ptGe[3] = ptGe[0] + vtV * dDn;

					pPl = FormatPolyline(ptGe, 4);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}

				//Section
				switch (dParam.eType)
				{
				case eRect:
				{
					ptGe[0] += vtMin * dDn;
					ptGe[1] = ptGe[2] + vtMin * dDn;

					pPl = FormatPolyline(ptGe, 2);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
					break;
				}
				case eCircle:
				{
					AcDbCircle *pCir = new AcDbCircle;
					pCir->setCenter(ptMid);
					pCir->setRadius(dDn * 0.5);
					pCir->setNormal(AcGeVector3d::kZAxis);

					dc.SetLayer(m_idDoubleLayer);
					dc.SetLineType(m_idDoubleLnType);

					dc.DrawEntity(pCir);
					Add2DBuffer(pCir);

					break;
				}
				default:
					break;
				}

				//cen
				ptGe[0] = ptMid;
				ptGe[1] = ptMid + vtMin * (dL + dLx);

				if (nCenNDraw == FALSE)
				{
					pPl = FormatPolyline(ptGe, 2);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
			}
		}
		else
		{
			//...
		}
	}
	return Acad::eOk;
}


Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d3(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L 
	dH = dParam.dSize[1];// H
	dDn2 = dParam.dSize[3];//分支宽度

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	double dL = dDn * dRatio;

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	AcGePoint3d ptGe[10];

	AcGeVector3d vtX, vtZ, vtY;
	if (vtMin.isParallelTo(AcGeVector3d::kZAxis))
	{
		vtZ = vtMin;
		vtX = vtMaj;
	}
	if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))
	{
		vtZ = vtMaj;
		vtX = vtMin;
	}
	vtY = vtX;
	vtY.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

	AcGeLine3d ln(ptMid, vtX);
	if (ln.isParallelTo(AcGePlane::kXYPlane))
	{
		ptGe[0] = ptMid;
		ptGe[0] -= vtX * (dL + dLx);
		ptGe[0] += vtY * 0.5 * dDn;

		ptGe[1] = ptGe[0] + vtX * 2.0 * (dL + dLx);
		ptGe[2] = ptGe[1] - vtY * dDn;
		ptGe[3] = ptGe[0] - vtY * dDn;
		ptGe[4] = ptGe[0];

		AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
		if (pPl != NULL)
		{
			pPl->setLayer(layerId());
			dc.DrawEntity(pPl);
			Add2DBuffer(pPl);
		}

		//Z向 userinf
		//调用 drawuserinf
	}
	else
	{
		//...
	}
	return Acad::eOk;
}

//上角垂直三通
Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d5(AcGiDraw &dc) const
{
	//一个水平弯头 + 竖桥架
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L 
	dH = dParam.dSize[1];// H
	dDn2 = dParam.dSize[3];//分支宽度

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	//double dL = dDn * dRatio + dLx;
	double dL = GetElbowL(&dParam);
	dL += dLx;//三通长度

	vtMaj.normalize();
	vtMin.normalize();

	//vtMaj vtMin 平行 XY 面
	AcGePoint3d ptGe[8], ptGeU[6];
	AcGeVector3d vtNormal = vtMin.crossProduct(vtMaj);
	if (vtNormal.isParallelTo(AcGeVector3d::kZAxis))//水平放置
	{
		AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
		AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
		vtMV.normalize();
		vtNV.normalize();

		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[0] -= vtMV * 0.5 * dDn;

		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;
		ptGe[2] -= vtNV * 0.5 * dDn2;

		AcGeLine3d ln1(ptGe[0], vtMaj);
		AcGeLine3d ln2(ptGe[2], vtMin);
		ln1.intersectWith(ln2, ptGe[1]);

		ptGe[3] = ptGe[2] + vtNV * dDn2;
		ptGe[4] = ptGe[3] - vtMin * dLx;

		ptGe[6] = ptGe[0] + vtMV * dDn;
		ptGe[5] = ptGe[6] - vtMaj * dLx;

		ptGe[7] = ptGe[0];

		BOOL bHide = FALSE;
		m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

		AcDbPolyline *pPl = NULL;
		if (!bHide)
		{
			pPl = FormatPolyline(ptGe, 8);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
		else
		{
			AcGePoint3d *ptGe2 = ptGe;
			pPl = FormatPolyline(ptGe2, 3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
			AcGePoint3d *ptGe3 = ptGe;
			ptGe3 += 3;//->3

			pPl = FormatPolyline(ptGe3, 4);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}

		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[1] = ptMid;
		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;

		if (nCenNDraw == FALSE)
		{
			pPl = FormatPolyline(ptGe, 3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());
				pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
	}

	//vtZ 方向为 userinf
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee2d(AcGiDraw &dc) const
{
	int nTeeStyle = 0;
	m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	//double dSingleW = 0.0;
	//m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	nStyle = 2;//双线

	switch (nStyle)
	{
	case 0://单线
	case 1://单线
		{
			//暂不绘制单线
			break;
		}
	case 2:
		{
			switch (nTeeStyle)
			{
				case 0: //水平三通 =||=
				{
					DrawIncline2Tee2d0(dc);
					break;
				}
				case 1: //上垂直三通 [ || ]
				case 2: //下垂直三通
				case 3: //上边垂直三通
				case 4: //下边垂直三通
				{
					DrawIncline2Tee2d3(dc);
					break;
				}
				case 5: //下角垂直三通
				case 6: //上角垂直三通
				{
					DrawIncline2Tee2d5(dc);
					break;
				}

			default:
				break;
			}
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrIncline2Tee2d(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	dH = dParam.dSize[1];// H
	dDn2 = dParam.dSize[3];//分支宽度

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	double dL = dDn * dRatio;
	//double dL = GetElbowL(&dParam);

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	double dSingleW = 0.0;
	m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	nStyle = 2;//双线

	AcGePoint3d ptGe[10],ptGeL[10];
	switch (nStyle)
	{
	case 0://单线
	case 1://单线
	{
		//暂不绘制单线
		break;
	}
	case 2:
	{
		//如果是俯视图
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//电缆沟水平
		{
			AcGePoint3dArray arPts;
			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * (dL + dLx);
			ptGe[0] -= vtMin * dDn * 0.5;
			arPts.append(ptGe[0]);

			ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
			arPts.append(ptGe[1]);

			ptGe[2] = ptGe[1] + vtMin * dDn;
			arPts.append(ptGe[2]);

			ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
			ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
			arPts.append(ptGe[3]);
			//电缆沟不画倒角线
			//InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
			arPts.append(ptGe[4]);

			ptGe[5] = ptGe[4] - vtMaj * dDn2;
			arPts.append(ptGe[5]);

			ptGe[6] = ptGe[3] - vtMaj * dDn2;
			ptGe[7] = ptGe[0] + vtMin * dDn;
			arPts.append(ptGe[6]);
			//InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
			arPts.append(ptGe[7]);

			ptGe[8] = ptGe[0];
			arPts.append(ptGe[8]);

			BOOL bHide = FALSE;
			m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

			AcDbPolyline *pPl = NULL;
			if (bHide)
			{
				AcDbVoidPtrArray arPls;
				AcGePoint3d *ptGe2 = arPts.asArrayPtr();
				pPl = FormatPolyline(ptGe2, 2);
				if (pPl != NULL)
					arPls.append(pPl);

				ptGe2 += 2;
				pPl = FormatPolyline(ptGe2, 3);
				if (pPl != NULL)
					arPls.append(pPl);

				ptGe2 += 3;
				pPl = FormatPolyline(ptGe2, 3);
				if (pPl != NULL)
					arPls.append(pPl);

				for (int k = 0; k < arPls.length(); k++)
				{
					pPl = (AcDbPolyline *)arPls.at(k);
					pPl->setLayer(layerId());
					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}
			else
			{
				pPl = FormatPolyline(arPts.asArrayPtr(), arPts.length());
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}

			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * (dL + dLx);
			ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);

			if (nCenNDraw == FALSE)
			{
				pPl = FormatPolyline(ptGe, 2);
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());
					pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}

			ptGe[0] = ptMid;
			ptGe[1] = ptMid + vtMin * (dL + dLx);

			if (nCenNDraw == FALSE)
			{
				pPl = FormatPolyline(ptGe, 2);
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());
					pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}
		}
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawCross2d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
	m_mapSpecXData.GetAt(HCRS_Type, (int&)eTeeType);

	switch(eTeeType)
	{
	case AecHvac::eInterCross://内斜线四通
		{
			DrawInterCross2d(dc);
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrCross2d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
	m_mapSpecXData.GetAt(HCRS_Type, (int &)eTeeType);

	switch (eTeeType)
	{
	case AecHvac::eInterCross://内斜线四通
	{
		DrawTrInterCross2d(dc);
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawInterCross2d(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj,vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dDn2 = 0;
	double dThick = 0.35,dLx = 50.0,dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	dDn2 = dParam.dSize[3];//支宽

	if (dDn2 < 1.e-6)
		dDn2 = dDn;
	dH = dParam.dSize[1];//H
	double dL = dDn * dRatio;

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	double dSingleW = 0.0;
	m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	nStyle = 2;//双线

	AcGePoint3d ptGe[12];
	switch (nStyle)
	{
	case 0://单线
	case 1://单线
		{
			//暂不绘制单线
			break;
		}
	case 2://双线
		{
			//如果是俯视图
			if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平
			{
				AcGePoint3dArray arPts;
				ptGe[0] = ptMid;
				ptGe[0] -= vtMaj * (dL + dLx);
				ptGe[0] -= vtMin * dDn * 0.5;
				arPts.append(ptGe[0]);

				ptGe[1] = ptGe[0] + vtMaj * (dL  + dLx - 0.5 * dDn2);
				ptGe[2] = ptGe[1] - vtMin * (dL  + dLx - 0.5 * dDn);

				InsertL2Point(ptGe[0],ptGe[1],ptGe[2],dLx,arPts);
				arPts.append(ptGe[2]);

				ptGe[3] = ptGe[2] + vtMaj * dDn2;
				arPts.append(ptGe[3]);
				
				ptGe[4] = ptGe[3] + vtMin * (dL  + dLx - 0.5 * dDn);
				ptGe[5] = ptGe[4] + vtMaj * (dL  + dLx - 0.5 * dDn2);
				InsertL2Point(ptGe[3],ptGe[4],ptGe[5],dLx,arPts);
				arPts.append(ptGe[5]);

				ptGe[6] = ptGe[5] + vtMin * dDn;
				arPts.append(ptGe[6]);

				ptGe[7] = ptGe[6] - vtMaj * (dL  + dLx - 0.5 * dDn2);
				ptGe[8] = ptGe[7] + vtMin * (dL  + dLx - 0.5 * dDn);
				InsertL2Point(ptGe[6],ptGe[7],ptGe[8],dLx,arPts);
				arPts.append(ptGe[8]);

				ptGe[9] = ptGe[8] - vtMaj * dDn2;
				arPts.append(ptGe[9]);

				ptGe[10] = ptGe[9] - vtMin * (dL  + dLx - 0.5 * dDn);
				ptGe[11] = ptGe[10] - vtMaj * (dL  + dLx - 0.5 * dDn2);
				InsertL2Point(ptGe[9],ptGe[10],ptGe[11],dLx,arPts);
				arPts.append(ptGe[11]);
				arPts.append(ptGe[0]);

				AcDbPolyline *pPl = NULL;
				BOOL bHide = FALSE;
				m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

				if (bHide)
				{
					AcDbVoidPtrArray arPls;

					AcGePoint3d *ptGe2 = arPts.asArrayPtr();
					pPl = FormatPolyline(ptGe2, 4);
					if (pPl != NULL)
					{
						arPls.append(pPl);
					}

					ptGe2 += 4;
					pPl = FormatPolyline(ptGe2, 4);
					if (pPl != NULL)
					{
						arPls.append(pPl);
					}

					ptGe2 += 4;
					pPl = FormatPolyline(ptGe2, 4);
					if (pPl != NULL)
					{
						arPls.append(pPl);
					}

					ptGe2 += 4;
					pPl = FormatPolyline(ptGe2, 4);
					if (pPl != NULL)
					{
						arPls.append(pPl);
					}

					for (int k = 0;k < arPls.length();k++)
					{
						pPl = (AcDbPolyline*)arPls.at(k);
						pPl->setLayer(layerId());
						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
				else
				{
					pPl = FormatPolyline(arPts.asArrayPtr(),arPts.length());
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}

				ptGe[0] = ptMid;
				ptGe[0] -= vtMaj * (dL + dLx);
				ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);

				if (nCenNDraw == FALSE)
				{
					pPl = FormatPolyline(ptGe,2);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}

				ptGe[0] = ptMid;
				ptGe[1] = ptMid + vtMin * (dL + dLx);

				if (nCenNDraw == FALSE)
				{
					pPl = FormatPolyline(ptGe,2);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
			}
			else
			{
				AcDbPolyline* pPl = NULL;
				AcGeLine3d ln3d;
				ln3d.set(AcGePoint3d::kOrigin,vtNorm);
				if (ln3d.isParallelTo(AcGePlane::kXYPlane))//竖放
				{

				}
			}
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrInterCross2d(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	dDn2 = dParam.dSize[3];//支宽

	if (dDn2 < 1.e-6)
		dDn2 = dDn;
	dH = dParam.dSize[1];//H
	double dL = dDn * dRatio;

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	double dSingleW = 0.0;
	m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	nStyle = 2;//双线

	AcGePoint3d ptGe[12];
	switch (nStyle)
	{
	case 0://单线
	case 1://单线
	{
		//暂不绘制单线
		break;
	}
	case 2://双线
	{
		//如果是俯视图
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//电缆沟水平
		{
			AcGePoint3dArray arPts;
			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * (dL + dLx);
			ptGe[0] -= vtMin * dDn * 0.5;
			arPts.append(ptGe[0]);

			ptGe[1] = ptGe[0] + vtMaj * (dL + dLx - 0.5 * dDn2);
			ptGe[2] = ptGe[1] - vtMin * (dL + dLx - 0.5 * dDn);

			//电缆沟不画倒角线
			arPts.append(ptGe[1]);
			//InsertL2Point(ptGe[0], ptGe[1], ptGe[2], dLx, arPts);
			arPts.append(ptGe[2]);

			ptGe[3] = ptGe[2] + vtMaj * dDn2;
			arPts.append(ptGe[3]);

			ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
			ptGe[5] = ptGe[4] + vtMaj * (dL + dLx - 0.5 * dDn2);

			//电缆沟不画倒角线
			arPts.append(ptGe[4]);
			//InsertL2Point(ptGe[3], ptGe[4], ptGe[5], dLx, arPts);
			arPts.append(ptGe[5]);

			ptGe[6] = ptGe[5] + vtMin * dDn;
			arPts.append(ptGe[6]);

			ptGe[7] = ptGe[6] - vtMaj * (dL + dLx - 0.5 * dDn2);
			ptGe[8] = ptGe[7] + vtMin * (dL + dLx - 0.5 * dDn);
			
			//电缆沟不画倒角线
			arPts.append(ptGe[7]);
			//InsertL2Point(ptGe[6], ptGe[7], ptGe[8], dLx, arPts);
			arPts.append(ptGe[8]);

			ptGe[9] = ptGe[8] - vtMaj * dDn2;
			arPts.append(ptGe[9]);

			ptGe[10] = ptGe[9] - vtMin * (dL + dLx - 0.5 * dDn);
			ptGe[11] = ptGe[10] - vtMaj * (dL + dLx - 0.5 * dDn2);
			
			//电缆沟不画倒角线
			arPts.append(ptGe[10]);
			//InsertL2Point(ptGe[9], ptGe[10], ptGe[11], dLx, arPts);

			arPts.append(ptGe[11]);
			arPts.append(ptGe[0]);

			AcDbPolyline *pPl = NULL;
			BOOL bHide = FALSE;
			m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

			if (bHide)
			{
				AcDbVoidPtrArray arPls;

				AcGePoint3d *ptGe2 = arPts.asArrayPtr();
				pPl = FormatPolyline(ptGe2, 3);
				if (pPl != NULL)
				{
					arPls.append(pPl);
				}

				ptGe2 += 3;
				pPl = FormatPolyline(ptGe2, 3);
				if (pPl != NULL)
				{
					arPls.append(pPl);
				}

				ptGe2 += 3;
				pPl = FormatPolyline(ptGe2, 3);
				if (pPl != NULL)
				{
					arPls.append(pPl);
				}

				ptGe2 += 3;
				pPl = FormatPolyline(ptGe2, 3);
				if (pPl != NULL)
				{
					arPls.append(pPl);
				}

				for (int k = 0; k < arPls.length(); k++)
				{
					pPl = (AcDbPolyline *)arPls.at(k);
					pPl->setLayer(layerId());
					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}
			else
			{
				pPl = FormatPolyline(arPts.asArrayPtr(), arPts.length());
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}

			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * (dL + dLx);
			ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);

			if (nCenNDraw == FALSE)
			{
				pPl = FormatPolyline(ptGe, 2);
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());
					pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}

			ptGe[0] = ptMid;
			ptGe[1] = ptMid + vtMin * (dL + dLx);

			if (nCenNDraw == FALSE)
			{
				pPl = FormatPolyline(ptGe, 2);
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());
					pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}
		}
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawReduce2d(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj,vtMin,vtNorm(0,0,1);
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dL = 0.0,dLx1 = 0,dLx2 = 0;
	double dThick = 0.35,dH = 0.0,dW1 = 0.0,dt = 0.0,dL3 = 0;

	int nEcCen = 0;//偏心
	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);
	m_mapSpecXData.GetAt(KEY_L,dL);
	m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
	m_mapSpecXData.GetAt(KEY_ECCEN,nEcCen);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);

	AecHvac::DuctParam dParam,dParam2;
	GetDuctParam(dParam);
	memcpy(&dParam2, &dParam, sizeof(AecHvac::DuctParam));
	dParam2.dSize[0] = dParam.dSize[3];
	dLx1 = GetElbowLx(&dParam2);
	dLx2 = GetElbowLx(&dParam);

	dDn = dParam.dSize[0];//W H
	dH = dParam.dSize[1];//末端
	dt = dParam.dSize[2];//thick
	dW1 = dParam.dSize[3];//开始端
	dL3 = dL / 3.0;

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();

	AcGeVector3d vtW = vtMaj;
	vtW.rotateBy(PI / 2.0,vtNorm);
	vtW.normalize();

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	double dSingleW = 0.0;
	m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	AcGeLine3d ln(AcGePoint3d::kOrigin,vtNorm);

	nStyle = 2;//双线
	AcGePoint3d ptGe[10],ptS,ptE,*pptGe = NULL;
	int nPoints = 0,nS = 0,nE = 0;

	switch (nStyle)
	{
	case 0://单线
	case 1://单线
		{
			//暂不绘制单线
			break;
		}
	case 2://双线
		{
			if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平放置
			{
				ptGe[0] = ptMid;
				ptGe[0] -= vtMaj * 0.5 * dL;
				ptGe[0] += vtW * 0.5 * dW1;

				if (nEcCen == 0)
				{
					ptGe[3] = ptMid;
					ptGe[3] += vtMaj * 0.5 * dL;
					ptGe[3] += vtW * 0.5 * dDn;

					ptGe[1] = ptGe[0] + vtMaj * dL3;
					ptGe[2] = ptGe[3] - vtMaj * dL3;

					ptGe[4] = ptGe[3] - vtW * dDn;
					ptGe[5] = ptGe[2] - vtW * dDn;

					ptGe[6] = ptGe[1] - vtW * dW1;
					ptGe[7] = ptGe[0] - vtW * dW1;
					ptGe[8] = ptGe[0];

					nPoints = 9;
					nS = 4;
					nE = 4;

					ptS = MidPoint(ptGe[0], ptGe[7]);
					ptE = MidPoint(ptGe[3], ptGe[4]);
				}
				else if (nEcCen == 1)
				{
					ptGe[1] = ptGe[0] + vtMaj * dL;

					ptGe[2] = ptGe[1] - vtW * dDn;
					ptGe[3] = ptGe[2] - vtMaj * dL3;

					ptGe[5] = ptGe[0] - vtW * dW1;
					ptGe[4] = ptGe[5] + vtMaj * dL3;

					ptGe[6] = ptGe[0];

					nPoints = 7;
					nS = 2;
					nE = 4;

					ptS = MidPoint(ptGe[0], ptGe[5]);
					ptE = MidPoint(ptGe[1], ptGe[2]);
				}
				else if (nEcCen == 2)
				{
					ptGe[3] = ptMid;
					ptGe[3] -= vtMaj * 0.5 * dL;
					ptGe[3] -= vtW * 0.5 * dW1;
					ptGe[3] += vtMaj * dL;
					ptGe[3] += vtW * dDn;

					ptGe[2] = ptGe[3] - vtMaj * dL3;
					ptGe[1] = ptGe[0] + vtMaj * dL3;

					ptGe[4] = ptGe[3] - vtW * dDn;
					ptGe[5] = ptGe[0] - vtW * dW1;

					ptGe[6] = ptGe[0];

					nPoints = 7;
					nS = 4;
					nE = 2;

					ptS = MidPoint(ptGe[0], ptGe[5]);
					ptE = MidPoint(ptGe[3], ptGe[4]);
				}

				AcDbPolyline *pPl = NULL;
				BOOL bHide = FALSE;
				m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

				if (bHide)//隐藏两头端线
				{
					pPl = FormatPolyline(ptGe, nS);
					if (pPl != NULL)
					{
						dc.SetLayer(layerId());
						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					pptGe = ptGe;
					pptGe += nS;
					pPl = FormatPolyline(pptGe, nE);
					if (pPl != NULL)
					{
						dc.SetLayer(layerId());
						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
				else
				{
					pPl = FormatPolyline(ptGe,nPoints);
					if (pPl != NULL)
					{
						dc.SetLayer(layerId());
						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}

				ptGe[0] = ptS;
				ptGe[1] = ptE;

				//中心线
				if (nCenNDraw == FALSE)
				{
					pPl = FormatPolyline(ptGe,2);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
				}
			}
			else
			{
				if ( ln.isParallelTo(AcGePlane::kXYPlane))//垂直放置 绘制 []形状
				{

				}
				else
				{
					//...
				}
			}
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrReduce2d(AcGiDraw &dc) const
{
	AcGeVector3d vtMaj, vtMin, vtNorm(0, 0, 1);
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dL = 0.0;
	double dThick = 0.35, dH = 0.0, dW1 = 0.0, dt = 0.0;

	int nEcCen = 0;//偏心
	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);
	m_mapSpecXData.GetAt(KEY_L, dL);
	m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
	m_mapSpecXData.GetAt(KEY_ECCEN, nEcCen);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//W H
	dH = dParam.dSize[1];//末端
	dt = dParam.dSize[2];//thick
	dW1 = dParam.dSize[3];//开始端

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();

	AcGeVector3d vtW = vtMaj;
	vtW.rotateBy(PI / 2.0, vtNorm);
	vtW.normalize();

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	double dSingleW = 0.0;
	m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	AcGeLine3d ln(AcGePoint3d::kOrigin, vtNorm);

	nStyle = 2;//双线
	AcGePoint3d ptGe[10];
	switch (nStyle)
	{
	case 0://单线
	case 1://单线
	{
		//暂不绘制单线
		break;
	}
	case 2://双线
	{
		if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平放置
		{
			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * 0.5 * dL;
			ptGe[0] += vtW * 0.5 * dW1;

			if (nEcCen == 0)
			{
				ptGe[1] = ptMid;
				ptGe[1] += vtMaj * 0.5 * dL;
				ptGe[1] += vtW * 0.5 * dDn;
			}
			else if (nEcCen == 1)
			{
				ptGe[1] = ptGe[0] + vtMaj * dL;
			}
			else if (nEcCen == 2)
			{
				ptGe[1] = ptMid;
				ptGe[1] -= vtMaj * 0.5 * dL;
				ptGe[1] -= vtW * 0.5 * dW1;
				ptGe[1] += vtMaj * dL;
				ptGe[1] += vtW * dDn;
			}

			ptGe[2] = ptGe[1] - vtW * dDn;
			ptGe[3] = ptGe[0] - vtW * dW1;

			ptGe[4] = ptGe[0];

			AcDbPolyline *pPl = NULL;
			BOOL bHide = FALSE;
			m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

			if (bHide)
			{
				AcGePoint3d *ptGe2 = ptGe;
				pPl = FormatPolyline(ptGe2, 2);
				if (pPl != NULL)
				{
					dc.SetLayer(layerId());
					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}

				ptGe2 += 2;
				pPl = FormatPolyline(ptGe2, 2);
				if (pPl != NULL)
				{
					dc.SetLayer(layerId());
					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}
			else
			{
				pPl = FormatPolyline(ptGe, 5);
				if (pPl != NULL)
				{
					dc.SetLayer(layerId());
					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}

			ptGe[0] = MidPoint(ptGe[0], ptGe[3]);
			ptGe[1] = MidPoint(ptGe[1], ptGe[2]);

			if (nCenNDraw == FALSE)
			{
				pPl = FormatPolyline(ptGe, 2);
				if (pPl != NULL)
				{
					pPl->setLayer(layerId());
					pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

					dc.DrawEntity(pPl);
					Add2DBuffer(pPl);
				}
			}
		}
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawOffset2d(AcGiDraw &dc) const
{
	//两个弯头,且水平放置,或垂直放置
	//90 < A < 180.0 乙字弯角度

	assertReadEnabled();

	AcGeVector3d vtMaj,vtMin,vtNorm,vtOffset;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
	double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0;
	double dOffsetH = 0.0;//偏西距离

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
	m_mapSpecXData.GetAt(KEY_OFFSETDIR,vtOffset);//偏移方向
	//vtMaj == vtMin

	m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
	m_mapSpecXData.GetAt(KEY_Offset,dOffsetH);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	double dH = dParam.dSize[1];//H
	double dR = dDn * dRatio;
	dW = dParam.dSize[1];//

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();
	vtOffset.normalize();

	//偏移方向的反方向
	AcGeVector3d vtV = vtOffset;//Maj->Min的方向
	vtV = vtV.orthoProject(vtMaj);//MAKE SURE
	vtV.negate();
	vtV.normalize();

	if (dOffsetH < 1.e-6)
	{
		acutPrintf(_T("\nOffset dist error!"));
		return Acad::eOk;
	}

	//乙字弯角度 90 < A < 180
	if ( ( dSweepAngle - 90.0 ) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
	{
		//转化为弧度
		dSweepAngle *= PI / 180.0;

		double dChrodx = dR * tan(dSweepAngle * 0.5);

		//斜段总桥架长度
		double dLseg = dOffsetH / sin(dSweepAngle);//180-a

		//投影到maj方向上 水平总长
		double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
		dL += dChrodx * 2.0;

		//伞心中最大对角线长
		double dAL = sqrt(dR * dR + dChrodx * dChrodx);
	
		AcGeLine3d ln(AcGePoint3d::kOrigin,vtNorm);
		if (ln.isParallelTo(AcGePlane::kXYPlane))//垂直桥架的Z字弯头
		{
			//绘制水平投影即可
			AcGePoint3d ptGe[5];

			ptMid.z = 0.0;
			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * 0.5 * dL;
			ptGe[0] += vtNorm * 0.5 * dDn;

			ptGe[1] = ptGe[0] + vtMaj * dL;
			ptGe[2] = ptGe[1] - vtNorm * dDn;
			ptGe[3] = ptGe[0] - vtNorm * dDn;
			ptGe[4] = ptGe[0];


			//绘制外弧度界限 中心位置投影示意
			double dAX = dChrodx;
			AcGePoint3d ptGeA[4];

			ptGeA[0] = ptGe[0] + vtMaj * dAX;
			ptGeA[1] = ptGe[3] + vtMaj * dAX;

			AcDbPolyline* pPl = FormatPolyline(ptGeA,2);
			if (pPl != NULL)
			{
				pPl->setLayer(m_idDoubleLayer);
				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}

			ptGeA[2] = ptGe[1] - vtMaj * dAX;
			ptGeA[3] = ptGe[2] - vtMaj * dAX;

			ptGeA[0] = ptGeA[2];
			ptGeA[1] = ptGeA[3];
			pPl = FormatPolyline(ptGeA,2);
			if (pPl != NULL)
			{
				pPl->setLayer(m_idDoubleLayer);
				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}

			pPl = FormatPolyline(ptGe, 5);
			if (pPl != NULL)
			{
				pPl->setLayer(m_idDoubleLayer);
				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
		else if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平桥架的Z字弯头
		{
			AcGePoint3d ptGe[4];

			ptGe[0] = ptMid - vtMaj * 0.5 * dL;
			ptGe[0] += vtV * 0.5 * dOffsetH;

			ptGe[1] = ptGe[0] + vtMaj * dChrodx;
			
			AcGeVector3d vtMidL = ptMid - ptGe[1];
			vtMidL.normalize();
			ptGe[2] = ptGe[1] + vtMidL * dLseg;

			ptGe[3] = ptGe[2] + vtMin * dChrodx;

			BOOL bHide = FALSE;
			m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

			AcDbPolyline* pPl = FormatPolyline(ptGe,4);
			if (pPl != NULL)
			{
				AcDbVoidPtrArray arOff1,arOff2;
				pPl->getOffsetCurves( dDn * 0.5,arOff1);
				pPl->getOffsetCurves(-dDn * 0.5,arOff2);

				if (arOff1.length() == 1 && arOff2.length() == 1)
				{
					AcDbCurve* pCurve1 = (AcDbCurve*)arOff1.first();
					AcDbCurve* pCurve2 = (AcDbCurve*)arOff2.last();

					if (pCurve1 != NULL && pCurve2 != NULL)
					{
						pCurve1->setLayer(m_idDoubleLayer);
						dc.DrawEntity(pCurve1);
						Add2DBuffer(pCurve1);

						pCurve2->setLayer(m_idDoubleLayer);
						dc.DrawEntity(pCurve2);
						Add2DBuffer(pCurve2);

						AcDbLine *pLn = NULL;
						if (!bHide)
						{
							pCurve1->getStartPoint(ptGe[0]);
							pCurve2->getStartPoint(ptGe[1]);

							pLn = new AcDbLine(ptGe[0],ptGe[1]);
							if (pLn != NULL)
							{
								pLn->setLayer(m_idDoubleLayer);
								dc.DrawEntity(pLn);
								Add2DBuffer(pLn);
							}
						
							pCurve1->getEndPoint(ptGe[0]);
							pCurve2->getEndPoint(ptGe[1]);

							pLn = new AcDbLine(ptGe[0],ptGe[1]);
							if (pLn != NULL)
							{
								pLn->setLayer(m_idDoubleLayer);
								dc.DrawEntity(pLn);
								Add2DBuffer(pLn);
							}
						}
					}
				}

				//删除中心线
				delete pPl;
			}
		}
		else
		{
			//...其他斜方向不画
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrOffset2d(AcGiDraw &dc) const
{
	//两个弯头,且水平放置,或垂直放置
	//90 < A < 180.0 乙字弯角度

	assertReadEnabled();

	AcGeVector3d vtMaj, vtMin, vtNorm, vtOffset;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0;
	double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0;
	double dOffsetH = 0.0;//偏西距离

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
	m_mapSpecXData.GetAt(KEY_OFFSETDIR, vtOffset);//偏移方向
	//vtMaj == vtMin

	m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
	m_mapSpecXData.GetAt(KEY_Offset, dOffsetH);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	double dH = dParam.dSize[1];//H
	double dR = dDn * dRatio;
	dW = dParam.dSize[1];//

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();
	vtOffset.normalize();

	//偏移方向的反方向
	AcGeVector3d vtV = vtOffset;//Maj->Min的方向
	vtV = vtV.orthoProject(vtMaj);//MAKE SURE
	vtV.negate();
	vtV.normalize();

	if (dOffsetH < 1.e-6)
	{
		acutPrintf(_T("\nOffset dist error!"));
		return Acad::eOk;
	}

	//乙字弯角度 90 < A < 180
	if ((dSweepAngle - 90.0) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
	{
		//转化为弧度
		dSweepAngle *= PI / 180.0;

		double dChrodx = dR * tan(dSweepAngle * 0.5);

		//斜段总桥架长度
		double dLseg = dOffsetH / sin(dSweepAngle);//180-a

		//投影到maj方向上 水平总长
		double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
		dL += dChrodx * 2.0;

		//伞心中最大对角线长
		double dAL = sqrt(dR * dR + dChrodx * dChrodx);

		AcGeLine3d ln(AcGePoint3d::kOrigin, vtNorm);

		if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//电缆沟水平
		{
			AcGePoint3d ptGe[4];

			ptGe[0] = ptMid - vtMaj * 0.5 * dL;
			ptGe[0] += vtV * 0.5 * dOffsetH;

			ptGe[1] = ptGe[0] + vtMaj * dChrodx;

			AcGeVector3d vtMidL = ptMid - ptGe[1];
			vtMidL.normalize();
			ptGe[2] = ptGe[1] + vtMidL * dLseg;

			ptGe[3] = ptGe[2] + vtMin * dChrodx;

			BOOL bHide = FALSE;
			m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

			AcDbPolyline *pPl = FormatPolyline(ptGe, 4);
			if (pPl != NULL)
			{
				AcDbVoidPtrArray arOff1, arOff2;
				pPl->getOffsetCurves(dDn * 0.5, arOff1);
				pPl->getOffsetCurves(-dDn * 0.5, arOff2);

				if (arOff1.length() == 1 && arOff2.length() == 1)
				{
					AcDbCurve *pCurve1 = (AcDbCurve *)arOff1.first();
					AcDbCurve *pCurve2 = (AcDbCurve *)arOff2.last();

					if (pCurve1 != NULL && pCurve2 != NULL)
					{
						pCurve1->setLayer(m_idDoubleLayer);
						dc.DrawEntity(pCurve1);
						Add2DBuffer(pCurve1);

						pCurve2->setLayer(m_idDoubleLayer);
						dc.DrawEntity(pCurve2);
						Add2DBuffer(pCurve2);

						AcDbLine *pLn = NULL;
						if (!bHide)
						{
							pCurve1->getStartPoint(ptGe[0]);
							pCurve2->getStartPoint(ptGe[1]);

							pLn = new AcDbLine(ptGe[0], ptGe[1]);
							if (pLn != NULL)
							{
								pLn->setLayer(m_idDoubleLayer);
								dc.DrawEntity(pLn);
								Add2DBuffer(pLn);
							}

							pCurve1->getEndPoint(ptGe[0]);
							pCurve2->getEndPoint(ptGe[1]);

							pLn = new AcDbLine(ptGe[0], ptGe[1]);
							if (pLn != NULL)
							{
								pLn->setLayer(m_idDoubleLayer);
								dc.DrawEntity(pLn);
								Add2DBuffer(pLn);
							}
						}
					}
				}
				//删除中心线
				delete pPl;
			}
		}
		else
		{
			//...其他斜方向不画
		}
	}
	return Acad::eOk;
}

int AecDbEcFitting::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
{
	assertReadEnabled();

	AecDbObjXDataMap xData;

	AcDbEntity* pEnt = NULL,*pEntCln = NULL;
	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	for (int i = 0;i < ar2D.length();i++)
	{
		pEnt = (AcDbEntity*)ar2D.at(i);
		pEntCln = (AcDbEntity*)pEnt->clone();
		
		if (xData.Read(pEnt,BIMDATA_APP))
		{
			xData.SetAt(KEY_ID,m_sGUID);
			xData.Write(pEntCln,BIMDATA_APP);
		}
		arEntPtrs.append(pEntCln);
	}
	return arEntPtrs.length();
}

int  AecDbEcFitting::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs,bool bWriteBimInfo) const
{
	assertReadEnabled();

	AcDbEntity* pEnt = NULL,*pEntClone = NULL;
	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);
		pEntClone = (AcDbEntity*)pEnt->clone();

		int nColor = 0;
		if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
		{
			pEntClone->setColorIndex(nColor);
		}
		else
		{
			pEntClone->setColorIndex(colorIndex());
		}

		pEntClone->setLayer(layerId());
		if (bWriteBimInfo)
		{
			m_mapSpecXData.Write(pEntClone,_T("BIMDATA"));
		}
		arEntPtrs.append(pEntClone);
	}
	return arEntPtrs.length();
}

Acad::ErrorStatus AecDbEcFitting::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	//管线系统屏蔽掉
	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());
	//dc.SetSelectionMarker(1);

	int nCrBk = dc.GetColor();
	int nColor = nCrBk;
	if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
	{
		dc.SetColor(nColor);
	}

	if (IsActive())
	{
		dc.SetColor(kMagenta);
	}

	if (Has3DBuffer())
	{
		AcDbEntity* pSubEnt = NULL;
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			if (IsActive())
			{
				pSubEnt = pEnt;
				pEnt->setColorIndex(kMagenta);
			}
			else
			{
				pEnt->setColorIndex(nColor);
			}
			dc.DrawEntity(*pEnt);
		}

		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	int nApp = 7;
	m_mapSpecXData.GetAt(KEY_APP, nApp);

	WPipe::EApp eApp = (WPipe::EApp)nApp;
	switch (eApp)
	{
		case WPipe::eBridge:
		{
			DrawBridge3D(dc);
			break;
		}
		case WPipe::eTrench:
		{
			DrawTrech3D(dc);
			break;
		}
		default:
			break;
	}

	DrawUserInf3d(dc);

	return Acad::eOk;
}

extern AcDbRegion *CreateRegion(const AcGePoint3d *pptGe, int nPoints, const AcGeVector3d &vtNorm, double dt);

Acad::ErrorStatus AecDbEcFitting::BoolSubtractUserInf3d(AecDbX3dPart& part) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();

	double dt = 0.0;
	m_mapSpecXData.GetAt(PIPE_THICK, dt);

	AcGeVector3d vtDirThick;
	AecUserInterface inf2;
	AcDbLine lnPath;
	AcDbRegion *pRegion = NULL;
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		const AecUserInterface &inf = m_arUserInfs.at(i);
		memcpy(&inf2, &inf, sizeof(AecUserInterface));

		vtDirThick = inf.vtDir;
		vtDirThick.normalize();
		vtDirThick *= 2.0 *dt;

		lnPath.setStartPoint(inf.ptGe[0] - vtDirThick);
		lnPath.setEndPoint(inf.ptGe[0] + vtDirThick);

		for (int ii = 0;ii < inf2.nPoints;ii++)
		{
			inf2.ptGe[ii] -= vtDirThick;
		}

		if (inf.nPoints >= 3) //多边形
		{
			pRegion = CreateRegion(inf2.ptGe, inf2.nPoints, inf2.vtDir, 0);
			if (pRegion != NULL)
			{
				AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
				pX3dSolidTop->CreateExtrude(pRegion, lnPath);
				part.AddX3dSolid(pX3dSolidTop, AcDb::kBoolSubtract);
			}
		}
		else if (inf.nPoints == 2)//圆
		{
			pRegion = CreateRegion(inf2.ptGe, inf2.nPoints, inf2.vtDir, 0);
			if (pRegion != NULL)
			{
				AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
				pX3dSolidTop->CreateExtrude(pRegion, lnPath);
				part.AddX3dSolid(pX3dSolidTop, AcDb::kBoolSubtract);
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawUserInf3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();

	double dt = 0.0;
	m_mapSpecXData.GetAt(PIPE_THICK, dt);

	AcDbLine lnPath;
	AcDbRegion *pRegion = NULL;
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		const AecUserInterface &inf = m_arUserInfs.at(i);

		lnPath.setStartPoint(inf.ptGe[0]);
		lnPath.setEndPoint(inf.ptGe[0] + inf.vtDir);

		AecDbX3dPart part;
		if (inf.nPoints >= 3) //多边形
		{
			pRegion = CreateRegion(inf.ptGe, inf.nPoints, inf.vtDir, dt);
			if (pRegion != NULL)
			{
				//CoreTools::AddToModelSpace(pRegion);
				//CoreTools::CloneAndAddToModelSpace(&lnPath);
				AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
				pX3dSolidTop->CreateExtrude(pRegion, lnPath);
				part.AddX3dSolid(pX3dSolidTop);
			}
		}
		else if (inf.nPoints == 2)//圆
		{
			pRegion = CreateRegion(inf.ptGe, inf.nPoints, inf.vtDir, dt);
			if (pRegion != NULL)
			{
				AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
				pX3dSolidTop->CreateExtrude(pRegion, lnPath);
				part.AddX3dSolid(pX3dSolidTop);
			}
		}

		part.Create();
		AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
		if (pSolid != NULL)
		{
			pSolid->setTransparency(tr);
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawElbow3d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
	m_mapSpecXData.GetAt(HELB_Type, (int&)eElbowType);

	switch(eElbowType)
	{
	case AecHvac::eIncline://内斜线方式
		{
			DrawIncline3d(dc);
			break;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrElbow3d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
	m_mapSpecXData.GetAt(HELB_Type, (int &)eElbowType);

	switch (eElbowType)
	{
	case AecHvac::eIncline://内斜线方式
	{
		DrawTrIncline3d(dc);
		break;
	}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTee3d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
	m_mapSpecXData.GetAt(HTEE_Type, (int&)eTeeType);

	switch(eTeeType)
	{
	case AecHvac::eIncline2Branch://内斜线
		{
			DrawIncline2Tee3d(dc);
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrTee3d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacTeeType eTeeType = AecHvac::eTShapeBranch;
	m_mapSpecXData.GetAt(HTEE_Type, (int &)eTeeType);

	switch (eTeeType)
	{
	case AecHvac::eIncline2Branch://内斜线
	{
		DrawTrIncline2Tee3d(dc);
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d0(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	dDn2 = dParam.dSize[3];
	if (dParam.m_app == WPipe::eTrench)
		dDn2 += 2.0 * dParam.dSize[2];

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	double dL = dDn * dRatio;

	if (dParam.m_app == WPipe::eTrench)
	{
		if (dDn - dL > 1.e-6)
		{
			dL = __min(dDn, dDn2);
		}
	}

	double dH = dParam.dSize[1];//

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);

	AcGeLine3d ln3d;
	ln3d.set(AcGePoint3d::kOrigin, vtNorm);
	if (ln3d.isParallelTo(AcGePlane::kXYPlane))
	{
		double dTmp = dH;
		dH = dDn;
		dDn = dTmp;
	}

	AcGePoint3d ptGe[10];
	AcGePoint3dArray arPts;
	ptGe[0] = ptMid;
	ptGe[0] -= vtMaj * (dL + dLx);
	ptGe[0] -= vtMin * dDn * 0.5;
	arPts.append(ptGe[0]);

	ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
	arPts.append(ptGe[1]);

	ptGe[2] = ptGe[1] + vtMin * dDn;
	arPts.append(ptGe[2]);

	ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
	ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);

	InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
	arPts.append(ptGe[4]);

	ptGe[5] = ptGe[4] - vtMaj * dDn2;
	arPts.append(ptGe[5]);

	ptGe[6] = ptGe[3] - vtMaj * dDn2;
	ptGe[7] = ptGe[0] + vtMin * dDn;
	InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
	arPts.append(ptGe[7]);

	ptGe[8] = ptGe[0];
	arPts.append(ptGe[8]);

	AcGePoint3d ptFr, ptTo;
	AcDbLine lnPath;
	AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
	if (pRegOut != NULL)
	{
		ptFr = ptMid - vtNorm * 0.5 * dH;//H
		ptTo = ptMid + vtNorm * 0.5 * dH;//H

		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		AcGeMatrix3d xform;
		AcGeVector3d vt = vtNorm * 0.5 * dH;
		xform.setToTranslation(vt);
		pRegOut->transformBy(xform);

		AecDbX3dPart part;

		AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
		pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
		part.AddX3dSolid(pX3dSolidOut);

		OffsetPoint(ptGe[0], ptGe[7], dThick);
		OffsetPoint(ptGe[1], ptGe[2], dThick);
		OffsetPoint(ptGe[4], ptGe[5], dThick);

		AcGePoint3d ptTemp = ptMid;
		OffsetPoint(ptGe[6], ptTemp, dThick * 1.41421356);

		ptTemp = ptMid;
		OffsetPoint(ptGe[3], ptTemp, dThick * 1.41421356);

		arPts.removeAll();
		arPts.append(ptGe[0]);
		arPts.append(ptGe[1]);
		arPts.append(ptGe[2]);

		InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
		arPts.append(ptGe[4]);

		arPts.append(ptGe[5]);
		InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
		arPts.append(ptGe[7]);

		ptGe[8] = ptGe[0];
		arPts.append(ptGe[8]);

		AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
		if (pRegIn != NULL)
		{
			if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
				!dParam.m_bCover)
			{
				//水平放置,不带盖子时
				AcGeVector3d vtRegNorm;
				pRegIn->getNormal(vtRegNorm);

				ptFr = ptMid - vtRegNorm * 0.5 * dH;
				ptTo = ptMid + vtRegNorm * 0.5 * (dH - 2.0 * dThick);//H

				lnPath.setStartPoint(ptFr);
				lnPath.setEndPoint(ptTo);

				vt = vtRegNorm * 0.5 * dH;
			}
			else
			{
				ptFr = ptMid - vtNorm * 0.5 * (dH - 2.0 * dThick);//H
				ptTo = ptMid + vtNorm * 0.5 * (dH - 2.0 * dThick);//H

				lnPath.setStartPoint(ptFr);
				lnPath.setEndPoint(ptTo);

				vt = vtNorm * 0.5 * (dH - 2.0 * dThick);
			}

			xform.setToTranslation(vt);
			pRegIn->transformBy(xform);

			AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
			pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
			part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);

			BoolSubtractUserInf3d(part);
			part.Create();

			AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
			if (pSolid != NULL)
			{
				pSolid->setTransparency(tr);
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
			delete pRegIn;
		}
		delete pRegOut;
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d3(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();

	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L 
	dH = dParam.dSize[1];// H
	dDn2 = dParam.dSize[3];//分支宽度

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	double dL = dDn * dRatio;

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	vtNorm.normalize();

	AcGePoint3d ptGe[5],ptGeI[5], ptFr,ptTo;

	AcGeVector3d vtX, vtZ, vtY;
	if (vtMin.isParallelTo(AcGeVector3d::kZAxis))
	{
		vtZ = vtMin;
		vtX = vtMaj;
	}
	if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))
	{
		vtZ = vtMaj;
		vtX = vtMin;
	}
	vtY = vtX;
	vtY.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

	AcGeLine3d ln(ptMid, vtX);
	if (ln.isParallelTo(AcGePlane::kXYPlane))
	{
		ptGe[0] = ptMid;
		ptGe[0] -= vtX * (dL + dLx);
		ptGe[0] += vtY * 0.5 * dDn;

		ptGe[1] = ptGe[0] + vtX * 2.0 * (dL + dLx);
		ptGe[2] = ptGe[1] - vtY * dDn;
		ptGe[3] = ptGe[0] - vtY * dDn;
		ptGe[4] = ptGe[0];

		memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);

		OffsetPoint(ptGeI[0], ptGeI[3], dThick);
		OffsetPoint(ptGeI[1], ptGeI[2], dThick);
		ptGeI[4] = ptGeI[0];

		AcDbLine lnPath;
		AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
		if (pRegOut != NULL)
		{
			ptFr = ptMid - vtMin * 0.5 * dH;//W
			ptTo = ptMid + vtMin * 0.5 * dH;//W

			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			AcGeMatrix3d xform;
			AcGeVector3d vt = vtMin * 0.5 * dH;
			xform.setToTranslation(vt);
			pRegOut->transformBy(xform);

			AecDbX3dPart part;
			AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
			pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
			part.AddX3dSolid(pX3dSolidOut);

			AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
			if (pRegIn != NULL)
			{
				if (vtMin.isParallelTo(AcGeVector3d::kZAxis) &&
					!dParam.m_bCover)
				{
					//水平放置,不带盖子时
					AcGeVector3d vtRegNorm;
					pRegIn->getNormal(vtRegNorm);

					ptFr = ptMid - vtRegNorm * 0.5 * dH;
					ptTo = ptMid + vtRegNorm * 0.5 * (dH - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtRegNorm * 0.5 * dH;
				}
				else
				{
					ptFr = ptMid - vtMin * 0.5 * (dH - 2.0 * dThick);//W
					ptTo = ptMid + vtMin * 0.5 * (dH - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtMin * 0.5 * (dH - 2.0 * dThick);
				}

				xform.setToTranslation(vt);
				pRegIn->transformBy(xform);

				AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
				pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
				part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);

				BoolSubtractUserInf3d(part);
				part.Create();

				AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(tr);
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
				delete pRegIn;
			}
			delete pRegOut;
		}

		//Z方向
		//调用 drawuserinf3d 
	}
	else
	{
		//...
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d5(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();

	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0, dH = 0;
	double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dDn2 = 0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nElbowStyle = 0;
	m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);

	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	vtNorm.normalize();
	vtMaj.normalize();
	vtMin.normalize();

	AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
	AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
	vtMV.normalize();
	vtNV.normalize();

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[3];
	dDn2 = dParam.dSize[0];//末端
	if (dDn < 1.e-6) dDn = dDn2;

	dW = dParam.dSize[1];
	dH = dW;
	//dL = dDn * dRatio + dLx;
	dL = GetElbowL(&dParam);
	dL += dLx;//三通长度

	AcGePoint3d ptGe[8], ptFr, ptTo, ptTmp, ptGeI[8], ptGeU[8], ptGeUI[8];
	AcDbLine lnPath;
	AecDbX3dPart part;

	vtMaj.normalize();
	vtMin.normalize();

	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平放置
	{
		//OUT
		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[0] -= vtMV * 0.5 * dDn;

		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;
		ptGe[2] -= vtNV * 0.5 * dDn2;

		AcGeLine3d ln1(ptGe[0], vtMaj);
		AcGeLine3d ln2(ptGe[2], vtMin);
		ln1.intersectWith(ln2, ptGe[1]);

		ptGe[3] = ptGe[2] + vtNV * dDn2;
		ptGe[4] = ptGe[3] - vtMin * dLx;

		ptGe[6] = ptGe[0] + vtMV * dDn;
		ptGe[5] = ptGe[6] - vtMaj * dLx;

		ptGe[7] = ptGe[0];

		//In
		AcGePoint3d ptTmp;
		memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 8);
		OffsetPoint(ptGeI[0], ptGeI[6], dThick);

		ptTmp = ptGeI[0];
		OffsetPoint(ptTmp, ptGeI[1], dThick);

		OffsetPoint(ptGeI[2], ptGeI[3], dThick);

		ptGeI[5] = ptGeI[6] - vtMaj * (dLx + dThick);//大约
		ptGeI[4] = ptGeI[3] - vtMin * (dLx + dThick);//大约
		ptGeI[7] = ptGeI[0];

		AcDbLine lnPath;
		AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 8);
		if (pRegOut != NULL)
		{
			ptFr = ptMid - vtNorm * 0.5 * dW;//W
			ptTo = ptMid + vtNorm * 0.5 * dW;//W

			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			AcGeMatrix3d xform;
			AcGeVector3d vt = vtNorm * 0.5 * dW;
			xform.setToTranslation(vt);
			pRegOut->transformBy(xform);

			AecDbX3dPart part;
			AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
			pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
			part.AddX3dSolid(pX3dSolidOut);

			AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 8);
			if (pRegIn != NULL)
			{
				if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
					!dParam.m_bCover)
				{
					//水平放置,不带盖子时
					AcGeVector3d vtRegNorm;
					pRegIn->getNormal(vtRegNorm);

					ptFr = ptMid - vtRegNorm * 0.5 * dW;
					ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtRegNorm * 0.5 * dW;
				}
				else
				{
					ptFr = ptMid - vtNorm * 0.5 * (dW - 2.0 * dThick);//W
					ptTo = ptMid + vtNorm * 0.5 * (dW - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtNorm * 0.5 * (dW - 2.0 * dThick);
				}

				xform.setToTranslation(vt);
				pRegIn->transformBy(xform);

				AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
				pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
				part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);

				BoolSubtractUserInf3d(part);
				part.Create();

				AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(tr);
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
				delete pRegIn;
			}
			delete pRegOut;
		}
		else
		{
			//...
			AcGePoint3dArray arPts;
			for (int i = 0; i < 8; i++)
			{
				arPts.append(ptGe[i]);
			}
			AcDb3dPolyline *pPl3d = Format3dPolyline(arPts);
			if (pPl3d != NULL)
			{
				dc.DrawEntity(pPl3d);
				Add3DBuffer(pPl3d);
			}
		}
	}

	//Z方向
	//调用 drawuserinf3d 

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2Tee3d(AcGiDraw &dc) const
{
	int nTeeStyle = 0;
	m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);
	
	switch (nTeeStyle)
	{
		case 0: //标准  =||=
		{
			DrawIncline2Tee3d0(dc);
			break;
		}
		case 1: //上下 垂直三通 [ || ]
		case 2: //上边垂直三通
		case 3: //下边垂直三通
		{
			DrawIncline2Tee3d3(dc);
			break;
		}
		case 4: //上边垂直三通
		case 5: //下角垂直三通
		{
			DrawIncline2Tee3d5(dc);
			break;
		}

	default:
		break;
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrIncline2Tee3d(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0.0;
	double dThick = 0.35, dLx = 50.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	DlgData data;
	memset(&data, 0, sizeof(DlgData));
	GetDlgData(data, 0);

	dDn = dParam.dSize[0];//D L
	double dL = dDn * dRatio;//不变

	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	dDn2 = dParam.dSize[3];
	if (dParam.m_app == WPipe::eTrench)
		dDn2 += 2.0 * dParam.dSize[2];

	if (dDn2 < 1.e-6)
		dDn2 = dDn;

	double dH = dParam.dSize[1];//

	vtMaj.normalize();
	vtMin.normalize();

	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//一律向下
		vtNorm.set(0, 0, -1);

	AcGePoint3d ptGe[10],ptGeW[10];
	AcGePoint3dArray arPts;
	ptGe[0] = ptMid;
	ptGe[0] -= vtMaj * (dL + dLx);
	ptGe[0] -= vtMin * dDn * 0.5;
	arPts.append(ptGe[0]);

	ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
	arPts.append(ptGe[1]);

	ptGe[2] = ptGe[1] + vtMin * dDn;
	arPts.append(ptGe[2]);

	ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * dDn2);
	ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);

	//电缆沟不需要倒角
	arPts.append(ptGe[3]);
	//InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
	arPts.append(ptGe[4]);

	ptGe[5] = ptGe[4] - vtMaj * dDn2;
	arPts.append(ptGe[5]);

	ptGe[6] = ptGe[3] - vtMaj * dDn2;
	ptGe[7] = ptGe[0] + vtMin * dDn;
	arPts.append(ptGe[6]);
	//InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
	arPts.append(ptGe[7]);

	ptGe[8] = ptGe[0];
	arPts.append(ptGe[8]);

	AecDbX3dPart part;
	AcGePoint3d ptFr, ptTo;
	AcDbLine lnPath;

	//顶板
	AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
	if (pRegTop != NULL)
	{
		ptFr = ptMid - vtNorm * 0.5 * dH;//H
		ptTo = ptFr + vtNorm * data.m_dk;//k
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegTop);
		AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
		pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
		part.AddX3dSolid(pX3dSolidTop);
	}

	//墙 vtMaj 直
	ptGeW[0] = ptGe[0]; ptGeW[1] = ptGe[1];
	ptGeW[2] = ptGeW[1] + vtMin * data.m_dt;
	ptGeW[3] = ptGeW[0] + vtMin * data.m_dt;
	ptGeW[4] = ptGeW[0];
	AcDbRegion *pRegWall = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW,5);
	if (pRegWall != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//墙 vtMin 右
	ptGeW[0] = ptGe[2]; ptGeW[1] = ptGe[3];
	ptGeW[2] = ptGe[4];
	ptGeW[3] = ptGeW[2] - vtMaj * data.m_dt;
	ptGeW[5] = ptGeW[0] - vtMin * data.m_dt;
	ptGeW[4] = GetIntersectPt(ptGeW[3], vtMin, ptGeW[5], vtMaj);
	ptGeW[6] = ptGeW[0];
	AcDbRegion *pRegWallR = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 7);
	if (pRegWallR != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWallR);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWallR, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//墙 vtMin 左
	ptGeW[0] = ptGe[5]; ptGeW[1] = ptGe[6];
	ptGeW[2] = ptGe[7];
	ptGeW[3] = ptGeW[2] - vtMin * data.m_dt;
	ptGeW[5] = ptGeW[0] + vtMaj * data.m_dt;
	ptGeW[4] = GetIntersectPt(ptGeW[3], vtMaj, ptGeW[5], vtMin);
	ptGeW[6] = ptGeW[0];
	AcDbRegion *pRegWallL = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 7);
	if (pRegWallL != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWallL);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWallL, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	DlgData data2;
	memset(&data2, 0, sizeof(DlgData));
	GetDlgData(data2, 1);

	if (data2.m_dd < 1.e-6)
		data2.m_dd = data.m_dd;
	
	//底板
	arPts.removeAll();
	ptGe[0] = ptMid;
	ptGe[0] -= vtMaj * (dL + dLx);
	ptGe[0] -= vtMin * 0.5 * data.m_dd;
	arPts.append(ptGe[0]);

	ptGe[1] = ptGe[0] + vtMaj * 2.0 * (dL + dLx);
	arPts.append(ptGe[1]);

	ptGe[2] = ptGe[1] + vtMin * data.m_dd;
	arPts.append(ptGe[2]);

	ptGe[3] = ptGe[2] - vtMaj * (dL + dLx - 0.5 * data2.m_dd);
	ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * data.m_dd);

	//电缆沟不需要倒角
	arPts.append(ptGe[3]);
	//InsertL2Point(ptGe[2], ptGe[3], ptGe[4], dLx, arPts);
	arPts.append(ptGe[4]);

	ptGe[5] = ptGe[4] - vtMaj * data2.m_dd;
	arPts.append(ptGe[5]);

	ptGe[6] = ptGe[3] - vtMaj * data2.m_dd;
	ptGe[7] = ptGe[0] + vtMin * data.m_dd;
	arPts.append(ptGe[6]);
	//InsertL2Point(ptGe[5], ptGe[6], ptGe[7], dLx, arPts);
	arPts.append(ptGe[7]);

	ptGe[8] = ptGe[0];
	arPts.append(ptGe[8]);

	AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
	if (pRegBom != NULL)
	{
		ptFr = ptMid + vtNorm * 0.5 * dH;//H
		ptTo = ptFr - vtNorm * data.m_db;//H

		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegBom);
		AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
		pX3dSlabB->CreateExtrude(pRegBom, lnPath);
		part.AddX3dSolid(pX3dSlabB);
	}

	part.Create();
	AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
	if (pSolid != NULL)
	{
		pSolid->setTransparency(tr);
		dc.DrawEntity(pSolid);
		Add3DBuffer(pSolid);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawCross3d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
	m_mapSpecXData.GetAt(HCRS_Type, (int&)eTeeType);

	switch(eTeeType)
	{
	case AecHvac::eInterCross://内斜线四通
		{
			DrawInterCross3d(dc);
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrCross3d(AcGiDraw &dc) const
{
	//外直角,内斜线方式
	//内外圆弧的方式2种
	AecHvac::HvacCrossType eTeeType = AecHvac::eOrthoCross;
	m_mapSpecXData.GetAt(HCRS_Type, (int &)eTeeType);

	switch (eTeeType)
	{
	case AecHvac::eInterCross://内斜线四通
	{
		DrawTrInterCross3d(dc);
		break;
	}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawInterCross3d(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();
	AcGeVector3d vtMaj,vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dDn2 = 0;
	double dThick = 0.35,dLx = 50.0,dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	dDn2 = dParam.dSize[3];
	if (dParam.m_app == WPipe::eTrench)
		dDn2 += 2.0 * dParam.dSize[2];

	if (dDn2 < 1.e-6)
		dDn2 = dDn;
	dH = dParam.dSize[1];
	double dL = dDn * dRatio;
	if (dParam.m_app == WPipe::eTrench)
	{
		if (dDn - dL > 1.e-6)
		{
			dL = __min(dDn, dDn2);
		}
	}

	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);


	/*				2    3
					 |   |
				 0___| 4 |___5
					1
				  ___10  7 ___6
				11	 |   |
				   9 |   |8
				*/

	AcGePoint3d ptGe[13];
	AcGePoint3dArray arPts;
	ptGe[0] = ptMid;
	ptGe[0] -= vtMaj * (dL + dLx);
	ptGe[0] -= vtMin * dDn * 0.5;
	arPts.append(ptGe[0]);

	ptGe[1] = ptGe[0] + vtMaj * (dL  + dLx - 0.5 * dDn2);
	ptGe[2] = ptGe[1] - vtMin * (dL  + dLx - 0.5 * dDn);

	InsertL2Point(ptGe[0],ptGe[1],ptGe[2],dLx,arPts);
	arPts.append(ptGe[2]);

	ptGe[3] = ptGe[2] + vtMaj * dDn2;
	arPts.append(ptGe[3]);

	ptGe[4] = ptGe[3] + vtMin * (dL  + dLx - 0.5 * dDn);
	ptGe[5] = ptGe[4] + vtMaj * (dL  + dLx - 0.5 * dDn2);
	InsertL2Point(ptGe[3],ptGe[4],ptGe[5],dLx,arPts);
	arPts.append(ptGe[5]);

	ptGe[6] = ptGe[5] + vtMin * dDn;
	arPts.append(ptGe[6]);

	ptGe[7] = ptGe[6] - vtMaj * (dL  + dLx - 0.5 * dDn2);
	ptGe[8] = ptGe[7] + vtMin * (dL  + dLx - 0.5 * dDn);
	InsertL2Point(ptGe[6],ptGe[7],ptGe[8],dLx,arPts);
	arPts.append(ptGe[8]);

	ptGe[9] = ptGe[8] - vtMaj * dDn2;
	arPts.append(ptGe[9]);

	ptGe[10] = ptGe[9] - vtMin * (dL  + dLx - 0.5 * dDn);
	ptGe[11] = ptGe[10] - vtMaj * (dL  + dLx - 0.5 * dDn2);
	InsertL2Point(ptGe[9],ptGe[10],ptGe[11],dLx,arPts);
	arPts.append(ptGe[11]);
	arPts.append(ptGe[0]);

	//TEST
	/*AcDbPolyline* pPlOut = FormatPolyline(arPts.asArrayPtr(),arPts.length());
	if (pPlOut != NULL)
	{
		pPlOut->setColorIndex(1);
		AddToModelSpace(pPlOut);
	}*/

	AcGePoint3d ptFr,ptTo;
	AcDbLine lnPath;
	AcDbRegion* pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
	if (pRegOut != NULL)
	{
		ptFr = ptMid - vtNorm * 0.5 * dH;//W
		ptTo = ptMid + vtNorm * 0.5 * dH;//W

		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		AcGeMatrix3d xform;
		AcGeVector3d vt = vtNorm * 0.5 * dH;
		xform.setToTranslation(vt);
		pRegOut->transformBy(xform);

		AecDbX3dPart part;

		AcDbX3dSolid* pX3dSolidOut = new AcDbX3dSolid;
		pX3dSolidOut->CreateExtrude(pRegOut,lnPath);
		part.AddX3dSolid(pX3dSolidOut);

		OffsetPoint(ptGe[0],ptGe[11],dThick);
		OffsetPoint(ptGe[2],ptGe[3],dThick);
		OffsetPoint(ptGe[5],ptGe[6],dThick);
		OffsetPoint(ptGe[8],ptGe[9],dThick);

		AcGePoint3d ptTemp = ptMid;
		OffsetPoint(ptGe[1],ptTemp,dThick * 1.41421356);

		ptTemp = ptMid;
		OffsetPoint(ptGe[4],ptTemp,dThick * 1.41421356);

		ptTemp = ptMid;
		OffsetPoint(ptGe[7],ptTemp,dThick * 1.41421356);

		ptTemp = ptMid;
		OffsetPoint(ptGe[10],ptTemp,dThick * 1.41421356);

		arPts.removeAll();

		arPts.append(ptGe[0]);
		InsertL2Point(ptGe[0],ptGe[1],ptGe[2],dLx,arPts);
		arPts.append(ptGe[2]);

		arPts.append(ptGe[3]);
		InsertL2Point(ptGe[3],ptGe[4],ptGe[5],dLx,arPts);
		arPts.append(ptGe[5]);
		
		arPts.append(ptGe[6]);
		InsertL2Point(ptGe[6],ptGe[7],ptGe[8],dLx,arPts);
		arPts.append(ptGe[8]);

		arPts.append(ptGe[9]);
		InsertL2Point(ptGe[9],ptGe[10],ptGe[11],dLx,arPts);
		arPts.append(ptGe[11]);
		arPts.append(ptGe[0]);


		AcDbRegion* pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
		if (pRegIn != NULL)
		{
			if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
				!dParam.m_bCover)
			{
				//水平放置,不带盖子时
				AcGeVector3d vtRegNorm;
				pRegIn->getNormal(vtRegNorm);

				ptFr = ptMid - vtRegNorm * 0.5 * dH;
				ptTo = ptMid + vtRegNorm * 0.5 * (dH - 2.0 * dThick);//W

				lnPath.setStartPoint(ptFr);
				lnPath.setEndPoint(ptTo);

				vt = vtRegNorm * 0.5 * dH;
			}
			else
			{
				ptFr = ptMid - vtNorm * 0.5 * (dH - 2.0 * dThick);//W
				ptTo = ptMid + vtNorm * 0.5 * (dH - 2.0 * dThick);//W

				lnPath.setStartPoint(ptFr);
				lnPath.setEndPoint(ptTo);

				vt = vtNorm * 0.5 * (dH - 2.0 * dThick);
			}

			xform.setToTranslation(vt);
			pRegIn->transformBy(xform);

			AcDbX3dSolid* pX3dSolidIn = new AcDbX3dSolid;
			pX3dSolidIn->CreateExtrude(pRegIn,lnPath);
			part.AddX3dSolid(pX3dSolidIn,AcDb::kBoolSubtract);

			BoolSubtractUserInf3d(part);
			part.Create();

			AcDb3dSolid* pSolid = part.CreateDraw3dSolid();
			if (pSolid != NULL)
			{
				pSolid->setTransparency(tr);
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
			delete pRegIn;
		}
		delete pRegOut;
	}
	return Acad::eOk;
}

static AcDbRegion* MakeCornerWallRegion(AcGePoint3d* pptGe,int nFr,double dt)
{
	assert(pptGe != NULL);
	AcGePoint3d ptGe[8];
	AcGeVector3d vt1 = pptGe[nFr + 1] - pptGe[nFr + 0];
	AcGeVector3d vt2 = pptGe[nFr + 1] - pptGe[nFr + 2];
	vt1.normalize(); vt2.normalize();

	ptGe[0] = pptGe[nFr+0];
	ptGe[1] = pptGe[nFr+1];
	ptGe[2] = pptGe[nFr+2];

	ptGe[3] = ptGe[2] + vt1 * dt;
	ptGe[5] = ptGe[0] + vt2 * dt;
	ptGe[4] = GetIntersectPt(ptGe[3], vt2, ptGe[5], vt1);
	ptGe[6] = ptGe[0];

	AcDbRegion *pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
	return pReg;
}

static void OffsetPoint(AcGePoint3d * pptGe, int nFr, double dOff1, double dOff2)
{
	assert(pptGe != NULL);
	AcGeVector3d vt1 = pptGe[nFr + 1] - pptGe[nFr + 0];
	AcGeVector3d vt2 = pptGe[nFr + 1] - pptGe[nFr + 2];
	vt1.normalize(); vt2.normalize();

	pptGe[nFr + 0] -= vt2 * dOff1;
	pptGe[nFr + 2] -= vt1 * dOff2;
	pptGe[nFr + 1] = GetIntersectPt(pptGe[nFr + 0], vt1, pptGe[nFr + 2], vt2);
}

Acad::ErrorStatus AecDbEcFitting::DrawTrInterCross3d(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();
	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dDn2 = 0;
	double dThick = 0.35, dLx = 50.0, dH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	DlgData data;
	memset(&data, 0, sizeof(DlgData));
	GetDlgData(data, 0);

	dDn = dParam.dSize[0];//D L
	double dL = dDn * dRatio;

	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	dDn2 = dParam.dSize[3];
	if (dParam.m_app == WPipe::eTrench)
		dDn2 += 2.0 * dParam.dSize[2];

	if (dDn2 < 1.e-6)
		dDn2 = dDn;
	dH = dParam.dSize[1];
	
	vtMaj.normalize();
	vtMin.normalize();
	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//一律向下
		vtNorm.set(0, 0, -1);

	/*				2    3
					 |   |
				 0___| 4 |___5
					1
				  ___10  7 ___6
				11	 |   |
				   9 |   |8
				*/

	AcGePoint3d ptGe[13],ptGeI[8];
	AcGePoint3dArray arPts;
	ptGe[0] = ptMid;
	ptGe[0] -= vtMaj * (dL + dLx);
	ptGe[0] -= vtMin * dDn * 0.5;
	arPts.append(ptGe[0]);

	ptGe[1] = ptGe[0] + vtMaj * (dL + dLx - 0.5 * dDn2);
	ptGe[2] = ptGe[1] - vtMin * (dL + dLx - 0.5 * dDn);

	//电缆沟不需要倒角
	arPts.append(ptGe[1]);
	//InsertL2Point(ptGe[0], ptGe[1], ptGe[2], dLx, arPts);
	arPts.append(ptGe[2]);

	ptGe[3] = ptGe[2] + vtMaj * dDn2;
	arPts.append(ptGe[3]);

	ptGe[4] = ptGe[3] + vtMin * (dL + dLx - 0.5 * dDn);
	ptGe[5] = ptGe[4] + vtMaj * (dL + dLx - 0.5 * dDn2);

	//电缆沟不需要倒角
	arPts.append(ptGe[4]);
	//InsertL2Point(ptGe[3], ptGe[4], ptGe[5], dLx, arPts);
	arPts.append(ptGe[5]);

	ptGe[6] = ptGe[5] + vtMin * dDn;
	arPts.append(ptGe[6]);

	ptGe[7] = ptGe[6] - vtMaj * (dL + dLx - 0.5 * dDn2);
	ptGe[8] = ptGe[7] + vtMin * (dL + dLx - 0.5 * dDn);
	//电缆沟不需要倒角
	arPts.append(ptGe[7]);
	//InsertL2Point(ptGe[6], ptGe[7], ptGe[8], dLx, arPts);
	arPts.append(ptGe[8]);

	ptGe[9] = ptGe[8] - vtMaj * dDn2;
	arPts.append(ptGe[9]);

	ptGe[10] = ptGe[9] - vtMin * (dL + dLx - 0.5 * dDn);
	ptGe[11] = ptGe[10] - vtMaj * (dL + dLx - 0.5 * dDn2);

	//电缆沟不需要倒角
	arPts.append(ptGe[10]);
	//InsertL2Point(ptGe[9], ptGe[10], ptGe[11], dLx, arPts);
	arPts.append(ptGe[11]);
	arPts.append(ptGe[0]);

	AecDbX3dPart part;
	AcGePoint3d ptFr, ptTo;
	AcDbLine lnPath;

	//顶板
	AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(), arPts.length());
	if (pRegTop != NULL)
	{
		ptFr = ptMid - vtNorm * 0.5 * dH;//H
		ptTo = ptFr + vtNorm * data.m_dk;//k
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegTop);
		AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
		pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
		part.AddX3dSolid(pX3dSolidTop);
	}

	//墙体1
	AcDbRegion * pRegWall1 = MakeCornerWallRegion(ptGe,0,data.m_dt);
	if (pRegWall1 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall1);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall1, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//墙体2
	pRegWall1 = MakeCornerWallRegion(ptGe, 3, data.m_dt);
	if (pRegWall1 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall1);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall1, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//墙体3
	pRegWall1 = MakeCornerWallRegion(ptGe, 6, data.m_dt);
	if (pRegWall1 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall1);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall1, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//墙体4
	pRegWall1 = MakeCornerWallRegion(ptGe, 9, data.m_dt);
	if (pRegWall1 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall1);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall1, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}
	
	DlgData data2;
	memset(&data2, 0, sizeof(DlgData));
	GetDlgData(data2, 1);

	//底板
	double dOff1 = 0.5 * (data.m_dd - dDn);
	double dOff2 = 0.5 * (data2.m_dd - dDn2);

	OffsetPoint(ptGe, 0, dOff1,dOff2);
	OffsetPoint(ptGe, 3, dOff2,dOff1);
	OffsetPoint(ptGe, 6, dOff1,dOff2);
	OffsetPoint(ptGe, 9, dOff2,dOff1);
	ptGe[12] = ptGe[0];

	AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 13);
	if (pRegBom != NULL)
	{
		ptFr = ptMid + vtNorm * 0.5 * dH;//H
		ptTo = ptFr - vtNorm * data.m_db;//H

		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegBom);
		AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
		pX3dSlabB->CreateExtrude(pRegBom, lnPath);
		part.AddX3dSolid(pX3dSlabB);
	}

	part.Create();
	AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
	if (pSolid != NULL)
	{
		pSolid->setTransparency(tr);
		dc.DrawEntity(pSolid);
		Add3DBuffer(pSolid);
	}
	return Acad::eOk;
}

DLLIMPEXP AcDbCurve *GetMinOffsetCurve(AcDbCurve *pPl, double dOff);
Acad::ErrorStatus AecDbEcFitting::DrawReduce3d(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();
	AcGeVector3d vtMaj,vtMin,vtNorm(0,0,1);
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dL = 0.0,dH = 0.0, dL3 = 0;
	double dThick = 0.35,dW = 0.0,dW1 = 0.0,dt = 0.0;

	int nEcCen = 0;//偏心
	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);
	m_mapSpecXData.GetAt(KEY_L,dL);
	m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
	m_mapSpecXData.GetAt(KEY_ECCEN,nEcCen);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(KEY_L,dL);

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//W H
	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	dH = dParam.dSize[1];//末端
	dt = dParam.dSize[2];//thick
	dW1 = dParam.dSize[3];//开始端
	dL3 = dL / 3.0;
	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();

	AcGeVector3d vtW = vtMaj;
	vtW.rotateBy(PI / 2.0,vtNorm);
	vtW.normalize();

	int nStyle = 0;
	m_mapSpecXData.GetAt(KEY_2DSTYLE, nStyle);

	double dSingleW = 0.0;
	m_mapSpecXData.GetAt(KEY_SINGLEW, dSingleW);

	AcGeLine3d ln(AcGePoint3d::kOrigin,vtNorm);
	AcGePoint3d ptGe[10],ptS,ptE,ptGeI[10];
	int nPoints = 0,nS = 0,nE = 0;
	CUIntArray arOff1, arOff2;

	if (ln.isPerpendicularTo(AcGePlane::kXYPlane))//水平放置
	{
		ptGe[0] = ptMid;
		ptGe[0] -= vtMaj * 0.5 * dL;
		ptGe[0] += vtW * 0.5 * dW1;

		if (nEcCen == 0)
		{
			ptGe[3] = ptMid;
			ptGe[3] += vtMaj * 0.5 * dL;
			ptGe[3] += vtW * 0.5 * dDn;

			ptGe[1] = ptGe[0] + vtMaj * dL3;
			ptGe[2] = ptGe[3] - vtMaj * dL3;

			ptGe[4] = ptGe[3] - vtW * dDn;
			ptGe[5] = ptGe[2] - vtW * dDn;

			ptGe[6] = ptGe[1] - vtW * dW1;
			ptGe[7] = ptGe[0] - vtW * dW1;
			ptGe[8] = ptGe[0];

			nPoints = 9;
			nS = 4;
			nE = 4;

			ptS = MidPoint(ptGe[0], ptGe[7]);
			ptE = MidPoint(ptGe[3], ptGe[4]);

			memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 10);

			OffsetPoint(ptGeI[0], ptGeI[7], dThick);
			OffsetPoint(ptGeI[1], ptGeI[6], dThick);
			OffsetPoint(ptGeI[2], ptGeI[5], dThick);
			OffsetPoint(ptGeI[3], ptGeI[4], dThick);
			ptGeI[8] = ptGeI[0];
		}
		else if (nEcCen == 1)
		{
			ptGe[1] = ptGe[0] + vtMaj * dL;

			ptGe[2] = ptGe[1] - vtW * dDn;
			ptGe[3] = ptGe[2] - vtMaj * dL3;

			ptGe[5] = ptGe[0] - vtW * dW1;
			ptGe[4] = ptGe[5] + vtMaj * dL3;

			ptGe[6] = ptGe[0];

			nPoints = 7;
			nS = 2;
			nE = 4;

			ptS = MidPoint(ptGe[0], ptGe[5]);
			ptE = MidPoint(ptGe[1], ptGe[2]);

			memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 10);
			OffsetPoint(ptGeI[0], ptGeI[5], dThick);
			OffsetPoint(ptGeI[1], ptGeI[2], dThick);
			ptGeI[3] = ptGeI[2] - vtMaj * dL3;
			ptGeI[4] = ptGeI[5] + vtMaj * dL3;
			ptGeI[6] = ptGeI[0];
		}
		else if (nEcCen == 2)
		{
			ptGe[3] = ptMid;
			ptGe[3] -= vtMaj * 0.5 * dL;
			ptGe[3] -= vtW * 0.5 * dW1;
			ptGe[3] += vtMaj * dL;
			ptGe[3] += vtW * dDn;

			ptGe[2] = ptGe[3] - vtMaj * dL3;
			ptGe[1] = ptGe[0] + vtMaj * dL3;

			ptGe[4] = ptGe[3] - vtW * dDn;
			ptGe[5] = ptGe[0] - vtW * dW1;

			ptGe[6] = ptGe[0];

			nPoints = 7;
			nS = 4;
			nE = 2;

			ptS = MidPoint(ptGe[0], ptGe[5]);
			ptE = MidPoint(ptGe[3], ptGe[4]);

			memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 10);
			OffsetPoint(ptGeI[0], ptGeI[5], dThick);
			OffsetPoint(ptGeI[3], ptGeI[4], dThick);
			ptGeI[2] = ptGeI[3] - vtMaj * dL3;
			ptGeI[1] = ptGeI[0] + vtMaj * dL3;
			ptGeI[6] = ptGeI[0];
		}

		AcGePoint3d ptFr,ptTo,ptTmp;
		AcDbLine lnPath;
		AcDbRegion* pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,nPoints);
		if (pRegOut != NULL)
		{
			ptFr = ptMid - vtNorm * 0.5 * dH;//W
			ptTo = ptMid + vtNorm * 0.5 * dH;//W

			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			AcGeMatrix3d xform;
			AcGeVector3d vt = vtNorm * 0.5 * dH;
			xform.setToTranslation(vt);
			pRegOut->transformBy(xform);

			AecDbX3dPart part;
			AcDbX3dSolid* pX3dSolidOut = new AcDbX3dSolid;
			pX3dSolidOut->CreateExtrude(pRegOut,lnPath);
			part.AddX3dSolid(pX3dSolidOut);

			AcDbRegion* pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, nPoints);
			if (pRegIn != NULL)
			{
				if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
					!dParam.m_bCover)
				{
					//水平放置,不带盖子时
					AcGeVector3d vtRegNorm;
					pRegIn->getNormal(vtRegNorm);

					ptFr = ptMid - vtRegNorm * 0.5 * dW;
					ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtRegNorm * 0.5 * dW;
				}
				else
				{
					ptFr = ptMid - vtNorm * 0.5 * (dH - 2.0 * dThick);//W
					ptTo = ptMid + vtNorm * 0.5 * (dH - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtNorm * 0.5 * (dH - 2.0 * dThick);
				}
				
				xform.setToTranslation(vt);
				pRegIn->transformBy(xform);

				AcDbX3dSolid* pX3dSolidIn = new AcDbX3dSolid;
				pX3dSolidIn->CreateExtrude(pRegIn,lnPath);
				part.AddX3dSolid(pX3dSolidIn,AcDb::kBoolSubtract);

				BoolSubtractUserInf3d(part);
				part.Create();

				AcDb3dSolid* pSolid = part.CreateDraw3dSolid();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(tr);
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
				delete pRegIn;
			}
			delete pRegOut;
		}
	}
	else
	{
		if ( ln.isParallelTo(AcGePlane::kXYPlane))//垂直放置 绘制 []形状
		{

		}
		else
		{
			//...
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrReduce3d(AcGiDraw &dc) const
{
	AcCmTransparency tr = transparency();
	AcGeVector3d vtMaj, vtMin, vtNorm(0, 0, 1);
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dL = 0.0, dH = 0.0;
	double dThick = 0.35, dW = 0.0, dW1 = 0.0, dt = 0.0;

	int nEcCen = 0;//偏心
	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);
	m_mapSpecXData.GetAt(KEY_L, dL);
	m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
	m_mapSpecXData.GetAt(KEY_ECCEN, nEcCen);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(KEY_L, dL);

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	DlgData data;
	memset(&data, 0, sizeof(DlgData));
	GetDlgData(data, 0);

	DlgData data2;
	memset(&data2, 0, sizeof(DlgData));
	GetDlgData(data2, 1);

	dDn = dParam.dSize[0];//W H
	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	dH = dParam.dSize[1];//末端
	dW = dH;
	dt = dParam.dSize[2];//thick
	dW1 = dParam.dSize[3];//开始端
	if (dParam.m_app == WPipe::eTrench)
		dW1 += 2.0 * dParam.dSize[2];

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();

	AcGeVector3d vtW = vtMaj;
	vtW.rotateBy(PI / 2.0, vtNorm);
	vtW.normalize();
	vtNorm.negate();

	AcGePoint3d ptGe[6], ptGeI[6],ptFr,ptTo;
	ptGe[0] = ptMid;
	ptGe[0] -= vtMaj * 0.5 * dL;
	ptGe[0] += vtW * 0.5 * dW1;

	ptGe[1] = ptMid;
	ptGe[1] += vtMaj * 0.5 * dL;
	ptGe[1] += vtW * 0.5 * dDn;

	ptGe[2] = ptGe[1] - vtW * dDn;
	ptGe[3] = ptGe[0] - vtW * dW1;
	ptGe[4] = ptGe[0];

	//顶板
	AcDbLine lnPath;
	AecDbX3dPart part;

	//顶板
	AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
	if (pRegTop != NULL)
	{
		ptFr = ptMid - vtNorm * 0.5 * dH;//H
		ptTo = ptFr + vtNorm * data.m_dk;//k
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegTop);
		AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
		pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
		part.AddX3dSolid(pX3dSolidTop);
	}

	//墙体1
	ptGeI[0] = ptGe[0];
	ptGeI[1] = ptGe[1];

	ptGeI[2] = ptGeI[1];
	ptGeI[2] -= vtW * data.m_dt;

	ptGeI[3] = ptGeI[0];
	ptGeI[3] -= vtW * data.m_dt;
	ptGeI[4] = ptGeI[0];

	AcDbRegion *pRegWall1 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
	if (pRegWall1 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall1);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall1, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//墙体2
	ptGeI[0] = ptGe[2];
	ptGeI[1] = ptGe[3];

	ptGeI[2] = ptGeI[1];
	ptGeI[2] += vtW * data.m_dt;

	ptGeI[3] = ptGeI[0];
	ptGeI[3] += vtW * data.m_dt;
	ptGeI[4] = ptGeI[0];

	AcDbRegion *pRegWall2 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
	if (pRegWall2 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall2);
		AcDbX3dSolid *pX3dWall2 = new AcDbX3dSolid;
		pX3dWall2->CreateExtrude(pRegWall2, lnPath);
		part.AddX3dSolid(pX3dWall2);
	}

	//底板
	ptGe[0] += 0.5 * (data.m_dd - dW1) * vtW;
	ptGe[1] += 0.5 * (data2.m_dd - dDn) * vtW;
	ptGe[2] -= 0.5 * (data.m_dd - dDn) * vtW;
	ptGe[3] -= 0.5 * (data2.m_dd - dW1) * vtW;
	ptGe[4] = ptGe[0];

	AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
	if (pRegBom != NULL)
	{
		ptFr = ptMid + vtNorm * 0.5 * dH;//H
		ptTo = ptFr - vtNorm * data.m_db;//H

		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegBom);
		AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
		pX3dSlabB->CreateExtrude(pRegBom, lnPath);
		part.AddX3dSolid(pX3dSlabB);
	}

	part.Create();
	AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
	if (pSolid != NULL)
	{
		pSolid->setTransparency(tr);
		dc.DrawEntity(pSolid);
		Add3DBuffer(pSolid);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawOffset3d(AcGiDraw &dc) const
{
	//两个弯头,且水平放置,或垂直放置
	//90 < A < 180.0 乙字弯角度

	AcCmTransparency tr = transparency();
	assertReadEnabled();

	AcGeVector3d vtMaj,vtMin,vtNorm,vtOffset;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
	double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0;
	double dOffsetH = 0.0;//偏西距离

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
	m_mapSpecXData.GetAt(KEY_OFFSETDIR,vtOffset);//偏移方向
	//vtMaj == vtMin

	m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
	m_mapSpecXData.GetAt(KEY_Offset,dOffsetH);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	if (dThick < 1.e-6)
		dThick = 5.0;//至少5mm

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[0];//D L
	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	double dH = dParam.dSize[1];//H
	double dR = dDn * dRatio;
	dW = dParam.dSize[1];//

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();
	vtOffset.normalize();

	//偏移方向的反方向
	AcGeVector3d vtV = vtOffset;//Maj->Min的方向
	vtV = vtV.orthoProject(vtMaj);//MAKE SURE
	vtV.negate();
	vtV.normalize();

	if (dOffsetH < 1.e-6)
	{
		acutPrintf(_T("\nOffset dist error!"));
		return Acad::eOk;
	}

	//乙字弯角度 90 < A < 180
	if ( ( dSweepAngle - 90.0 ) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
	{
		//转化为弧度
		dSweepAngle *= PI / 180.0;

		//玄段长度
		double dChrodx = dR * tan(dSweepAngle * 0.5);

		//斜段总桥架长度
		double dLseg = dOffsetH / sin(dSweepAngle);//180-a

		//投影到maj方向上 总长
		double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
		dL += dChrodx * 2.0;

		//伞心中最大对角线长
		double dAL = sqrt(dR * dR + dChrodx * dChrodx);

		AcGePoint3d ptGeCen[4];

		ptGeCen[0] = ptMid - vtMaj * 0.5 * dL;
		ptGeCen[0] += vtV * 0.5 * dOffsetH;

		ptGeCen[1] = ptGeCen[0] + vtMaj * dChrodx;

		AcGeVector3d vtMidL = ptMid - ptGeCen[1];
		vtMidL.normalize();
		ptGeCen[2] = ptGeCen[1] + vtMidL * dLseg;
		ptGeCen[3] = ptGeCen[2] + vtMin * dChrodx;

		AcGeLine3d ln3d;
		ln3d.set(AcGePoint3d::kOrigin,vtNorm);

		//确定拉伸方向的尺寸
		double dh = dDn;
		if (ln3d.isParallelTo(AcGePlane::kXYPlane))//和XY面平行,立着放置
		{
			dh = dDn;
			dDn = dParam.dSize[1];
		}
		else if (ln3d.isPerpendicularTo(AcGePlane::kXYPlane))//和XY面垂直,水平放置
		{
			dh = dH;
		}
		else
		{
			//..
			return Acad::eOk;
		}

		//计算
		AcGeVector3d vt1,vt2,vt3,vt4;
		AcGePoint3d ptGe[10];

		ptGe[0] = ptGeCen[0];
		ptGe[0] += vtV * 0.5 * dDn;

		vt1 = ptGeCen[0] - ptGeCen[1];
		vt2 = ptGeCen[2] - ptGeCen[1];
		vt1.normalize();
		vt2.normalize();

		vt3 = vt1 + vt2;
		vt3.normalize(); 

		double dLA = 0.5 * dDn / sin(dSweepAngle * 0.5);
		vt3 *= dLA;
		vt3.negate();

		ptGe[1] = ptGeCen[1] + vt3;
		ptGe[2] = ptGe[1] + vtMidL * dLseg;

		ptGe[3] = ptGeCen[2] + vtMin * dChrodx;
		ptGe[3] += vtV * 0.5 * dDn;

		ptGe[4] = ptGe[3] - dDn * vtV;
		
		vt1 = ptGeCen[1] - ptGeCen[2];
		vt2 = ptGeCen[3] - ptGeCen[2];
		vt1.normalize();
		vt2.normalize();

		vt4 = vt1 + vt2;
		vt4.normalize();
		vt4 *= dLA;
		vt4.negate();

		ptGe[5] = ptGeCen[2] + vt4;

		ptGe[6] = ptGe[5] - vtMidL * dLseg;

		ptGe[7] = ptGe[0] - vtV * dDn;
		ptGe[8] = ptGe[0];

		AcGePoint3d ptGeB[9];
		memcpy(ptGeB,ptGe,sizeof(AcGePoint3d) * 9);

		//A移到顶
		for(int i = 0;i < 9;i++ )
		{
			ptGeB[i] += vtNorm * 0.5 * dh;
		}

		AcDbLine lnPath;
		AcGePoint3d ptS,ptE;
		ptS = ptMid;
		ptS += vtNorm * 0.5 * dh;
		ptE = ptMid;
		ptE -= vtNorm * 0.5 * dh;
		lnPath.setStartPoint(ptS);
		lnPath.setEndPoint(ptE);

		AcDbRegion* pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeB,9);
		if (pRegOut != NULL)
		{
			AecDbX3dPart part;
			AcDbX3dSolid* pX3dSolidOut = new AcDbX3dSolid;
			pX3dSolidOut->CreateExtrude(pRegOut,lnPath);
			part.AddX3dSolid(pX3dSolidOut);

			//根据A,下调一个厚度
			if (dParam.m_bCover)
			{
				for(int i = 0;i < 9;i++)
				{
					ptGeB[i] -= vtNorm * dThick;
				}
			}

			OffsetPoint(ptGeB[0],ptGeB[7],dThick);
			ptGeB[8] = ptGeB[0];

			OffsetPoint(ptGeB[3],ptGeB[4],dThick);
			
			OffsetPoint(ptGeB[1],ptGeB[6],dThick / sin(dSweepAngle * 0.5) );
			OffsetPoint(ptGeB[2],ptGeB[5],dThick / sin(dSweepAngle * 0.5) );

			AcDbRegion* pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeB,9);

			if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
				!dParam.m_bCover && pRegIn != NULL)
			{
				//水平放置,不带盖子时
				AcGeVector3d vtRegNorm;
				pRegIn->getNormal(vtRegNorm);

				//水平不带盖子
				ptS = ptMid;
				ptS += vtRegNorm * 0.5 * dh;
				ptE = ptMid;
				ptE -= vtRegNorm * (0.5 * dh - dThick);
				lnPath.setStartPoint(ptS);
				lnPath.setEndPoint(ptE);
			}
			else
			{
				ptS = ptMid;
				ptS += vtNorm * (0.5 * dh - dThick);
				ptE = ptMid;
				ptE -= vtNorm * (0.5 * dh - dThick);
				lnPath.setStartPoint(ptS);
				lnPath.setEndPoint(ptE);
			}

			if (pRegIn != NULL)
			{
				AcDbX3dSolid* pX3dSolidIn = new AcDbX3dSolid;
				pX3dSolidIn->CreateExtrude(pRegIn,lnPath);
				part.AddX3dSolid(pX3dSolidIn,AcDb::kBoolSubtract);

				BoolSubtractUserInf3d(part);
				part.Create();

				AcDb3dSolid* pSolid = part.CreateDraw3dSolid();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(tr);
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
				delete pRegIn;
			}
			delete pRegOut;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrOffset3d(AcGiDraw &dc) const
{
	//两个弯头,且水平放置,或垂直放置
	//90 < A < 180.0 乙字弯角度

	AcCmTransparency tr = transparency();
	assertReadEnabled();

	AcGeVector3d vtMaj, vtMin, vtNorm, vtOffset;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0;
	double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0;
	double dOffsetH = 0.0;//偏西距离

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);//进口方向
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);//出口方向
	m_mapSpecXData.GetAt(KEY_OFFSETDIR, vtOffset);//偏移方向
	//vtMaj == vtMin

	m_mapSpecXData.GetAt(KEY_NORMAL, vtNorm);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);//中间点
	m_mapSpecXData.GetAt(KEY_Offset, dOffsetH);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	if (dThick < 1.e-6)
		dThick = 5.0;//至少5mm

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	DlgData data;
	memset(&data, 0, sizeof(DlgData));
	GetDlgData(data, 0);

	dDn = dParam.dSize[0];//D L
	double dR = dDn * dRatio;
	if (dParam.m_app == WPipe::eTrench)
		dDn += 2.0 * dParam.dSize[2];

	double dH = dParam.dSize[1];//H
	dW = dParam.dSize[1];//

	vtMaj.normalize();
	vtMin.normalize();
	vtNorm.normalize();
	vtOffset.normalize();

	//偏移方向的反方向
	AcGeVector3d vtV = vtOffset;//Maj->Min的方向
	vtV = vtV.orthoProject(vtMaj);//MAKE SURE
	vtV.negate();
	vtV.normalize();

	if (dOffsetH < 1.e-6)
	{
		acutPrintf(_T("\nOffset dist error!"));
		return Acad::eOk;
	}

	//乙字弯角度 90 < A < 180
	if ((dSweepAngle - 90.0) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
	{
		//转化为弧度
		dSweepAngle *= PI / 180.0;

		//玄段长度
		double dChrodx = dR * tan(dSweepAngle * 0.5);

		//斜段总桥架长度
		double dLseg = dOffsetH / sin(dSweepAngle);//180-a

		//投影到maj方向上 总长
		double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
		dL += dChrodx * 2.0;

		//伞心中最大对角线长
		double dAL = sqrt(dR * dR + dChrodx * dChrodx);

		AcGePoint3d ptGeCen[4];

		ptGeCen[0] = ptMid - vtMaj * 0.5 * dL;
		ptGeCen[0] += vtV * 0.5 * dOffsetH;

		ptGeCen[1] = ptGeCen[0] + vtMaj * dChrodx;

		AcGeVector3d vtMidL = ptMid - ptGeCen[1];
		vtMidL.normalize();
		ptGeCen[2] = ptGeCen[1] + vtMidL * dLseg;
		ptGeCen[3] = ptGeCen[2] + vtMin * dChrodx;

		AcGeLine3d ln3d;
		ln3d.set(AcGePoint3d::kOrigin, vtNorm);

		//确定拉伸方向的尺寸
		double dh = dDn;
		if (ln3d.isPerpendicularTo(AcGePlane::kXYPlane))//和XY面垂直,缆沟水平放置
		{
			dh = dH;
		}
		else
		{
			//..
			return Acad::eOk;
		}

		//计算
		AcGeVector3d vt1, vt2, vt3, vt4;
		AcGePoint3d ptGe[10];

		ptGe[0] = ptGeCen[0];
		ptGe[0] += vtV * 0.5 * dDn;

		vt1 = ptGeCen[0] - ptGeCen[1];
		vt2 = ptGeCen[2] - ptGeCen[1];
		vt1.normalize();
		vt2.normalize();

		vt3 = vt1 + vt2;
		vt3.normalize();

		double dLA = 0.5 * dDn / sin(dSweepAngle * 0.5);
		vt3 *= dLA;
		vt3.negate();

		ptGe[1] = ptGeCen[1] + vt3;
		ptGe[2] = ptGe[1] + vtMidL * dLseg;

		ptGe[3] = ptGeCen[2] + vtMin * dChrodx;
		ptGe[3] += vtV * 0.5 * dDn;

		ptGe[4] = ptGe[3] - dDn * vtV;

		vt1 = ptGeCen[1] - ptGeCen[2];
		vt2 = ptGeCen[3] - ptGeCen[2];
		vt1.normalize();
		vt2.normalize();

		vt4 = vt1 + vt2;
		vt4.normalize();
		vt4 *= dLA;
		vt4.negate();

		ptGe[5] = ptGeCen[2] + vt4;

		ptGe[6] = ptGe[5] - vtMidL * dLseg;

		ptGe[7] = ptGe[0] - vtV * dDn;
		ptGe[8] = ptGe[0];

		//向下
		vtNorm.negate();

		//顶板
		AecDbX3dPart part;
		AcGePoint3d ptFr, ptTo;
		AcDbLine lnPath;

		//顶板
		AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 9);
		if (pRegTop != NULL)
		{
			ptFr = ptMid - vtNorm * 0.5 * dH;//H
			ptTo = ptFr + vtNorm * data.m_dk;//k
			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			MoveRegion(ptFr - ptMid, pRegTop);
			AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
			pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
			part.AddX3dSolid(pX3dSolidTop);
		}

		AcGePoint3d ptGeB[9],ptGeW[9];
		memcpy(ptGeB, ptGe, sizeof(AcGePoint3d) * 9);

		//侧墙1
		OffsetPoint(ptGeB[0], ptGeB[7], dThick);
		ptGeB[8] = ptGeB[0];

		OffsetPoint(ptGeB[3], ptGeB[4], dThick);

		OffsetPoint(ptGeB[1], ptGeB[6], dThick / sin(dSweepAngle * 0.5));
		OffsetPoint(ptGeB[2], ptGeB[5], dThick / sin(dSweepAngle * 0.5));

		memcpy(ptGeW, ptGe, sizeof(AcGePoint3d) * 9);
		ptGeW[4] = ptGeB[3];
		ptGeW[5] = ptGeB[2];
		ptGeW[6] = ptGeB[1];
		ptGeW[7] = ptGeB[0];
		ptGeW[8] = ptGeW[0];

		AcDbRegion *pRegWall = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 9);
		if (pRegWall != NULL)
		{
			ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
			ptTo = ptFr + vtNorm * data.m_dH;//H
			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			MoveRegion(ptFr - ptMid, pRegWall);
			AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
			pX3dWall1->CreateExtrude(pRegWall, lnPath);
			part.AddX3dSolid(pX3dWall1);
		}

		//侧墙2
		memcpy(ptGeW, ptGe, sizeof(AcGePoint3d) * 9);
		ptGeW[0] = ptGeB[7];
		ptGeW[1] = ptGeB[6];
		ptGeW[2] = ptGeB[5];
		ptGeW[3] = ptGeB[4];

		ptGeW[4] = ptGe[4];
		ptGeW[5] = ptGe[5];
		ptGeW[6] = ptGe[6];
		ptGeW[7] = ptGe[7];
		ptGeW[8] = ptGeW[0];

		AcDbRegion *pRegWall2 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeW, 9);
		if (pRegWall != NULL)
		{
			ptFr = ptMid - vtNorm * (0.5 * dH - data.m_dk);//H
			ptTo = ptFr + vtNorm * data.m_dH;//H
			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			MoveRegion(ptFr - ptMid, pRegWall2);
			AcDbX3dSolid *pX3dWall2 = new AcDbX3dSolid;
			pX3dWall2->CreateExtrude(pRegWall2, lnPath);
			part.AddX3dSolid(pX3dWall2);
		}

		//底板
		memcpy(ptGeB, ptGe, sizeof(AcGePoint3d) * 9);
		dThick = -0.5 * (data.m_dd - dDn);

		OffsetPoint(ptGeB[7], ptGeB[0], dThick);
		ptGeB[8] = ptGeB[0];

		OffsetPoint(ptGeB[4], ptGeB[3], dThick);

		OffsetPoint(ptGeB[6], ptGeB[1], dThick / sin(dSweepAngle * 0.5));
		OffsetPoint(ptGeB[5], ptGeB[2], dThick / sin(dSweepAngle * 0.5));

		AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeB, 9);
		if (pRegBom != NULL)
		{
			ptFr = ptMid + vtNorm * 0.5 * dH;//H
			ptTo = ptFr - vtNorm * data.m_db;//H

			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			MoveRegion(ptFr - ptMid, pRegBom);
			AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
			pX3dSlabB->CreateExtrude(pRegBom, lnPath);
			part.AddX3dSolid(pX3dSlabB);
		}

		part.Create();
		AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
		if (pSolid != NULL)
		{
			pSolid->setTransparency(tr);
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}
	}
	return Acad::eOk;
}

void AecDbEcFitting::DrawInfCircle(AcGiDraw &dc,AcDbArc* pArcElbow,double dR,int nStyle) const
{
	assertReadEnabled();

	if (pArcElbow != NULL)
	{
		double dSta = 0.0,dEnd = 0.0;
		pArcElbow->getStartParam(dSta);
		pArcElbow->getEndParam(dEnd);

		AcGePoint3d ptSta,ptEnd;
		pArcElbow->getStartPoint(ptSta);
		pArcElbow->getEndPoint(ptEnd);

		//一阶求导
		AcGeVector3d vt1,vt2;
		pArcElbow->getFirstDeriv(dSta,vt1);//方向指向有弧侧
		pArcElbow->getFirstDeriv(dEnd,vt2);//方向指向无弧侧
		vt1.negate();//方向指向无弧侧

		//端面向上 画圆
		if (vt1.isCodirectionalTo(AcGeVector3d::kZAxis))
		{
			AcDbCircle* pCir = new AcDbCircle;
			pCir->setCenter(ptSta);
			pCir->setRadius(dR);
			pCir->setLayer(pArcElbow->layerId());
			pCir->setNormal(AcGeVector3d::kZAxis);
			dc.DrawEntity(pCir);
			Add2DBuffer(pCir);
			return;
		}

		if (vt2.isCodirectionalTo(AcGeVector3d::kZAxis))
		{
			AcDbCircle* pCir = new AcDbCircle;
			pCir->setCenter(ptEnd);
			pCir->setRadius(dR);
			pCir->setLayer(pArcElbow->layerId());
			pCir->setNormal(AcGeVector3d::kZAxis);
			dc.DrawEntity(pCir);
			Add2DBuffer(pCir);
			return;
		}

		double dOpenAng = PI / 12.0;
		if (nStyle == 2)//单线
		{
			dOpenAng = PI / 2.0;
		}

		//端面向下 画弧
		AcGePoint3d ptGe[3];
		if (vt1.isCodirectionalTo(-AcGeVector3d::kZAxis))
		{
			vt2 = ptEnd - ptSta;
			vt2.z = 0.0;
			vt2.normalize();
			vt2.rotateBy(dOpenAng,AcGeVector3d::kZAxis);

			ptGe[0] = ptSta + dR * vt2;
			vt2.rotateBy(-2.0 * dOpenAng,AcGeVector3d::kZAxis);
			ptGe[2] = ptSta + dR * vt2;

			vt2 = ptSta - ptEnd;
			vt2.z = 0.0;
			vt2.normalize();
			ptGe[1] = ptSta + dR * vt2;

			AcDbArc* pArc = KTCADUtilityEx::FormatArc(ptGe[0],ptGe[1],ptGe[2]);
			if (pArc != NULL)
			{
				pArc->setLayer(pArcElbow->layerId());
				pArc->setNormal(AcGeVector3d::kZAxis);
				pArc->setCenter(ptSta);
				dc.DrawEntity(pArc);
				Add2DBuffer(pArc);
			}
			return;
		}

		if (vt2.isCodirectionalTo(-AcGeVector3d::kZAxis))
		{
			vt1 = ptSta - ptEnd;
			vt1.z = 0.0;
			vt1.normalize();
			vt1.rotateBy(dOpenAng,AcGeVector3d::kZAxis);

			ptGe[0] = ptEnd + dR * vt1;
			vt1.rotateBy(-2.0 * dOpenAng,AcGeVector3d::kZAxis);
			ptGe[2] = ptEnd + dR * vt1;

			vt1 = ptEnd - ptSta;
			vt1.z = 0.0;
			vt1.normalize();
			ptGe[1] = ptEnd + dR * vt1;

			AcDbArc* pArc = KTCADUtilityEx::FormatArc(ptGe[0],ptGe[1],ptGe[2]);
			if (pArc != NULL)
			{
				pArc->setLayer(pArcElbow->layerId());
				pArc->setNormal(AcGeVector3d::kZAxis);
				pArc->setCenter(ptEnd);
				dc.DrawEntity(pArc);
				Add2DBuffer(pArc);
			}
			return;
		}
	}
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcGeVector3d vtMaj,vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
	double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dDn2 = 0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);

	int nElbowStyle = 0;
	m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[3];
	dDn2 = dParam.dSize[0];
	if (dDn < 1.e-6) dDn = dDn2;

	dL = GetElbowL(&dParam);
	dW = dParam.dSize[1];

	vtMaj.normalize();
	vtMin.normalize();

	AcGePoint3d ptGe[8],ptGeU[6];
	AcGeVector3d vtNormal = vtMin.crossProduct(vtMaj);
	if (vtNormal.isParallelTo(AcGeVector3d::kZAxis))//水平放置
	{
		AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
		AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
		vtMV.normalize();
		vtNV.normalize(); 

		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[0] -= vtMV * 0.5 * dDn;

		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;
		ptGe[2] -= vtNV * 0.5 * dDn2;

		AcGeLine3d ln1(ptGe[0],vtMaj);
		AcGeLine3d ln2(ptGe[2],vtMin);
		ln1.intersectWith(ln2,ptGe[1]);

		ptGe[3] = ptGe[2] + vtNV * dDn2;
		ptGe[4] = ptGe[3] - vtMin * dLx;

		ptGe[6] = ptGe[0] + vtMV * dDn;
		ptGe[5] = ptGe[6] - vtMaj * dLx;

		ptGe[7] = ptGe[0];

		BOOL bHide = FALSE;
		m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

		AcDbPolyline *pPl = NULL;
		if (!bHide)
		{
			pPl = FormatPolyline(ptGe,8);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
		else
		{
			AcGePoint3d *ptGe2 = ptGe;
			pPl = FormatPolyline(ptGe2, 3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
			AcGePoint3d *ptGe3 = ptGe;
			ptGe3 += 3;//->3

			pPl = FormatPolyline(ptGe3, 4);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}

		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[1] = ptMid;
		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;

		if (nCenNDraw == FALSE)
		{
			pPl = FormatPolyline(ptGe,3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());
				pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
	}
	else
	{
		//有一个向量平行 Z
		if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
			vtMin.isParallelTo(AcGeVector3d::kZAxis))
		{
			AcGeVector3d vtH, vtV;

			//弯头类型
			switch (nElbowStyle)
			{
				case 0://垂直上弯
				case 1://垂直下弯
				{
					if (vtMin.isParallelTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtMaj;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtMin;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
	
					//简易画法
					ptGe[0] = ptMid;
					ptGe[0] += vtH * dL;

					ptGe[1] = ptMid;
					ptGe[1] -= vtH * 0.5 * dW;

					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[1] += vtV * 0.5 * dDn;

					ptGe[2] = ptGe[1] - vtV * dDn;
					ptGe[3] = ptGe[0] - vtV * dDn;
					ptGe[4] = ptGe[0];

					AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					ptGe[0] = ptMid;
					ptGe[0] += vtH * 0.5 * dW;

					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[1] = ptGe[0] - vtV * dDn;

					AcDbLine *pLn = new AcDbLine(ptGe[0], ptGe[1]);
					pLn->setLayer(layerId());

					dc.DrawEntity(pLn);
					Add2DBuffer(pLn);

					break;
				}
				case 2://垂直左上弯
				{
					if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					ptGe[0] = ptMid;
					ptGe[0] += vtH * dL;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
					ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
					ptGe[4] = ptGe[0];

					AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] += vtV * 0.5 * dW;

					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] - vtV * dW;
					ptGeU[3] = ptGeU[0] - vtV * dW;
					ptGeU[4] = ptGeU[0];

					pPl = FormatPolyline(ptGeU, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
							pPl->setLayer(this->GetDashLayer());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
					break;
				}
				case 3://垂直右上弯
				{
					if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//简易画法
					ptGe[0] = ptMid;
					ptGe[0] += vtH * dL;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
					ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
					ptGe[4] = ptGe[0];

					AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] += vtV * 0.5 * dW;

					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] - vtV * dW;
					ptGeU[3] = ptGeU[0] - vtV * dW;
					ptGeU[4] = ptGeU[0];

					pPl = FormatPolyline(ptGeU, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
							pPl->setLayer(this->GetDashLayer());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}
					break;
				}
				case 4://垂直左下弯
				{
					if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//简易画法
					ptGe[0] = ptMid;
					ptGe[0] += vtH * dL;
					ptGe[0] += vtV * 0.5 * dW;
					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dW;

					ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
					ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
					ptGe[4] = ptGe[0];

					AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] += vtV * 0.5 * dW;

					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] - vtV * dW;
					ptGeU[3] = ptGeU[0] - vtV * dW;
					ptGeU[4] = ptGeU[0];

					pPl = FormatPolyline(ptGeU, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
							pPl->setLayer(this->GetDashLayer());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					break;
				}
				case 5://垂直右下弯
				{
					if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//简易画法
					ptGe[0] = ptMid;
					ptGe[0] += vtH * dL;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - vtH * (dL + 0.5 * dDn);
					ptGe[3] = ptGe[0] - vtH * (dL + 0.5 * dDn);
					ptGe[4] = ptGe[0];

					AcDbPolyline *pPl = FormatPolyline(ptGe, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] += vtV * 0.5 * dW;

					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] - vtV * dW;
					ptGeU[3] = ptGeU[0] - vtV * dW;
					ptGeU[4] = ptGeU[0];

					pPl = FormatPolyline(ptGeU, 5);
					if (pPl != NULL)
					{
						pPl->setLayer(layerId());
						if (!vtV.isCodirectionalTo(AcGeVector3d::kZAxis))
							pPl->setLayer(this->GetDashLayer());

						dc.DrawEntity(pPl);
						Add2DBuffer(pPl);
					}

					break;
				}
				default:
					break;
			}
		}
		else
		{
			//空间倾斜不考虑
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrIncline2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0;
	double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dDn2=0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	int nCenNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW, nCenNDraw);

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn2 = dParam.dSize[0];//末端
	dW = dParam.dSize[1]; //H
	dDn = dParam.dSize[3];//开始端
	if (dDn < 1.e-1) dDn = dDn2;

	//dL = dDn * dRatio + dLx;
	dL = GetElbowL(&dParam);

	vtMaj.normalize();
	vtMin.normalize();

	AcGePoint3d ptGe[8],ptGeL[8];
	AcGeVector3d vtNormal = vtMin.crossProduct(vtMaj);
	if (vtNormal.isParallelTo(AcGeVector3d::kZAxis))//电缆沟水平放置
	{
		AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
		AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
		vtMV.normalize();
		vtNV.normalize();

		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[0] -= vtMV * 0.5 * dDn;

		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;
		ptGe[2] -= vtNV * 0.5 * dDn2;

		AcGeLine3d ln1(ptGe[0], vtMaj);
		AcGeLine3d ln2(ptGe[2], vtMin);
		ln1.intersectWith(ln2, ptGe[1]);

		ptGe[3] = ptGe[2] + vtNV * dDn2;
		ptGe[4] = ptGe[3] - vtMin * dLx;

		ptGe[6] = ptGe[0] + vtMV * dDn;
		ptGe[5] = ptGe[6] - vtMaj * dLx;

		ptGe[7] = ptGe[0];

		//电缆沟直角结构!
		memcpy(ptGeL, ptGe, sizeof(AcGePoint3d) * 8);
		ptGeL[4] = GetIntersectPt(ptGe[3], vtMin, ptGe[6], vtMaj);
		ptGeL[5] = ptGe[6];
		ptGeL[6] = ptGeL[0];

		BOOL bHide = FALSE;
		m_mapSpecXData.GetAt(KEY_HIDEEND, bHide);

		AcDbPolyline *pPl = NULL;
		if (!bHide)
		{
			//pPl = FormatPolyline(ptGe, 8);
			pPl = FormatPolyline(ptGeL, 7);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
		else
		{
			AcGePoint3d *ptGe2 = ptGe;
			pPl = FormatPolyline(ptGe2, 3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}

			// AcGePoint3d *ptGe3 = ptGe;
			AcGePoint3d *ptGe3 = ptGeL;
			ptGe3 += 3;//->3

			pPl = FormatPolyline(ptGe3, 3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}

		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[1] = ptMid;
		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;

		if (nCenNDraw == FALSE)
		{
			pPl = FormatPolyline(ptGe, 3);
			if (pPl != NULL)
			{
				pPl->setLayer(layerId());
				pPl->setLinetype(KTSetting::InitLineStyle(_T("CENTER")));

				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawIncline3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();

	AcGeVector3d vtMaj,vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0,dH = 0;
	double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0, dDn2 = 0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度
	int nElbowStyle = 0;
	m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);

	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	vtNorm.normalize();
	vtMaj.normalize();
	vtMin.normalize();

	AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
	AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
	vtMV.normalize();
	vtNV.normalize();

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn = dParam.dSize[3];
	dDn2 = dParam.dSize[0];//末端
	if (dDn < 1.e-6) dDn = dDn2;

	dW = dParam.dSize[1];
	dH = dW;
	//dL = dDn * dRatio + dLx;
	dL = GetElbowL(&dParam);

	AcGePoint3d ptGe[8], ptFr, ptTo, ptTmp,ptGeI[8],ptGeU[8],ptGeUI[8];
	AcDbLine lnPath;
	AecDbX3dPart part;

	vtMaj.normalize();
	vtMin.normalize();

	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))//水平放置
	{
		//OUT
		ptGe[0] = ptMid;
		ptGe[0] += dL * vtMaj;
		ptGe[0] -= vtMV * 0.5 * dDn;

		ptGe[2] = ptMid;
		ptGe[2] += dL * vtMin;
		ptGe[2] -= vtNV * 0.5 * dDn2;

		AcGeLine3d ln1(ptGe[0], vtMaj);
		AcGeLine3d ln2(ptGe[2], vtMin);
		ln1.intersectWith(ln2, ptGe[1]);

		ptGe[3] = ptGe[2] + vtNV * dDn2;
		ptGe[4] = ptGe[3] - vtMin * dLx;

		ptGe[6] = ptGe[0] + vtMV * dDn;
		ptGe[5] = ptGe[6] - vtMaj * dLx;

		ptGe[7] = ptGe[0];

		//In
		AcGePoint3d ptTmp;
		memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 8);
		OffsetPoint(ptGeI[0], ptGeI[6], dThick);

		ptTmp = ptGeI[0];
		OffsetPoint(ptTmp, ptGeI[1], dThick);

		OffsetPoint(ptGeI[2], ptGeI[3], dThick);

		ptGeI[5] = ptGeI[6] - vtMaj * (dLx + dThick);//大约
		ptGeI[4] = ptGeI[3] - vtMin * (dLx + dThick);//大约
		ptGeI[7] = ptGeI[0];

		AcDbLine lnPath;
		AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 8);
		if (pRegOut != NULL)
		{
			ptFr = ptMid - vtNorm * 0.5 * dW;//W
			ptTo = ptMid + vtNorm * 0.5 * dW;//W

			lnPath.setStartPoint(ptFr);
			lnPath.setEndPoint(ptTo);

			AcGeMatrix3d xform;
			AcGeVector3d vt = vtNorm * 0.5 * dW;
			xform.setToTranslation(vt);
			pRegOut->transformBy(xform);

			AecDbX3dPart part;
			AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
			pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
			part.AddX3dSolid(pX3dSolidOut);

			AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 8);
			if (pRegIn != NULL)
			{
				if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) &&
					!dParam.m_bCover)
				{
					//水平放置,不带盖子时
					AcGeVector3d vtRegNorm;
					pRegIn->getNormal(vtRegNorm);

					ptFr = ptMid - vtRegNorm * 0.5 * dW;
					ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtRegNorm * 0.5 * dW;
				}
				else
				{
					ptFr = ptMid - vtNorm * 0.5 * (dW - 2.0 * dThick);//W
					ptTo = ptMid + vtNorm * 0.5 * (dW - 2.0 * dThick);//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					vt = vtNorm * 0.5 * (dW - 2.0 * dThick);
				}

				xform.setToTranslation(vt);
				pRegIn->transformBy(xform);

				AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
				pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
				part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);

				BoolSubtractUserInf3d(part);
				part.Create();

				AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(tr);
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
				delete pRegIn;
			}
			delete pRegOut;
		}
		else
		{
			//...
			AcGePoint3dArray arPts;
			for (int i = 0; i < 8; i++)
			{
				arPts.append(ptGe[i]);
			}
			AcDb3dPolyline *pPl3d = Format3dPolyline(arPts);
			if (pPl3d != NULL)
			{
				dc.DrawEntity(pPl3d);
				Add3DBuffer(pPl3d);
			}
		}
	}
	else
	{
		//有一个向量平行 Z
		if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
			vtMin.isParallelTo(AcGeVector3d::kZAxis))
		{
			AcGeVector3d vtH, vtV, vtZ,vt34;

			if (nElbowStyle <= 1)
			{
				ptGe[0] = ptMid;
				ptGe[0] += dL * vtMaj;
				ptGe[0] -= vtMin * 0.5 * dH;

				ptGe[2] = ptMid;
				ptGe[2] += dL * vtMin;
				ptGe[2] -= vtMaj * 0.5 * dH;

				AcGeLine3d ln1(ptGe[0], vtMaj);
				AcGeLine3d ln2(ptGe[2], vtMin);
				ln1.intersectWith(ln2, ptGe[1]);

				ptGe[3] = ptGe[2] + vtMaj * dH;
				ptGe[4] = ptGe[3] - vtMin * dLx;

				ptGe[6] = ptGe[0] + vtMin * dH;
				ptGe[5] = ptGe[6] - vtMaj * dLx;

				ptGe[7] = ptGe[0];

				//In
				AcGePoint3d ptTmp;
				memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 8);
				OffsetPoint(ptGeI[0], ptGeI[6], dThick);

				ptTmp = ptGeI[0];
				OffsetPoint(ptTmp, ptGeI[1], dThick);

				OffsetPoint(ptGeI[2], ptGeI[3], dThick);

				ptGeI[5] = ptGeI[6] - vtMaj * (dLx + dThick);//大约
				ptGeI[4] = ptGeI[3] - vtMin * (dLx + dThick);//大约
				ptGeI[7] = ptGeI[0];

				AcDbLine lnPath;
				AcDbRegion *pRegOut = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 8);
				if (pRegOut != NULL)
				{
					ptFr = ptMid - vtNorm * 0.5 * dDn;//W
					ptTo = ptMid + vtNorm * 0.5 * dDn;//W

					lnPath.setStartPoint(ptFr);
					lnPath.setEndPoint(ptTo);

					AcGeMatrix3d xform;
					AcGeVector3d vt = vtNorm * 0.5 * dDn;
					xform.setToTranslation(vt);
					pRegOut->transformBy(xform);

					AecDbX3dPart part;
					AcDbX3dSolid *pX3dSolidOut = new AcDbX3dSolid;
					pX3dSolidOut->CreateExtrude(pRegOut, lnPath);
					part.AddX3dSolid(pX3dSolidOut);

					AcDbRegion *pRegIn = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 8);
					if (pRegIn != NULL)
					{
						if (vtNorm.isParallelTo(AcGeVector3d::kZAxis) && !dParam.m_bCover)
						{
							//水平放置,不带盖子时
							AcGeVector3d vtRegNorm;
							pRegIn->getNormal(vtRegNorm);

							ptFr = ptMid - vtRegNorm * 0.5 * dW;
							ptTo = ptMid + vtRegNorm * 0.5 * (dW - 2.0 * dThick);//W

							lnPath.setStartPoint(ptFr);
							lnPath.setEndPoint(ptTo);

							vt = vtRegNorm * 0.5 * dW;
						}
						else //非水平放置
						{
							ptFr = ptMid - vtNorm * 0.5 * (dDn - 2.0 * dThick);//W
							ptTo = ptMid + vtNorm * 0.5 * (dDn - 2.0 * dThick);//W

							lnPath.setStartPoint(ptFr);
							lnPath.setEndPoint(ptTo);

							vt = vtNorm * 0.5 * (dDn - 2.0 * dThick);
						}

						xform.setToTranslation(vt);
						pRegIn->transformBy(xform);

						AcDbX3dSolid *pX3dSolidIn = new AcDbX3dSolid;
						pX3dSolidIn->CreateExtrude(pRegIn, lnPath);
						part.AddX3dSolid(pX3dSolidIn, AcDb::kBoolSubtract);

						BoolSubtractUserInf3d(part);
						part.Create();

						AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
						if (pSolid != NULL)
						{
							pSolid->setTransparency(tr);
							dc.DrawEntity(pSolid);
							Add3DBuffer(pSolid);
						}
						delete pRegIn;
					}
					delete pRegOut;
				}
				else
				{
					//...
					AcGePoint3dArray arPts;
					for (int i = 0; i < 8; i++)
					{
						arPts.append(ptGe[i]);
					}
					AcDb3dPolyline *pPl3d = Format3dPolyline(arPts);
					if (pPl3d != NULL)
					{
						dc.DrawEntity(pPl3d);
						Add3DBuffer(pPl3d);
					}
				}
			}
			else
			{
				bool bGeSet = false;
				if (nElbowStyle == 2)	  //垂直左上弯
				{
					if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtZ = vtMaj;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtZ = vtMin;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//3d
					ptGe[0] = ptMid;
					ptGe[0] -= vtH * 0.5 * dDn;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;

					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
					ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
					ptGe[4] = ptGe[0];

					memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeI[0], ptGeI[3], dThick);
					OffsetPoint(ptGeI[1], ptGeI[2], dThick);
					OffsetPoint(ptGeI[0], ptGeI[1], dThick);
					OffsetPoint(ptGeI[2], ptGeI[3], dThick);
					ptGeI[4] = ptGeI[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeI[ii] += vtH * dThick;
					}

					//口
					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] += vtV * 0.5 * dW;

					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] - vtV * dW;
					ptGeU[3] = ptGeU[0] - vtV * dW;
					ptGeU[4] = ptGeU[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeU[ii] += vtZ * 0.5 * dW;
					}

					memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
					OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
					OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
					OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
					ptGeUI[4] = ptGeUI[0];

					bGeSet = true;
				}
				else if (nElbowStyle == 3)//垂直右上弯
				{
					if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtZ = vtMaj;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtZ = vtMin;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//3d
					ptGe[0] = ptMid;
					ptGe[0] -= vtH * 0.5 * dDn;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;

					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
					ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
					ptGe[4] = ptGe[0];

					memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeI[0], ptGeI[3], dThick);
					OffsetPoint(ptGeI[1], ptGeI[2], dThick);
					OffsetPoint(ptGeI[0], ptGeI[1], dThick);
					OffsetPoint(ptGeI[2], ptGeI[3], dThick);
					ptGeI[4] = ptGeI[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeI[ii] += vtH * dThick;
					}

					//口
					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] -= vtV * 0.5 * dW;
					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] + vtV * dW;
					ptGeU[3] = ptGeU[0] + vtV * dW;
					ptGeU[4] = ptGeU[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeU[ii] += vtZ * 0.5 * dW;
					}

					memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
					OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
					OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
					OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
					ptGeUI[4] = ptGeUI[0];

					bGeSet = true;
				}
				else if (nElbowStyle == 4)//垂直左下弯
				{
					if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtZ = vtMaj;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtZ = vtMin;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//3d
					ptGe[0] = ptMid;
					ptGe[0] -= vtH * 0.5 * dDn;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;

					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
					ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
					ptGe[4] = ptGe[0];

					memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeI[0], ptGeI[3], dThick);
					OffsetPoint(ptGeI[1], ptGeI[2], dThick);
					OffsetPoint(ptGeI[0], ptGeI[1], dThick);
					OffsetPoint(ptGeI[2], ptGeI[3], dThick);
					ptGeI[4] = ptGeI[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeI[ii] += vtH * dThick;
					}

					//口
					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] += vtV * 0.5 * dW;
					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] - vtV * dW;
					ptGeU[3] = ptGeU[0] - vtV * dW;
					ptGeU[4] = ptGeU[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeU[ii] += vtZ * 0.5 * dW;
					}

					memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
					OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
					OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
					OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
					ptGeUI[4] = ptGeUI[0];

					bGeSet = true;
				}
				else if (nElbowStyle == 5)//垂直右下弯
				{
					if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMin;
						vtV = vtH;
						vtZ = vtMaj;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
					{
						vtH = vtMaj;
						vtV = vtH;
						vtZ = vtMin;
						vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
					}
					else
					{
						return Acad::eOk;
					}

					//3d
					ptGe[0] = ptMid;
					ptGe[0] -= vtH * 0.5 * dDn;
					ptGe[0] += vtV * 0.5 * dDn;
					ptGe[0] += AcGeVector3d::kZAxis * 0.5 * dW;

					ptGe[1] = ptGe[0];
					ptGe[1] -= vtV * dDn;

					ptGe[2] = ptGe[1] - AcGeVector3d::kZAxis * dW;
					ptGe[3] = ptGe[0] - AcGeVector3d::kZAxis * dW;
					ptGe[4] = ptGe[0];

					memcpy(ptGeI, ptGe, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeI[0], ptGeI[3], dThick);
					OffsetPoint(ptGeI[1], ptGeI[2], dThick);
					OffsetPoint(ptGeI[0], ptGeI[1], dThick);
					OffsetPoint(ptGeI[2], ptGeI[3], dThick);
					ptGeI[4] = ptGeI[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeI[ii] += vtH * dThick;
					}

					//口
					ptGeU[0] = ptMid;
					ptGeU[0] -= vtH * 0.5 * dDn;
					ptGeU[0] -= vtV * 0.5 * dW;
					ptGeU[1] = ptGeU[0] + vtH * dDn;
					ptGeU[2] = ptGeU[1] + vtV * dW;
					ptGeU[3] = ptGeU[0] + vtV * dW;
					ptGeU[4] = ptGeU[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeU[ii] += vtZ * 0.5 * dW;
					}

					memcpy(ptGeUI, ptGeU, sizeof(AcGePoint3d) * 5);
					OffsetPoint(ptGeUI[0], ptGeUI[3], dThick);
					OffsetPoint(ptGeUI[1], ptGeUI[2], dThick);
					OffsetPoint(ptGeUI[0], ptGeUI[1], dThick);
					OffsetPoint(ptGeUI[2], ptGeUI[3], dThick);
					ptGeUI[4] = ptGeUI[0];
					for (int ii = 0; ii < 5; ii++)
					{
						ptGeUI[ii] -= vtZ * 1.1 * dThick;
					}
					bGeSet = true;
				}

				if (bGeSet)
				{
					//主
					AcDbRegion *pRegM = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
					if (pRegM != NULL)
					{
						lnPath.setStartPoint(ptGe[0]);
						lnPath.setEndPoint(ptGe[0] + vtH * (dL + 0.5 * dDn));

						AcDbX3dSolid *pX3dSolidM = new AcDbX3dSolid;
						pX3dSolidM->CreateExtrude(pRegM, lnPath);
						part.AddX3dSolid(pX3dSolidM);

						AcDbRegion *pRegMI = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 5);
						if (pRegMI != NULL)
						{
							lnPath.setStartPoint(ptGeI[0]);
							lnPath.setEndPoint(ptGeI[0] + vtH * (dL + 0.5 * dDn));

							AcDbX3dSolid *pX3dSolidMI = new AcDbX3dSolid;
							pX3dSolidMI->CreateExtrude(pRegMI, lnPath);
							part.AddX3dSolid(pX3dSolidMI, AcDb::kBoolSubtract);
						}
					}

					AcDbRegion *pRegN = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeU, 5);
					if (pRegN != NULL)
					{
						lnPath.setStartPoint(ptGeU[0]);
						lnPath.setEndPoint(ptGeU[0] + vtZ * dL);

						AcDbX3dSolid *pX3dSolidN = new AcDbX3dSolid;
						pX3dSolidN->CreateExtrude(pRegN, lnPath);
						part.AddX3dSolid(pX3dSolidN);

						AcDbRegion *pRegNI = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeUI, 5);
						if (pRegNI != NULL)
						{
							lnPath.setStartPoint(ptGeUI[0]);
							lnPath.setEndPoint(ptGeUI[0] + vtZ * (dL + 2.2 * dThick));

							AcDbX3dSolid *pX3dSolidNI = new AcDbX3dSolid;
							pX3dSolidNI->CreateExtrude(pRegNI, lnPath);
							part.AddX3dSolid(pX3dSolidNI, AcDb::kBoolSubtract);
						}
					}

					part.Create();
					AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
					if (pSolid != NULL)
					{
						pSolid->setTransparency(tr);
						dc.DrawEntity(pSolid);
						Add3DBuffer(pSolid);
					}
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEcFitting::DrawTrIncline3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();

	AcGeVector3d vtMaj, vtMin;
	AcGePoint3d ptMid;
	double dDn = 0.0, dRatio = 1.0, dSweepAngle = PI / 2.0, dDn2 = 0;
	double dThick = 0.35, dLx = 50.0, dL = 0.0, dW = 0.0, dOD = 0.0, dOD2 = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG, dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	DlgData data;
	memset(&data, 0, sizeof(DlgData));
	GetDlgData(data,0);

	AcGeVector3d vtNorm = vtMin.crossProduct(vtMaj);
	vtNorm.normalize();
	vtMaj.normalize();
	vtMin.normalize();
	if (vtNorm.isCodirectionalTo(AcGeVector3d::kZAxis))
		vtNorm *= -1;//(0,0,-1)//一律向下

	AcGeVector3d vtMV = vtMin.orthoProject(vtMaj);
	AcGeVector3d vtNV = vtMaj.orthoProject(vtMin);
	vtMV.normalize();
	vtNV.normalize();

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn2 = dParam.dSize[0];//内径 末端
	dOD2 = dDn2 + 2.0 * dParam.dSize[2];

	dW = dParam.dSize[1];//H

	dDn = dParam.dSize[3];//开始端
	if (dDn < 1.e-1) dDn = dDn2;

	dOD = dDn + 2.0 * dParam.dSize[2];

	//dL = dDn * dRatio + dLx;
	dL = GetElbowL(&dParam);

	DlgData data2;
	memset(&data2, 0, sizeof(DlgData));
	GetDlgData(data2, 1);

	vtMaj.normalize();
	vtMin.normalize();

	AcGeLine3d ln3d;
	ln3d.set(AcGePoint3d::kOrigin, vtNorm);
	if (ln3d.isParallelTo(AcGePlane::kXYPlane))
	{
		double dTmp = dW;
		dW = dDn;
		dDn = dTmp;
	}

	AcGePoint3d ptGe[8], ptFr, ptTo, ptGeI[8];

	//OUT
	ptGe[0] = ptMid;
	ptGe[0] += dL * vtMaj;
	ptGe[0] -= vtMV * 0.5 * dOD;

	ptGe[2] = ptMid;
	ptGe[2] += dL * vtMin;
	ptGe[2] -= vtNV * 0.5 * dOD2;

	AcGeLine3d ln1(ptGe[0], vtMaj);
	AcGeLine3d ln2(ptGe[2], vtMin);
	ln1.intersectWith(ln2, ptGe[1]);

	ptGe[3] = ptGe[2] + vtNV * dOD2;
	ptGe[5] = ptGe[0] + vtMV * dOD;

	AcGeLine3d ln3(ptGe[3], vtMin);
	AcGeLine3d ln4(ptGe[5], vtMaj);
	ln3.intersectWith(ln4, ptGe[4]);
	ptGe[6] = ptGe[0];

	//TestPoint(ptGe, 7, 1);

	AcDbLine lnPath;
	AecDbX3dPart part;

	//顶板
	AcDbRegion *pRegTop = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
	if (pRegTop != NULL)
	{
		ptFr = ptMid - vtNorm * 0.5 * dW;//H
		ptTo = ptFr + vtNorm * data.m_dk;//k
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegTop);
		AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
		pX3dSolidTop->CreateExtrude(pRegTop, lnPath);
		part.AddX3dSolid(pX3dSolidTop);
	}

	//外侧墙
	ptGeI[0] = ptGe[0];
	ptGeI[1] = ptGe[1];
	ptGeI[2] = ptGe[2];
	ptGeI[3] = ptGe[2] + vtNV * data.m_dt;
	ptGeI[5] = ptGe[0] + vtMV * data.m_dt;
	ptGeI[4] = GetIntersectPt(ptGeI[3], vtMin, ptGeI[5], vtMaj);
	ptGeI[6] = ptGeI[0];
	
	//TestPoint(ptGeI, 7, 2);

	AcDbRegion *pRegWall1 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 7);
	if (pRegWall1 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dW - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall1);
		AcDbX3dSolid *pX3dWall1 = new AcDbX3dSolid;
		pX3dWall1->CreateExtrude(pRegWall1, lnPath);
		part.AddX3dSolid(pX3dWall1);
	}

	//内侧墙
	ptGeI[0] = ptGe[5];
	ptGeI[1] = ptGe[4];
	ptGeI[2] = ptGe[3];

	ptGeI[3] = ptGe[3] - vtNV * data.m_dt;
	ptGeI[5] = ptGe[5] - vtMV * data.m_dt;

	ptGeI[4] = GetIntersectPt(ptGeI[3], vtMin, ptGeI[5], vtMaj);
	ptGeI[6] = ptGeI[0];
	//TestPoint(ptGeI, 7, 3);

	AcDbRegion *pRegWall2 = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeI, 7);
	if (pRegWall2 != NULL)
	{
		ptFr = ptMid - vtNorm * (0.5 * dW - data.m_dk);//H
		ptTo = ptFr + vtNorm * data.m_dH;//H
		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegWall2);
		AcDbX3dSolid *pX3dWall2 = new AcDbX3dSolid;
		pX3dWall2->CreateExtrude(pRegWall2, lnPath);
		part.AddX3dSolid(pX3dWall2);
	}

	//底板
	ptGe[0] = ptMid;
	ptGe[0] += dL * vtMaj;
	ptGe[0] -= vtMV * 0.5 * data2.m_dd;

	ptGe[2] = ptMid;
	ptGe[2] += dL * vtMin;
	ptGe[2] -= vtNV * 0.5 * data.m_dd;
	ptGe[1] = GetIntersectPt(ptGe[0], vtMaj, ptGe[2], vtMin);

	ptGe[3] = ptGe[2] + vtNV * data.m_dd;
	ptGe[5] = ptGe[0] + vtMV * data2.m_dd;
	ptGe[4] = GetIntersectPt(ptGe[3], vtMin, ptGe[5], vtMaj);
	ptGe[6] = ptGe[0];

	//TestPoint(ptGe, 7, 4);

	AcDbRegion *pRegBom = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
	if (pRegBom != NULL)
	{
		ptFr = ptMid + vtNorm * 0.5 * dW;//H
		ptTo = ptFr - vtNorm * data.m_db;//H

		lnPath.setStartPoint(ptFr);
		lnPath.setEndPoint(ptTo);

		MoveRegion(ptFr - ptMid, pRegBom);
		AcDbX3dSolid *pX3dSlabB = new AcDbX3dSolid;
		pX3dSlabB->CreateExtrude(pRegBom, lnPath);
		part.AddX3dSolid(pX3dSlabB);
	}

	part.Create();
	AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
	if (pSolid != NULL)
	{
		pSolid->setTransparency(tr);
		dc.DrawEntity(pSolid);
		Add3DBuffer(pSolid);
	}

	return Acad::eOk;
}

AecDbObjXDataMap* AecDbEcFitting::GetSpecialtyData(AcDb::OpenMode bMode)
{
	switch(bMode)
	{
	case AcDb::kForRead:
		{
			assertReadEnabled();
			break;
		}
	case AcDb::kForWrite:
		{
			if (!isWriteEnabled())
			{
				upgradeOpen();
			}
			assertWriteEnabled();
			break;
		}
	case AcDb::kForNotify:
		{
			assertReadEnabled();
		}
	default:
		break;
	}
	return &m_mapSpecXData;
}

const AecDbObjXDataMap * AecDbEcFitting::GetSpecialtyData() const
{
	assertReadEnabled();
	return &m_mapSpecXData;
}

//接口重载
bool AecDbEcFitting::GetInterface(AcArray<AecInterface>& arInfs) const
{
	assertReadEnabled();

	AcGeVector3d vtNorm(0,0,1);
	AcGeVector3d vtMaj,vtMin,vtOffset;
	AcGePoint3d ptMid;
	double dDn = 0.0,dRatio = 1.0,dSweepAngle = PI / 2.0;
	double dThick = 0.35,dLx = 50.0,dL = 0.0,dW = 0.0,dDn2 = 0.0;
	double dOffsetH = 0.0;

	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	m_mapSpecXData.GetAt(KEY_MID, ptMid);

	m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
	m_mapSpecXData.GetAt(KEY_OFFSETDIR,vtOffset);//偏移方向

	vtMaj.normalize();
	vtMin.normalize();
	vtOffset.normalize();
	vtNorm.normalize();

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
	m_mapSpecXData.GetAt(KEY_Offset,dOffsetH);

	m_mapSpecXData.GetAt(HELB_RadRatio, dRatio);
	m_mapSpecXData.GetAt(PIPE_ELBOWANG,dSweepAngle);
	m_mapSpecXData.GetAt(PIPE_THICK, dThick);
	m_mapSpecXData.GetAt(HELB_LX, dLx);//直边长度

	if (dThick < 1.e-6)
		dThick = 5.0;//至少5mm

	AecHvac::DuctParam dParam;
	GetDuctParam(dParam);

	dDn2 = dParam.dSize[0];//D L 末端
	dDn = dParam.dSize[3];//开始端
	if (dDn < 1.e-6)
		dDn = dDn2;

	double dH = dParam.dSize[1];//H
	double dR = dDn * dRatio;
	dW = dParam.dSize[1];//

	//变径偏心
	int nEcCen = 0;//偏心
	m_mapSpecXData.GetAt(KEY_ECCEN,nEcCen);

	if (!m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm))
	{
		vtNorm = vtMin.crossProduct(vtMaj);
	}
	vtNorm.normalize();

	//变径
	AcGeVector3d vtW = vtMaj;
	vtW.rotateBy(PI / 2.0,vtNorm);
	vtW.normalize();
	double dW1 = dParam.dSize[3];//开始端

	AcGePoint3d ptGe[5];
	AcGeVector3d vtH, vtV, vtZ;

	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME,nType);
	EFittingType eType = (EFittingType)nType;

	AecHvac::HvacElbowType eElbowType = AecHvac::eAllArcuate;
	m_mapSpecXData.GetAt(HELB_Type, (int&)eElbowType);
	AecInterface inf;
	inf.nSectType = 0;
	inf.dV = inf.dA = 0;
	inf.bSizeUnLock = true;
	inf.nType = nType;
	inf.dGasket = 0;
	int nElbowStyle = 0;
	m_mapSpecXData.GetAt(KEY_ELBOWSTYLE, nElbowStyle);

	int nTeeStyle = 0;
	m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);

	switch( eType )
	{
	case eElbow:
		{
			switch(dParam.eType)
			{
			case eRect:
				{
					if (nElbowStyle <= 1) //0,1 标准 [电缆沟] [桥架]
					{
						dL = GetElbowL(&dParam);

						//L W t
						ptGe[0] = ptMid;
						ptGe[0] += dL * vtMaj;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						arInfs.append(inf);

						inf.dSize1 = dDn2;
						inf.dSize2 = dW;
						ptGe[0] = ptMid;
						ptGe[0] += dL * vtMin;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMin;
						arInfs.append(inf);
					}
					else if (nElbowStyle ==2 )//垂直左上弯 [桥架]
					{
						if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
						{
							vtH = vtMin;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMaj;
						}
						else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
						{
							vtH = vtMaj;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMin;
						}
						else
						{
							return false;
						}

						dL = GetElbowL(&dParam);

						//L W t
						ptGe[0] = ptMid;
						ptGe[0] += dL * vtH;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 0;
						arInfs.append(inf);

						ptGe[0] = ptMid;
						//ptGe[0] += vtV * 0.5 * dDn;
						//ptGe[0] -= vtV * 0.5 * dW;
						ptGe[0] += vtZ * 0.5 * dW;

						ptGe[0] += vtZ * dL;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 1;
						arInfs.append(inf);

					}
					else if (nElbowStyle == 3)//垂直右上弯 [桥架]
					{
						if (vtMaj.isCodirectionalTo(-AcGeVector3d::kZAxis))
						{
							vtH = vtMin;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMaj;
						}
						else if (vtMin.isCodirectionalTo(-AcGeVector3d::kZAxis))
						{
							vtH = vtMaj;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMin;
						}
						else
						{
							return false;
						}

						dL = GetElbowL(&dParam);

						//L W t
						ptGe[0] = ptMid;
						ptGe[0] += dL * vtH;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 0;
						arInfs.append(inf);

						ptGe[0] = ptMid;
						//ptGe[0] -= vtV * 0.5 * dDn;
						//ptGe[0] += vtV * 0.5 * dW;
						ptGe[0] += vtZ * 0.5 * dW;

						ptGe[0] += vtZ * dL;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 1;
						arInfs.append(inf);
					}
					else if (nElbowStyle == 4)//垂直左下弯
					{
						if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
						{
							vtH = vtMin;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMaj;
						}
						else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
						{
							vtH = vtMaj;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMin;
						}
						else
						{
							return false;
						}

						dL = GetElbowL(&dParam);

						//L W t
						ptGe[0] = ptMid;
						ptGe[0] += dL * vtH;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 0;
						arInfs.append(inf);

						ptGe[0] = ptMid;
						//ptGe[0] += vtV * 0.5 * dDn;
						//ptGe[0] -= vtV * 0.5 * dW;
						ptGe[0] += vtZ * 0.5 * dW;

						ptGe[0] += vtZ * dL;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 1;
						arInfs.append(inf);
					}
					else if (nElbowStyle == 5)//垂直右下弯
					{
						if (vtMaj.isCodirectionalTo(AcGeVector3d::kZAxis))
						{
							vtH = vtMin;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMaj;
						}
						else if (vtMin.isCodirectionalTo(AcGeVector3d::kZAxis))
						{
							vtH = vtMaj;
							vtV = vtH;
							vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
							vtZ = vtMin;
						}
						else
						{
							return false;
						}

						dL = GetElbowL(&dParam);

						//L W t
						ptGe[0] = ptMid;
						ptGe[0] += dL * vtH;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 0;
						arInfs.append(inf);

						ptGe[0] = ptMid;
						//ptGe[0] -= vtV * 0.5 * dDn;
						//ptGe[0] += vtV * 0.5 * dW;
						ptGe[0] += vtZ * 0.5 * dW;

						ptGe[0] += vtZ * dL;

						inf.dSize1 = dDn;
						inf.dSize2 = dW;
						inf.ptPos = ptGe[0];
						inf.vtDir = vtMaj;
						inf.idOwner = objectId();
						inf.nLevel = 1;
						arInfs.append(inf);
					}
					else
					{
						return false;
					}
					break;
				}
			case eCircle:
				{
					dL = GetElbowL(&dParam);
					ptGe[0] = ptMid;
					ptGe[0] += dL * vtMaj;

					AecInterface inf;
					inf.dSize1 = dDn;
					inf.dSize2 = dDn;
					inf.ptPos = ptGe[0];
					inf.vtDir = vtMaj;
					inf.idOwner = objectId();
					inf.nLevel = 0;
					arInfs.append(inf);

					inf.dSize1 = dDn2;
					inf.dSize2 = dDn2;
					ptGe[0] = ptMid;
					ptGe[0] += dL * vtMin;
					inf.ptPos = ptGe[0];
					inf.vtDir = vtMin;
					inf.nLevel = 1;
					arInfs.append(inf);

					break;
				}
			default:
				break;
			}
			break;
		}
	case eTee:
		{
			dL = GetElbowL(&dParam);

			//L W t
			ptGe[0] = ptMid;
			ptGe[0] -= dL * vtMaj;

			inf.dSize1 = dDn;
			inf.dSize2 = dW;
			inf.ptPos = ptGe[0];
			inf.vtDir = vtMaj;
			inf.vtDir.negate();
			inf.idOwner = objectId();
			inf.nLevel = 0;
			arInfs.append(inf);

			ptGe[0] += 2.0 * dL * vtMaj;
			inf.ptPos = ptGe[0];
			inf.vtDir = vtMaj;
			inf.nLevel = 1;
			arInfs.append(inf);

			if (nTeeStyle == 0)
			{
				ptGe[0] = ptMid;
				ptGe[0] += dL * vtMin;
				inf.ptPos = ptGe[0];
				inf.vtDir = vtMin;
				inf.nLevel = 2;
				arInfs.append(inf);
			}
			/*else
			{
				//userinf
			}*/
			break;
		}
	case eCross:
		{
			dL = GetElbowL(&dParam);

			//L W t
			ptGe[0] = ptMid;
			ptGe[0] -= dL * vtMaj;

			inf.dSize1 = dDn;
			inf.dSize2 = dW;
			inf.ptPos = ptGe[0];
			inf.vtDir = vtMaj;
			inf.vtDir.negate();
			inf.idOwner = objectId();
			inf.nLevel = 0;
			arInfs.append(inf);

			ptGe[0] += 2.0 * dL * vtMaj;
			inf.ptPos = ptGe[0];
			inf.vtDir = vtMaj;
			inf.nLevel = 1;
			arInfs.append(inf);

			//min
			ptGe[0] = ptMid;
			ptGe[0] -= dL * vtMin;

			inf.dSize1 = dDn;
			inf.dSize2 = dW;
			inf.ptPos = ptGe[0];
			inf.vtDir = vtMin;
			inf.vtDir.negate();
			inf.idOwner = objectId();
			inf.nLevel = 2;
			arInfs.append(inf);

			ptGe[0] += 2.0 * dL * vtMaj;
			inf.ptPos = ptGe[0];
			inf.vtDir = vtMin;
			inf.nLevel = 3;
			arInfs.append(inf);

			break;
		}
	case eReduce:
		{
			m_mapSpecXData.GetAt(KEY_L,dL);

			ptGe[0] = ptMid;
			ptGe[0] -= vtMaj * 0.5 * dL;
			ptGe[0] += vtW * 0.5 * dW1;

			if (nEcCen == 0)
			{
				ptGe[1] = ptMid;
				ptGe[1] += vtMaj * 0.5 * dL;
				ptGe[1] += vtW * 0.5 * dDn;
			}
			else if (nEcCen == 1)
			{
				ptGe[1] = ptGe[0] + vtMaj * dL;
			}
			else if (nEcCen == 2)
			{
				ptGe[1] = ptMid;
				ptGe[1] -= vtMaj * 0.5 * dL;
				ptGe[1] -= vtW * 0.5 * dW1;
				ptGe[1] += vtMaj * dL;
				ptGe[1] += vtW * dDn;
			}

			ptGe[2] = ptGe[1] - vtW * dDn;
			ptGe[3] = ptGe[0] - vtW * dW1;

			inf.dSize1 = dDn;
			inf.dSize2 = dW1;
			inf.ptPos = MidPoint(ptGe[0],ptGe[3]);
			inf.vtDir = vtMaj;
			inf.vtDir.negate();
			inf.idOwner = objectId();
			inf.nLevel = 0;
			arInfs.append(inf);

			inf.dSize1 = dDn;
			inf.dSize2 = dW;
			inf.ptPos = MidPoint(ptGe[1],ptGe[2]);
			inf.vtDir = vtMaj;
			inf.idOwner = objectId();
			inf.nLevel = 1;
			arInfs.append(inf);

			break;
		}
	case eOffset:
		{
			vtMaj.normalize();
			vtMin.normalize();
			vtNorm.normalize();
			vtOffset.normalize();

			//偏移方向的反方向
			AcGeVector3d vtV = vtOffset;//Maj->Min的方向
			vtV = vtV.orthoProject(vtMaj);//MAKE SURE
			vtV.negate();
			vtV.normalize();

			if (dOffsetH < 1.e-6)
			{
				acutPrintf(_T("\nOffset dist error!"));
				return Acad::eOk;
			}

			//乙字弯角度 90 < A < 180
			if ( ( dSweepAngle - 90.0 ) > 1.e-10 && (dSweepAngle - 180.0) < 1.e-10)
			{
				AcGePoint3d ptGeCen[4];

				//转化为弧度
				dSweepAngle *= PI / 180.0;

				//玄段长度
				double dChrodx = dR * tan(dSweepAngle * 0.5);

				//斜段总桥架长度
				double dLseg = dOffsetH / sin(dSweepAngle);//180-a

				//投影到maj方向上 总长
				double dL = dOffsetH / fabs(tan(dSweepAngle));//180-a
				dL += dChrodx * 2.0;

				//伞心中最大对角线长
				double dAL = sqrt(dR * dR + dChrodx * dChrodx);

				ptGeCen[0] = ptMid - vtMaj * 0.5 * dL;
				ptGeCen[0] += vtV * 0.5 * dOffsetH;

				ptGeCen[1] = ptGeCen[0] + vtMaj * dChrodx;

				AcGeVector3d vtMidL = ptMid - ptGeCen[1];
				vtMidL.normalize();
				ptGeCen[2] = ptGeCen[1] + vtMidL * dLseg;
				ptGeCen[3] = ptGeCen[2] + vtMin * dChrodx;

				inf.dSize1 = dDn;
				inf.dSize2 = dW1;
				inf.ptPos = ptGeCen[0];
				inf.vtDir = vtMaj;
				inf.vtDir.negate();
				inf.idOwner = objectId();
				inf.nLevel = 0;
				arInfs.append(inf);

				inf.dSize1 = dDn;
				inf.dSize2 = dW;
				inf.ptPos = ptGeCen[3];
				inf.vtDir = vtMin;
				inf.idOwner = objectId();
				inf.nLevel = 1;
				arInfs.append(inf);
			}
			break;
		}
	default:
		break;
	}

	int nCount = arInfs.length();
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		const AecUserInterface &infu = m_arUserInfs.at(i);
		if (infu.nPoints == 2)
		{
			inf.ptPos = infu.ptGe[0];
			inf.dSize1 = infu.ptGe[0].distanceTo(infu.ptGe[1]);
			inf.nSectType = 1;
			inf.vtDir = infu.vtDir;
			inf.ptPos += infu.vtDir;
			inf.nLevel = i + 2;
			inf.nLevel = nCount + i;
			arInfs.append(inf);
		}
		else if (infu.nPoints == 4)//目前只考虑矩形
		{
			inf.ptPos = MidPoint(infu.ptGe[0], infu.ptGe[2]);
			inf.dSize1 = infu.ptGe[0].distanceTo(infu.ptGe[1]);
			inf.dSize2 = infu.ptGe[1].distanceTo(infu.ptGe[2]);
			inf.nSectType = 0;
			inf.vtDir = infu.vtDir;
			inf.ptPos += infu.vtDir;
			inf.nLevel = i + 2;
			inf.nLevel = nCount + i;
			arInfs.append(inf);
		}
		else if (infu.nPoints == 5)//目前只考虑矩形 0 == 4
		{
			inf.ptPos = MidPoint(infu.ptGe[0], infu.ptGe[2]);
			inf.dSize1 = infu.ptGe[0].distanceTo(infu.ptGe[1]);
			inf.dSize2 = infu.ptGe[1].distanceTo(infu.ptGe[2]);
			inf.nSectType = 0;
			inf.vtDir = infu.vtDir;
			inf.ptPos += infu.vtDir;
			inf.nLevel = i + 2;
			inf.nLevel = nCount + i;
			inf.dGasket = 0;
			arInfs.append(inf);
		}
	}

	return !arInfs.isEmpty();
}

bool AecDbEcFitting::GetInterface(int nIndex,AecInterface& inf) const
{
	assertReadEnabled();

	AcArray<AecInterface> arInfs;
	GetInterface(arInfs);

	if (nIndex > -1 && nIndex < arInfs.length())
	{
		inf = arInfs.at(nIndex);
		return true;
	}
	return false;
}

int AecDbEcFitting::GetInterfaceCount() const
{
	assertReadEnabled();

	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME,nType);
	EFittingType eType = (EFittingType)nType;

	int nTeeStyle = 0;
	m_mapSpecXData.GetAt(KEY_TEESTYLE, nTeeStyle);

	int nInfs = 0;
	switch( eType )
	{
	case eElbow:
		nInfs = 2;
		break;
	case eTee:
		{
			nInfs = 3;
			if (nTeeStyle > 0)
			{
				nInfs = 2;
			}
		}
		break;
	case eCross:
		nInfs = 4;
		break;
	case eReduce:
		nInfs = 2;
		break;
	case eOffset:
		nInfs = 2;
		break;
	default:
		break;
	}

	nInfs += GetUserInterfaceCount();

	return nInfs;
}

AcGeVector3d AecDbEcFitting::GetNormal() const
{
	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME,nType);
	EFittingType eType = (EFittingType)nType;

	AcGeVector3d vtMaj,vtMin,vtNorm(0,0,1);
	m_mapSpecXData.GetAt(KEY_MAJBR, vtMaj);
	m_mapSpecXData.GetAt(KEY_MINBR, vtMin);
	vtMaj.normalize();
	vtMin.normalize();

	int nInfs = 0;
	switch( eType )
	{
	case eElbow:
	case eTee:
	case eCross:
		{
			vtNorm = vtMaj.crossProduct(vtMin);
			break;
		}
	case eReduce:
	case eOffset:
		{
			m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
			break;
		}
	default:
		break;
	}
	return vtNorm;
}

int AecDbEcFitting::GetActiveInf() const
{
	assertReadEnabled();
	return m_nInfActive;
}

void AecDbEcFitting::SetActiveInf(int nIndex)
{
	assertWriteEnabled();
	m_nInfActive = nIndex;
}

void AecDbEcFitting::LockInf(int nInf)
{
	bool bUpgraded = false;
	if (!isWriteEnabled())
	{
		upgradeOpen();
		bUpgraded = true;
	}

	CString sKey;
	if (nInf == -1)
	{
		int nCnt = GetInterfaceCount();
		for (int k = 0;k < nCnt;k++)
		{
			sKey.Format(_T("LK_%d"),k);
			m_mapSpecXData.RemoveAt(sKey);
		}

		if (bUpgraded)
		{
			downgradeOpen();
		}
		return;
	}

	sKey.Format(_T("LK_%d"),nInf);
	m_mapSpecXData.SetAt(sKey,nInf);

	if (bUpgraded)
	{
		downgradeOpen();
	}
}

Acad::ErrorStatus AecDbEcFitting::TransformBy(const AcGeMatrix3d xform)
{
	AssertWriteEnabled();
	return subTransformBy(xform);
}

bool AecDbEcFitting::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	//FITTING件没有橡皮拉伸特征,固定整体移动
	AecInterface inf;
	if ( GetInterface(nInf,inf) )
	{
		AcGeVector3d vtDir = inf.vtDir;
		AcGePoint3d pt1 = inf.ptPos;
		pt1.transformBy(xform);

		//AcGeVector3d vt2 = pt1 - inf.ptPos;
		//if (vt2.isParallelTo(vtDir))
		//{
		//	return false;
		//}

		TransformBy(xform);
		return true;//继续发消息
	}
	return false;//不继续发消息
}

bool AecDbEcFitting::GetFittingName(CString &sName) const
{
	assertReadEnabled();

	int nType = 0;
	m_mapSpecXData.GetAt(KEY_RUNTIME, nType);
	EFittingType eType = (EFittingType)nType;

	switch (eType)
	{
	case eElbow:
		sName = _T("桥架弯头");
		break;
	case eTee:
		sName = _T("桥架三通");
		break;
	case eCross:
		sName = _T("桥架四通");
		break;
	case eReduce:
		sName = _T("桥架变径");
		break;
	case eOffset:
		sName = _T("桥架乙字弯");
		break;
	default:
		break;
	}
	return true;
}

bool AecDbEcFitting::GetSectionDraw(AcGePlane& plan,const AcGeVector3d& vtTo,AcDbVoidPtrArray&  arRegionPtrs) const
{
	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	AcDbVoidPtrArray arSubPtrs;
	AecDbEcFitting* pFit = (AecDbEcFitting*)clone();
	if (pFit != NULL)
	{
		pFit->transformBy(xform);

		AcGiViewDraw dc(NULL, NULL);
		pFit->Draw2d(dc);

		pFit->GetDraw2dables(0,arSubPtrs);

		CString sName;
		GetFittingName(sName);
		MakeBlockRefSet(arSubPtrs, layerId(),Adesk::kTrue,sName);

		arRegionPtrs.append(arSubPtrs);
		delete pFit;
	}
	return true;
}

int AecDbEcFitting::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegionPtrs) const
{
	AcGePlane plan;
	AcGeVector3d vtU = ptTo - ptFr;

	Acad::ErrorStatus es = Acad::eOk;
	plan.set(ptFr,vtU,vtViewDir);

	int nCount = arRegionPtrs.length();
	GetSectionDraw(plan,vtTo,arRegionPtrs);

	int nCoundPre = arRegionPtrs.length();
	return (nCount - nCoundPre);
}

int AecDbEcFitting::ComparedTo(AecDbEntityBase* pCurOther) const
{
	assertReadEnabled();

	AecDbEcFitting* pPipeOther = AecDbEcFitting::cast(pCurOther);
	if (pPipeOther != NULL)
	{
		AecHvac::DuctParam dpThis;
		GetDuctParam(dpThis);

		AecHvac::DuctParam dpThat;
		pPipeOther->GetDuctParam(dpThat);

		if (dpThis.eType != dpThat.eType)
			return 1;

		if ( fabs(dpThis.dSize[0] - dpThat.dSize[0]) > 0.1)
			return 1;

		if ( fabs(dpThis.dSize[1] - dpThat.dSize[1]) > 0.1)
			return 1;

		if ( fabs(dpThis.dSize[2] - dpThat.dSize[2]) > 0.1)
			return 1;

		if ( fabs(dpThis.m_dEl - dpThat.m_dEl) > 0.1)
			return 1;

		AcGePoint3d ptSta(0,0,0);
		m_mapSpecXData.GetAt(KEY_MID, ptSta);

		AcGePoint3d ptSta2(0,0,0);
		pPipeOther->GetSpecialtyData()->GetAt(KEY_MID, ptSta2);

		if (ptSta.distanceTo(ptSta2) > 2.0)//误差2毫米
			return 1;
	}
	return 0;
}

//用户接口
void AecDbEcFitting::AddUserInterface(const AecUserInterface &inf)
{
	AssertWriteEnabled();
	m_arUserInfs.append(inf);
}

bool AecDbEcFitting::RemoveUserInterface(const TCHAR *pszNo)
{
	if (pszNo == NULL)
		return false;

	AssertWriteEnabled();
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		AecUserInterface &inf = m_arUserInfs.at(i);
		if (_tcscmp(inf.szNo, pszNo) == 0)
		{
			m_arUserInfs.removeAt(i);
			return true;
		}
	}
	return false;
}

bool AecDbEcFitting::RemoveUserInterface(int nIndex)
{
	AssertWriteEnabled();
	if (nIndex > -1 && nIndex < m_arUserInfs.length())
	{
		m_arUserInfs.removeAt(nIndex);
		return true;
	}
	return false;
}

int  AecDbEcFitting::GetUserInterfaceCount() const
{
	assertReadEnabled();
	return m_arUserInfs.length();
}

bool AecDbEcFitting::GetUserInterface(int nIndex, AecUserInterface &inf) const
{
	assertReadEnabled();
	if (nIndex > -1 && nIndex < m_arUserInfs.length())
	{
		inf = m_arUserInfs.at(nIndex);
		return true;
	}
	return false;
}

bool AecDbEcFitting::GetUserInterface(const AcGePoint3d &ptHit, AecUserInterface &inf) const
{
	assertReadEnabled();

	AcGePoint3d ptInf;
	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		const AecUserInterface &infu = m_arUserInfs.at(i);
		if (infu.nPoints == 2)
		{
			ptInf = infu.ptGe[0] + infu.vtDir;
			if (ptHit.distanceTo(ptInf) < 1.e-6)
			{
				inf = infu;
				return true;
			}
		}
		else if (infu.nPoints == 4)//目前只考虑矩形
		{
			ptInf = MidPoint(infu.ptGe[0], infu.ptGe[2]) + infu.vtDir;
			if (ptHit.distanceTo(ptInf) < 1.e-6)
			{
				inf = infu;
				return true;
			}
		}
	}
	return false;
}

bool AecDbEcFitting::ReadUserInterface(AcDbDwgFiler *pFiler)
{
	//读取用户接口
	m_arUserInfs.removeAll();
	AecUserInterface userInf;

	Adesk::UInt32 nLen = 0;
	pFiler->readUInt32(&nLen);

	TCHAR *pszTemp = NULL;
	for (Adesk::UInt32 i = 0; i < nLen; i++)
	{
		memset(&userInf, 0, sizeof(AecUserInterface));

		pFiler->readString(&pszTemp);
		if (pszTemp != NULL)
		{
			_tcscpy(userInf.szNo, pszTemp);
			acutDelString(pszTemp);
		}

		Adesk::UInt16 nPts = 0;
		pFiler->readUInt16(&nPts);
		userInf.nPoints = nPts;

		for (Adesk::UInt16 j = 0; j < nPts; j++)
		{
			pFiler->readPoint3d(&userInf.ptGe[j]);
		}

		pFiler->readVector3d(&userInf.vtDir);

		pszTemp = NULL;
		pFiler->readString(&pszTemp);

		if (pszTemp != NULL)
		{
			_tcscpy(userInf.szSys, pszTemp);
			acutDelString(pszTemp);
		}
		m_arUserInfs.append(userInf);
	}
	return false;
}

void AecDbEcFitting::WriteUserInterface(AcDbDwgFiler *pFiler) const
{
	assertReadEnabled();

	pFiler->writeUInt32(m_arUserInfs.length());

	for (int i = 0; i < m_arUserInfs.length(); i++)
	{
		const AecUserInterface &inf = m_arUserInfs.at(i);

		pFiler->writeString(inf.szNo);

		pFiler->writeUInt16(inf.nPoints);

		for (Adesk::UInt16 ii = 0; ii < inf.nPoints; ii++)
		{
			pFiler->writePoint3d(inf.ptGe[ii]);
		}

		pFiler->writeVector3d(inf.vtDir);

		pFiler->writeString(inf.szSys);
	}
}

#include "hlrcutoption.h"
void AecDbEcFitting::ProcessHlrResult(const AcArray<AcDbEntity *> &ar, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr, AcArray<AcDbEntity *> &output) const
{
	double dW;
	HlrCutOption::ProcessHlrResult(this
		, HlrCutOption::getHlrLW_ElecSys(dW)
		, dW
		, HlrCutOption::getHlrBLK_FITTING()
		, ar
		, preAr
		, output);
}