#include "StdAfx.h"
#include "uiiado.h"
#include "ktsetting.h"
#include "AecDbEwEquipment.h"
#include "makeValve.h"
#include "KTCadUtility.h"
#include "KTCADUtilityEx.h"
#include <AcDbX3dSolid.h>
#include "EarThwormDef.h"
#include "EquInsDirJig.h"
#include "AecDbEarthWorm.h"
#include "CoreTools.h"

#define LAY_PIPE_CENTER		_T("PIPE_CEN")
#define LAY_PIPE_OUTSIDE	_T("PIPE_OUT")
#define LAY_FITN_CENTER		LAY_PIPE_CENTER
#define LAY_FITN_DASH		_T("FITN_DSH")

DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts, int nCount);

namespace MKValve
{
	AcDbObjectId AecInitLayerEx(LPCTSTR pszLayer, LPCTSTR pszSys, int nColorIndex, LPCTSTR pszLineType, AcDbDatabase* pDb)
	{
		return CoreTools::AecInitLayerEx(pszLayer, pszSys, nColorIndex, pszLineType, pDb);
	}

	template <typename T>
	void setData(AecEqui::XPrimData *pXPData, void *pData)
	{
		::Sleep(30);
		pXPData->m_nID = ::GetTickCount();
		switch (pXPData->m_eType)
		{
		case AecEqui::kExtrude:
		case AecEqui::kRevolve:
			pXPData->m_nSize = ((AecEqui::XBuffer*)pData)->nSize;
			if (pXPData->m_nSize > 0)
			{
				pXPData->m_pData = new byte[pXPData->m_nSize];
				::memcpy(pXPData->m_pData, ((AecEqui::XBuffer*)pData)->pData, pXPData->m_nSize);
			}
			break;
		default:
			pXPData->m_pData = new T;
			::memcpy(pXPData->m_pData, pData, sizeof(T));
			pXPData->m_nSize = sizeof(T);
			break;
		}
	}

	void clearData(AecEqui::XPrimData &data)
	{
		data.releaseData();
	}

	CString makeValveName(LPCTSTR valve, const double &dDN, LPCTSTR sPN)
	{
		if (!valve || !sPN) return _T("");
		CString s(_T(""));
		s.Format(_T("%s(DN%d)(PN%s)"), valve, (int)dDN, sPN);
		return s;
	}

	AecDbEwEquipment* makeBaseEquiment(LPCTSTR name, bool bHvac = false)
	{
		if (!name) return NULL;
		AecDbEwEquipment* pWEquip = new AecDbEwEquipment;
		AecDbObjXDataMap* pXDataMap = pWEquip->GetSpecialtyData();
		pXDataMap->SetAt(KEY_NAME, name);
		pXDataMap->SetAt(KEY_FITSRV, KEY_FITWPIPE);
		pXDataMap->SetAt(KEY_RUNTIME, eEquipment);

		//设置图层
		CString sSys;
		pXDataMap->GetAt(PIPE_SYS, sSys);
		AcDbObjectId idLayer = AecInitLayerEx(LAY_PIPE_OUTSIDE, sSys, 7, _T("Continuous"), NULL);

		pWEquip->setLayer(idLayer);
		pWEquip->SetDashLayer(KTSetting::InitLayer(LAY_FITN_DASH));
		pWEquip->SetCenterLayer(KTSetting::InitLayer(LAY_FITN_CENTER));

		return pWEquip;
	}

	void getNozzInfo(const double &dDN, LPCTSTR sPN, double &dWD, double &dC, double &dYh, double &dN)
	{
		CUIISQLiteServer db;
		db.InitADOServer(FilePath::GetSysDir() + _T("\\plumbing.db"));

		double dPre(1.);
		if (sPN)
			dPre = _ttof(sPN);

		CoreTools::QueryFlangData(&db, dDN, dPre, dWD, dC, dYh, dN);
	}

	double getNozzRadius(const int &nFlangeType, const double &dDN, LPCTSTR sPN)
	{
		double dWD(.0), dC(.0), dYh(.0), dN(.0);
		getNozzInfo(dDN, sPN, dWD, dC, dYh, dN);
		if (!nFlangeType) return dDN * .5;
		return dWD * .5;
	}

	double getNozzLength(const int &nFlangeType, const double &dDN, LPCTSTR sPN)
	{
		double dWD(.0), dC(.0), dYh(.0), dN(.0);
		getNozzInfo(dDN, sPN, dWD, dC, dYh, dN);
		dYh = dC > dYh ? dYh : dC;
		return 2 * dYh * nFlangeType;
	}

	double getFlangeThick(const double &dDN, LPCTSTR sPN)
	{
		double dWD(.0), dC(.0), dYh(.0), dN(.0);
		getNozzInfo(dDN, sPN, dWD, dC, dYh, dN);
		return dYh;
	}

	void rotationSubPrimObj(AecDbEwEquipment *pEqu
		, const Adesk::Int32 &id
		, const double &angle
		, const int &axis)
	{
		AecEqui::XPrimData data;
		data.m_ptRotation = AcGePoint3d::kOrigin;
		data.m_ptRotation[axis] = CoreTools::A2R(angle);
		pEqu->ModifyPrimData(id, data, 3);
	}

	void moveSubPrimObj(AecDbEwEquipment *pEqu
		, const Adesk::Int32 &id
		, const double &dist
		, const int &axis)
	{
		AecEqui::XPrimData data;
		data.m_vtMove.set(0.0, 0.0, 0.0);
		data.m_vtMove[axis] = dist;
		pEqu->ModifyPrimData(id, data, 2);
	}

	void moveSubPrimObj(AecDbEwEquipment *pEqu
		, const Adesk::Int32 &id
		, const AcGePoint3d &pt1
		, const AcGePoint3d &pt2)
	{
		AcGeVector3d vtMove = pt2 - pt1;
		moveSubPrimObj(pEqu, id, vtMove.x, 0);
		moveSubPrimObj(pEqu, id, vtMove.y, 1);
		moveSubPrimObj(pEqu, id, vtMove.z, 2);
	}

	void makeNozzData(double dDN, LPCTSTR sPN, const int &nFlangeType, AecEqui::XNozz &nozz)
	{
		// 构造管嘴
		double nD = 0.0, nN = 0.0, nC = 0.0, dYMinh(.0);
		getNozzInfo(dDN, sPN, nD, nC, dYMinh, nN);

		// nFlangeType为0，说明阀门管嘴不需要法兰，默认为焊接管嘴
		nozz.bTwoFlags = nFlangeType == 0 ? 2 : 0;
		//if (nFlangeType == 0) nozz.bTwoFlags = 2;
		//else if (nFlangeType == 1) nozz.bTwoFlags = 0;
		//else nozz.bTwoFlags = 1;

		nozz.nCmd = 0;
		nozz.nType = 0;
		nozz.dVal1 = 1.0 * dDN;
		nozz.dVal2 = 1.0 * nD;
		nozz.dVal3 = 1.0 * nN;
		nozz.dVal4 = 1.0 * (nC = nC > dYMinh ? dYMinh : nC);
		nozz.dVal5 = 2 * nozz.dVal4;

		//兼容之前的,放到szResvr中
		sprintf(nozz.szResvr, "N=%d;P=%g;H=%d;", (int)nN, _ttof(sPN), (int)nozz.dVal5);
	}

	Adesk::Int32 addNozz(AecDbEwEquipment *pEqu
		, const Adesk::Int32 &id
		, double dDN
		, LPCTSTR sPN
		, const int &nFlangeType
		, const int &idxInter )
	{
		AecEqui::XPrimData* pPrimData = pEqu->GetSUbPrimObjByID(id);
		if (!pPrimData) return -1;


		int count = pEqu->GetInfFaceCount(pPrimData);
		if (idxInter < 0 || idxInter >= count) return -1;

		AcGePoint3d ptGe(AcGePoint3d::kOrigin);
		AcGeVector3d vtDir(AcGeVector3d::kIdentity);
		// 设置活动接口
		pPrimData->m_nActiveInf = idxInter;
		pEqu->GetInfFaceInf(pPrimData, vtDir, ptGe);
		if (vtDir.isZeroLength()) return -1;

		AecEqui::XNOZZ nozz;
		makeNozzData(dDN, sPN, nFlangeType, nozz);

		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNozz;
		setData<AecEqui::XNozz>(&data, &nozz);
		data.m_nActiveInf = 0;

		CoreTools::addNozzForEqu(pEqu, vtDir, ptGe, data);

		clearData(data);

		return data.m_nID;
	}

	template <typename T>
	Adesk::Int32 addSubPrimObj(AecDbEwEquipment *pEqu, T &t, const AecEqui::Primitive &type)
	{
		AecEqui::XPrimData data;
		data.m_eType = type;
		setData<T>(&data, &t);
		pEqu->AddSubPrimObj(&data);
		clearData(data);
		return data.m_nID;
	}

	AecDbEwEquipment *makeGuanDaoBuChangQi(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("管道补偿器"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment *pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(1, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(1, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - (nFlangeType == 1 ? (2 * dNozzL) : 0.)))
			L = (nFlangeType == 1 ? (2 * dNozzL) : 0.) + 1;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = L - (nFlangeType == 1 ? (2 * dNozzL) : 0.);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
		Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);
		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		cln.dr = R*.1;
		//cln.dH = L;
		double dist(cln.dr + FR);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
		moveSubPrimObj(pEqu, itemID, dist, 1);

		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
		moveSubPrimObj(pEqu, itemID, -dist, 1);

		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
		moveSubPrimObj(pEqu, itemID, dist, 2);

		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
		moveSubPrimObj(pEqu, itemID, -dist, 2);

		AecEqui::XBox box;
		box.dL = dNozzL;
		box.dW = 2 * R * .1;
		box.dH = 2 * FR + 2 * cln.dr;
		itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
		moveSubPrimObj(pEqu, itemID, -box.dH * .5, 2);
		dist = cln.dH * .5 - box.dL * .5;
		moveSubPrimObj(pEqu, itemID, dist, 0);

		itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
		moveSubPrimObj(pEqu, itemID, -box.dH * .5, 2);
		moveSubPrimObj(pEqu, itemID, -dist, 0);

		box.dL = dNozzL;
		box.dW = 2 * FR + 4 * cln.dr;
		box.dH = 2 * R * .1;
		itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
		moveSubPrimObj(pEqu, itemID, -box.dH * .5, 2);
		moveSubPrimObj(pEqu, itemID, dist, 0);

		itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
		moveSubPrimObj(pEqu, itemID, -box.dH * .5, 2);
		moveSubPrimObj(pEqu, itemID, -dist, 0);

		AecEqui::XCirtorus torus;
		torus.dInr = R;
		torus.dOutR = R * 1.2;
		torus.dStaAngle = .0;
		torus.dEndAngle = CoreTools::A2R(360 - 0.1);
		itemID = addSubPrimObj(pEqu, torus, AecEqui::kCirTorus);
		rotationSubPrimObj(pEqu, itemID, 90, 1);

		dist = (L - 2 * dNozzL) * .25 - (torus.dOutR - torus.dInr) * .5;
		itemID = addSubPrimObj(pEqu, torus, AecEqui::kCirTorus);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, dist, 0);

		itemID = addSubPrimObj(pEqu, torus, AecEqui::kCirTorus);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, 2 * dist, 0);

		itemID = addSubPrimObj(pEqu, torus, AecEqui::kCirTorus);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -dist, 0);

		itemID = addSubPrimObj(pEqu, torus, AecEqui::kCirTorus);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -2 * dist , 0);

		return pEqu;
	}


	AecDbEwEquipment* makeChuanLiJieTou(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("传力接头"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(1, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(1, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - (nFlangeType == 1 ? (2 * dNozzL) : 0.)))
			L = (nFlangeType == 1 ? (2 * dNozzL) : 0.) + 1;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = L - (nFlangeType == 1 ? (2 * dNozzL) : 0.);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
		Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);
		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = FR;
		cln.dH = dFangleL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -dFangleL * .5, 0);

		return pEqu;
	}

	AecDbEwEquipment* makeShenShuoJieTou(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("伸缩接头"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(1, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(1, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - (nFlangeType == 1 ? (2 * dNozzL) : 0.)))
			L = (nFlangeType == 1 ? (2 * dNozzL) : 0.) + 1;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = L - (nFlangeType == 1 ? (2 * dNozzL) : 0.);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
		Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);
		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		double dMainL(cln.dH);


		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = FR;
		cln.dH = dMainL * .5 * .618;
		double dl = dMainL * .25 - cln.dH * .5;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, dl, 0);

		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, -90, 1);
		moveSubPrimObj(pEqu, itemID, -dl, 0);

		return pEqu;
	}

	AecDbEwEquipment* makeXiangJiaoJieTou(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("橡胶接头"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(1, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(1, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - (nFlangeType == 1 ? (2 * dNozzL) : 0.)))
			L = (nFlangeType == 1 ? (2 * dNozzL) : 0.) + 1;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = L - (nFlangeType == 1 ? (2 * dNozzL) : 0.);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
		Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);
		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		AecEqui::XCone cone;
		memset(&cone, 0, sizeof(AecEqui::XCone));
		cone.dr = FR * .5;
		cone.dR = FR * .75;
		cone.dH = (L - 2 * dFangleL) / 3;
		cone.dXOffset = .0;
		itemID = addSubPrimObj(pEqu, cone, AecEqui::kCone);
		rotationSubPrimObj(pEqu, itemID, -90, 1);
		moveSubPrimObj(pEqu, itemID, -cone.dH * .5, 0);

		itemID = addSubPrimObj(pEqu, cone, AecEqui::kCone);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, cone.dH * .5, 0);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = cone.dR;
		cln.dH = cone.dH;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		return pEqu;
	}

	AecDbEwEquipment* makeDianCiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("电磁阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = L - 2 * dNozzL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
		Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);
		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		cln.dr = R * 1.5;
		cln.dH *= .75;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, 90, 1);
		moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = H - 2 * dFangleL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);


		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.2;
		cln.dH = dFangleL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H - 2 * dFangleL, 2);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H - 3 * dFangleL, 2);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.2 * .25;
		cln.dH = H * 1.2;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

		return pEqu;
	}

	AecDbEwEquipment* makePaiNiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("排泥阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		H -= dNozzL;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.2;
		cln.dH = H;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		// 下面加一个管嘴
		Adesk::Int32 id = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.2;
		cln.dH = L - R - dNozzL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		rotationSubPrimObj(pEqu, itemID, -90, 1);
		moveSubPrimObj(pEqu, itemID, (H + dNozzL) * .5, 2);

		id = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
		moveSubPrimObj(pEqu, id, -(L - R - dNozzL), 2);
		rotationSubPrimObj(pEqu, id, 180, 1);

		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.2 * 1.2;
		cln.dH = dFangleL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H, 2);
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H + dFangleL, 2);

		cln.dr = R * 1.2 * 1.2 * .5;
		cln.dH = L * .25;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H + 2 * dFangleL, 2);

		return pEqu;
	}

	AecDbEwEquipment* makeFuQiuFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("浮球阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		//阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀芯
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, -R * 1.5, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2 * 1.2;
			cln.dH = dFangleL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, -R * 1.5 - cln.dH, 2);

			AecEqui::XSphere sph;
			memset(&sph, 0, sizeof(AecEqui::XSphere));
			sph.dr = R * 1.2;
			itemID = addSubPrimObj(pEqu, sph, AecEqui::kSphere);
			moveSubPrimObj(pEqu, itemID, H - R * 1.5, 2);


			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = 150;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90 + 20, 1);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&sph, 0, sizeof(AecEqui::XSphere));
			sph.dr = 25;
			itemID = addSubPrimObj(pEqu, sph, AecEqui::kSphere);
			moveSubPrimObj(pEqu, itemID, H, 2);
			moveSubPrimObj(pEqu, itemID, 150, 0);
			moveSubPrimObj(pEqu, itemID, -150 * sin(CoreTools::A2R(10)), 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeShuiLiKongZhiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("水力控制阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		//阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀芯
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, -R * 1.5, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2 * 1.2;
			cln.dH = dFangleL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, -R * 1.5 - cln.dH, 2);

			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, H - R * 1.5, 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeTiaoJieFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("调节阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		//阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀芯
		{
			AecEqui::XSphere sph;
			memset(&sph, 0, sizeof(AecEqui::XSphere));
			sph.dr = R * 1.2 * 2;
			if (2 * sph.dr > L)
				sph.dr = L * .5 * .75;
			itemID = addSubPrimObj(pEqu, sph, AecEqui::kSphere);

			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R;
			cln.dH = 1.5 * sph.dr;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			AecEqui::XBox box;
			box.dL = 2 * R * 1.2;
			box.dW = box.dL;
			box.dH = dFangleL;
			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, cln.dH - box.dH, 2);

			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, cln.dH - 2 * box.dH, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R;
			cln.dH = R;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, H - R, 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeQiuFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("球阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		//阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀芯
		{
			AecEqui::XSphere sph;
			memset(&sph, 0, sizeof(AecEqui::XSphere));
			sph.dr = R * 1.2 * 2;
			if (2 * sph.dr > L)
				sph.dr = L * .5 * .75;
			itemID = addSubPrimObj(pEqu, sph, AecEqui::kSphere);

			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			AecEqui::XBox box;
			box.dL = 2 * R * 1.2;
			box.dW = box.dL;
			box.dH = dMaxW;
			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, cln.dH - box.dH, 2);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			itemID = addSubPrimObj(pEqu, cirtor, AecEqui::kCirTorus);
			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, -(R * .5 * .5 + R * .2 + box.dW * .5), 1);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, -(R * .5 * .5 + R * .2 + box.dW * .5), 1);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, -(R * .5 * .5 + R * .2 + box.dW * .5), 1);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR - cln.dH * .5, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = R * .5 * .5 + R * .2 + box.dW * .5;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR, 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeZhuShaiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("柱塞阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		//阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀芯
		{
			AecEqui::XSphere sph;
			memset(&sph, 0, sizeof(AecEqui::XSphere));
			sph.dr = R * 1.2 * 2;
			if (2 * sph.dr > L)
				sph.dr = L * .5 * .75;
			itemID = addSubPrimObj(pEqu, sph, AecEqui::kSphere);

			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R;
			cln.dH = 1.5 * sph.dr;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			AecEqui::XBox box;
			box.dL = 2 * R * 1.2;
			box.dW = box.dL;
			box.dH = dFangleL;
			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, cln.dH - box.dH, 2);

			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, cln.dH - 2 * box.dH, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			itemID = addSubPrimObj(pEqu, cirtor, AecEqui::kCirTorus);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, cln.dH * .5, 1);
			moveSubPrimObj(pEqu, itemID, H, 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeJiangYeFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("浆液阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);

		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		// 阀体 圆柱
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀芯
		{
			AecEqui::XBox box;
			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = L * .25;
			box.dW = 2 * R * 1.5;
			box.dH = box.dW;
			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, -box.dH * .5, 2);

			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = L * .25 * 1.5;
			box.dW = 2 * R * 1.5 * .5;
			box.dH = FR * .25;
			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);
			moveSubPrimObj(pEqu, itemID, 1.5 * R, 2);

			box.dL *= .5;
			box.dW *= .5;
			box.dH = H - 50;
			itemID = addSubPrimObj(pEqu, box, AecEqui::kBox);

			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			itemID = addSubPrimObj(pEqu, cirtor, AecEqui::kCirTorus);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, cln.dH * .5, 1);
			moveSubPrimObj(pEqu, itemID, H, 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makePaiQiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("排气阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);

		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		H -= dNozzL;

		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R;
		cln.dH = H;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		// 下面加一个管嘴
		Adesk::Int32 id = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);

		// 上面加一个管嘴
		id = addNozz(pEqu, itemID, dDN, pszPN, 0, 1);
		
		pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.5;
		cln.dH = dFangleL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H - dFangleL, 2);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.5;
		cln.dH = dFangleL;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H - 2 * dFangleL, 2);

		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = R * 1.2;
		cln.dH = H * .5;
		itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		moveSubPrimObj(pEqu, itemID, H * .5 - 2 * dFangleL, 2);
		return pEqu;
	}

	AecDbEwEquipment* makeZhaFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("闸阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);

		Adesk::Int32 itemID(0);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		if (DOWNEQUAL(H, L))
			H = 1.5 * L;
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		// 阀体 圆柱
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			// 先绕Y转90
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			// 再沿X走 dH 的一半
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			// 圆柱有两个接口，分别建两个管嘴
			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			// 关闭箭头
			pEqu->ModifyPrimData(0, data, 10);

		}

		// 阀台,其高度等于阀长
		{
			// 圆台
			AecEqui::XCone cone;
			memset(&cone, 0, sizeof(AecEqui::XCone));
			cone.dr = R * .5;
			cone.dR = R;
			cone.dH = L;
			cone.dXOffset = .0;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kCone;
			setData<AecEqui::XCone>(&data, &cone);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 绕Y转180
			rotationSubPrimObj(pEqu, itemID, 180, 1);
			// 沿Z移 dDN * .5
			moveSubPrimObj(pEqu, itemID, cone.dH, 2);

			// 其上画两个法片
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = dFangleL;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			// 沿Z移 动到圆台的顶部
			moveSubPrimObj(pEqu, itemID, cone.dH, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = dFangleL;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 沿Z移 动到圆台的顶部
			moveSubPrimObj(pEqu, itemID, cone.dH + dFangleL, 2);

			// 阀芯
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = .1 * R;
			cln.dH = H;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			data.m_eType = AecEqui::kCirTorus;
			setData<AecEqui::XCIRTORUS>(&data, &cirtor);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 移动到阀芯顶部
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, cln.dH * .5, 1);
			moveSubPrimObj(pEqu, itemID, H, 2);

		}

		return pEqu;
	}

	AecDbEwEquipment* makeDaoXingZhaFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("刀型闸阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);

		Adesk::Int32 itemID(0);


		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5), FR = getNozzRadius(nFlangeType, dDN, pszPN);

		if (DOWNEQUAL(H, 5 * FR))
			H = 5 * FR;

		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		// 阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			// 先绕Y转90
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			// 再沿X走 dH 的一半
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			// 圆柱有两个接口，分别建两个管嘴
			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			// 关闭箭头
			pEqu->ModifyPrimData(0, data, 10);
		}

		// 阀台
		{
			AecEqui::XBox box;
			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = L;
			box.dW = 2 * R * .9;
			box.dH = FR * 1.5;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kBox;
			setData<AecEqui::XBOX>(&data, &box);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 两个法兰片
			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = L * 1.1;
			box.dW = 2 * R * .9 * 1.1;
			box.dH = dFangleL;
			data.m_eType = AecEqui::kBox;
			setData<AecEqui::XBOX>(&data, &box);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			moveSubPrimObj(pEqu, itemID, FR * 1.5, 2);

			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = L * 1.1;
			box.dW = 2 * R * .9 * 1.1;
			box.dH = dFangleL;
			data.m_eType = AecEqui::kBox;
			setData<AecEqui::XBOX>(&data, &box);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			moveSubPrimObj(pEqu, itemID, FR * 1.5 + dFangleL, 2);

			// 方柱
			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = L * .9;
			box.dW = 2 * R * .9 * .9;
			box.dH = H * .75;
			data.m_eType = AecEqui::kBox;
			setData<AecEqui::XBOX>(&data, &box);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 圆柱
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = H;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			data.m_eType = AecEqui::kCirTorus;
			setData<AecEqui::XCIRTORUS>(&data, &cirtor);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 移动到阀芯顶部
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, cln.dH * .5, 1);
			moveSubPrimObj(pEqu, itemID, H, 2);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeJieZhiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("截止阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);

		if (DOWNEQUAL(H, FR + dFangleL))
		{
			H = FR + dFangleL + 50;
		}
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		Adesk::Int32 itemID(0);

		// 阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			// 先绕Y转90
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			// 再沿X走 dH 的一半
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			// 圆柱有两个接口，分别建两个管嘴
			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			// 关闭箭头
			pEqu->ModifyPrimData(0, data, 10);
		}
		// 阀台
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = L * .25;
			cln.dH = FR;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			AecEqui::XSphere sph;
			sph.dr = L * .25;
			data.m_eType = AecEqui::kSphere;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = L * .25;
			cln.dH = dFangleL;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			moveSubPrimObj(pEqu, itemID, FR, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = L * .25 * .5;
			cln.dH = H - dFangleL - FR - 10;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1;
			cln.dH = H;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			data.m_eType = AecEqui::kCirTorus;
			setData<AecEqui::XCIRTORUS>(&data, &cirtor);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 移动到阀芯顶部
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, H, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, cln.dH * .5, 1);
			moveSubPrimObj(pEqu, itemID, H, 2);
		}
		return pEqu;
	}

	AecDbEwEquipment* makeDieFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("蝶阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);

		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		if (DOWNEQUAL(H, FR))
		{
			H = 4 * L;
		}

		Adesk::Int32 itemID(0);

		// 阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			// 先绕Y转90
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			// 再沿X走 dH 的一半
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			// 圆柱有两个接口，分别建两个管嘴
			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			// 关闭箭头
			pEqu->ModifyPrimData(0, data, 10);
		}
		//
		{
			AecEqui::XBox box;
			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = (L + 2 * dNozzL) * .25;
			box.dW = R * .5;
			box.dH = H;
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kBox;
			setData<AecEqui::XBOX>(&data, &box);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			// 手盘
			AecEqui::XCirtorus cirtor;
			memset(&cirtor, 0, sizeof(AecEqui::XCirtorus));
			cirtor.dOutR = dMaxW * .5;
			cirtor.dInr = cirtor.dOutR - R * .2;
			cirtor.dStaAngle = .0;
			cirtor.dEndAngle = CoreTools::A2R(360 - 0.1);
			data.m_eType = AecEqui::kCirTorus;
			setData<AecEqui::XCIRTORUS>(&data, &cirtor);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);

			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, -(R * .5 * .5 + R * .2 + 10), 1);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR, 2);

			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
			moveSubPrimObj(pEqu, itemID, -(R * .5 * .5 + R * .2 + 10), 1);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = dMaxW - R * .1;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			moveSubPrimObj(pEqu, itemID, -(R * .5 * .5 + R * .2 + 10), 1);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR - cln.dH * .5, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .1 * .5;
			cln.dH = R * .5 * .5 + R * .2 + 10;
			data.m_eType = AecEqui::kCylinder;
			setData<AecEqui::XCYLINDER>(&data, &cln);
			pEqu->AddSubPrimObj(&data);
			itemID = data.m_nID;
			clearData(data);
			rotationSubPrimObj(pEqu, itemID, 90, 0);
			moveSubPrimObj(pEqu, itemID, H - cirtor.dOutR, 2);
		}
		return pEqu;
	}

	AecDbEwEquipment* makeZhiHuiFa(const double &dDN
		, LPCTSTR pszPN
		, LPCTSTR pszMaterial
		, const double &dMaxL
		, const double &dMaxW
		, const double &dMaxH
		, const int &nFlangeType
		, std::map<CString, CString> &bims)
	{
		if (!pszPN) return NULL;
		CString sName = makeValveName(_T("止回阀"), dDN, pszPN);
		if (sName.IsEmpty()) return NULL;
		AecDbEwEquipment* pEqu = makeBaseEquiment(sName);

		double L(dMaxL), H(dMaxH), W(dMaxW), R(dDN * .5);
		double FR = getNozzRadius(nFlangeType, dDN, pszPN);
		double dNozzL = getNozzLength(nFlangeType, dDN, pszPN);
		double dFangleL = getFlangeThick(dDN, pszPN);
		if (DOWN_ZERO(L - 2 * dNozzL))
			L = 2 * dNozzL + 1;

		Adesk::Int32 itemID(0);

		// 阀体
		{
			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * 1.2;
			cln.dH = L - 2 * dNozzL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			// 先绕Y转90
			rotationSubPrimObj(pEqu, itemID, 90, 1);
			// 再沿X走 dH 的一半
			moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);

			// 圆柱有两个接口，分别建两个管嘴
			Adesk::Int32 id0 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 0);
			Adesk::Int32 id1 = addNozz(pEqu, itemID, dDN, pszPN, nFlangeType, 1);

			// 关闭箭头
			pEqu->ModifyPrimData(0, AecEqui::XPrimData(), 10);
		}

		// 阀台
		{
			AecEqui::XSphere sph;
			memset(&sph, 0, sizeof(AecEqui::XSphere));
			sph.dr = 1.5 * R;
			itemID = addSubPrimObj(pEqu, sph, AecEqui::kSphere);

			AecEqui::XTydf tydf;
			memset(&tydf, 0, sizeof(AecEqui::XTydf));
			tydf.dTR = sph.dr;
			tydf.dTL = 2 * sph.dr;
			tydf.dTW = tydf.dTL;
			tydf.dH = sph.dr;
			tydf.dXOffset = .0;
			itemID = addSubPrimObj(pEqu, tydf, AecEqui::kTydf);
			rotationSubPrimObj(pEqu, itemID, -90, 1);
			moveSubPrimObj(pEqu, itemID, tydf.dH, 0);

			AecEqui::XCylinder cln;
			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .5;
			cln.dH = H;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .5 * 1.5;
			cln.dH = dFangleL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, H - dFangleL, 2);

			memset(&cln, 0, sizeof(AecEqui::XCylinder));
			cln.dr = R * .5 * 1.5;
			cln.dH = dFangleL;
			itemID = addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
			moveSubPrimObj(pEqu, itemID, H - 2 * dFangleL, 2);
		}

		return pEqu;
	}
}

namespace MKHvacValve
{
	namespace
	{
		AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
			, const double& dL
			, const double& dW)
		{
			AcGePoint3d pt0(-dL * .5, dW * .5, .0)
				, pt1(dL * .5, dW * .5, .0)
				, pt2(dL * .5, -dW * .5, .0)
				, pt3(-dL * .5, -dW * .5, .0);

			AcDbVoidPtrArray ar;
			ar.append(new AcDbLine(pt0, pt1));
			ar.append(new AcDbLine(pt1, pt2));
			ar.append(new AcDbLine(pt2, pt3));
			ar.append(new AcDbLine(pt3, pt0));
			AcDbRegion* pReg = CoreTools::createRegion(ar);

			if (pReg)
			{
				AcGeMatrix3d mat;
				mat.setToTranslation(ptOrg.asVector());
				pReg->transformBy(mat);
			}

			deleteArrayVoidPtrs< AcDbLine>(ar);
			return pReg;
		}

		AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
			, const double& dL
			, const double& dW
			, const AcGeVector3d& vecL
			, const AcGeVector3d& vecW
		)
		{
			AcGePoint3d ptGe[5] ;

			ptGe[0] = ptOrg + vecW * dW * .5;
			ptGe[0] += vecL * dL * .5;
			ptGe[1] = ptGe[0] - vecW * dW;
			ptGe[2] = ptGe[1] - vecL * dL;
			ptGe[3] = ptGe[2] + vecW * dW;
			ptGe[4] = ptGe[0];

			return AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
		}

		AcDbPolyline* makeRectPoly(const AcGePoint3d& ptOrg
			, const double& dL
			, const double& dW
			, const AcGeVector3d& vecL
			, const AcGeVector3d& vecW
		)
		{
			AcGePoint3d ptGe[5];

			ptGe[0] = ptOrg + vecW * dW * .5;
			ptGe[0] += vecL * dL * .5;
			ptGe[1] = ptGe[0] - vecW * dW;
			ptGe[2] = ptGe[1] - vecL * dL;
			ptGe[3] = ptGe[2] + vecW * dW;
			ptGe[4] = ptGe[0];

			return FormatPolyline(ptGe, 5);
		}

		AcDbRegion* makeCircleRegion(const AcGePoint3d& ptOrg
			, const AcGeVector3d& vtZ
			, const double& dR)
		{
			AcDbCircle* pCir(new AcDbCircle(ptOrg, vtZ, dR));
			AcDbRegion* pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			return pReg;
		}
		
		template <typename T>
		void setData(AecEqui::XPrimData* pXPData, void* pData)
		{
			pXPData->m_nID = ::_time32(NULL);
			switch (pXPData->m_eType)
			{
			case AecEqui::kExtrude:
			case AecEqui::kRevolve:
				pXPData->m_nSize = ((AecEqui::XBuffer*)pData)->nSize;
				if (pXPData->m_nSize > 0)
				{
					pXPData->m_pData = new byte[pXPData->m_nSize];
					::memcpy(pXPData->m_pData, ((AecEqui::XBuffer*)pData)->pData, pXPData->m_nSize);
				}
				break;
			default:
				pXPData->m_pData = new T;
				::memcpy(pXPData->m_pData, pData, sizeof(T));
				pXPData->m_nSize = sizeof(T);
				break;
			}
		}
	}

	Adesk::Int32 makeValveBody_Rect(AecDbEwEquipment* pEqu
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecEqui::XBox box;
		box.dL = dH;
		box.dW = dW;
		box.dH = dFL - 2 * dFlT;
		Adesk::Int32 itemID = MKValve::addSubPrimObj(pEqu, box, AecEqui::kBox);
		MKValve::rotationSubPrimObj(pEqu, itemID, 90, 1);
		MKValve::moveSubPrimObj(pEqu, itemID, -box.dH * .5, 0);

		CoreTools::addNozzForEqu_Rect(pEqu
			, AcGeVector3d::kXAxis
			, AcGePoint3d(box.dH * .5, 0, 0)
			, dH, dW, dFlT, dFlE, dFlT, 0, false, false);
		CoreTools::addNozzForEqu_Rect(pEqu
			, -AcGeVector3d::kXAxis
			, AcGePoint3d(-box.dH * .5, 0, 0)
			, dH, dW, dFlT, dFlE, dFlT, 0, false, false);

		return itemID;
	}

	Adesk::Int32 makeValveBody_Circle(AecDbEwEquipment* pEqu
		, const double& dDN	// 圆管公称
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecEqui::XCylinder cln;
		memset(&cln, 0, sizeof(AecEqui::XCylinder));
		cln.dr = dDN * .5;
		cln.dH = dFL - 2 * dFlT;
		Adesk::Int32 itemID = MKValve::addSubPrimObj(pEqu, cln, AecEqui::kCylinder);
		MKValve::rotationSubPrimObj(pEqu, itemID, 90, 1);
		MKValve::moveSubPrimObj(pEqu, itemID, -cln.dH * .5, 0);
		CoreTools::addNozzForEqu_Rect(pEqu
			, AcGeVector3d::kXAxis
			, AcGePoint3d(cln.dH * .5, 0, 0)
			, dDN, dDN + dFlE, dFlT, dFlT, dFlT, 0, true, false);

		CoreTools::addNozzForEqu_Rect(pEqu
			, -AcGeVector3d::kXAxis
			, AcGePoint3d(-cln.dH * .5, 0, 0)
			, dDN, dDN + dFlE, dFlT, dFlT, dFlT, 0, true, false);
		return itemID;
	}


	// 2d 绘制数据埋入
	void setDrawData(AecDbEwEquipment* pEqu
		, const int& type
		, const bool bRect
		, const double& dDN		// 圆管公称
		, const double& dW		// 方管长
		, const double& dFL		// 阀门长
		, const double& dFlE	// 法兰卷边
	)
	{
		pEqu->GetSpecialtyData()->SetAt(_T("_hvac_valve_shape"), bRect ? 0 : 1);
		pEqu->GetSpecialtyData()->SetAt(_T("_hvac_valve_w"), bRect ? dW : dDN);
		pEqu->GetSpecialtyData()->SetAt(_T("_hvac_valve_l"), dFL);
		pEqu->GetSpecialtyData()->SetAt(_T("_hvac_valve_fle"), dFlE);

		//类型 0调节阀 1止回阀 2防火阀 3闸板阀 4蝶阀 5定风量阀 6风口
		pEqu->GetSpecialtyData()->SetAt(_T("_hvac_valve_type"), type);
	}

	void clearData(AecEqui::XPrimData& data)
	{
		// 再XPrimData类的析构函数中已经释放了m_pData
		return;
		switch (data.m_eType)
		{
		case AecEqui::kExtrude:
		case AecEqui::kRevolve:
			DELETE_ARR_(data.m_pData);
			break;
		default:
			DELETE_PTR(data.m_pData);
			break;
		}
		return;
	}

	void FunmakeFangZhiDingFa_Rect(AecDbEwEquipment* pEqu
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{

		AecEqui::XBox boxFront;
		memset(&boxFront, 0, sizeof(AecEqui::XBox));
		boxFront.dL = 2 * dW / 15;
		boxFront.dW = dH / 15;
		boxFront.dH = 7 * dH / 18;

		AcGeVector3d vecFrontR(-dH / 5, -dW / 2 - dH / 30, dH / 4);
		AecEqui::XPrimData dataFront;
		dataFront.m_eType = AecEqui::kBox;
		dataFront.m_iClr = 256;
		dataFront.m_bBoolSubtract = FALSE;
		dataFront.m_vtMove = vecFrontR;
		dataFront.m_ptRotation.set(PI / 2.0, PI / 2.0, PI / 2.0);
		setData<AecEqui::XBOX>(&dataFront, &boxFront);
		pEqu->AddSubPrimObj(&dataFront);
		clearData(dataFront);

		AecEqui::XCylinder CylinderFrontC;
		memset(&CylinderFrontC, 0, sizeof(AecEqui::XCylinder));
		CylinderFrontC.dr = dW / 30;
		CylinderFrontC.dH = dH / 15;

		AcGeVector3d vecFrontC(0, -dW / 2 - dH / 15, dH / 4);
		AecEqui::XPrimData dataFrontC;
		dataFrontC.m_eType = AecEqui::kCylinder;
		dataFrontC.m_iClr = 256;
		dataFrontC.m_bBoolSubtract = false;
		dataFrontC.m_vtMove = vecFrontC;
		dataFrontC.m_ptRotation.set(PI / 2, 0, 0);
		setData<AecEqui::XCylinder>(&dataFrontC, &CylinderFrontC);
		pEqu->AddSubPrimObj(&dataFrontC);
		clearData(dataFrontC);

		AecEqui::XCylinder CylinderFrontCM;
		memset(&CylinderFrontCM, 0, sizeof(AecEqui::XCylinder));
		CylinderFrontCM.dr = dW / 400;
		CylinderFrontCM.dH = dH / 3;

		AcGeVector3d vecFrontCM(0, -38 * dW / 75 - dH / 10, dH / 4);
		AecEqui::XPrimData dataFrontCM;
		dataFrontCM.m_eType = AecEqui::kCylinder;
		dataFrontCM.m_iClr = 256;
		dataFrontCM.m_bBoolSubtract = false;
		dataFrontCM.m_vtMove = vecFrontCM;
		dataFrontCM.m_ptRotation.set(PI / 4, 0, PI / 2);
		setData<AecEqui::XCylinder>(&dataFrontCM, &CylinderFrontCM);
		pEqu->AddSubPrimObj(&dataFrontCM);
		clearData(dataFrontCM);

		AecEqui::XCylinder CylinderFrontCT;
		memset(&CylinderFrontCT, 0, sizeof(AecEqui::XCylinder));
		CylinderFrontCT.dr = 3 * dW / 400;
		CylinderFrontCT.dH = dH / 30;

		AcGeVector3d vecFrontCT(dH * cos(PI / 4) / 3, -38 * dW / 75 - dH / 3 + dH * sin(PI / 4) / 3, dH / 4 + dH * cos(PI / 4) / 3);
		AecEqui::XPrimData dataFrontCT;
		dataFrontCT.m_eType = AecEqui::kCylinder;
		dataFrontCT.m_iClr = 256;
		dataFrontCT.m_bBoolSubtract = false;
		dataFrontCT.m_vtMove = vecFrontCT;
		dataFrontCT.m_ptRotation.set(0, PI / 4, 0);
		setData<AecEqui::XCylinder>(&dataFrontCT, &CylinderFrontCT);
		pEqu->AddSubPrimObj(&dataFrontCT);
		clearData(dataFrontCT);
	}

	void FunmakeFangZhiDingFa_Circle(AecDbEwEquipment* pEqu
		, const double& dDN //圆管公称
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		
		AecEqui::XBox boxFront;
		memset(&boxFront, 0, sizeof(AecEqui::XBox));
		boxFront.dL = 2 * dDN / 15;
		boxFront.dW = dDN / 45;
		boxFront.dH = 7 * dDN / 54;

		AcGeVector3d vecFrontR(-dDN / 15, -dDN / 2 - dDN / 90, dDN / 12);
		AecEqui::XPrimData dataFront;
		dataFront.m_eType = AecEqui::kBox;
		dataFront.m_iClr = 256;
		dataFront.m_bBoolSubtract = FALSE;
		dataFront.m_vtMove = vecFrontR;
		dataFront.m_ptRotation.set(PI / 2.0, PI / 2.0, PI / 2.0);
		setData<AecEqui::XBOX>(&dataFront, &boxFront);
		pEqu->AddSubPrimObj(&dataFront);
		clearData(dataFront);

		AecEqui::XCylinder CylinderFrontC;
		memset(&CylinderFrontC, 0, sizeof(AecEqui::XCylinder));
		CylinderFrontC.dr = dDN / 30;
		CylinderFrontC.dH = dDN / 45;

		AcGeVector3d vecFrontC(0, -dDN / 2 - dDN / 45, dDN / 12);
		AecEqui::XPrimData dataFrontC;
		dataFrontC.m_eType = AecEqui::kCylinder;
		dataFrontC.m_iClr = 256;
		dataFrontC.m_bBoolSubtract = false;
		dataFrontC.m_vtMove = vecFrontC;
		dataFrontC.m_ptRotation.set(PI / 2, 0, 0);
		setData<AecEqui::XCylinder>(&dataFrontC, &CylinderFrontC);
		pEqu->AddSubPrimObj(&dataFrontC);
		clearData(dataFrontC);

		AecEqui::XCylinder CylinderFrontCM;
		memset(&CylinderFrontCM, 0, sizeof(AecEqui::XCylinder));
		CylinderFrontCM.dr = dDN / 400;
		CylinderFrontCM.dH = dDN / 9;

		AcGeVector3d vecFrontCM(0, -38 * dDN / 75 - dDN / 30, dDN / 12);
		AecEqui::XPrimData dataFrontCM;
		dataFrontCM.m_eType = AecEqui::kCylinder;
		dataFrontCM.m_iClr = 256;
		dataFrontCM.m_bBoolSubtract = false;
		dataFrontCM.m_vtMove = vecFrontCM;
		dataFrontCM.m_ptRotation.set(PI / 4, 0, PI / 2);
		setData<AecEqui::XCylinder>(&dataFrontCM, &CylinderFrontCM);
		pEqu->AddSubPrimObj(&dataFrontCM);
		clearData(dataFrontCM);

		AecEqui::XCylinder CylinderFrontCT;
		memset(&CylinderFrontCT, 0, sizeof(AecEqui::XCylinder));
		CylinderFrontCT.dr = 3 * dDN / 400;
		CylinderFrontCT.dH = dDN / 90;

		AcGeVector3d vecFrontCT(dDN * cos(PI / 4) / 9, -38 * dDN / 75 - dDN / 9 + dDN * sin(PI / 4) / 9, dDN / 12 + dDN * cos(PI / 4) / 9);
		AecEqui::XPrimData dataFrontCT;
		dataFrontCT.m_eType = AecEqui::kCylinder;
		dataFrontCT.m_iClr = 256;
		dataFrontCT.m_bBoolSubtract = false;
		dataFrontCT.m_vtMove = vecFrontCT;
		dataFrontCT.m_ptRotation.set(0, PI / 4, 0);
		setData<AecEqui::XCylinder>(&dataFrontCT, &CylinderFrontCT);
		pEqu->AddSubPrimObj(&dataFrontCT);
		clearData(dataFrontCT);
		
	}

	void FunmakeZhaBanFa_Rect(AecDbEwEquipment* pEqu
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecEqui::XBox boxTop;
		memset(&boxTop, 0, sizeof(AecEqui::XBox));
		boxTop.dL = dW;
		boxTop.dW = dH / 10;
		boxTop.dH = 7 * dH / 12;

		AcGeVector3d vecTop(-17 * dH / 60, 0, 29 * dH / 20);
		AecEqui::XPrimData dataTop;
		dataTop.m_eType = AecEqui::kBox;
		dataTop.m_iClr = 256;
		dataTop.m_bBoolSubtract = FALSE;
		dataTop.m_vtMove = vecTop;
		dataTop.m_ptRotation.set(PI / 2.0, 0, PI / 2.0);
		setData<AecEqui::XBOX>(&dataTop, &boxTop);


		AecEqui::XBox boxLeft;
		memset(&boxLeft, 0, sizeof(AecEqui::XBox));
		boxLeft.dL = dH / 10;
		boxLeft.dW = 7 * dH / 12;
		boxLeft.dH = 9 * dH / 10;

		AcGeVector3d vecLeft(dH / 120, dH, dH / 2);
		AecEqui::XPrimData dataLeft;
		dataLeft.m_eType = AecEqui::kBox;
		dataLeft.m_iClr = 256;
		dataLeft.m_bBoolSubtract = FALSE;
		dataLeft.m_vtMove = vecLeft;
		dataLeft.m_ptRotation.set(0, 0, PI / 2.0);
		setData<AecEqui::XBOX>(&dataLeft, &boxLeft);

		AcGeVector3d vecRight(dH / 120, -dH, dH / 2);
		AecEqui::XPrimData dataRight;
		dataRight.m_eType = AecEqui::kBox;
		dataRight.m_iClr = 256;
		dataRight.m_bBoolSubtract = FALSE;
		dataRight.m_vtMove = vecRight;
		dataRight.m_ptRotation.set(0, 0, PI * .5);
		setData<AecEqui::XBOX>(&dataRight, &boxLeft);

		pEqu->AddSubPrimObj(&dataTop);
		pEqu->AddSubPrimObj(&dataLeft);
		pEqu->AddSubPrimObj(&dataRight);
		clearData(dataTop);
		clearData(dataLeft);
		clearData(dataRight);

		AecEqui::XCylinder CylinderDown;
		memset(&CylinderDown, 0, sizeof(AecEqui::XCylinder));
		CylinderDown.dr = dW / 80;
		CylinderDown.dH = 7 * dH / 4;

		AecEqui::XPrimData dataDown;
		dataDown.m_eType = AecEqui::kCylinder;
		dataDown.m_iClr = 256;
		dataDown.m_bBoolSubtract = false;
		setData<AecEqui::XCylinder>(&dataDown, &CylinderDown);
		pEqu->AddSubPrimObj(&dataDown);
		clearData(dataDown);
		

		AcGePoint3d ptPath(0, 0, 0);
		AcGeVector3d vtN(0, 0, 1);
		AcDbCircle* pCir = new AcDbCircle(ptPath, vtN, 3 * dH / 10);
		AcDbPolyline* pPath = CoreTools::MakePolyline(pCir);
		DELETE_PTR(pCir);

		AcGePoint3d ptreg(dH / 4, 0, dH / 60);
		AcGeVector3d vec(0, 1, 0);
		pCir = new AcDbCircle(ptreg, vec, dH / 60);
		AcDbRegion* pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);

		if (!pPath || !pReg)
		{
			DELETE_PTR(pPath);
			DELETE_PTR(pReg);
			DELETE_PTR(pEqu);
			return ;
		}

		AcGeVector3d vecPt(0, 0, 26 * dH / 15);

		NewSweep ns(true, pReg, pPath);
		DELETE_PTR(pPath);
		DELETE_PTR(pReg);

		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		data.m_vtMove = vecPt;
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);


		AcGeVector3d vecPt1(-dH / 4, 0, 26 * dH / 15);
		AecEqui::XCylinder CylinderDown1;
		memset(&CylinderDown1, 0, sizeof(AecEqui::XCylinder));
		CylinderDown1.dr = dH / 60;
		CylinderDown1.dH = dH / 2;

		AecEqui::XPrimData dataDown1;
		dataDown1.m_eType = AecEqui::kCylinder;
		dataDown1.m_iClr = 256;
		dataDown1.m_bBoolSubtract = false;
		dataDown1.m_vtMove = vecPt1;
		dataDown1.m_ptRotation.set(0, PI / 2, 0);
		setData<AecEqui::XCylinder>(&dataDown1, &CylinderDown1);
		pEqu->AddSubPrimObj(&dataDown1);
		clearData(dataDown1);

		AcGeVector3d vecPt2(0, dH / 4, 26 * dH / 15);
		AecEqui::XPrimData dataDown2;
		dataDown2.m_eType = AecEqui::kCylinder;
		dataDown2.m_iClr = 256;
		dataDown2.m_bBoolSubtract = false;
		dataDown2.m_vtMove = vecPt2;
		dataDown2.m_ptRotation.set(PI / 2, 0, 0);
		setData<AecEqui::XCylinder>(&dataDown2, &CylinderDown1);
		pEqu->AddSubPrimObj(&dataDown2);
		clearData(dataDown2);
	}

	void FunmakeZhaBanFa_Circle(AecDbEwEquipment* pEqu
		, const double& dDN //圆管公称
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecEqui::XCylinder CylinderDown;
		memset(&CylinderDown, 0, sizeof(AecEqui::XCylinder));
		CylinderDown.dr = dDN / 80;
		CylinderDown.dH = 7 * dDN / 12;

		AecEqui::XPrimData dataDown;
		dataDown.m_eType = AecEqui::kCylinder;
		dataDown.m_iClr = 256;
		dataDown.m_bBoolSubtract = false;
		setData<AecEqui::XCylinder>(&dataDown, &CylinderDown);
		pEqu->AddSubPrimObj(&dataDown);
		clearData(dataDown);


		AcGePoint3d ptPath(0, 0, 0);
		AcGeVector3d vtN(0, 0, 1);
		AcDbCircle* pCir = new AcDbCircle(ptPath, vtN, dDN / 10);
		AcDbPolyline* pPath = CoreTools::MakePolyline(pCir);
		DELETE_PTR(pCir);

		AcGePoint3d ptreg(dDN / 12, 0, dDN / 180);
		AcGeVector3d vec(0, 1, 0);
		pCir = new AcDbCircle(ptreg, vec, dDN / 180);
		AcDbRegion* pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);

		if (!pPath || !pReg)
		{
			DELETE_PTR(pPath);
			DELETE_PTR(pReg);
			DELETE_PTR(pEqu);
			return;
		}

		AcGeVector3d vecPt(0, 0, 26 * dDN / 45);

		NewSweep ns(true, pReg, pPath);
		DELETE_PTR(pPath);
		DELETE_PTR(pReg);

		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		data.m_vtMove = vecPt;
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);


		AcGeVector3d vecPt1(-dDN / 12, 0, 26 * dDN / 45);
		AecEqui::XCylinder CylinderDown1;
		memset(&CylinderDown1, 0, sizeof(AecEqui::XCylinder));
		CylinderDown1.dr = dDN / 180;
		CylinderDown1.dH = dDN / 6;

		AecEqui::XPrimData dataDown1;
		dataDown1.m_eType = AecEqui::kCylinder;
		dataDown1.m_iClr = 256;
		dataDown1.m_bBoolSubtract = false;
		dataDown1.m_vtMove = vecPt1;
		dataDown1.m_ptRotation.set(0, PI / 2, 0);
		setData<AecEqui::XCylinder>(&dataDown1, &CylinderDown1);
		pEqu->AddSubPrimObj(&dataDown1);
		clearData(dataDown1);

		AcGeVector3d vecPt2(0, dDN / 12, 26 * dDN / 45);
		AecEqui::XPrimData dataDown2;
		dataDown2.m_eType = AecEqui::kCylinder;
		dataDown2.m_iClr = 256;
		dataDown2.m_bBoolSubtract = false;
		dataDown2.m_vtMove = vecPt2;
		dataDown2.m_ptRotation.set(PI / 2, 0, 0);
		setData<AecEqui::XCylinder>(&dataDown2, &CylinderDown1);
		pEqu->AddSubPrimObj(&dataDown2);
		clearData(dataDown2);
	}

	void FunmakeDieFa_Rect(AecDbEwEquipment* pEqu
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecEqui::XCylinder CylinderDown;
		memset(&CylinderDown, 0, sizeof(AecEqui::XCylinder));
		CylinderDown.dr = dW / 320;
		CylinderDown.dH = dH;

		AecEqui::XPrimData dataDown;
		dataDown.m_eType = AecEqui::kCylinder;
		dataDown.m_iClr = 256;
		dataDown.m_bBoolSubtract = false;
		setData<AecEqui::XCylinder>(&dataDown, &CylinderDown);
		pEqu->AddSubPrimObj(&dataDown);
		clearData(dataDown);

		AecEqui::XCylinder CylinderUp;
		memset(&CylinderUp, 0, sizeof(AecEqui::XCylinder));
		CylinderUp.dr = dW / 40;
		CylinderUp.dH = dH / 4.0;

		AcGeVector3d Vec(0, dH / 8.0, dH + dW / 40.0);
		AecEqui::XPrimData dataUp;
		dataUp.m_eType = AecEqui::kCylinder;
		dataUp.m_iClr = 256;
		dataUp.m_bBoolSubtract = false;
		dataUp.m_ptRotation.set(PI / 2.0, PI / 2.0, 0);
		dataUp.m_vtMove = Vec;
		setData<AecEqui::XCylinder>(&dataUp, &CylinderUp);
		pEqu->AddSubPrimObj(&dataUp);
		clearData(dataUp);

		AecEqui::XCylinder CylinderUpL;
		memset(&CylinderUpL, 0, sizeof(AecEqui::XCylinder));
		CylinderUpL.dr = dW / 20;
		CylinderUpL.dH = dH / 4.0;

		AcGeVector3d VecL(0, 3.0 * dH / 8.0, dH + dW / 40.0);
		AecEqui::XPrimData dataUpL;
		dataUpL.m_eType = AecEqui::kCylinder;
		dataUpL.m_iClr = 256;
		dataUpL.m_bBoolSubtract = false;
		dataUpL.m_ptRotation.set(PI / 2.0, PI / 2.0, 0);
		dataUpL.m_vtMove = VecL;
		setData<AecEqui::XCylinder>(&dataUpL, &CylinderUpL);
		pEqu->AddSubPrimObj(&dataUpL);
		clearData(dataUpL);

		AecEqui::XCylinder CylinderUpR;
		memset(&CylinderUpR, 0, sizeof(AecEqui::XCylinder));
		CylinderUpR.dr = dW / 20;
		CylinderUpR.dH = dH / 4.0;

		AcGeVector3d VecR(0, -dH / 8.0, dH + dW / 40.0);
		AecEqui::XPrimData dataUpR;
		dataUpR.m_eType = AecEqui::kCylinder;
		dataUpR.m_iClr = 256;
		dataUpR.m_bBoolSubtract = false;
		dataUpR.m_ptRotation.set(PI / 2.0, PI / 2.0, 0);
		dataUpR.m_vtMove = VecR;
		setData<AecEqui::XCylinder>(&dataUpR, &CylinderUpR);
		pEqu->AddSubPrimObj(&dataUpR);
		clearData(dataUpR);
	}

	void FunmakeDieFa_Circle(AecDbEwEquipment* pEqu
		, const double& dDN //圆管公称
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecEqui::XCylinder CylinderDown;
		memset(&CylinderDown, 0, sizeof(AecEqui::XCylinder));
		CylinderDown.dr = dDN / 160;
		CylinderDown.dH = 2 * dDN / 3;

		AecEqui::XPrimData dataDown;
		dataDown.m_eType = AecEqui::kCylinder;
		dataDown.m_iClr = 256;
		dataDown.m_bBoolSubtract = false;
		setData<AecEqui::XCylinder>(&dataDown, &CylinderDown);
		pEqu->AddSubPrimObj(&dataDown);
		clearData(dataDown);

		AecEqui::XCylinder CylinderUp;
		memset(&CylinderUp, 0, sizeof(AecEqui::XCylinder));
		CylinderUp.dr = dDN / 20;
		CylinderUp.dH = dDN / 6;

		AcGeVector3d Vec(0, dDN / 12, 43 * dDN / 60);
		AecEqui::XPrimData dataUp;
		dataUp.m_eType = AecEqui::kCylinder;
		dataUp.m_iClr = 256;
		dataUp.m_bBoolSubtract = false;
		dataUp.m_ptRotation.set(PI / 2.0, PI / 2.0, 0);
		dataUp.m_vtMove = Vec;
		setData<AecEqui::XCylinder>(&dataUp, &CylinderUp);
		pEqu->AddSubPrimObj(&dataUp);
		clearData(dataUp);

		AecEqui::XCylinder CylinderUpL;
		memset(&CylinderUpL, 0, sizeof(AecEqui::XCylinder));
		CylinderUpL.dr = dDN / 10;
		CylinderUpL.dH = dDN / 6;

		AcGeVector3d VecL(0, dDN / 4, 43 * dDN / 60);
		AecEqui::XPrimData dataUpL;
		dataUpL.m_eType = AecEqui::kCylinder;
		dataUpL.m_iClr = 256;
		dataUpL.m_bBoolSubtract = false;
		dataUpL.m_ptRotation.set(PI / 2.0, PI / 2.0, 0);
		dataUpL.m_vtMove = VecL;
		setData<AecEqui::XCylinder>(&dataUpL, &CylinderUpL);
		pEqu->AddSubPrimObj(&dataUpL);
		clearData(dataUpL);

		AecEqui::XCylinder CylinderUpR;
		memset(&CylinderUpR, 0, sizeof(AecEqui::XCylinder));
		CylinderUpR.dr = dDN / 10;
		CylinderUpR.dH = dDN / 6;

		AcGeVector3d VecR(0, - dDN / 12, 43 * dDN / 60);
		AecEqui::XPrimData dataUpR;
		dataUpR.m_eType = AecEqui::kCylinder;
		dataUpR.m_iClr = 256;
		dataUpR.m_bBoolSubtract = false;
		dataUpR.m_ptRotation.set(PI / 2.0, PI / 2.0, 0);
		dataUpR.m_vtMove = VecR;
		setData<AecEqui::XCylinder>(&dataUpR, &CylinderUpR);
		pEqu->AddSubPrimObj(&dataUpR);
		clearData(dataUpR);
	}

	AecDbEwEquipment* makeTiaoJieFa(const bool bRect
		, const double& dDN	// 圆管公称
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("调节阀"), true));
		if (!pEqu) return NULL;

		if (bRect)
		{
			makeValveBody_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
			FunmakeZhaBanFa_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
		}
		else
		{
			makeValveBody_Circle(pEqu, dDN, dFL, dFlT, dFlE);
			FunmakeZhaBanFa_Circle(pEqu, dDN, dFL, dFlT, dFlE);
		}

		setDrawData(pEqu, 0, bRect, dDN, dW, dFL, dFlE);
		return pEqu;

	}

	AecDbEwEquipment* makeZhiHuiFa(const bool bRect
		, const double& dDN	// 圆管公称
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("止回阀"), true));
		if (!pEqu) return NULL;

		if (bRect)
		{
			makeValveBody_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
			FunmakeFangZhiDingFa_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
	
		}
		else
		{
			makeValveBody_Circle(pEqu, dDN, dFL, dFlT, dFlE);
			FunmakeFangZhiDingFa_Circle(pEqu, dDN, dFL, dFlT, dFlE);
		}
			

		setDrawData(pEqu, 1, bRect, dDN, dW, dFL, dFlE);
		return pEqu;
	}

	AecDbEwEquipment* makeFangHuoFa(const bool bRect
		, const double& dDN	// 圆管公称
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("防火阀"), true));
		if (!pEqu) return NULL;

		if (bRect)

		{
			makeValveBody_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
			FunmakeFangZhiDingFa_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
		}

		else
		{
			makeValveBody_Circle(pEqu, dDN, dFL, dFlT, dFlE);
			FunmakeFangZhiDingFa_Circle(pEqu, dDN, dFL, dFlT, dFlE);
		}
			

		setDrawData(pEqu, 2, bRect, dDN, dW, dFL, dFlE);
		return pEqu;
	}

	AecDbEwEquipment* makeZhaBanFa(const bool bRect
		, const double& dDN	// 圆管公称
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("闸板阀"), true));
		if (!pEqu) return NULL;

		if (bRect)
		{
			makeValveBody_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
			FunmakeZhaBanFa_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
		}
		else
		{
			makeValveBody_Circle(pEqu, dDN, dFL, dFlT, dFlE);
			FunmakeZhaBanFa_Circle(pEqu, dDN, dFL, dFlT, dFlE);
		}
			

		setDrawData(pEqu, 3, bRect, dDN, dW, dFL, dFlE);
		return pEqu;

	}

	AecDbEwEquipment* makeDieFa(const bool bRect
		, const double& dDN	// 圆管公称
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("蝶阀"), true));
		if (!pEqu) return NULL;

		if (bRect)
		{
			makeValveBody_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);

			FunmakeDieFa_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
		}
			
		else
		{
			makeValveBody_Circle(pEqu, dDN, dFL, dFlT, dFlE);
			FunmakeDieFa_Circle(pEqu, dDN, dFL, dFlT, dFlE);
		}
			

		setDrawData(pEqu, 4, bRect, dDN, dW, dFL, dFlE);

		return pEqu;
	}

	AecDbEwEquipment* makeDingFengLiangFa(const bool bRect
		, const double& dDN	// 圆管公称
		, const double& dW	// 方管长
		, const double& dH	// 方管宽
		, const double& dFL	// 阀门长
		, const double& dFlT // 法兰厚
		, const double& dFlE // 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("定风量阀"), true));
		if (!pEqu) return NULL;

		if (bRect)
		{
			makeValveBody_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
			FunmakeFangZhiDingFa_Rect(pEqu, dW, dH, dFL, dFlT, dFlE);
			
		}
		else
		{
			makeValveBody_Circle(pEqu, dDN, dFL, dFlT, dFlE);
			FunmakeFangZhiDingFa_Circle(pEqu, dDN, dFL, dFlT, dFlE);
		}
			
		setDrawData(pEqu, 5, bRect, dDN, dW, dFL, dFlE);
		return pEqu;
	}

	AecDbEwEquipment* makeXiChenZhao(const bool bTRect	// 风管形状
		, const double& dDN		// 圆风管公称
		, const double& dL		// 方风管长
		, const double& dW		// 方风管宽
		, const bool bBRect		// 罩口形状
		, const double& dXDN	// 罩口公称
		, const double& dXL		// 罩口长
		, const double& dXW		// 罩口宽
		, const double& _dH		// 总高
		, const double& dBH		// 边高
		, const double& dFlT	// 法兰厚
		, const double& dFlE	// 法兰卷边
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("吸尘罩"), true));
		if (!pEqu) return NULL;

		AcArray<AcDbRegion*> regs;

		// 总高减掉法兰片的厚度
		double dH(_dH - dFlT);

		// 罩体
		{
			AcDbRegion* pTopReg(NULL), * pSubTopReg(NULL);
			if (!bTRect)
			{
				pTopReg = makeCircleRegion(
					AcGePoint3d(0, 0, dH)
					, AcGeVector3d::kZAxis, dDN * .5);

				pSubTopReg = makeCircleRegion(AcGePoint3d(0, 0, dH - dFlT)
					, AcGeVector3d::kZAxis
					, dDN * .5 - dFlT);
			}
			else
			{
				pTopReg = makeRectRegion(AcGePoint3d(0., 0., dH), dL, dW);
				pSubTopReg = makeRectRegion(AcGePoint3d(0., 0., dH - dFlT), dL - dFlT, dW - dFlT);
			}

			AcDbRegion* pBotReg(NULL), * pSubBotReg(NULL);
			if (!bBRect)
			{
				pBotReg = makeCircleRegion(AcGePoint3d(0, 0, dBH)
					, AcGeVector3d::kZAxis
					, dXDN * .5);
				pSubBotReg = makeCircleRegion(AcGePoint3d(0, 0, dBH - dFlT)
					, AcGeVector3d::kZAxis
					, dXDN * .5 - dFlT);
			}
			else
			{
				pBotReg = makeRectRegion(AcGePoint3d(0., 0., dBH), dXL, dXW);
				pSubBotReg = makeRectRegion(AcGePoint3d(0., 0., dBH - dFlT), dXL - dFlT, dXW - dFlT);
			}

			if (pBotReg && pTopReg)
			{
				regs.append(pTopReg);
				regs.append(pBotReg);
			}
			else
			{
				DELETE_PTR(pTopReg);
				DELETE_PTR(pBotReg);
				return NULL;
			}

			AecEqui::XPrimData data;
			NewLoft nl(true, regs, NULL);
			data.m_nID = ::GetTickCount();
			data.m_eType = AecEqui::kNewLoft;
			data.m_bBoolSubtract = false;
			data.m_iClr = 256;
			nl.toData(data.m_pData, data.m_nSize);
			pEqu->AddSubPrimObj(&data);
			clearData(data);
			deleteContainerOfArx<AcDbRegion>(regs);

			// 挖空
			regs.removeAll();
			if (pSubBotReg && pSubTopReg)
			{
				regs.append(pSubTopReg);
				regs.append(pSubBotReg);

				AecEqui::XPrimData subData;
				NewLoft nl(false, regs, NULL);
				subData.m_nID = data.m_nID + 1;
				subData.m_eType = AecEqui::kNewLoft;
				subData.m_bBoolSubtract = true;
				subData.m_iClr = 256;
				nl.toData(subData.m_pData, subData.m_nSize);
				pEqu->AddSubPrimObj(&subData);
				clearData(subData);
				deleteContainerOfArx<AcDbRegion>(regs);
			}
			else
			{
				DELETE_PTR(pSubTopReg);
				DELETE_PTR(pSubBotReg);
			}
		}

		// 罩体下边
		{
			AcDbRegion* pReg(NULL), * pSubReg(NULL);
			if (bBRect)
			{
				pReg = makeRectRegion(AcGePoint3d::kOrigin, dXL, dXW);
				pSubReg = makeRectRegion(AcGePoint3d::kOrigin, dXL - dFlT, dXW - dFlT);
			}
			else
			{
				pReg = makeCircleRegion(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis, dXDN * .5);
				pSubReg = makeCircleRegion(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis, dXDN * .5 - dFlT);
			}

			if (pReg && pSubReg)
			{
				AecEqui::XPrimData data, subData;
				NewExtrude box(true, pReg, dBH), subBox(false, pSubReg, dBH);
				data.m_nID = ::GetTickCount();
				data.m_eType = AecEqui::kNewExtrude;
				data.m_bBoolSubtract = false;
				data.m_iClr = 256;
				box.toData(data.m_pData, data.m_nSize);
				pEqu->AddSubPrimObj(&data);
				clearData(data);

				subData.m_nID = data.m_nID + 1;
				subData.m_eType = AecEqui::kNewExtrude;
				subData.m_bBoolSubtract = true;
				subData.m_iClr = 256;
				subBox.toData(subData.m_pData, subData.m_nSize);
				pEqu->AddSubPrimObj(&subData);
				clearData(data);
			}
			else
			{
				DELETE_PTR(pReg);
				DELETE_PTR(pSubReg);
			}
		}

		// 管嘴
		{
			if (bTRect)
			{
				CoreTools::addNozzForEqu_Rect(pEqu
					, AcGeVector3d::kZAxis
					, AcGePoint3d(0., 0., dH)
					, dL
					, dW
					, dFlT
					, dFlE
					, dFlT
					, 0
					, false
					, false);
			}
			else
			{
				CoreTools::addNozzForEqu_Rect(pEqu
					, AcGeVector3d::kZAxis
					, AcGePoint3d(0., .0, dH)
					, dDN
					, dDN + dFlE
					, dFlT
					, .0
					, dFlT
					, 0
					, true
					, false);
			}
		}

		return pEqu;
	}
	
	AecDbEwEquipment* makeLiXinShiFengJi(const double dL0	// 安装长度
		, const double dW0      // 安装宽度
		, const double dH0      // 安装高度
		, const double dR1      // 叶轮半径
		, const double dH1      // 叶轮高度
		, const bool bshape	    // 出风口形状
		, const double& dL2		// 方口长度
		, const double& dW2		// 方口宽度
		, const double& dR3		// 圆口半径
		, const double& dH2		// 风口高度
		, const double& dL4	    // 底座长度
		, const double& dW4  	// 底座宽度
		, const double& dH4	    // 底座高度
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("FENGJI"), true));
		if (!pEqu) return NULL;

		//风机外廓
		AcGePoint3d ptPath(0, 0, 0);
		AcGeVector3d vtN(0, 1, 0);
		AcDbCircle* pPath = new AcDbCircle(ptPath, vtN, dR1);
		AcDbPolyline* pPoly = CoreTools::MakePolyline(pPath); //截面
		DELETE_PTR(pPath);

		AcGePoint3d ptReg(ptPath.x + 5 * dR1 / 8, ptPath.y + dH1 * .5, ptPath.z);
		AcGePoint3d pt0(ptReg.x - 3 * dR1 / 8, ptReg.y + dH1 * .5, .0)
			, pt1(ptReg.x + 3 * dR1 / 8, ptReg.y + dH1 * .5, .0)
			, pt2(ptReg.x + 3 * dR1 / 8, ptReg.y - dH1 * .5, .0)
			, pt3(ptReg.x - 3 * dR1 / 8, ptReg.y - dH1 * .5, .0);

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbLine(pt3, pt0));

		AcDbRegion* pReg = CoreTools::createRegion(ar); //截面
		deleteArrayVoidPtrs< AcDbLine>(ar);

		if (!pReg)
		{
			DELETE_PTR(pPoly);
			DELETE_PTR(pReg);
			DELETE_PTR(pEqu);
			return NULL;
		}

		
		/*		
		NewSweep ns(true, pReg, pPoly);
		DELETE_PTR(pPoly);
		DELETE_PTR(pReg);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		data.m_vtMove = vecPt;
		data.m_ptRotation.set(0, PI / 2, 0);
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);
		*/
		AcGePoint3d ptOrg(0, 0, 0);		// 旋转轴原点
		AcGeVector3d vtDir(0, 1, 0);	// 旋转轴方向
		double dStartAngle = 0;			// 旋转起始角
		double dSweepAngle = 2 * PI;	// 旋转终止角
		AcGeVector3d vecPt(0, 0, 3 * dR1 / 20 + dH4 + dW4);

		NewRevolve Nr(true, pReg, ptOrg, vtDir, dSweepAngle, dStartAngle);
		DELETE_PTR(pReg);
		AecEqui::XPrimData dataNr;
		dataNr.m_eType = AecEqui::kNewRevolve;
		dataNr.m_bBoolSubtract = false;
		dataNr.m_iClr = 256;
		dataNr.m_nSize = 0;
		dataNr.m_vtMove = vecPt;
		Nr.toData(dataNr.m_pData, dataNr.m_nSize);
		pEqu->AddSubPrimObj(&dataNr);
		clearData(dataNr);

		// 风口
		if (!bshape)
		{
			AecEqui::XBox boxTop;
			memset(&boxTop, 0, sizeof(AecEqui::XBox));
			boxTop.dL = dR1 / 2;
			boxTop.dW = dR1 / 100;
			boxTop.dH = 6 * dR1 / 5;

			AcGeVector3d vecTop(3 * dR1 / 4, 0, 3 * dR1 / 20 + dH4 + dW4);
			AecEqui::XPrimData dataTop;
			dataTop.m_eType = AecEqui::kBox;
			dataTop.m_iClr = 256;
			dataTop.m_bBoolSubtract = FALSE;
			dataTop.m_vtMove = vecTop;
			setData<AecEqui::XBOX>(&dataTop, &boxTop);

			AcGeVector3d vecBottom(3 * dR1 / 4, dH1, 3 * dR1 / 20 + dH4 + dW4);
			AecEqui::XPrimData dataBottom;
			dataBottom.m_eType = AecEqui::kBox;
			dataBottom.m_iClr = 256;
			dataBottom.m_bBoolSubtract = FALSE;
			dataBottom.m_vtMove = vecBottom;
			setData<AecEqui::XBOX>(&dataBottom, &boxTop);

			AecEqui::XBox boxLeft;
			memset(&boxLeft, 0, sizeof(AecEqui::XBox));
			boxLeft.dL = dR1 / 100;
			boxLeft.dW = dH1 - dR1 / 100;
			boxLeft.dH = 6 * dR1 / 5;

			AcGeVector3d vecLeft(dR1 / 2 + dR1 / 200, dH1 / 2, 3 * dR1 / 20 + dH4 + dW4);
			AecEqui::XPrimData dataLeft;
			dataLeft.m_eType = AecEqui::kBox;
			dataLeft.m_iClr = 256;
			dataLeft.m_bBoolSubtract = FALSE;
			dataLeft.m_vtMove = vecLeft;
			setData<AecEqui::XBOX>(&dataLeft, &boxLeft);

			AcGeVector3d vecRight(dR1 - dR1 / 200, dH1 / 2, 3 * dR1 / 20 + dH4 + dW4);
			AecEqui::XPrimData dataRight;
			dataRight.m_eType = AecEqui::kBox;
			dataRight.m_iClr = 256;
			dataRight.m_bBoolSubtract = FALSE;
			dataRight.m_vtMove = vecRight;
			setData<AecEqui::XBOX>(&dataRight, &boxLeft);

			pEqu->AddSubPrimObj(&dataTop);
			pEqu->AddSubPrimObj(&dataBottom);
			pEqu->AddSubPrimObj(&dataLeft);
			pEqu->AddSubPrimObj(&dataRight);
			clearData(dataTop);
			clearData(dataBottom);
			clearData(dataLeft);
			clearData(dataRight);
			
			//管嘴
			CoreTools::addNozzForEqu_Rect(pEqu
				, AcGeVector3d::kZAxis
				, AcGePoint3d(3 * dR1 / 4, dH1 / 2 + dR1 / 200, 3 * dR1 / 20 + dH4 + dW4 + 6 * dR1 / 5)
				, dR1 / 2
				, dH1 + dR1 / 100
				, dR1 / 100
				, .0
				, dR1 / 100
				, 0
				, false
				, false
			);
			
		}
		else
		{
			AcGePoint3d ptRegC(5 * dR1 / 8, .0, 6 * dR1 / 5);
			AcGePoint3d pt0C(ptRegC.x - dR1 / 200, .0, ptRegC.z + 3 * dR1 / 5)
				, pt1C(ptRegC.x + dR1 / 200, .0, ptRegC.z + 3 * dR1 / 5)
				, pt2C(ptRegC.x + dR1 / 200, .0, ptRegC.z - 3 * dR1 / 5)
				, pt3C(ptRegC.x - dR1 / 200, .0, ptRegC.z - 3 * dR1 / 5);

			AcDbVoidPtrArray arC;
			arC.append(new AcDbLine(pt0C, pt1C));
			arC.append(new AcDbLine(pt1C, pt2C));
			arC.append(new AcDbLine(pt2C, pt3C));
			arC.append(new AcDbLine(pt3C, pt0C));

			AcDbRegion* pRegC = CoreTools::createRegion(arC);
			deleteArrayVoidPtrs< AcDbLine>(arC);

			if (!pRegC)
			{
				DELETE_PTR(pRegC);
				DELETE_PTR(pEqu);
				return NULL;
			}

			AcGeVector3d vecPtC(3 * dR1 / 4 + 5 * dW4 / 4 + dR1 / 200, 5 * dR1 / 8, 6 * dR1 / 5 - dW4 / 2);
			/*
			NewSweep nsC(true, pRegC, pPolyC);
			DELETE_PTR(pPolyC);
			DELETE_PTR(pRegC);
			AecEqui::XPrimData dataC;
			dataC.m_eType = AecEqui::kNewSweep;
			dataC.m_bBoolSubtract = false;
			dataC.m_iClr = 256;
			dataC.m_nSize = 0;
			dataC.m_vtMove = vecPtC;
			nsC.toData(dataC.m_pData, dataC.m_nSize);
			pEqu->AddSubPrimObj(&dataC);
			clearData(dataC);
			*/
			AcGePoint3d ptOrgC(0, 0, 0);		// 旋转轴原点
			AcGeVector3d vtDirC(0, 0, 1);		// 旋转轴方向
			double dStartAngleC = 0;			// 旋转起始角
			double dSweepAngleC = 2 * PI;		// 旋转终止角

			NewRevolve NrC(true, pRegC, ptOrgC, vtDirC, dSweepAngleC, dStartAngleC);
			DELETE_PTR(pRegC);
			AecEqui::XPrimData dataNrC;
			dataNrC.m_eType = AecEqui::kNewRevolve;
			dataNrC.m_bBoolSubtract = false;
			dataNrC.m_iClr = 256;
			dataNrC.m_nSize = 0;
			dataNrC.m_vtMove = vecPtC;
			NrC.toData(dataNrC.m_pData, dataNrC.m_nSize);
			pEqu->AddSubPrimObj(&dataNrC);
			clearData(dataNrC);
			
			//管嘴
			CoreTools::addNozzForEqu_Rect(pEqu
				, AcGeVector3d::kZAxis 
				, AcGePoint3d(3 * dR1 / 4 + 5 * dW4 / 4 + dR1 / 200, 5 * dR1 / 8, 3 * dR1 -dW4 / 2 -dR1 / 200)
				, 5 * dR1 / 4
				, dR1 / 200
				, dR1 / 200
				, .0
				, 0
				, 0
				, true
				, false);
			
		}
		/*
		//电机
		AcGePoint3d ptPathDj(0, dH1, 0);
		AcGeVector3d vtNDj(0, 1, 0);
		AcDbCircle* pPathDj = new AcDbCircle(ptPathDj, vtNDj, dR1);

		AcDbPolyline* pPolyDj = CoreTools::MakePolyline(pPathDj); //截面
		AcGePoint3d ptRegDj(ptPathDj.x + dR1 / 4, ptPathDj.y + dH1 * .5, ptPathDj.z);
		AcGePoint3d pt00(ptRegDj.x - 3 * dR1 / 256, ptRegDj.y + dH1 * .5, .0)
			, pt11(ptRegDj.x + 3 * dR1 / 256, ptRegDj.y + dH1 * .5, .0)
			, pt22(ptRegDj.x + 3 * dR1 / 256, ptRegDj.y - dH1 * .5, .0)
			, pt33(ptRegDj.x - 3 * dR1 / 256, ptRegDj.y - dH1 * .5, .0);

		AcDbVoidPtrArray arDj;
		arDj.append(new AcDbLine(pt00, pt11));
		arDj.append(new AcDbLine(pt11, pt22));
		arDj.append(new AcDbLine(pt22, pt33));
		arDj.append(new AcDbLine(pt33, pt00));

		AcDbRegion* pRegDj = CoreTools::createRegion(arDj);
		deleteArrayVoidPtrs< AcDbLine>(arDj);

		if (!pRegDj) return NULL;

		AcGeVector3d vecPtDj(-ptPathDj.x, 0, 0);
		NewSweep nsDj(true, pRegDj, pPolyDj);
		AecEqui::XPrimData dataDj;
		dataDj.m_eType = AecEqui::kNewSweep;
		dataDj.m_bBoolSubtract = false;
		dataDj.m_iClr = 256;
		dataDj.m_nSize = 0;
		dataDj.m_vtMove = vecPtDj;
		dataDj.m_ptRotation.set(0, PI / 2, 0);
		nsDj.toData(dataDj.m_pData, dataDj.m_nSize);
		pEqu->AddSubPrimObj(&dataDj);
		clearData(dataDj);
		DELETE_PTR(pPathDj);
		*/

		//中心
		AecEqui::XCylinder CylinderIn1;
		memset(&CylinderIn1, 0, sizeof(AecEqui::XCylinder));
		CylinderIn1.dr = dR1 / 8;
		CylinderIn1.dH = dH1;

		AcGeVector3d vecIn1(0, 0, 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataIn1;
		dataIn1.m_eType = AecEqui::kCylinder;
		dataIn1.m_iClr = 256;
		dataIn1.m_bBoolSubtract = false;
		dataIn1.m_ptRotation.set(-PI / 2, 0, 0);
		dataIn1.m_vtMove = vecIn1;
		setData<AecEqui::XCylinder>(&dataIn1, &CylinderIn1);
		pEqu->AddSubPrimObj(&dataIn1);
		clearData(dataIn1);

		//接线箱
		AecEqui::XCylinder CylinderIn2;
		memset(&CylinderIn2, 0, sizeof(AecEqui::XCylinder));
		CylinderIn2.dr = dR1 / 4;
		CylinderIn2.dH = dH1 / 2;

		AcGeVector3d vecIn2(0, dH1, dR1 / 2 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataIn2;
		dataIn2.m_eType = AecEqui::kCylinder;
		dataIn2.m_iClr = 256;
		dataIn2.m_bBoolSubtract = false;
		dataIn2.m_ptRotation.set(-PI / 2, 0, 0);
		dataIn2.m_vtMove = vecIn2;
		setData<AecEqui::XCylinder>(&dataIn2, &CylinderIn2);
		pEqu->AddSubPrimObj(&dataIn2);
		clearData(dataIn2);

		//电机
		AecEqui::XCylinder CylinderIn3;
		memset(&CylinderIn3, 0, sizeof(AecEqui::XCylinder));
		CylinderIn3.dr = dR1 / 4;
		CylinderIn3.dH = dH1;

		AcGeVector3d vecIn3(0, dH1, 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataIn3;
		dataIn3.m_eType = AecEqui::kCylinder;
		dataIn3.m_iClr = 256;
		dataIn3.m_bBoolSubtract = false;
		dataIn3.m_ptRotation.set(-PI / 2, 0, 0);
		dataIn3.m_vtMove = vecIn3;
		setData<AecEqui::XCylinder>(&dataIn3, &CylinderIn3);
		pEqu->AddSubPrimObj(&dataIn3);
		clearData(dataIn3);

		//底座
		AecEqui::XBox boxRect;
		memset(&boxRect, 0, sizeof(AecEqui::XBox));
		boxRect.dL = dL4;
		boxRect.dW = dW4;
		boxRect.dH = dH4;

		AcGeVector3d vecRect1(dR1 / 4, dH1 + dW4 / 2, -3 * dR1 / 2 - dH1 / 10 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect1;
		dataRect1.m_eType = AecEqui::kBox;
		dataRect1.m_iClr = 256;
		dataRect1.m_bBoolSubtract = FALSE;
		dataRect1.m_vtMove = vecRect1;
		setData<AecEqui::XBox>(&dataRect1, &boxRect);
		pEqu->AddSubPrimObj(&dataRect1);
		clearData(dataRect1);

		AcGeVector3d vecRect2(-dR1 / 4, 2 * dH1 - dW4 / 2, -3 * dR1 / 2 - dH1 / 10 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect2;
		dataRect2.m_eType = AecEqui::kBox;
		dataRect2.m_iClr = 256;
		dataRect2.m_bBoolSubtract = FALSE;
		dataRect2.m_vtMove = vecRect2;
		setData<AecEqui::XBox>(&dataRect2, &boxRect);
		pEqu->AddSubPrimObj(&dataRect2);
		clearData(dataRect2);

		AcGeVector3d vecRect3(dR1 / 4, 2 * dH1 - dW4 / 2, -3 * dR1 / 2 - dH1 / 10 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect3;
		dataRect3.m_eType = AecEqui::kBox;
		dataRect3.m_iClr = 256;
		dataRect3.m_bBoolSubtract = FALSE;
		dataRect3.m_vtMove = vecRect3;
		setData<AecEqui::XBox>(&dataRect3, &boxRect);
		pEqu->AddSubPrimObj(&dataRect3);
		clearData(dataRect3);

		AcGeVector3d vecRect4(-dR1 / 4, dH1 + dW4 / 2, -3 * dR1 / 2 - dH1 / 10 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect4;
		dataRect4.m_eType = AecEqui::kBox;
		dataRect4.m_iClr = 256;
		dataRect4.m_bBoolSubtract = FALSE;
		dataRect4.m_vtMove = vecRect4;
		setData<AecEqui::XBox>(&dataRect4, &boxRect);
		pEqu->AddSubPrimObj(&dataRect4);
		clearData(dataRect4);

		AecEqui::XBox boxRect1;
		memset(&boxRect1, 0, sizeof(AecEqui::XBox));
		boxRect1.dL = dL4;
		boxRect1.dW = dW4;
		boxRect1.dH = 2 * dH1;

		AcGeVector3d vecRect5(dR1 / 4, 2 * dH1, -3 * dR1 / 2 - dH1 / 10 - dW4 / 2 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect5;
		dataRect5.m_eType = AecEqui::kBox;
		dataRect5.m_iClr = 256;
		dataRect5.m_bBoolSubtract = FALSE;
		dataRect5.m_vtMove = vecRect5;
		dataRect5.m_ptRotation.set(PI / 2, 0, 0);
		setData<AecEqui::XBox>(&dataRect5, &boxRect1);
		pEqu->AddSubPrimObj(&dataRect5);
		clearData(dataRect5);

		AcGeVector3d vecRect6(-dR1 / 4, 2 * dH1, -3 * dR1 / 2 - dH1 / 10 - dW4 / 2 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect6;
		dataRect6.m_eType = AecEqui::kBox;
		dataRect6.m_iClr = 256;
		dataRect6.m_bBoolSubtract = FALSE;
		dataRect6.m_vtMove = vecRect6;
		dataRect6.m_ptRotation.set(PI / 2, 0, 0);
		setData<AecEqui::XBox>(&dataRect6, &boxRect1);
		pEqu->AddSubPrimObj(&dataRect6);
		clearData(dataRect6);

		AecEqui::XBox boxRect2;
		memset(&boxRect1, 0, sizeof(AecEqui::XBox));
		boxRect2.dL = dL4;
		boxRect2.dW = dW4;
		boxRect2.dH = dR1 / 2 - dW4;

		AcGeVector3d vecRect7(-dR1 / 4 + dW4 / 2, dW4 / 2, -dR1 / 4 - dH4 + 3 * dW4 / 4 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect7;
		dataRect7.m_eType = AecEqui::kBox;
		dataRect7.m_iClr = 256;
		dataRect7.m_bBoolSubtract = FALSE;
		dataRect7.m_vtMove = vecRect7;
		dataRect7.m_ptRotation.set(0, PI / 2, 0);
		setData<AecEqui::XBox>(&dataRect7, &boxRect2);
		pEqu->AddSubPrimObj(&dataRect7);
		clearData(dataRect7);

		AcGeVector3d vecRect8(-dR1 / 4 + dW4 / 2, 2 * dH1 - dW4 / 2, -dR1 / 4 - dH4 + 3 * dW4 / 4 + 3 * dR1 / 20 + dH4 + dW4);
		AecEqui::XPrimData dataRect8;
		dataRect8.m_eType = AecEqui::kBox;
		dataRect8.m_iClr = 256;
		dataRect8.m_bBoolSubtract = FALSE;
		dataRect8.m_vtMove = vecRect8;
		dataRect8.m_ptRotation.set(0, PI / 2, 0);
		setData<AecEqui::XBox>(&dataRect8, &boxRect2);
		pEqu->AddSubPrimObj(&dataRect8);
		clearData(dataRect8);

		AecEqui::XBox boxBw;
		memset(&boxBw, 0, sizeof(AecEqui::XBox));
		boxBw.dL = 10;
		boxBw.dW = 4;
		boxBw.dH = dR1 / 4;

		for (int i = 0; i < 6; i++)
		{
			AcGeVector3d vecBw(0, 0, 3 * dR1 / 20 + dH4 + dW4);
			AecEqui::XPrimData dataBw;
			dataBw.m_eType = AecEqui::kBox;
			dataBw.m_iClr = 256;
			dataBw.m_bBoolSubtract = false;
			dataBw.m_vtMove = vecBw;
			dataBw.m_ptRotation.set(0, i * (2 * PI / 6), 0);
			setData<AecEqui::XBOX>(&dataBw, &boxBw);
			pEqu->AddSubPrimObj(&dataBw);
			clearData(dataBw);
		}

		return pEqu;
		
}

	AecDbEwEquipment* makeZhouLiuShiFengJi(const double& dL0	// 安装长度
		, const double& dW0      // 安装宽度
		, const double& dH0      // 安装高度
		, const double& dR1      // 风口半径
		, const double& dH1      // 风机高度
		, const double& dT1		 // 风口厚度
		, const double& dfe		 // 法兰卷边
		, const double& dW2		 // 风叶长度
		, const double& dH2		 // 风叶高度
		, const double& dL30	 // 梯形底座上底长度
		, const double& dL31  	 // 梯形底座下底宽度
		, const double& dH3	     // 梯形底座高度
	)
	{

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("FENGJI"), true));
		if (!pEqu) return NULL;

		// 风机机壳
		AcGePoint3d ptPathJK(AcGePoint3d::kOrigin);
		AcGeVector3d vtNJK(0, 1, 0);
		AcDbCircle* pCirJK = new AcDbCircle(ptPathJK, vtNJK, dR1 - dT1 * .5);
		AcDbPolyline* pPolyJK = CoreTools::MakePolyline(pCirJK);
		DELETE_PTR(pCirJK);

		AcGePoint3d ptOrgJK(-(dR1 - dT1 * .5), 0, 0);
		AcDbRegion* pRegJK = makeRectRegion(ptOrgJK, dT1, dH1);
		if (!pPolyJK || !pRegJK)
		{
			DELETE_PTR(pPolyJK);
			DELETE_PTR(pRegJK);
			DELETE_PTR(pEqu);
			return NULL;
		}

		NewSweep sweepJK(true, pRegJK, pPolyJK);
		DELETE_PTR(pPolyJK);
		DELETE_PTR(pRegJK);

		AecEqui::XPrimData dataJK;
		dataJK.m_eType = AecEqui::kNewSweep;
		dataJK.m_bBoolSubtract = false;
		dataJK.m_iClr = 50;
		sweepJK.toData(dataJK.m_pData, dataJK.m_nSize);
		pEqu->AddSubPrimObj(&dataJK);
		clearData(dataJK);

		// 风叶
		AecEqui::XBox boxFY;
		memset(&boxFY, 0, sizeof(AecEqui::XBox));
		boxFY.dL = dR1 * .75;
		boxFY.dW = dW2;
		boxFY.dH = dH2;

		AcGePoint3d ptFYS(0, 0, 0);
		AcGePoint3d ptFYE(0, dH1 * -.25, 0);
		AcGeVector3d vecFY;
		for (int i = 0; i < 6; i++)
		{
			ptFYE.x = ptFYS.x + dR1 * .25 * cos(i * ((2 * PI) / 6));
			ptFYE.z = ptFYS.z + dR1 * .25 * sin(i * ((2 * PI) / 6));
			vecFY = ptFYE - ptFYS;
			AecEqui::XPrimData dataFY;
			dataFY.m_eType = AecEqui::kBox;
			dataFY.m_iClr = 100;
			dataFY.m_bBoolSubtract = false;
			dataFY.m_vtMove = vecFY;
			dataFY.m_ptRotation.set(PI * .3, i * -((2 * PI) / 6), 0);
			setData<AecEqui::XBOX>(&dataFY, &boxFY);
			pEqu->AddSubPrimObj(&dataFY);
			clearData(dataFY);
		}

		// 电机
		AecEqui::XCylinder CylinderDJ;
		memset(&CylinderDJ, 0, sizeof(AecEqui::XCylinder));
		CylinderDJ.dr = dR1 * .25;
		CylinderDJ.dH = dH1 * .75 + dW2 * .5;

		AcGeVector3d vecDJ(0, dH1 * .5, 0);
		AecEqui::XPrimData dataDJ;
		dataDJ.m_eType = AecEqui::kCylinder;
		dataDJ.m_iClr = 150;
		dataDJ.m_bBoolSubtract = false;
		dataDJ.m_vtMove = vecDJ;
		dataDJ.m_ptRotation.set(PI * .5, 0, 0);
		setData<AecEqui::XCylinder>(&dataDJ, &CylinderDJ);
		pEqu->AddSubPrimObj(&dataDJ);
		clearData(dataDJ);

		// 管嘴
		CoreTools::addNozzForEqu_Rect(pEqu
			, AcGeVector3d::kYAxis
			, AcGePoint3d(0., dH1 * .5, 0.)
			, dR1 * .5
			, dR1 * .5 + dfe
			, dT1
			, .0
			, dT1
			, 0
			, true
			, false);

		// 梯形底座
		AcGePoint3d pt0(dL30 * -.5, .0, dH3)
			, pt1(dL30 * .5, .0, dH3)
			, pt2(dL31 * .5, .0, .0)
			, pt3(dL31 * -.5, .0, .0);

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbLine(pt3, pt0));
		AcDbRegion* pRegDZ = CoreTools::createRegion(ar);
		deleteArrayVoidPtrs< AcDbLine>(ar);
		if (!pRegDZ)
		{
			DELETE_PTR(pEqu);
			return NULL;
		}

		NewExtrude extrudeDZ(true, pRegDZ, dH3 * .5);
		DELETE_PTR(pRegDZ);

		AcGeVector3d vecDZFront(0, dH1 * -.5, -(dR1 + dH3 * .5));
		AecEqui::XPrimData dataDZFront;
		dataDZFront.m_eType = AecEqui::kNewExtrude;
		dataDZFront.m_bBoolSubtract = false;
		dataDZFront.m_iClr = 200;
		dataDZFront.m_vtMove = vecDZFront;
		extrudeDZ.toData(dataDZFront.m_pData, dataDZFront.m_nSize);
		pEqu->AddSubPrimObj(&dataDZFront);
		clearData(dataDZFront);

		AcGeVector3d vecDZBack(0, (dH1 - dH3) * .5, -(dR1 + dH3 * .5));
		AecEqui::XPrimData dataDZBack;
		dataDZBack.m_eType = AecEqui::kNewExtrude;
		dataDZBack.m_bBoolSubtract = false;
		dataDZBack.m_iClr = 200;
		dataDZBack.m_vtMove = vecDZBack;
		extrudeDZ.toData(dataDZBack.m_pData, dataDZBack.m_nSize);
		pEqu->AddSubPrimObj(&dataDZBack);
		clearData(dataDZBack);

		// 接线箱
		AecEqui::XBox boxJXX;
		memset(&boxJXX, 0, sizeof(AecEqui::XBox));
		boxJXX.dL = dH3 * .5;
		boxJXX.dW = dH3 * .5;
		boxJXX.dH = dH3 * .5;

		AcGeVector3d vecJXX(dR1 + dH3 * .25, 0, dH3 * -.25);
		AecEqui::XPrimData dataJXX;
		dataJXX.m_eType = AecEqui::kBox;
		dataJXX.m_iClr = 25;
		dataJXX.m_bBoolSubtract = FALSE;
		dataJXX.m_vtMove = vecJXX;
		setData<AecEqui::XBOX>(&dataJXX, &boxJXX);
		pEqu->AddSubPrimObj(&dataJXX);
		clearData(dataJXX);

		// 法兰卷边flannels
		AcGePoint3d ptPathFE(0, 0, 0);
		AcGeVector3d vtNFE(0, 1, 0);
		AcDbCircle* pCirFE = new AcDbCircle(ptPathFE, vtNFE, dR1 + dfe * .5);
		AcDbPolyline* pPolyFE = CoreTools::MakePolyline(pCirFE);
		DELETE_PTR(pCirFE);

		AcGePoint3d ptOrgFE(-(dR1 + dfe * .5), 0, 0);
		AcDbRegion* pRegFE = makeRectRegion(ptOrgFE, dfe, dfe * .25);
		if (!pPolyFE || !pRegFE)
		{
			DELETE_PTR(pPolyFE);
			DELETE_PTR(pRegFE);
			DELETE_PTR(pEqu);
			return NULL;
		}

		NewSweep sweepJuanBian(true, pRegFE, pPolyFE);
		DELETE_PTR(pPolyFE);
		DELETE_PTR(pRegFE);

		AcGeVector3d vecFEFront(0, dH1 * -.5 + dT1 * .5, 0);
		AecEqui::XPrimData dataFEFront;
		dataFEFront.m_eType = AecEqui::kNewSweep;
		dataFEFront.m_bBoolSubtract = false;
		dataFEFront.m_iClr = 125;
		dataFEFront.m_vtMove = vecFEFront;
		sweepJuanBian.toData(dataFEFront.m_pData, dataFEFront.m_nSize);
		pEqu->AddSubPrimObj(&dataFEFront);
		clearData(dataFEFront);

		AcGeVector3d vecFEBack(0, dH1 * .5 - dT1 * .5, 0);
		AecEqui::XPrimData dataFEBack;
		dataFEBack.m_eType = AecEqui::kNewSweep;
		dataFEBack.m_bBoolSubtract = false;
		dataFEBack.m_iClr = 125;
		dataFEBack.m_vtMove = vecFEBack;
		sweepJuanBian.toData(dataFEBack.m_pData, dataFEBack.m_nSize);
		pEqu->AddSubPrimObj(&dataFEBack);
		clearData(dataFEBack);

		return pEqu;
	}

	AecDbEwEquipment* makeHunLiuShiFengJi(const double& dL0	// 安装长度
		, const double& dW0      // 安装宽度
		, const double& dH0      // 安装高度
		, const double& dR1      // 风口半径
		, const double& dH1      // 风机高度
		, const double& dT1		 // 风口厚度
		, const double& dfe		 // 法兰卷边
		, const double& dW2		 // 风叶长度
		, const double& dH2		 // 风叶高度
		, const double& dL30	 // 梯形底座上底长度
		, const double& dL31  	 // 梯形底座下底宽度
		, const double& dH3	     // 梯形底座高度
	)
	{
		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d ptO(AcGePoint3d::kOrigin);

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("FENGJI"), true));
		if (!pEqu) return NULL;

		// 风机机壳
		AcDbCircle* pCirJK = new AcDbCircle(ptO, Y, dR1 - dT1 * .5);
		AcDbPolyline* pPolyJK = CoreTools::MakePolyline(pCirJK);
		DELETE_PTR(pCirJK);

		AcGePoint3d ptOrgJK(ptO + X * (dT1 * .5 - dR1));
		AcDbRegion* pRegJK = makeRectRegion(ptOrgJK, dT1, dH1);
		if (!pPolyJK || !pRegJK)
		{
			DELETE_PTR(pPolyJK);
			DELETE_PTR(pRegJK);
			DELETE_PTR(pEqu);
			return NULL;
		}

		NewSweep sweepJK(true, pRegJK, pPolyJK);
		DELETE_PTR(pPolyJK);
		DELETE_PTR(pRegJK);

		AecEqui::XPrimData dataJK;
		dataJK.m_eType = AecEqui::kNewSweep;
		dataJK.m_bBoolSubtract = false;
		dataJK.m_iClr = 50;
		sweepJK.toData(dataJK.m_pData, dataJK.m_nSize);
		pEqu->AddSubPrimObj(&dataJK);
		clearData(dataJK);

		// 风叶
		AecEqui::XBox boxFY;
		memset(&boxFY, 0, sizeof(AecEqui::XBox));
		boxFY.dL = dR1 * .75;
		boxFY.dW = dW2;
		boxFY.dH = dH2;

		AcGePoint3d ptFYE(ptO + Y * dH1 * -.25);
		AcGeVector3d vecFY;
		for (int i = 0; i < 6; i++)
		{
			ptFYE.x = ptO.x + dR1 * .25 * cos(i * ((2 * PI) / 6));
			ptFYE.z = ptO.z + dR1 * .25 * sin(i * ((2 * PI) / 6));
			vecFY = ptFYE - ptO;
			AecEqui::XPrimData dataFY;
			dataFY.m_eType = AecEqui::kBox;
			dataFY.m_iClr = 100;
			dataFY.m_bBoolSubtract = false;
			dataFY.m_vtMove = vecFY;
			dataFY.m_ptRotation.set(PI * .3, i * -((2 * PI) / 6), 0);
			setData<AecEqui::XBOX>(&dataFY, &boxFY);
			pEqu->AddSubPrimObj(&dataFY);
			clearData(dataFY);
		}

		// 电机
		AecEqui::XCylinder CylinderDJ;
		memset(&CylinderDJ, 0, sizeof(AecEqui::XCylinder));
		CylinderDJ.dr = dR1 * .25;
		CylinderDJ.dH = dH1 * .75 + dW2 * .5;

		AcGeVector3d vecDJ(Y * dH1 * .5);
		AecEqui::XPrimData dataDJ;
		dataDJ.m_eType = AecEqui::kCylinder;
		dataDJ.m_iClr = 150;
		dataDJ.m_bBoolSubtract = false;
		dataDJ.m_vtMove = vecDJ;
		dataDJ.m_ptRotation.set(PI * .5, 0, 0);
		setData<AecEqui::XCylinder>(&dataDJ, &CylinderDJ);
		pEqu->AddSubPrimObj(&dataDJ);
		clearData(dataDJ);


		// 管嘴
		CoreTools::addNozzForEqu_Rect(pEqu
			, AcGeVector3d::kYAxis
			, AcGePoint3d(ptO + Y * dH1 * .5)
			, dR1 * .5
			, dR1 * .5 + dfe
			, dT1
			, .0
			, dT1
			, 0
			, true
			, false);

		// 梯形底座
		AcGePoint3d pt1(ptO.x + dL30 * -.5, ptO.y, ptO.z + dH3)
			, pt2(ptO.x + dL30 * .5, ptO.y, ptO.z + dH3)
			, pt3(ptO + X * dL31 * .5)
			, pt4(ptO + X * dL31 * -.5);

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbLine(pt3, pt4));
		ar.append(new AcDbLine(pt4, pt1));
		AcDbRegion* pRegDZ = CoreTools::createRegion(ar);
		deleteArrayVoidPtrs< AcDbLine>(ar);
		if (!pRegDZ)
		{
			DELETE_PTR(pEqu);
			return NULL;
		}

		NewExtrude extrudeDZ(true, pRegDZ, dH3 * .5);
		DELETE_PTR(pRegDZ);

		AcGeVector3d vecDZFront(ptO.x, ptO.y + dH1 * -.5, ptO.z - (dR1 + dH3 * .5));
		AecEqui::XPrimData dataDZFront;
		dataDZFront.m_eType = AecEqui::kNewExtrude;
		dataDZFront.m_bBoolSubtract = false;
		dataDZFront.m_iClr = 200;
		dataDZFront.m_vtMove = vecDZFront;
		extrudeDZ.toData(dataDZFront.m_pData, dataDZFront.m_nSize);
		pEqu->AddSubPrimObj(&dataDZFront);
		clearData(dataDZFront);

		AcGeVector3d vecDZBack(ptO.x, ptO.y + (dH1 - dH3) * .5, ptO.z - (dR1 + dH3 * .5));
		AecEqui::XPrimData dataDZBack;
		dataDZBack.m_eType = AecEqui::kNewExtrude;
		dataDZBack.m_bBoolSubtract = false;
		dataDZBack.m_iClr = 200;
		dataDZBack.m_vtMove = vecDZBack;
		extrudeDZ.toData(dataDZBack.m_pData, dataDZBack.m_nSize);
		pEqu->AddSubPrimObj(&dataDZBack);
		clearData(dataDZBack);

		// 接线箱
		AecEqui::XBox boxJXX;
		memset(&boxJXX, 0, sizeof(AecEqui::XBox));
		boxJXX.dL = dH3 * .5;
		boxJXX.dW = dH3 * .5;
		boxJXX.dH = dH3 * .5;

		AcGeVector3d vecJXX(ptO.x + dR1 + dH3 * .25, ptO.y, ptO.z + dH3 * -.25);
		AecEqui::XPrimData dataJXX;
		dataJXX.m_eType = AecEqui::kBox;
		dataJXX.m_iClr = 25;
		dataJXX.m_bBoolSubtract = FALSE;
		dataJXX.m_vtMove = vecJXX;
		setData<AecEqui::XBOX>(&dataJXX, &boxJXX);
		pEqu->AddSubPrimObj(&dataJXX);
		clearData(dataJXX);

		// 法兰卷边flannels
		AcDbCircle* pCirFE = new AcDbCircle(ptO, Y, dR1 + dfe * .5);
		AcDbPolyline* pPolyFE = CoreTools::MakePolyline(pCirFE);
		DELETE_PTR(pCirFE);

		AcGePoint3d ptOrgFE(ptO - X * (dR1 + dfe * .5));
		AcDbRegion* pRegFE = makeRectRegion(ptOrgFE, dfe, dfe * .25);
		if (!pPolyFE || !pRegFE)
		{
			DELETE_PTR(pPolyFE);
			DELETE_PTR(pRegFE);
			DELETE_PTR(pEqu);
			return NULL;
		}

		NewSweep sweepJuanBian(true, pRegFE, pPolyFE);
		DELETE_PTR(pPolyFE);
		DELETE_PTR(pRegFE);

		AcGeVector3d vecFEFront(Y * (dH1 * -.5 + dT1 * .5));
		AecEqui::XPrimData dataFEFront;
		dataFEFront.m_eType = AecEqui::kNewSweep;
		dataFEFront.m_bBoolSubtract = false;
		dataFEFront.m_iClr = 125;
		dataFEFront.m_vtMove = vecFEFront;
		sweepJuanBian.toData(dataFEFront.m_pData, dataFEFront.m_nSize);
		pEqu->AddSubPrimObj(&dataFEFront);
		clearData(dataFEFront);

		AcGeVector3d vecFEBack(Y * (dH1 * .5 - dT1 * .5));
		AecEqui::XPrimData dataFEBack;
		dataFEBack.m_eType = AecEqui::kNewSweep;
		dataFEBack.m_bBoolSubtract = false;
		dataFEBack.m_iClr = 125;
		dataFEBack.m_vtMove = vecFEBack;
		sweepJuanBian.toData(dataFEBack.m_pData, dataFEBack.m_nSize);
		pEqu->AddSubPrimObj(&dataFEBack);
		clearData(dataFEBack);

		return pEqu;
	}

	AecDbEwEquipment* makeWuDingFengJi(const double& dL0	// 安装长度
		, const double& dW0     // 安装宽度
		, const double& dH0     // 安装高度
		, const double& dL1	    // 底座长度
		, const double& dW1  	// 底座宽度
		, const double& dH1	    // 底座高度
		, const double& dR2		// 风筒半径
		, const double& dH2		// 风筒高度
		, const double& dR3		// 风帽半径
		, const double& dH3		// 风帽高度
	)
	{
		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d ptO(AcGePoint3d::kOrigin);

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("FENGJI"), true));
		if (!pEqu) return NULL;

		// 底座
		AecEqui::XBox boxDZ;
		memset(&boxDZ, 0, sizeof(AecEqui::XBox));
		boxDZ.dL = dL1;
		boxDZ.dW = dW1;
		boxDZ.dH = dH1;

		AecEqui::XPrimData dataDZ;
		dataDZ.m_eType = AecEqui::kBox;
		dataDZ.m_iClr = 50;
		dataDZ.m_bBoolSubtract = false;
		setData<AecEqui::XCylinder>(&dataDZ, &boxDZ);
		pEqu->AddSubPrimObj(&dataDZ);
		clearData(dataDZ);

		// 风筒
		AecEqui::XCylinder CylinderFT;
		memset(&CylinderFT, 0, sizeof(AecEqui::XCylinder));
		CylinderFT.dr = dR2;
		CylinderFT.dH = dH2;

		AcGeVector3d vecFT(Z * dH1);
		AecEqui::XPrimData dataFT;
		dataFT.m_eType = AecEqui::kCylinder;
		dataFT.m_iClr = 100;
		dataFT.m_bBoolSubtract = false;
		dataFT.m_vtMove = vecFT;
		setData<AecEqui::XCylinder>(&dataFT, &CylinderFT);
		pEqu->AddSubPrimObj(&dataFT);
		clearData(dataFT);

		// 风帽
		AcGePoint3d pt(AcGePoint3d::kOrigin);
		AcGePoint3d pt1(ptO + X * dR3);
		AcGePoint3d pt2(ptO + Z * dH3);
		AcGeVector3d majorAxis(X * dR3);
		double radiusRatio(dH3 / dR3);
		double startAngle(PI * 1.5);
		double endAngle(PI * 2);
		AcDbEllipse* pEllipse = new AcDbEllipse(pt, Y, majorAxis, radiusRatio, startAngle, endAngle);
		AcDbLine* pline1 = new AcDbLine(pt, pt1);
		AcDbLine* pline2 = new AcDbLine(pt, pt2);
		AcDbVoidPtrArray ar;
		ar.append(pEllipse);
		ar.append(pline1);
		ar.append(pline2);
		AcDbRegion* pReg = CoreTools::createRegion(ar);
		deleteArrayVoidPtrs< AcDbEntity>(ar);
		if (!pReg)
		{
			DELETE_PTR(pEqu);
			return NULL;
		}

		AcGeVector3d vecFM(Z * (dH1 + dH2));
		NewRevolve revolveFM(true, pReg, pt, AcGeVector3d::kZAxis, PI * 2, 0);
		DELETE_PTR(pReg);
		AecEqui::XPrimData dataFM;
		dataFM.m_eType = AecEqui::kNewRevolve;
		dataFM.m_bBoolSubtract = false;
		dataFM.m_iClr = 200;
		dataFM.m_vtMove = vecFM;
		revolveFM.toData(dataFM.m_pData, dataFM.m_nSize);
		pEqu->AddSubPrimObj(&dataFM);
		clearData(dataFM);

		return pEqu;
	}

	AecDbEwEquipment* makeFENGKOUCZ(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dL		// 方风口长
		, const double& dW		// 方风口宽
		, const bool& bType		// 风口类型
		, const double& dT		// 风口厚度T
		, const double& dW1	    // 风口边框宽W1
		, const double& dBYNUM	// 百叶条数BYNUM
		, const double& dDist	// 风叶间距
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeSNFKCZ!"));
	#endif
		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d ptO(AcGePoint3d::kOrigin);
		Adesk::Int32 itemID(0);

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("SHINEIFENGKOU"), true));
		if (!pEqu) return NULL;

		if (bType)
		{
			// 百叶
			if (bShape)
			{
				// 方
				AcGeMatrix3d mat;

				AecEqui::XBox boxTop;
				memset(&boxTop, 0, sizeof(AecEqui::XBox));
				boxTop.dL = dL;
				boxTop.dW = dW1;
				boxTop.dH = dT;

				AecEqui::XBox boxBw;
				memset(&boxBw, 0, sizeof(AecEqui::XBox));
				boxBw.dL = 1;
				boxBw.dW = dW - 2 * dW1;
				boxBw.dH = 10;

				AecEqui::XBox boxLeft;
				memset(&boxLeft, 0, sizeof(AecEqui::XBox));
				boxLeft.dL = dW1;
				boxLeft.dW = dW - 2 * dW1;
				boxLeft.dH = dT;

				AcGePoint3d pt(ptO - Z * dT);
				AcGePoint3d ptTop(pt + Y * (dW * .5 - dW1 * .5));
				AcGeVector3d vecTop(ptTop - ptO);
				AecEqui::XPrimData dataTop;
				dataTop.m_eType = AecEqui::kBox;
				dataTop.m_iClr = 50;
				dataTop.m_bBoolSubtract = FALSE;
				dataTop.m_vtMove = vecTop;
				setData<AecEqui::XBOX>(&dataTop, &boxTop);
				AcGeVector3d vtDir(AcGeVector3d::kXAxis);
				AcGeVector3d vt = vtDir.crossProduct(Y);
				if (vt == AcGeVector3d::kIdentity)
					vt = X;
				double a = Y.angleTo(vtDir, vt);
				mat.setToIdentity();
				mat.setToRotation(a, vt);
				pEqu->TransformBy(mat);

				AcGePoint3d ptBottom(pt - Y * (dW * .5 - dW1 * .5));
				AcGeVector3d vecBottom(ptBottom - ptO);
				AecEqui::XPrimData dataBottom;
				dataBottom.m_eType = AecEqui::kBox;
				dataBottom.m_iClr = 100;
				dataBottom.m_bBoolSubtract = FALSE;
				dataBottom.m_vtMove = vecBottom;
				setData<AecEqui::XBOX>(&dataBottom, &boxTop);

				for (int i = 0; i < dBYNUM; i++)
				{
					AcGePoint3d ptBw(pt + X * (dL * -.5 + dW1 + i * dL * 0.08));
					AcGeVector3d vecBw(ptBw - ptO);
					AecEqui::XPrimData dataBw;
					dataBw.m_eType = AecEqui::kBox;
					dataBw.m_iClr = 251;
					dataBw.m_bBoolSubtract = FALSE;
					dataBw.m_vtMove = vecBw;
					dataBw.m_ptRotation.set(0, PI / 3.5, 0);
					setData<AecEqui::XBOX>(&dataBw, &boxBw);
					pEqu->AddSubPrimObj(&dataBw);
					clearData(dataBw);
				}

				AcGePoint3d ptLeft(pt - X * (dL * .5 - dW1 * .5));
				AcGeVector3d vecLeft(ptLeft - ptO);
				AecEqui::XPrimData dataLeft;
				dataLeft.m_eType = AecEqui::kBox;
				dataLeft.m_iClr = 150;
				dataLeft.m_bBoolSubtract = FALSE;
				dataLeft.m_vtMove = vecLeft;
				setData<AecEqui::XBOX>(&dataLeft, &boxLeft);

				AcGePoint3d ptRight(pt + X * (dL * .5 - dW1 * .5));
				AcGeVector3d vecRight(ptRight - ptO);
				AecEqui::XPrimData dataRight;
				dataRight.m_eType = AecEqui::kBox;
				dataRight.m_iClr = 200;
				dataRight.m_bBoolSubtract = FALSE;
				dataRight.m_vtMove = vecRight;
				setData<AecEqui::XBOX>(&dataRight, &boxLeft);

				pEqu->AddSubPrimObj(&dataLeft);
				pEqu->AddSubPrimObj(&dataRight);
				pEqu->AddSubPrimObj(&dataTop);
				pEqu->AddSubPrimObj(&dataBottom);
				clearData(dataLeft);
				clearData(dataRight);
				clearData(dataTop);
				clearData(dataBottom);
			}
			else
			{
				// 圆
				AcGePoint3d ptPath(0, 0, 0);
				AcGeVector3d vtN(0, 0, 1);
				AcDbCircle* pPath = new AcDbCircle(ptPath, vtN, dDN * .5);
				AcDbPolyline* pPoly = CoreTools::MakePolyline(pPath);
				DELETE_PTR(pPath);

				AcGePoint3d ptReg(ptPath.x + (dDN * .5 - dW1 * .5), ptPath.y, ptPath.z + dT * .5);
				AcGePoint3d pt0(ptReg.x - dW1 * .5, .0, ptReg.z + dT * .5)
					, pt1(ptReg.x + dW1 * .5, .0, ptReg.z + dT * .5)
					, pt2(ptReg.x + dW1 * .5, .0, ptReg.z - dT * .5)
					, pt3(ptReg.x - dW1 * .5, .0, ptReg.z - dT * .5);

				AcDbVoidPtrArray ar;
				ar.append(new AcDbLine(pt0, pt1));
				ar.append(new AcDbLine(pt1, pt2));
				ar.append(new AcDbLine(pt2, pt3));
				ar.append(new AcDbLine(pt3, pt0));
				AcDbRegion* pReg = CoreTools::createRegion(ar);
				deleteArrayVoidPtrs< AcDbLine>(ar);

				if (!pReg)
				{
					DELETE_PTR(pPoly);
					DELETE_PTR(pEqu);
					return NULL;
				}

				AcGeVector3d vecPt(-ptPath.x, 0, -dT);
				NewSweep ns(true, pReg, pPoly);
				DELETE_PTR(pReg);
				DELETE_PTR(pPoly);
				AecEqui::XPrimData data;
				data.m_eType = AecEqui::kNewSweep;
				data.m_bBoolSubtract = false;
				data.m_iClr = 256;
				data.m_nSize = 0;
				data.m_vtMove = vecPt;
				ns.toData(data.m_pData, data.m_nSize);
				pEqu->AddSubPrimObj(&data);
				clearData(data);

				AecEqui::XBox boxBw;
				memset(&boxBw, 0, sizeof(AecEqui::XBox));
				boxBw.dL = dDN - 2 * dW1;
				boxBw.dW = 2;
				boxBw.dH = dT;

				AcGeVector3d vecBw(0, 0, -dT);
				for (int i = 0; i < dBYNUM; i++)
				{
					AecEqui::XPrimData dataBw;
					dataBw.m_eType = AecEqui::kBox;
					dataBw.m_iClr = 256;
					dataBw.m_bBoolSubtract = false;
					dataBw.m_vtMove = vecBw;
					dataBw.m_ptRotation.set(0, 0, i * ((2 * PI) / 10));
					setData<AecEqui::XBOX>(&dataBw, &boxBw);
					pEqu->AddSubPrimObj(&dataBw);
					clearData(dataBw);
				}

				AecEqui::XCylinder CylinderIn;
				memset(&CylinderIn, 0, sizeof(AecEqui::XCylinder));
				CylinderIn.dr = 7.5;
				CylinderIn.dH = dT;

				AcGeVector3d vecIn(0, 0, -dT);
				AecEqui::XPrimData dataIn;
				dataIn.m_eType = AecEqui::kCylinder;
				dataIn.m_iClr = 256;
				dataIn.m_bBoolSubtract = false;
				dataIn.m_vtMove = vecIn;
				setData<AecEqui::XCylinder>(&dataIn, &CylinderIn);
				pEqu->AddSubPrimObj(&dataIn);
				clearData(dataIn);
			}
		}
		else
		{
			// 散流
			if (bShape)
			{
				// 方
				int nCount = (int)(dW / dDist);
				AcDbPolyline* pPoly(NULL);
				AcDbRegion* pReg(NULL);
				AcGePoint3d pt;
				for (int i = 1; i <= nCount; ++i)
				{
					pt = ptO + X * dDist * .5 * i;
					pt += Y * dDist * .5 * i;
					pReg = makeRectRegion(pt, dW1 * .1, dT, X, Z);
					if (!pReg)
					{
						return NULL;
					}
					pPoly = makeRectPoly(ptO, dDist * i, dDist * i, X, Y);
					if (!pPoly)
					{
						return NULL;
					}
					NewSweep ns(true, pReg, pPoly);
					AecEqui::XPrimData data;
					data.m_eType = AecEqui::kNewSweep;
					data.m_bBoolSubtract = false;
					data.m_iClr = 256;
					data.m_nSize = 0;
					data.m_vtMove = Z * dT * -.5;
					ns.toData(data.m_pData, data.m_nSize);
					pEqu->AddSubPrimObj(&data);
					clearData(data);
				}
			}
			else
			{
				// 圆
				int nCount = (int)(dDN / dDist);
				AcDbPolyline* pPoly(NULL);
				AcDbRegion* pReg(NULL);
				AcGePoint3d pt;
				AcDbCircle* pCir(NULL);
				for (int i = 1; i <= nCount; ++i)
				{
					pt = ptO + X * dDist * .5 * i;
					pReg = makeRectRegion(pt, dW1 * .1, dT, X, Z);
					if (!pReg)
					{
						return NULL;
					}
					pCir = new AcDbCircle(ptO, Z, dDist * .5 * i);
					if (!pCir)
					{
						return NULL;
					}
					pPoly = CoreTools::MakePolyline(pCir);
					if (!pPoly)
					{
						return NULL;
					}
					NewSweep ns(true, pReg, pPoly);
					AecEqui::XPrimData data;
					data.m_eType = AecEqui::kNewSweep;
					data.m_bBoolSubtract = false;
					data.m_iClr = 256;
					data.m_nSize = 0;
					data.m_vtMove = Z * dT * -.5;
					ns.toData(data.m_pData, data.m_nSize);
					pEqu->AddSubPrimObj(&data);
					clearData(data);
				}
			}
		}

		return pEqu;
	}

	AecDbEwEquipment* makeFENGKOUSP(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dL		// 方风口长
		, const double& dW		// 方风口宽
		, const bool& bType		// 风口类型
		, const double& dT		// 风口厚度T
		, const double& dW1	    // 风口边框宽W1
		, const double& dBYNUM	// 百叶条数BYNUM
		, const double& dDist	// 风叶间距
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeSNFKSP!"));
	#endif // _DEBUG

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d ptO(AcGePoint3d::kOrigin);
		Adesk::Int32 itemID(0);

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("SHINEIFENGKOU"), true));
		if (!pEqu) return NULL;

		if (bType)
		{
			if (bShape)
			{
				AcGeMatrix3d mat;

				AecEqui::XBox boxTop;
				memset(&boxTop, 0, sizeof(AecEqui::XBox));
				boxTop.dL = dT;
				boxTop.dW = dW1;
				boxTop.dH = dL;

				AecEqui::XBox boxBw;
				memset(&boxBw, 0, sizeof(AecEqui::XBox));
				boxBw.dL = 10;
				boxBw.dW = dW - 2 * dW1;
				boxBw.dH = 1;

				AecEqui::XBox boxLeft;
				memset(&boxLeft, 0, sizeof(AecEqui::XBox));
				boxLeft.dL = dW1;
				boxLeft.dW = dW - 2 * dW1;
				boxLeft.dH = dT;

				AcGeVector3d vecTop(-dT / 2, dW * .5 - dW1 * .5, -dL / 2);
				AecEqui::XPrimData dataTop;
				dataTop.m_eType = AecEqui::kBox;
				dataTop.m_iClr = 50;
				dataTop.m_bBoolSubtract = FALSE;
				dataTop.m_vtMove = vecTop;
				setData<AecEqui::XBOX>(&dataTop, &boxTop);

				AcGeVector3d vecBottom(-dT / 2, -(dW * .5 - dW1 * .5), -dL / 2);
				AecEqui::XPrimData dataBottom;
				dataBottom.m_eType = AecEqui::kBox;
				dataBottom.m_iClr = 100;
				dataBottom.m_bBoolSubtract = FALSE;
				dataBottom.m_vtMove = vecBottom;
				setData<AecEqui::XBOX>(&dataBottom, &boxTop);
				double dWNDistance = (dL - 2 * dW1) / 10;
				for (int i = 1; i <= dBYNUM; i++)
				{
					AcGeVector3d vecBw(-dT / 2, 0, i * dWNDistance + dT / 2 - dL / 2);
					AecEqui::XPrimData dataBw;
					dataBw.m_eType = AecEqui::kBox;
					dataBw.m_iClr = 251;
					dataBw.m_bBoolSubtract = FALSE;
					dataBw.m_vtMove = vecBw;
					dataBw.m_ptRotation.set(0, -PI / 3.5, 0);
					setData<AecEqui::XBOX>(&dataBw, &boxBw);
					pEqu->AddSubPrimObj(&dataBw);
					clearData(dataBw);
				}

				AcGeVector3d vecLeft(-dT / 2, 0, -dL / 2);
				AecEqui::XPrimData dataLeft;
				dataLeft.m_eType = AecEqui::kBox;
				dataLeft.m_iClr = 150;
				dataLeft.m_bBoolSubtract = FALSE;
				dataLeft.m_vtMove = vecLeft;
				setData<AecEqui::XBOX>(&dataLeft, &boxLeft);

				AcGeVector3d vecRight(-dT / 2, 0, dL / 2 - dT);
				AecEqui::XPrimData dataRight;
				dataRight.m_eType = AecEqui::kBox;
				dataRight.m_iClr = 200;
				dataRight.m_bBoolSubtract = FALSE;
				dataRight.m_vtMove = vecRight;
				setData<AecEqui::XBOX>(&dataRight, &boxLeft);

				pEqu->AddSubPrimObj(&dataLeft);
				pEqu->AddSubPrimObj(&dataRight);
				pEqu->AddSubPrimObj(&dataTop);
				pEqu->AddSubPrimObj(&dataBottom);
				clearData(dataLeft);
				clearData(dataRight);
				clearData(dataTop);
				clearData(dataBottom);
			}
			else
			{
				AcGePoint3d ptPath(0, 0, 0);
				AcGeVector3d vtN(1, 0, 0);
				AcDbCircle* pPath = new AcDbCircle(ptPath, vtN, dDN * .5);
				AcDbPolyline* pPoly = CoreTools::MakePolyline(pPath);
				DELETE_PTR(pPath);

				AcGePoint3d ptReg(ptPath.x + dT * .5, ptPath.y, ptPath.z + (dDN * .5 - dW1 * .5));
				AcGePoint3d pt0(ptReg.x + dT * .5, .0, ptReg.z - dW1 * .5)
					, pt1(ptReg.x + dT * .5, .0, ptReg.z + dW1 * .5)
					, pt2(ptReg.x - dT * .5, .0, ptReg.z + dW1 * .5)
					, pt3(ptReg.x - dT * .5, .0, ptReg.z - dW1 * .5);

				AcDbVoidPtrArray ar;
				ar.append(new AcDbLine(pt0, pt1));
				ar.append(new AcDbLine(pt1, pt2));
				ar.append(new AcDbLine(pt2, pt3));
				ar.append(new AcDbLine(pt3, pt0));
				AcDbRegion* pReg = CoreTools::createRegion(ar);
				deleteArrayVoidPtrs< AcDbLine>(ar);

				if (!pReg)
				{
					DELETE_PTR(pPoly);
					DELETE_PTR(pEqu);
					return NULL;
				}

				AcGePoint3d ptOrg(0, 0, 0);		// 旋转轴原点
				AcGeVector3d vtDir(1, 0, 0);		// 旋转轴方向
				double dStartAngle = 0;			// 旋转起始角
				double dSweepAngle = 2 * PI;		// 旋转终止角

				AcGeVector3d vecPt(-ptPath.x, 0, 0);
				NewRevolve Nr(true, pReg, ptOrg, vtDir, dSweepAngle, dStartAngle);
				DELETE_PTR(pReg);
				AecEqui::XPrimData dataNr;
				dataNr.m_eType = AecEqui::kNewRevolve;
				dataNr.m_bBoolSubtract = false;
				dataNr.m_iClr = 256;
				dataNr.m_nSize = 0;
				dataNr.m_vtMove = vecPt;
				Nr.toData(dataNr.m_pData, dataNr.m_nSize);
				pEqu->AddSubPrimObj(&dataNr);
				clearData(dataNr);
				AecEqui::XBox boxBw;
				memset(&boxBw, 0, sizeof(AecEqui::XBox));
				boxBw.dL = dT;
				boxBw.dW = 2;
				boxBw.dH = dDN / 2 - dW1;

				AcGeVector3d vecBw(dT / 2, 0, 0);
				for (int i = 0; i < dBYNUM; i++)
				{
					AecEqui::XPrimData dataBw;
					dataBw.m_eType = AecEqui::kBox;
					dataBw.m_iClr = 256;
					dataBw.m_bBoolSubtract = false;
					dataBw.m_vtMove = vecBw;
					dataBw.m_ptRotation.set(i * ((2 * PI) / 10), 0, 0);
					setData<AecEqui::XBOX>(&dataBw, &boxBw);
					pEqu->AddSubPrimObj(&dataBw);
					clearData(dataBw);
				}

				AecEqui::XCylinder CylinderIn;
				memset(&CylinderIn, 0, sizeof(AecEqui::XCylinder));
				CylinderIn.dr = 7.5;
				CylinderIn.dH = dT;

				AecEqui::XPrimData dataIn;
				dataIn.m_eType = AecEqui::kCylinder;
				dataIn.m_iClr = 256;
				dataIn.m_bBoolSubtract = false;
				dataIn.m_ptRotation.set(0, PI / 2, 0);
				setData<AecEqui::XCylinder>(&dataIn, &CylinderIn);
				pEqu->AddSubPrimObj(&dataIn);
				clearData(dataIn);
			}
		}
		else
		{
			if (bShape)
			{
				int nCount = (int)min(dL / dDist, dW / dDist);
				AcDbPolyline* pPoly(NULL);
				AcDbRegion* pReg(NULL);
				AcGePoint3d pt;
				for (int i = 1; i <= nCount; ++i)
				{
					pt = ptO + X * dDist * .5 * i;
					pt += Y * dDist * .5 * i;
					pReg = makeRectRegion(pt, dW1 * .1, dT, X, Z);
					if (!pReg)
					{
						return NULL;
					}
					pPoly = makeRectPoly(ptO, dDist * i, dDist * i, X, Y);
					if (!pPoly)
					{
						return NULL;
					}
					NewSweep ns(true, pReg, pPoly);
					AecEqui::XPrimData data;
					data.m_eType = AecEqui::kNewSweep;
					data.m_bBoolSubtract = false;
					data.m_iClr = 256;
					data.m_nSize = 0;
					data.m_ptRotation.set(.0, PI * .5, .0);
					ns.toData(data.m_pData, data.m_nSize);
					pEqu->AddSubPrimObj(&data);
					clearData(data);
				}
			}
			else
			{
				int nCount = (int)(dDN / dDist);
				AcDbPolyline* pPoly(NULL);
				AcDbRegion* pReg(NULL);
				AcGePoint3d pt;
				AcDbCircle* pCir(NULL);
				for (int i = 1; i <= nCount; ++i)
				{
					pt = ptO + Y * dDist * .5 * i;
					pReg = makeCircleRegion(pt, Z, dW1 * .1);
					if (!pReg)
					{
						return NULL;
					}
					pCir = new AcDbCircle(ptO, X, dDist * .5 * i);
					if (!pCir)
					{
						return NULL;
					}
					pPoly = CoreTools::MakePolyline(pCir);
					if (!pPoly)
					{
						return NULL;
					}
					NewSweep ns(true, pReg, pPoly);
					AecEqui::XPrimData data;
					data.m_eType = AecEqui::kNewSweep;
					data.m_bBoolSubtract = false;
					data.m_iClr = 256;
					data.m_nSize = 0;
					ns.toData(data.m_pData, data.m_nSize);
					pEqu->AddSubPrimObj(&data);
					clearData(data);
				}
			}
		}

		return pEqu;
	}

	AecDbEwEquipment* makeFENGMAOTXCZ(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dW		// 方风口宽
		, const double& dH		// 方风口高
		, const double& dR1		// 底座半径
		, const double& dH1		// 风帽高度
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeFENGMAOTXCZ!"));
	#endif 

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("makeFENGMAOTXCZ"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		double dFMR(.0);
		if (bShape)
		{
			dFMR = dW * .5;
		}
		else
		{
			dFMR = dDN * .5;
		}

		AcGePoint3d ptGe[6];
		ptGe[0] = pt0 + Z * dH1;
		ptGe[1] = ptGe[0] - Z * dH1 * .1;
		ptGe[1] += X * dFMR;
		ptGe[2] = ptGe[1] - Z * dH1 * .8;
		ptGe[3] = ptGe[2] - Z * dH1 * .1;
		ptGe[4] = pt0;
		ptGe[5] = ptGe[0];

		AcGePoint3d pt = ptGe[1] - Z * dH1 * .4;

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(ptGe[0], ptGe[1]));
		ar.append(new AcDbArc(pt, Y, dH1 * .4, PI * -1.5, PI * -.5));
		ar.append(new AcDbLine(ptGe[2], ptGe[3]));
		ar.append(new AcDbLine(ptGe[3], ptGe[4]));
		ar.append(new AcDbLine(ptGe[4], ptGe[0]));
		AcDbRegion* pReg = CoreTools::createRegion(ar);
		deleteArrayVoidPtrs< AcDbEntity>(ar);
		if (!pReg)
		{
			DELETE_PTR(pEqu);
			return NULL;
		}
		NewRevolve nr(true, pReg, pt0, AcGeVector3d::kZAxis, PI * 2, 0);
		DELETE_PTR(pReg);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewRevolve;
		data.m_bBoolSubtract = false;
		data.m_iClr = 200;
		nr.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);

		return pEqu;
	}

	AecDbEwEquipment* makeFENGMAOSXCZ(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dW		// 方风口宽
		, const double& dH		// 方风口高
		, const double& dR1		// 底座半径
		, const double& dH1		// 风帽高度
		, const double& dL2		// 支架长度
		, const double& dW2		// 支架宽度
		, const double& dH2		// 支架高度
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeFENGMAOSXCZ!"));
	#endif 

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("makeFENGMAOSXCZ"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		double dFMR(.0);
		if (bShape)
		{
			dFMR = dW * .5;
		}
		else
		{
			dFMR = dDN * .5;
		}

		AcDbCircle* pCir = new AcDbCircle(pt0, Z, dFMR - dL2 * .5);
		if (!pCir)
		{
			return NULL;
		}
		AcDbPolyline* pPath = CoreTools::MakePolyline(pCir);
		DELETE_PTR(pCir);
		if (!pPath)
		{
			return NULL;
		}
		AcGePoint3d pt = pt0 + X * (dFMR - dL2 * .5);
		pt += Z * dH2 * .1 * .5;
		AcDbRegion* pReg = MKHvacValve::makeRectRegion(pt, dL2, dH2 * .1, X, Z);
		if (!pReg)
		{
			DELETE_PTR(pPath);
			return NULL;
		}
		NewSweep ns(true, pReg, pPath);
		DELETE_PTR(pPath);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);

		// 支架
		for (int i(0); i < 3; ++i)
		{
			pt = pt0 - X * (dFMR - dL2 * .5);
			pt += Z * dH2 * .1;
			pReg = MKHvacValve::makeRectRegion(pt, dW2, dL2, X, Y);
			if (!pReg)
			{
				return NULL;
			}
			
			NewExtrude neZJ(true, pReg, dH2);
			AecEqui::XPrimData dataZJ;			
			dataZJ.m_nID = ::GetTickCount();
			dataZJ.m_eType = AecEqui::kNewExtrude;
			dataZJ.m_bBoolSubtract = false;
			dataZJ.m_iClr = 256;
			dataZJ.m_ptRotation.set(.0, .0, PI * 2 / 3 * i);
			neZJ.toData(dataZJ.m_pData, dataZJ.m_nSize);
			pEqu->AddSubPrimObj(&dataZJ);
			clearData(dataZJ);
		}

		AcGePoint3d ptGe[4];
		ptGe[0] = pt0;
		ptGe[0] += Z * dH2 * 1.1;
		ptGe[1] = ptGe[0] + X * dFMR * 2;
		ptGe[2] = ptGe[0] + Z * dH2;
		ptGe[3] = ptGe[0];
		pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 4);
		if (!pReg)
		{
			return NULL;
		}
		NewRevolve nrFMTop(true, pReg, pt0, Z, 2 * PI, .0);
		AecEqui::XPrimData dataFMTop;
		dataFMTop.m_eType = AecEqui::kNewRevolve;
		dataFMTop.m_bBoolSubtract = false;
		dataFMTop.m_iClr = 256;
		dataFMTop.m_nSize = 0;
		nrFMTop.toData(dataFMTop.m_pData, dataFMTop.m_nSize);
		pEqu->AddSubPrimObj(&dataFMTop);
		clearData(dataFMTop);

		return pEqu;
	}

	AecDbEwEquipment* makeFENGMAOZXCZ(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dW		// 方风口宽
		, const double& dH		// 方风口高
		, const double& dR1		// 底座半径
		, const double& dH1		// 风帽高度
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeFENGMAOZXCZ!"));
	#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("makeFENGMAOZXCZ"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		double dFMR(.0);
		if (bShape)
		{
			dFMR = dW * .5;
		}
		else
		{
			dFMR = dDN * .5;
		}

		AcGePoint3d ptGe[10];
		ptGe[0] = pt0 + Z * dH1 * .1;
		ptGe[0] += X * dFMR * .9;
		ptGe[1] = ptGe[0] + X * dFMR * .1;
		ptGe[2] = ptGe[1] + X * dFMR;
		ptGe[2] += Z * dH1 * .5;
		ptGe[3] = ptGe[2] - X * dFMR;
		ptGe[3] += Z * dH1 * .5;
		ptGe[4] = ptGe[3] - X * dFMR * .1;
		ptGe[5] = ptGe[4] + X * dFMR * .9;
		ptGe[5] -= Z * dH1 * .5;
		ptGe[6] = ptGe[0];
		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
		if (!pReg)
		{
			return NULL;
		}
		AcGePoint3d pt = pt0 + Z * dH1 * .1;
		AcDbCircle* pCir = new AcDbCircle(pt, Z, dFMR * .9);
		AcDbPolyline* pPath = CoreTools::MakePolyline(pCir);
		DELETE_PTR(pCir);
		NewSweep ns(true, pReg, pPath);
		DELETE_PTR(pPath);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);

		ptGe[0] = pt0 + Z * dH1 * .1;
		ptGe[1] = ptGe[0] + Z * dH1;
		ptGe[2] = ptGe[1] + X * dFMR * .5;
		ptGe[2] -= Z * dH1 * .5;
		ptGe[3] = ptGe[0];
		pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 4);
		if (!pReg)
		{
			return NULL;
		}
		pt = pt0 + Z * dH1 * .1;
		NewRevolve nrFMMid(true, pReg, pt, Z, 2 * PI, .0);
		AecEqui::XPrimData dataFMMid;
		dataFMMid.m_eType = AecEqui::kNewRevolve;
		dataFMMid.m_bBoolSubtract = false;
		dataFMMid.m_iClr = 256;
		nrFMMid.toData(dataFMMid.m_pData, dataFMMid.m_nSize);
		pEqu->AddSubPrimObj(&dataFMMid);
		clearData(dataFMMid);

		AecEqui::XCylinder CylDZ;
		memset(&CylDZ, 0, sizeof(AecEqui::XCylinder));
		CylDZ.dr = dFMR;
		CylDZ.dH = dH1 * .1;
		AecEqui::XPrimData dataDZ;
		dataDZ.m_eType = AecEqui::kCylinder;
		dataDZ.m_iClr = 50;
		dataDZ.m_bBoolSubtract = FALSE;
		setData<AecEqui::XCylinder>(&dataDZ, &CylDZ);
		pEqu->AddSubPrimObj(&dataDZ);
		clearData(dataDZ);

		return pEqu;
	}

	AecDbEwEquipment* makeFENGMAOTXSP(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dW		// 方风口宽
		, const double& dH		// 方风口高
		, const double& dR1		// 底座半径
		, const double& dH1		// 风帽高度
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeFENGMAOTXSP!"));
	#endif 

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("makeFENGMAOTXSP"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		double dFMR(.0);
		if (bShape)
		{
			dFMR = dW * .5;
		}
		else
		{
			dFMR = dDN * .5;
		}

		AcGePoint3d ptGe[6];
		ptGe[0] = pt0 + Z * dH1;
		ptGe[1] = ptGe[0] - Z * dH1 * .1;
		ptGe[1] += X * dFMR;
		ptGe[2] = ptGe[1] - Z * dH1 * .8;
		ptGe[3] = ptGe[2] - Z * dH1 * .1;
		ptGe[4] = pt0;
		ptGe[5] = ptGe[0];

		AcGePoint3d pt = ptGe[1] - Z * dH1 * .4;

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(ptGe[0], ptGe[1]));
		ar.append(new AcDbArc(pt, Y, dH1 * .4, PI * -1.5, PI * -.5));
		ar.append(new AcDbLine(ptGe[2], ptGe[3]));
		ar.append(new AcDbLine(ptGe[3], ptGe[4]));
		ar.append(new AcDbLine(ptGe[4], ptGe[0]));
		AcDbRegion* pReg = CoreTools::createRegion(ar);
		deleteArrayVoidPtrs< AcDbEntity>(ar);
		if (!pReg)
		{
			DELETE_PTR(pEqu);
			return NULL;
		}
		NewRevolve nr(true, pReg, pt0, AcGeVector3d::kZAxis, PI * 2, 0);
		DELETE_PTR(pReg);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewRevolve;
		data.m_bBoolSubtract = false;
		data.m_iClr = 200;
		data.m_ptRotation.set(.0, PI * -.5, .0);
		nr.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);

		return pEqu;
	}

	AecDbEwEquipment* makeFENGMAOSXSP(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dW		// 方风口宽
		, const double& dH		// 方风口高
		, const double& dR1		// 底座半径
		, const double& dH1		// 风帽高度
		, const double& dL2		// 支架长度
		, const double& dW2		// 支架宽度
		, const double& dH2		// 支架高度
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeFENGMAOSXSP!"));
	#endif 

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("makeFENGMAOSXSP"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		double dFMR(.0);
		if (bShape)
		{
			dFMR = dW * .5;
		}
		else
		{
			dFMR = dDN * .5;
		}

		AcDbCircle* pCir = new AcDbCircle(pt0, Z, dFMR - dL2 * .5);
		if (!pCir)
		{
			return NULL;
		}
		AcDbPolyline* pPath = CoreTools::MakePolyline(pCir);
		DELETE_PTR(pCir);
		if (!pPath)
		{
			return NULL;
		}
		AcGePoint3d pt = pt0 + X * (dFMR - dL2 * .5);
		pt += Z * dH2 * .1 * .5;
		AcDbRegion* pReg = MKHvacValve::makeRectRegion(pt, dL2, dH2 * .1, X, Z);
		if (!pReg)
		{
			DELETE_PTR(pPath);
			return NULL;
		}
		NewSweep ns(true, pReg, pPath);
		DELETE_PTR(pPath);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		data.m_ptRotation.set(.0, PI * -.5, .0);
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);

		// 支架
		for (int i(0); i < 3; ++i)
		{
			pt = pt0 - Y * (dFMR - dL2 * .5);
			pt -= X * dH2 * .1;
			pReg = MKHvacValve::makeRectRegion(pt, dW2, dL2, Z, Y);
			if (!pReg)
			{
				return NULL;
			}

			NewExtrude neZJ(true, pReg, -dH2);
			AecEqui::XPrimData dataZJ;
			dataZJ.m_nID = ::GetTickCount();
			dataZJ.m_eType = AecEqui::kNewExtrude;
			dataZJ.m_bBoolSubtract = false;
			dataZJ.m_iClr = 256;
			dataZJ.m_ptRotation.set(PI * 2 / 3 * i, .0, .0);
			neZJ.toData(dataZJ.m_pData, dataZJ.m_nSize);
			pEqu->AddSubPrimObj(&dataZJ);
			clearData(dataZJ);
		}

		AcGePoint3d ptGe[4];
		ptGe[0] = pt0;
		ptGe[0] += Z * dH2 * 1.1;
		ptGe[1] = ptGe[0] + X * dFMR * 2;
		ptGe[2] = ptGe[0] + Z * dH2;
		ptGe[3] = ptGe[0];
		pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 4);
		if (!pReg)
		{
			return NULL;
		}
		NewRevolve nrFMTop(true, pReg, pt0, Z, 2 * PI, .0);
		AecEqui::XPrimData dataFMTop;
		dataFMTop.m_eType = AecEqui::kNewRevolve;
		dataFMTop.m_bBoolSubtract = false;
		dataFMTop.m_iClr = 256;
		dataFMTop.m_nSize = 0;
		dataFMTop.m_ptRotation.set(.0, PI * -.5, .0);
		nrFMTop.toData(dataFMTop.m_pData, dataFMTop.m_nSize);
		pEqu->AddSubPrimObj(&dataFMTop);
		clearData(dataFMTop);

		return pEqu;
	}

	AecDbEwEquipment* makeFENGMAOZXSP(const bool& bShape		// 风口形状
		, const double& dDN		// 圆风口公称
		, const double& dW		// 方风口宽
		, const double& dH		// 方风口高
		, const double& dR1		// 底座半径
		, const double& dH1		// 风帽高度
	)
	{
	#ifdef _DEBUG
		acutPrintf(_T("\n makeFENGMAOZXSP!"));
	#endif
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("makeFENGMAOZXSP"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		double dFMR(.0);
		if (bShape)
		{
			dFMR = dW * .5;
		}
		else
		{
			dFMR = dDN * .5;
		}

		AcGePoint3d ptGe[10];
		ptGe[0] = pt0 + Z * dH1 * .1;
		ptGe[0] += X * dFMR * .9;
		ptGe[1] = ptGe[0] + X * dFMR * .1;
		ptGe[2] = ptGe[1] + X * dFMR;
		ptGe[2] += Z * dH1 * .5;
		ptGe[3] = ptGe[2] - X * dFMR;
		ptGe[3] += Z * dH1 * .5;
		ptGe[4] = ptGe[3] - X * dFMR * .1;
		ptGe[5] = ptGe[4] + X * dFMR * .9;
		ptGe[5] -= Z * dH1 * .5;
		ptGe[6] = ptGe[0];
		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 7);
		if (!pReg)
		{
			return NULL;
		}
		AcGePoint3d pt = pt0 + Z * dH1 * .1;
		AcDbCircle* pCir = new AcDbCircle(pt, Z, dFMR * .9);
		AcDbPolyline* pPath = CoreTools::MakePolyline(pCir);
		DELETE_PTR(pCir);
		NewSweep ns(true, pReg, pPath);
		DELETE_PTR(pPath);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kNewSweep;
		data.m_bBoolSubtract = false;
		data.m_iClr = 256;
		data.m_nSize = 0;
		data.m_ptRotation.set(.0, PI * -.5, .0);
		ns.toData(data.m_pData, data.m_nSize);
		pEqu->AddSubPrimObj(&data);
		clearData(data);

		ptGe[0] = pt0 + Z * dH1 * .1;
		ptGe[1] = ptGe[0] + Z * dH1;
		ptGe[2] = ptGe[1] + X * dFMR * .5;
		ptGe[2] -= Z * dH1 * .5;
		ptGe[3] = ptGe[0];
		pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 4);
		if (!pReg)
		{
			return NULL;
		}
		pt = pt0 + Z * dH1 * .1;
		NewRevolve nrFMMid(true, pReg, pt, Z, 2 * PI, .0);
		AecEqui::XPrimData dataFMMid;
		dataFMMid.m_eType = AecEqui::kNewRevolve;
		dataFMMid.m_bBoolSubtract = false;
		dataFMMid.m_iClr = 256;
		dataFMMid.m_ptRotation.set(.0, PI * -.5, .0);
		nrFMMid.toData(dataFMMid.m_pData, dataFMMid.m_nSize);
		pEqu->AddSubPrimObj(&dataFMMid);
		clearData(dataFMMid);

		// 底座
		AecEqui::XCylinder CylDZ;
		memset(&CylDZ, 0, sizeof(AecEqui::XCylinder));
		CylDZ.dr = dFMR;
		CylDZ.dH = dH1 * .1;
		AecEqui::XPrimData dataDZ;
		dataDZ.m_eType = AecEqui::kCylinder;
		dataDZ.m_iClr = 50;
		dataDZ.m_bBoolSubtract = FALSE;
		dataDZ.m_ptRotation.set(.0, PI * -.5, .0);
		setData<AecEqui::XCylinder>(&dataDZ, &CylDZ);
		pEqu->AddSubPrimObj(&dataDZ);
		clearData(dataDZ);

		return pEqu;
	}

	AecDbEwEquipment* makeSXRECT(const bool& bHole	// 人孔
		, const double& dL0			// 方形人孔长度
		, const double& dD0			// 圆形人孔直径
		, const double& dL1			// 水箱长度
		, const double& dW1			// 水箱宽度
		, const double& dH1			// 水箱高度
		, const bool& bSupport		// 水箱是否需要支架
		, const double& dNum		// 支架数目
		, const bool& bLocation		// 支架位置
		, const double& dL2			// 支架长度
		, const double& dW2			// 支架宽度
		, const double& dH2			// 支架高度
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeSXRECT!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("SHUIXIANG"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d ptO(AcGePoint3d::kOrigin);

		// 水箱
		AecEqui::XBox boxSX;
		memset(&boxSX, 0, sizeof(AecEqui::XBox));
		boxSX.dL = dL1;
		boxSX.dW = dW1;
		boxSX.dH = dH1;

		AecEqui::XPrimData dataSX;
		dataSX.m_eType = AecEqui::kBox;
		dataSX.m_iClr = 50;
		dataSX.m_bBoolSubtract = FALSE;
		setData<AecEqui::XBOX>(&dataSX, &boxSX);
		pEqu->AddSubPrimObj(&dataSX);
		clearData(dataSX);

		// 人孔
		if (bHole)
		{
			AecEqui::XBox boxRectRK;
			memset(&boxRectRK, 0, sizeof(AecEqui::XBox));
			boxRectRK.dL = dL0;
			boxRectRK.dW = dL0;
			boxRectRK.dH = dL0 * .1;

			AcGeVector3d vecRectRK(Z * boxSX.dH);
			vecRectRK += X * -(boxSX.dL * .5 - boxRectRK.dL * .5);
			vecRectRK += Y * (boxSX.dW * .5 - boxRectRK.dW * .5);
			AecEqui::XPrimData dataRectRK;
			dataRectRK.m_eType = AecEqui::kBox;
			dataRectRK.m_iClr = 100;
			dataRectRK.m_bBoolSubtract = FALSE;
			dataRectRK.m_vtMove = vecRectRK;
			setData<AecEqui::XBOX>(&dataRectRK, &boxRectRK);
			pEqu->AddSubPrimObj(&dataRectRK);
			clearData(dataRectRK);

			AecEqui::XBox boxRectRKWK;
			memset(&boxRectRKWK, 0, sizeof(AecEqui::XBox));
			boxRectRKWK.dL = boxRectRK.dL * .99;
			boxRectRKWK.dW = boxRectRK.dW * .99;
			boxRectRKWK.dH = boxRectRK.dH;

			dataRectRK.m_eType = AecEqui::kBox;
			dataRectRK.m_iClr = 100;
			dataRectRK.m_bBoolSubtract = TRUE;
			dataRectRK.m_vtMove = vecRectRK;
			setData<AecEqui::XBOX>(&dataRectRK, &boxRectRKWK);
			pEqu->AddSubPrimObj(&dataRectRK);
			clearData(dataRectRK);

			// 管嘴
			CoreTools::addNozzForEqu_Rect(pEqu
				, AcGeVector3d::kZAxis
				, AcGePoint3d(ptO.x - (boxSX.dL - boxRectRK.dL) * .5, ptO.y + (boxSX.dW - boxRectRK.dW) * .5, ptO.z + boxSX.dH + boxRectRK.dH)
				, boxRectRK.dL
				, boxRectRK.dW
				, boxRectRK.dH * .01
				, boxRectRK.dL * .05
				, boxRectRK.dH * .01
				, 0
				, false
				, false);
		}
		else
		{
			AecEqui::XCylinder ClnCirRK;
			memset(&ClnCirRK, 0, sizeof(AecEqui::XCylinder));
			ClnCirRK.dr = dL0 * .5;
			ClnCirRK.dH = dL0 * .1;

			AcGeVector3d vecCirRK(Z * boxSX.dH);
			vecCirRK += X * (boxSX.dL * -.5 + ClnCirRK.dr);
			vecCirRK += Y * (boxSX.dW * .5 - ClnCirRK.dr);
			AecEqui::XPrimData dataCirRK;
			dataCirRK.m_eType = AecEqui::kCylinder;
			dataCirRK.m_iClr = 100;
			dataCirRK.m_bBoolSubtract = FALSE;
			dataCirRK.m_vtMove = vecCirRK;
			setData<AecEqui::XCylinder>(&dataCirRK, &ClnCirRK);
			pEqu->AddSubPrimObj(&dataCirRK);
			clearData(dataCirRK);

			AecEqui::XCylinder ClnCirRKWK;
			memset(&ClnCirRKWK, 0, sizeof(AecEqui::XCylinder));
			ClnCirRKWK.dr = ClnCirRK.dr * .99;
			ClnCirRKWK.dH = ClnCirRK.dH;

			AecEqui::XPrimData dataCirRKWK;
			dataCirRKWK.m_eType = AecEqui::kCylinder;
			dataCirRKWK.m_iClr = 100;
			dataCirRKWK.m_bBoolSubtract = TRUE;
			dataCirRKWK.m_vtMove = vecCirRK;
			setData<AecEqui::XCylinder>(&dataCirRKWK, &ClnCirRKWK);
			pEqu->AddSubPrimObj(&dataCirRKWK);
			clearData(dataCirRKWK);

			// 管嘴
			CoreTools::addNozzForEqu_Rect(pEqu
				, AcGeVector3d::kZAxis
				, AcGePoint3d(ptO.x + (boxSX.dL * -.5 + ClnCirRK.dr), ptO.y + (boxSX.dW * .5 - ClnCirRK.dr), ptO.z + boxSX.dH + ClnCirRK.dH)
				, ClnCirRK.dr * 2
				, ClnCirRK.dr * 2.1
				, ClnCirRK.dH * .01
				, .0
				, ClnCirRK.dH * .01
				, 0
				, true
				, false);
		}

		// 支架
		if (bSupport)
		{
			double average(1 / (dNum - 1));
			AecEqui::XPrimData dataZJ;
			if (bLocation)
			{
				for (int i = 0; i < dNum; i++)
				{
					AecEqui::XBox boxSPZJ;
					memset(&boxSPZJ, 0, sizeof(AecEqui::XBox));
					boxSPZJ.dL = dL2;
					boxSPZJ.dW = dW2;
					boxSPZJ.dH = dH2;

					AcGeVector3d vecSPZJ(Z * -boxSPZJ.dH);
					vecSPZJ += Y * (boxSX.dW * -.5 + boxSX.dW * i * average);
					dataZJ.m_eType = AecEqui::kBox;
					dataZJ.m_iClr = 150;
					dataZJ.m_bBoolSubtract = FALSE;
					dataZJ.m_vtMove = vecSPZJ;
					setData<AecEqui::XBOX>(&dataZJ, &boxSPZJ);
					pEqu->AddSubPrimObj(&dataZJ);
					clearData(dataZJ);
				}
			}
			else
			{
				for (int i = 0; i < dNum; i++)
				{
					AecEqui::XBox boxCZZJ;
					memset(&boxCZZJ, 0, sizeof(AecEqui::XBox));
					boxCZZJ.dL = dL2;
					boxCZZJ.dW = dW2;
					boxCZZJ.dH = dH2;

					AcGeVector3d vecCZZJ(Z * -boxCZZJ.dH);
					vecCZZJ += X * (boxSX.dL * -.5 + boxSX.dL * i * average);
					dataZJ.m_eType = AecEqui::kBox;
					dataZJ.m_iClr = 150;
					dataZJ.m_bBoolSubtract = FALSE;
					dataZJ.m_vtMove = vecCZZJ;
					setData<AecEqui::XBOX>(&dataZJ, &boxCZZJ);
					pEqu->AddSubPrimObj(&dataZJ);
					clearData(dataZJ);
				}
			}
		}

		return pEqu;
	}

	AecDbEwEquipment* makeSXCIRCLE(const bool& bShape		// 水箱放置形状
		, const double& dD1			// 水箱直径D1
		, const double& dH1			// 水箱高度H1
		, const double& dH2			// 支架高度H2
		, const double& dL2			// 支架边距L2
		, const double& dD2			// 支架间距D2
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeSXCIRCLE!"));
#endif
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("SHUIXIANG"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		if (bShape)
		{
			AcGePoint3d pt1(pt0 - Z * dH1 * .45);
			AcGePoint3d pt2(pt1 + X * dD1 * .5);
			AcGePoint3d pt3(pt2 + Z * dH1 * .9);
			AcGePoint3d pt4(pt3 - X * dD1 * .5);
			AcGePoint3d pt5(pt1 - Z * dH1 * .05);
			AcGePoint3d pt6(pt4 + Z * dH1 * .05);
			AcGePoint3d ptUp(pt4);
			AcGePoint3d ptDown(pt1);

			AcGeVector3d UpunitNormal(0, 1, 0);
			AcGeVector3d UpmajorAxis(dD1 * .5, 0, 0);
			double UpradiusRatio(dH1 * .05 / (dD1 * .5));
			double UpstartAngle(PI * 1.5);
			double UpendAngle(PI * 2);

			AcGeVector3d DownunitNormal(0, 1, 0);
			AcGeVector3d DownmajorAxis(dD1 * .5, 0, 0);
			double DownradiusRatio(dH1 * .05 / (dD1 * .5));
			double DownstartAngle(0);
			double DownendAngle(PI * .5);

			AcDbEllipse* pEllipse1 = new AcDbEllipse(ptUp, UpunitNormal, UpmajorAxis, UpradiusRatio, UpstartAngle, UpendAngle);
			AcDbEllipse* pEllipse2 = new AcDbEllipse(ptDown, DownunitNormal, DownmajorAxis, DownradiusRatio, DownstartAngle, DownendAngle);
			AcDbLine* pline1 = new AcDbLine(pt2, pt3);
			AcDbLine* pline2 = new AcDbLine(pt5, pt6);

			AcDbVoidPtrArray ar;
			ar.append(pline1);
			ar.append(pline2);
			ar.append(pEllipse1);
			ar.append(pEllipse2);

			AcDbRegion* pReg = CoreTools::createRegion(ar);
			deleteArrayVoidPtrs< AcDbEntity>(ar);

			if (!pReg)
			{
				DELETE_PTR(pEqu);
				return NULL;
			}

			AcGeVector3d vec(Z * (dH1 * .5 + dH2 * .5));
			NewRevolve nr(true, pReg, pt0, AcGeVector3d::kZAxis, PI * 2, 0);
			DELETE_PTR(pReg);
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kNewRevolve;
			data.m_bBoolSubtract = false;
			data.m_iClr = 200;
			data.m_vtMove = vec;
			nr.toData(data.m_pData, data.m_nSize);
			pEqu->AddSubPrimObj(&data);
			clearData(data);

			//底座
			AecEqui::XCylinder Cyl;
			memset(&Cyl, 0, sizeof(AecEqui::XCylinder));
			Cyl.dr = dL2 * .5;
			Cyl.dH = dH2;

			for (int i = 0; i < 3; i++)
			{
				AcGeVector3d vecCyl((dD1 * .5 - dL2 * .5) * cos(i * 2 * PI / 3), (dD1 * .5 - dL2 * .5) * sin(i * 2 * PI / 3), 0);
				AecEqui::XPrimData dataCyl;
				dataCyl.m_eType = AecEqui::kCylinder;
				dataCyl.m_iClr = 100;
				dataCyl.m_bBoolSubtract = FALSE;
				dataCyl.m_vtMove = vecCyl;
				setData<AecEqui::XCylinder>(&dataCyl, &Cyl);
				pEqu->AddSubPrimObj(&dataCyl);
				clearData(dataCyl);
			}


			AecEqui::XCylinder Cyl1;
			memset(&Cyl1, 0, sizeof(AecEqui::XCylinder));
			Cyl1.dr = dD1 * .05;
			Cyl1.dH = dD1 * .05;

			AcGeVector3d vecCyl1(0, 0, dH2 * .5 - dD1 * .05);
			AecEqui::XPrimData dataCyl1;
			dataCyl1.m_eType = AecEqui::kCylinder;
			dataCyl1.m_iClr = 100;
			dataCyl1.m_bBoolSubtract = FALSE;
			dataCyl1.m_vtMove = vecCyl1;
			setData<AecEqui::XCylinder>(&dataCyl1, &Cyl1);
			pEqu->AddSubPrimObj(&dataCyl1);
			clearData(dataCyl1);

			AcGeVector3d vecCyl2(0, 0, dH2 * .5 + dH1);
			AecEqui::XPrimData dataCyl2;
			dataCyl2.m_eType = AecEqui::kCylinder;
			dataCyl2.m_iClr = 100;
			dataCyl2.m_bBoolSubtract = FALSE;
			dataCyl2.m_vtMove = vecCyl2;
			setData<AecEqui::XCylinder>(&dataCyl2, &Cyl1);
			pEqu->AddSubPrimObj(&dataCyl2);
			clearData(dataCyl2);

			// 管嘴
			CoreTools::addNozzForEqu_Rect(pEqu
				, AcGeVector3d::kZAxis
				, AcGePoint3d(0., 0., dH2 * .5 + dH1 + dD2 * .1)
				, dD1 * .05
				, dD1 * .05 
				, dD1 * .05
				, .0
				, dD1 * .05
				, 0
				, true
				, false);
		}	

		else
		{
			AcGePoint3d pt1(pt0 + X * dH1 * .45);
			AcGePoint3d pt2(pt1 + Y * dD1 * .5);
			AcGePoint3d pt3(pt2 - X * dH1 * .9);
			AcGePoint3d pt4(pt3 - Y * dD1 * .5);
			AcGePoint3d pt5(pt1 + X * dH1 * .05);
			AcGePoint3d pt6(pt4 - X * dH1 * .05);
			AcGePoint3d ptLeft(pt4);
			AcGePoint3d ptRight(pt1);

			AcGeVector3d LeftunitNormal(0, 0, 1);
			AcGeVector3d LeftmajorAxis(0, dD1 * .5, 0);
			double LeftradiusRatio(dH1 * .05 / (dD1 * .5));
			double LeftstartAngle(0);
			double LeftendAngle(PI * .5);

			AcGeVector3d RightunitNormal(0, 0, 1);
			AcGeVector3d RightmajorAxis(0, dD1 * .5, 0);
			double RightradiusRatio(dH1 * .05 / (dD1 * .5));
			double RightstartAngle(PI * 1.5);
			double RightendAngle(PI * 2);

			AcDbEllipse* pEllipse1 = new AcDbEllipse(ptLeft, LeftunitNormal, LeftmajorAxis, LeftradiusRatio, LeftstartAngle, LeftendAngle);
			AcDbEllipse* pEllipse2 = new AcDbEllipse(ptRight, RightunitNormal, RightmajorAxis, RightradiusRatio, RightstartAngle, RightendAngle);
			AcDbLine* pline1 = new AcDbLine(pt2, pt3);
			AcDbLine* pline2 = new AcDbLine(pt5, pt6);

			AcDbVoidPtrArray ar;
			ar.append(pline1);
			ar.append(pline2);
			ar.append(pEllipse1);
			ar.append(pEllipse2);

			AcDbRegion* pReg = CoreTools::createRegion(ar);
			deleteArrayVoidPtrs< AcDbEntity>(ar);

			if (!pReg)
			{
				DELETE_PTR(pEqu);
				return NULL;
			}

			AcGeVector3d vec(Z * dD1);
			NewRevolve nr(true, pReg, pt0, AcGeVector3d::kXAxis, PI * 2, 0);
			DELETE_PTR(pReg);
			AecEqui::XPrimData data;
			data.m_eType = AecEqui::kNewRevolve;
			data.m_bBoolSubtract = false;
			data.m_iClr = 200;
			data.m_vtMove = vec;
			nr.toData(data.m_pData, data.m_nSize);
			pEqu->AddSubPrimObj(&data);
			clearData(data);

			AecEqui::XBox box;
			memset(&box, 0, sizeof(AecEqui::XBox));
			box.dL = dL2;
			box.dW = dD1;
			box.dH = dD1;

			for (int i = 0; i < 2; i++)
			{
				AcGeVector3d vec(X * (dL2 * .5 - dH1 * .225 + i *( dH1 * .45 - dL2)));
				AecEqui::XPrimData data;
				data.m_eType = AecEqui::kBox;
				data.m_iClr = 100;
				data.m_bBoolSubtract = FALSE;
				data.m_vtMove = vec;
				setData<AecEqui::XBOX>(&data, &box);
				pEqu->AddSubPrimObj(&data);
				clearData(data);
			}

			AecEqui::XCylinder Cyl3;
			memset(&Cyl3, 0, sizeof(AecEqui::XCylinder));
			Cyl3.dr = dD1 * .05;
			Cyl3.dH = dD1 * .05;

			AcGeVector3d vecCyl3( - dH1 * .5 - dD1 * .05, 0, dD1);
			AecEqui::XPrimData dataCyl3;
			dataCyl3.m_eType = AecEqui::kCylinder;
			dataCyl3.m_iClr = 100;
			dataCyl3.m_bBoolSubtract = FALSE;
			dataCyl3.m_vtMove = vecCyl3;
			dataCyl3.m_ptRotation.set(0, PI * .5, 0);
			setData<AecEqui::XCylinder>(&dataCyl3, &Cyl3);
			pEqu->AddSubPrimObj(&dataCyl3);
			clearData(dataCyl3);

			AcGeVector3d vecCyl4(dH1 * .5, 0, dD1);
			AecEqui::XPrimData dataCyl4;
			dataCyl4.m_eType = AecEqui::kCylinder;
			dataCyl4.m_iClr = 100;
			dataCyl4.m_bBoolSubtract = FALSE;
			dataCyl4.m_vtMove = vecCyl4;
			dataCyl4.m_ptRotation.set(0, PI * .5, 0);
			setData<AecEqui::XCylinder>(&dataCyl4, &Cyl3);
			pEqu->AddSubPrimObj(&dataCyl4);
			clearData(dataCyl4);

			// 管嘴
			AcGeVector3d vecX(-1, 0, 0);
			CoreTools::addNozzForEqu_Rect(pEqu
				, vecX
				, AcGePoint3d( - dH1 * .5 - dD1 * .05, 0, dD1)
				, dD1 * .05
				, dD1 * .05
				, dD1 * .05
				, .0
				, dD1 * .05
				, 0
				, true
				, false);

			// 管嘴
			CoreTools::addNozzForEqu_Rect(pEqu
				, AcGeVector3d::kXAxis
				, AcGePoint3d(dH1 * .5 + dD1 * .05, 0, dD1)
				, dD1 * .05
				, dD1 * .05
				, dD1 * .05
				, .0
				, dD1 * .05
				, 0
				, true
				, false);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeFGRLJ(const bool bFRect			// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
		, const bool& bEnterShape		// 风管软连接入口形状
		, const double& dL1				// 风管软连接入口长度L1
		, const double& dW1				// 风管软连接入口宽度W1
		, const double& dD1				// 风管软连接入口直径D1
		, const double& dH1				// 风管软连接高度H1
		, const double& dFla			// 风管软连接法兰延伸长度Flange
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeFGRLJ!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("FENGGUANRUANLIANJIE"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		AcArray<AcDbRegion*> regs;

		AcDbRegion* pTopReg(NULL), * pSubTopReg(NULL), * pFlaTopReg(NULL);
		AcGePoint3d ptTop(pt0 + Z * (dH1 * .5 - dFla));
		if (!bEnterShape)
		{
			pTopReg = makeCircleRegion(ptTop, Z, dD1 * .5);
			pSubTopReg = makeCircleRegion(ptTop, Z, dD1 * .5 - dFla);
			pFlaTopReg = makeCircleRegion(ptTop, Z, dD1 * .5 + dFla);
		}
		else
		{
			pTopReg = makeRectRegion(ptTop, dL1, dW1);
			pSubTopReg = makeRectRegion(ptTop, dL1 - dFla * 2, dW1 - dFla * 2);
			pFlaTopReg = makeRectRegion(ptTop, dL1 + dFla * 2, dW1 + dFla * 2);
		}

		AcDbRegion* pBotReg(NULL), * pSubBotReg(NULL), * pFlaBotReg(NULL), * pFlaSubBotReg(NULL);
		AcGePoint3d ptBot(pt0 - Z * (dH1 * .5 - dFla));
		AcGePoint3d ptFlaBot(pt0 + Z * (dH1 * -.5));
		if (!bFRect)
		{
			pBotReg = makeCircleRegion(ptBot, Z, dDN * .5);
			pSubBotReg = makeCircleRegion(ptBot, Z, dDN * .5 - dFla);
			pFlaBotReg = makeCircleRegion(ptFlaBot, Z, dDN * .5 + dFla);
			pFlaSubBotReg = makeCircleRegion(ptFlaBot, Z, dDN * .5);
		}
		else
		{
			pBotReg = makeRectRegion(ptBot, dL, dW);
			pSubBotReg = makeRectRegion(ptBot, dL - dFla * 2, dW - dFla * 2);
			pFlaBotReg = makeRectRegion(ptFlaBot, dL + dFla * 2, dW + dFla * 2);
			pFlaSubBotReg = makeRectRegion(ptFlaBot, dL, dW);
		}

		AcGeVector3d vecFGRLJ(X * dH1 * -.5);

		// 风管软连接
		if (pTopReg && pBotReg)
		{
			regs.append(pBotReg);
			regs.append(pTopReg);

			NewLoft nlFGRLJ(true, regs, NULL);

			AecEqui::XPrimData dataFGRLJ;
			dataFGRLJ.m_nID = ::GetTickCount();
			dataFGRLJ.m_eType = AecEqui::kNewLoft;
			dataFGRLJ.m_bBoolSubtract = false;
			dataFGRLJ.m_iClr = 50;
			dataFGRLJ.m_ptRotation.set(PI * .5, 0, PI * -.5);
			dataFGRLJ.m_vtMove = vecFGRLJ;
			nlFGRLJ.toData(dataFGRLJ.m_pData, dataFGRLJ.m_nSize);
			pEqu->AddSubPrimObj(&dataFGRLJ);
			clearData(dataFGRLJ);
		}

		// 挖空
		regs.removeAll();
		if (pSubTopReg && pSubBotReg)
		{
			regs.append(pSubTopReg);
			regs.append(pSubBotReg);

			NewLoft nlWK(false, regs, NULL);
			deleteContainerOfArx<AcDbRegion>(regs);

			AecEqui::XPrimData dataWK;
			dataWK.m_nID = ::GetTickCount();
			dataWK.m_eType = AecEqui::kNewLoft;
			dataWK.m_bBoolSubtract = true;
			dataWK.m_iClr = 100;
			dataWK.m_ptRotation.set(PI * .5, 0, PI * -.5);
			dataWK.m_vtMove = vecFGRLJ;
			nlWK.toData(dataWK.m_pData, dataWK.m_nSize);
			pEqu->AddSubPrimObj(&dataWK);
			clearData(dataWK);
		}

		// 风管软连接法兰
		if (pFlaTopReg && pTopReg)
		{
			NewExtrude neFla(true, pFlaTopReg, dFla), neFlaWk(false, pTopReg, dFla);
			DELETE_PTR(pFlaTopReg);
			DELETE_PTR(pTopReg);

			AecEqui::XPrimData dataFla, dataFlaWk;
			dataFla.m_nID = ::GetTickCount();
			dataFla.m_eType = AecEqui::kNewExtrude;
			dataFla.m_bBoolSubtract = false;
			dataFla.m_iClr = 200;
			dataFla.m_ptRotation.set(PI * .5, 0, PI * -.5);
			dataFla.m_vtMove = vecFGRLJ;
			neFla.toData(dataFla.m_pData, dataFla.m_nSize);
			pEqu->AddSubPrimObj(&dataFla);
			clearData(dataFla);

			dataFlaWk.m_nID = dataFla.m_nID + 1;
			dataFlaWk.m_eType = AecEqui::kNewExtrude;
			dataFlaWk.m_bBoolSubtract = true;
			dataFlaWk.m_iClr = 200;
			dataFlaWk.m_ptRotation.set(PI * .5, 0, PI * -.5);
			dataFlaWk.m_vtMove = vecFGRLJ;
			neFlaWk.toData(dataFlaWk.m_pData, dataFlaWk.m_nSize);
			pEqu->AddSubPrimObj(&dataFlaWk);
			clearData(dataFlaWk);
		}

		DELETE_PTR(pBotReg);
		if (pFlaBotReg && pFlaSubBotReg)
		{
			NewExtrude neFla(true, pFlaBotReg, dFla), neFlaWk(false, pFlaSubBotReg, dFla);
			DELETE_PTR(pFlaBotReg);
			DELETE_PTR(pFlaSubBotReg);

			AecEqui::XPrimData dataFla, dataFlaWk;
			dataFla.m_nID = ::GetTickCount();
			dataFla.m_eType = AecEqui::kNewExtrude;
			dataFla.m_bBoolSubtract = false;
			dataFla.m_iClr = 200;
			dataFla.m_ptRotation.set(PI * .5, 0, PI * -.5);
			dataFla.m_vtMove = vecFGRLJ;
			neFla.toData(dataFla.m_pData, dataFla.m_nSize);
			pEqu->AddSubPrimObj(&dataFla);
			clearData(dataFla);

			dataFlaWk.m_nID = dataFla.m_nID + 1;
			dataFlaWk.m_eType = AecEqui::kNewExtrude;
			dataFlaWk.m_bBoolSubtract = true;
			dataFlaWk.m_iClr = 200;
			dataFlaWk.m_ptRotation.set(PI * .5, 0, PI * -.5);
			dataFlaWk.m_vtMove = vecFGRLJ;
			neFlaWk.toData(dataFlaWk.m_pData, dataFlaWk.m_nSize);
			pEqu->AddSubPrimObj(&dataFlaWk);
			clearData(dataFlaWk);
		}

		// 管嘴
		if (!bEnterShape)
		{
			CoreTools::addNozzForEqu_Rect(pEqu
				, X
				, AcGePoint3d(-(dH1 + dFla), .0, .0)
				, dD1
				, .0
				, dFla
				, .0
				, .0
				, 0
				, true
				, false);
		}
		else
		{
			CoreTools::addNozzForEqu_Rect(pEqu
				, X
				, AcGePoint3d(-(dH1 + dFla), .0, .0)
				, dW1
				, dL1
				, dFla
				, .0
				, .0
				, 0
				, false
				, false);
		}

		if (!bFRect)
		{
			CoreTools::addNozzForEqu_Rect(pEqu
				, X
				, AcGePoint3d(.0, .0, .0)
				, dDN
				, .0
				, dFla
				, .0
				, .0
				, 0
				, true
				, false);
		}
		else
		{
			CoreTools::addNozzForEqu_Rect(pEqu
				, X
				, AcGePoint3d(.0, .0, .0)
				, dW
				, dL
				, dFla
				, .0
				, .0
				, 0
				, false
				, false);
		}

		return pEqu;
	}

	AecDbEwEquipment* makeFENGGUANXIAOSHENGQI(const bool bFRect			// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
		, const double& dL1				// 消声器长度
		, const double& dT1				// 法兰厚度
	)
	{
		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("FENGGUANXIAOSHENGQI"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		if (bFRect)
		{
			AecEqui::XBox boxFGXSQ;
			memset(&boxFGXSQ, 0, sizeof(AecEqui::XBox));
			boxFGXSQ.dL = dL1;
			boxFGXSQ.dW = dL;
			boxFGXSQ.dH = dW;

			AcGeVector3d vecFGXSQ(0, 0, boxFGXSQ.dH * -.5);
			AecEqui::XPrimData dataFGXSQ;
			dataFGXSQ.m_eType = AecEqui::kBox;
			dataFGXSQ.m_iClr = 50;
			dataFGXSQ.m_bBoolSubtract = FALSE;
			dataFGXSQ.m_vtMove = vecFGXSQ;
			setData<AecEqui::XBOX>(&dataFGXSQ, &boxFGXSQ);
			pEqu->AddSubPrimObj(&dataFGXSQ);
			clearData(dataFGXSQ);
		
			AcArray<AcDbRegion*> regs;
			AcDbRegion* pTopReg(NULL), * pBotReg(NULL);
			AcGePoint3d ptBot(pt0 + Z * boxFGXSQ.dL * .1);
			pTopReg = makeRectRegion(pt0, boxFGXSQ.dH * .8, boxFGXSQ.dW * .8);
			pBotReg = makeRectRegion(ptBot, boxFGXSQ.dH * .6, boxFGXSQ.dW * .6);

			if (pTopReg && pBotReg)
			{
				regs.append(pBotReg);
				regs.append(pTopReg);

				NewLoft nlXSQ(true, regs, NULL);
				deleteContainerOfArx<AcDbRegion>(regs);

				for (int i = 0; i < 2; i++)
				{
					AcGeVector3d vecXSQLeft(boxFGXSQ.dL * -.5 + boxFGXSQ.dL * i, 0, 0);
					AecEqui::XPrimData dataXSQLeft;
					dataXSQLeft.m_nID = ::GetTickCount();
					dataXSQLeft.m_eType = AecEqui::kNewLoft;
					dataXSQLeft.m_bBoolSubtract = false;
					dataXSQLeft.m_iClr = 150;
					dataXSQLeft.m_ptRotation.set(0, PI * -.5, PI * i);
					dataXSQLeft.m_vtMove = vecXSQLeft;
					nlXSQ.toData(dataXSQLeft.m_pData, dataXSQLeft.m_nSize);
					pEqu->AddSubPrimObj(&dataXSQLeft);
					clearData(dataXSQLeft);

					// 管嘴
					AcGePoint3d ptNozz(-(boxFGXSQ.dL * .5 + dT1 + boxFGXSQ.dL * .1), 0, 0);
					ptNozz.x = ptNozz.x + (boxFGXSQ.dL + boxFGXSQ.dL * .2 + dT1) * i;
					CoreTools::addNozzForEqu_Rect(pEqu
						, X
						, ptNozz
						, dW
						, dL
						, dT1
						, .0
						, .0
						, 0
						, false
						, false);
				}
			}
		}
		else
		{
			AecEqui::XCylinder CylXSQ;
			memset(&CylXSQ, 0, sizeof(AecEqui::XCylinder));
			CylXSQ.dr = dDN * .5;
			CylXSQ.dH = dL1;

			AcGeVector3d vecXSQ(CylXSQ.dH * .5, 0, 0);
			AecEqui::XPrimData dataXSQ;
			dataXSQ.m_eType = AecEqui::kCylinder;
			dataXSQ.m_iClr = 50;
			dataXSQ.m_bBoolSubtract = FALSE;
			dataXSQ.m_ptRotation.set(0, PI * -.5, 0);
			dataXSQ.m_vtMove = vecXSQ;
			setData<AecEqui::XCylinder>(&dataXSQ, &CylXSQ);
			pEqu->AddSubPrimObj(&dataXSQ);
			clearData(dataXSQ);
			
			AecEqui::XCylinder CylXSQWK;
			memset(&CylXSQWK, 0, sizeof(AecEqui::XCylinder));
			CylXSQWK.dr = CylXSQ.dr * .4;
			CylXSQWK.dH = CylXSQ.dH;

			AecEqui::XPrimData dataXSQWK;
			dataXSQWK.m_eType = AecEqui::kCylinder;
			dataXSQWK.m_iClr = 50;
			dataXSQWK.m_bBoolSubtract = TRUE;
			dataXSQWK.m_ptRotation.set(0, PI * -.5, 0);
			dataXSQWK.m_vtMove = vecXSQ;
			setData<AecEqui::XCylinder>(&dataXSQWK, &CylXSQWK);
			pEqu->AddSubPrimObj(&dataXSQWK);
			clearData(dataXSQWK);

			// 管嘴
			AcGePoint3d ptNozz(-(CylXSQ.dH * .5 + dT1), 0, 0);
			for (int i = 0; i < 2; i++)
			{
				ptNozz.x = ptNozz.x + (CylXSQ.dH + dT1) * i;

				CoreTools::addNozzForEqu_Rect(pEqu
					, X
					, ptNozz
					, dDN
					, .0
					, dT1
					, .0
					, .0
					, 0
					, true
					, false);
			}
		}
		return pEqu;
	}

	AecDbEwEquipment* makeNENGLIANGBIAO(const bool bFRect			// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
		, const double& dH				// 圆环底座高度
		, const double& dL1				// 量表边长
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeNENGLIANGBIAO!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("NENGLIANGBIAO"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		// 能量表
		AecEqui::XCylinder CylNLB;
		memset(&CylNLB, 0, sizeof(AecEqui::XCylinder));
		CylNLB.dr = dDN * .25;
		CylNLB.dH = dH;

		AcGeVector3d vecNLB(CylNLB.dH * .5, 0, 0);
		AecEqui::XPrimData dataNLB;
		dataNLB.m_eType = AecEqui::kCylinder;
		dataNLB.m_iClr = 50;
		dataNLB.m_bBoolSubtract = FALSE;
		dataNLB.m_vtMove = vecNLB;
		dataNLB.m_ptRotation.set(0, PI * -.5, 0);
		setData<AecEqui::XCylinder>(&dataNLB, &CylNLB);
		pEqu->AddSubPrimObj(&dataNLB);
		clearData(dataNLB);

		// 能量表挖空
		AecEqui::XCylinder CylNLBWK;
		memset(&CylNLBWK, 0, sizeof(AecEqui::XCylinder));
		CylNLBWK.dr = CylNLB.dr * .9;
		CylNLBWK.dH = CylNLB.dH;

		AecEqui::XPrimData dataNLBWK;
		dataNLBWK.m_eType = AecEqui::kCylinder;
		dataNLBWK.m_iClr = 50;
		dataNLBWK.m_bBoolSubtract = TRUE;
		dataNLBWK.m_vtMove = vecNLB;
		dataNLBWK.m_ptRotation.set(0, -PI * .5, 0);
		setData<AecEqui::XCylinder>(&dataNLBWK, &CylNLBWK);
		pEqu->AddSubPrimObj(&dataNLBWK);
		clearData(dataNLBWK);

		// 能量表底座
		AecEqui::XCylinder CylDZ;
		memset(&CylDZ, 0, sizeof(AecEqui::XCylinder));
		CylDZ.dr = dDN * .5;
		CylDZ.dH = dH * .1;

		// 能量表底座挖空
		AecEqui::XCylinder CylDZWK;
		memset(&CylDZWK, 0, sizeof(AecEqui::XCylinder));
		CylDZWK.dr = CylNLB.dr;
		CylDZWK.dH = CylDZ.dH;

		AcGeVector3d vecDZ(-(dH * .5), 0, 0);
		for (int i = 0; i < 2; i++)
		{
			vecDZ.x = vecDZ.x + (CylNLB.dH + CylDZ.dH) * i;

			AecEqui::XPrimData dataDZ;
			dataDZ.m_eType = AecEqui::kCylinder;
			dataDZ.m_iClr = 150;
			dataDZ.m_bBoolSubtract = FALSE;
			dataDZ.m_vtMove = vecDZ;
			dataDZ.m_ptRotation.set(0, PI * -.5, 0);
			setData<AecEqui::XCylinder>(&dataDZ, &CylDZ);
			pEqu->AddSubPrimObj(&dataDZ);
			clearData(dataDZ);

			AecEqui::XPrimData dataDZWK;
			dataDZWK.m_eType = AecEqui::kCylinder;
			dataDZWK.m_iClr = 150;
			dataDZWK.m_bBoolSubtract = TRUE;
			dataDZWK.m_vtMove = vecDZ;
			dataDZWK.m_ptRotation.set(0, -PI * .5, 0);
			setData<AecEqui::XCylinder>(&dataDZWK, &CylDZWK);
			pEqu->AddSubPrimObj(&dataDZWK);
			clearData(dataDZWK);
		}

		// 能量表换能器
		AecEqui::XBox boxHNQ;
		memset(&boxHNQ, 0, sizeof(AecEqui::XBox));
		boxHNQ.dL = dL1;
		boxHNQ.dW = dL1;
		boxHNQ.dH = dL1 * .1;

		AcGeVector3d vecHNQ(0, 0, CylNLB.dr * 2);
		AecEqui::XPrimData dataHNQ;
		dataHNQ.m_eType = AecEqui::kBox;
		dataHNQ.m_iClr = 200;
		dataHNQ.m_bBoolSubtract = FALSE;
		dataHNQ.m_vtMove = vecHNQ;
		setData<AecEqui::XBOX>(&dataHNQ, &boxHNQ);
		pEqu->AddSubPrimObj(&dataHNQ);
		clearData(dataHNQ);

		// 能量表换能器支架
		AecEqui::XBox boxHNQZJ;
		memset(&boxHNQZJ, 0, sizeof(AecEqui::XBox));
		boxHNQZJ.dL = boxHNQ.dH;
		boxHNQZJ.dW = boxHNQ.dH;
		boxHNQZJ.dH = CylNLB.dr;

		AcGeVector3d vecHNQZJ(0, 0, CylNLB.dr);
		AecEqui::XPrimData dataHNQZJ;
		dataHNQZJ.m_eType = AecEqui::kBox;
		dataHNQZJ.m_iClr = 200;
		dataHNQZJ.m_bBoolSubtract = FALSE;
		dataHNQZJ.m_vtMove = vecHNQZJ;
		setData<AecEqui::XBOX>(&dataHNQZJ, &boxHNQZJ);
		pEqu->AddSubPrimObj(&dataHNQZJ);
		clearData(dataHNQZJ);

		// 能量表接口
		AecEqui::XCylinder CylJK;
		memset(&CylJK, 0, sizeof(AecEqui::XCylinder));
		CylJK.dr = CylNLB.dr * .25;
		CylJK.dH = CylNLB.dr;

		AcGeVector3d vecJK(CylNLB.dH * .35, CylNLB.dr * -1.5, 0);
		AecEqui::XPrimData dataJK;
		dataJK.m_eType = AecEqui::kCylinder;
		dataJK.m_iClr = 230;
		dataJK.m_bBoolSubtract = FALSE;
		dataJK.m_vtMove = vecJK;
		dataJK.m_ptRotation.set(PI * -.25, PI * -.5, 0);
		setData<AecEqui::XCylinder>(&dataJK, &CylJK);
		pEqu->AddSubPrimObj(&dataJK);
		clearData(dataJK);

		// 管嘴
		for (int i = 0; i < 2; i++)
		{
			AcGePoint3d ptNozz = pt0 + X * -(CylNLB.dH * .5 + CylDZ.dH + dH * .1);
			ptNozz += X * (CylNLB.dH + CylDZ.dH * 2 + dH * .1) * i;

			if (bFRect)
			{
				CoreTools::addNozzForEqu_Rect(pEqu
					, X
					, ptNozz
					, dW
					, dL
					, dH * .1
					, dH * .1
					, dH * .1
					, 0
					, false
					, false);
			}
			else
			{
				CoreTools::addNozzForEqu_Rect(pEqu
					, X
					, ptNozz
					, dDN
					, dDN * 1.1
					, dH * .1
					, dH * .1
					, dH * .1
					, 0
					, true
					, false);
			}
		}

		return pEqu;
	}
	
	AecDbEwEquipment* makeSHISHIBAOJINGFA(const bool bFRect			// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeSHISHIBAOJINGFA!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("SHISHIBAOJINGFA"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		// 法兰
		AecEqui::XCylinder CylFlange;
		memset(&CylFlange, 0, sizeof(AecEqui::XCylinder));
		CylFlange.dr = 200;
		CylFlange.dH = 100;

		AcGeVector3d vtFlange;
		for (int i = 0; i < 2; ++i)
		{
			vtFlange = Z * 900 * i;
			AecEqui::XPrimData dataFlange;
			dataFlange.m_eType = AecEqui::kCylinder;
			dataFlange.m_iClr = 50;
			dataFlange.m_bBoolSubtract = FALSE;
			dataFlange.m_vtMove = vtFlange;
			setData<AecEqui::XCylinder>(&dataFlange, &CylFlange);
			pEqu->AddSubPrimObj(&dataFlange);
			clearData(dataFlange);
		}

		// 颈部
		AecEqui::XCylinder CylNeck;
		memset(&CylNeck, 0, sizeof(AecEqui::XCylinder));
		CylNeck.dr = 100;
		CylNeck.dH = 800;

		AcGeVector3d vtNeck(Z * CylFlange.dH);
		AecEqui::XPrimData dataNeck;
		dataNeck.m_eType = AecEqui::kCylinder;
		dataNeck.m_iClr = 50;
		dataNeck.m_bBoolSubtract = FALSE;
		dataNeck.m_vtMove = vtNeck;
		setData<AecEqui::XCylinder>(&dataNeck, &CylNeck);
		pEqu->AddSubPrimObj(&dataNeck);
		clearData(dataNeck);

		// 腹部
		AecEqui::XCylinder CylAbdomen;
		memset(&CylAbdomen, 0, sizeof(AecEqui::XCylinder));
		CylAbdomen.dr = 150;
		CylAbdomen.dH = 100;

		AcGeVector3d vtAbdomen(Z * 450);
		AecEqui::XPrimData dataAbdomen;
		dataAbdomen.m_eType = AecEqui::kCylinder;
		dataAbdomen.m_iClr = 50;
		dataAbdomen.m_bBoolSubtract = FALSE;
		dataAbdomen.m_vtMove = vtAbdomen;
		setData<AecEqui::XCylinder>(&dataAbdomen, &CylAbdomen);
		pEqu->AddSubPrimObj(&dataAbdomen);
		clearData(dataAbdomen);

		// 阀门
		AecEqui::XCylinder CylValve;
		memset(&CylValve, 0, sizeof(AecEqui::XCylinder));
		CylValve.dr = 25;
		CylValve.dH = 300;

		AcGeVector3d vtValve(Z * 500);
		AecEqui::XPrimData dataValve;
		dataValve.m_eType = AecEqui::kCylinder;
		dataValve.m_iClr = 50;
		dataValve.m_bBoolSubtract = FALSE;
		dataValve.m_vtMove = vtValve;
		dataValve.m_ptRotation.set(.0, PI * -.5, .0);
		setData<AecEqui::XCylinder>(&dataValve, &CylValve);
		pEqu->AddSubPrimObj(&dataValve);
		clearData(dataValve);

		// 警报器
		AecEqui::XCylinder CylAlarm;
		memset(&CylAlarm, 0, sizeof(AecEqui::XCylinder));
		CylAlarm.dr = 50;
		CylAlarm.dH = 300;

		AcGeVector3d vtAlarm(Z * 500);
		AecEqui::XPrimData dataAlarm;
		dataAlarm.m_eType = AecEqui::kCylinder;
		dataAlarm.m_iClr = 50;
		dataAlarm.m_bBoolSubtract = FALSE;
		dataAlarm.m_vtMove = vtAlarm;
		dataAlarm.m_ptRotation.set(PI * .5, .0, .0);
		setData<AecEqui::XCylinder>(&dataAlarm, &CylAlarm);
		pEqu->AddSubPrimObj(&dataAlarm);
		clearData(dataAlarm);

		return pEqu;
	}
	
	AecDbEwEquipment* makeGANSHIBAOJINGFA(const bool bFRect			// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeGANSHIBAOJINGFA!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("GANSHIBAOJINGFA"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		AcGeVector3d vtFlange;

		// 法兰
		AecEqui::XCylinder CylFlangeOut;
		memset(&CylFlangeOut, 0, sizeof(AecEqui::XCylinder));
		CylFlangeOut.dr = 200;
		CylFlangeOut.dH = 50;

		AecEqui::XPrimData dataFlangeOut;
		dataFlangeOut.m_eType = AecEqui::kCylinder;
		dataFlangeOut.m_iClr = 50;
		dataFlangeOut.m_bBoolSubtract = FALSE;
		//dataFlangeOut.m_vtMove = vtFlange;
		setData<AecEqui::XCylinder>(&dataFlangeOut, &CylFlangeOut);
		pEqu->AddSubPrimObj(&dataFlangeOut);
		clearData(dataFlangeOut);

		AecEqui::XCylinder CylFlangeIn;
		memset(&CylFlangeIn, 0, sizeof(AecEqui::XCylinder));
		CylFlangeIn.dr = 180;
		CylFlangeIn.dH = 50;

		AecEqui::XPrimData dataFlangeIn;
		dataFlangeIn.m_eType = AecEqui::kCylinder;
		dataFlangeIn.m_iClr = 50;
		dataFlangeIn.m_bBoolSubtract = TRUE;
		//dataFlangeIn.m_vtMove = vtFlange;
		setData<AecEqui::XCylinder>(&dataFlangeIn, &CylFlangeIn);
		pEqu->AddSubPrimObj(&dataFlangeIn);
		clearData(dataFlangeIn);

		for (int i = 0; i < 2; ++i)
		{
		}

		return pEqu;
	}
	
	AecDbEwEquipment* makeYUZUOYONGBAOJINGFA(const bool bFRect		// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeYUZUOYONGBAOJINGFA!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("YUZUOYONGBAOJINGFA"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		AecEqui::XCylinder CylNLB;
		memset(&CylNLB, 0, sizeof(AecEqui::XCylinder));
		CylNLB.dr = 100;
		CylNLB.dH = 1000;

		AecEqui::XPrimData dataNLB;
		dataNLB.m_eType = AecEqui::kCylinder;
		dataNLB.m_iClr = 50;
		dataNLB.m_bBoolSubtract = FALSE;
		setData<AecEqui::XCylinder>(&dataNLB, &CylNLB);
		pEqu->AddSubPrimObj(&dataNLB);
		clearData(dataNLB);

		return pEqu;
	}
	
	AecDbEwEquipment* makeYULINBAOJINGFA(const bool bFRect			// 风管形状
		, const double& dDN				// 圆风管公称
		, const double& dL				// 方风管长
		, const double& dW				// 方风管宽
	)
	{
#ifdef _DEBUG
		acutPrintf(_T("\n makeYULINBAOJINGFA!"));
#endif

		AecDbEwEquipment* pEqu(MKValve::makeBaseEquiment(_T("YULINBAOJINGFA"), true));
		if (!pEqu) return NULL;

		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);

		// 
		AecEqui::XCylinder CylNLB;
		memset(&CylNLB, 0, sizeof(AecEqui::XCylinder));
		CylNLB.dr = 100;
		CylNLB.dH = 1000;

		AecEqui::XPrimData dataNLB;
		dataNLB.m_eType = AecEqui::kCylinder;
		dataNLB.m_iClr = 50;
		dataNLB.m_bBoolSubtract = FALSE;
		setData<AecEqui::XCylinder>(&dataNLB, &CylNLB);
		pEqu->AddSubPrimObj(&dataNLB);
		clearData(dataNLB);

		return pEqu;
	}
}