#include "stdafx.h"
#include "ParamEquImpl.h"
#include "GiDrawUtility.h"
#include "CoreTools.h"

#define GETXDATA(key) bRel = m_pXDataMap->GetAt(_T(#key), key)

#define TESTXDATA(name)\
if (!bRel) \
{\
acutPrintf(\
	_T("\n ")\
	_T(#name)\
	_T(" 获取数据失败！"));\
	return;\
}

#pragma region GeShTools
namespace
{

	AcDb3dSolid* makeSolid(AcDbRegion *pReg, const AcGeVector3d &vt)
	{
		AcDb3dSolid *pSolid(NULL);
		if (pReg)
		{
			AcDbSweepOptions op;
			pSolid = new AcDb3dSolid();
			Acad::ErrorStatus es =  pSolid->createExtrudedSolid(pReg, vt, op);
			if (es != Acad::eOk)
				DELETE_PTR(pSolid);
			return pSolid;
		}
		return NULL;
	}

	AcDbRegion* makeRegion(const int count, va_list ap)
	{
		AcDbVoidPtrArray ar;
		AcGePoint3dArray pts;
		for (int i = 0; i < count; ++i)
		{
			pts.append(va_arg(ap, AcGePoint3d));
		}
		if (pts.length() < 3) return NULL;
		pts.append(pts[0]);

		for (int i = 0; i < pts.length() - 1; ++i)
			ar.append(new AcDbLine(pts[i], pts[i + 1]));

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

	AcDbRegion* makeRegion2(const int count, ...)
	{
		va_list vlist;
		va_start(vlist, count);	
		AcDbRegion *pReg = makeRegion(count, vlist);
		va_end(vlist);
		return pReg;
	}

	AcDb3dSolid* makeSolid(const AcGeVector3d &vt, const int count, ...)
	{
		AcDb3dSolid *pSolid(NULL);
		va_list vlist;
		va_start(vlist, count);
		AcDbRegion *pReg(makeRegion(count, vlist));
		va_end(vlist);
		if (pReg)
		{
			pSolid = makeSolid(pReg, vt);
			DELETE_PTR(pReg);
		}
		return pSolid;
	}

	// 给出中心点及长宽，得到一个矩形，左下角点开始，逆时针方向
	void getRect(const AcGePoint3d &ptCenter
		, const AcGeVector3d &vtX
		, const double &L
		, const double &W
		, AcGePoint3d &pt0
		, AcGePoint3d &pt1
		, AcGePoint3d &pt2
		, AcGePoint3d &pt3
		, const AcGeVector3d &vtZ = AcGeVector3d::kZAxis )
	{
		AcGeVector3d Y(vtX), X(vtX);
		Y.rotateBy(PI * .5, vtZ);
		Y.normalize();
		X.normalize();

		pt0 = ptCenter - X * (L * .5);
		pt0 -= Y * (W * .5);
		pt1 = pt0 + X * L;
		pt2 = pt1 + Y * W;
		pt3 = pt2 - X * L;
	}

	AcDb3dSolid* drawExtruded(AcDbRegion *pReg, const AcGeVector3d &vt)
	{
		AcDb3dSolid *pSolid = new AcDb3dSolid();
		AcDbSweepOptions op;
		if (pSolid->createExtrudedSolid(pReg, vt, op) == Acad::eOk)
			return pSolid;
		else
			DELETE_PTR(pSolid);
		return pSolid;
	}

	AcDb3dSolid* drawCylinder(const AcGeVector3d &vt, const AcGePoint3d &pt, const double & r)
	{
		AcDb3dSolid *pSolid(NULL);
		AcDbCircle *pCir(new AcDbCircle(pt, vt, r));
		AcDbRegion *pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);
		if (pReg)
		{
			pSolid = drawExtruded(pReg, vt);
			DELETE_PTR(pReg);
		}

		return pSolid;
	}

	AcDb3dSolid* drawRevolved(AcDbRegion *pReg, const AcGePoint3d &pt, const AcGeVector3d &vt, const double &sA = 0., const double &eA = 2 * PI)
	{
		AcDb3dSolid *pSolid = new AcDb3dSolid();
		AcDbRevolveOptions op;
		if (pSolid->createRevolvedSolid(pReg, pt, vt, eA - sA, sA, op) == Acad::eOk)
			return pSolid;
		else
			DELETE_PTR(pSolid);
		return pSolid;
	}

	// 绘制电机 从pt点开始向Dir方向 dR半径 L长度 dh上下盖的高度
	void drawDianJi( const AcGePoint3d &ptO
		, const AcGeVector3d &vtDir
		, const double &dR
		, AcDbVoidPtrArray &ar3d
		, const double &dL = 500
		, const double &dh = 50)
	{
		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);

		AcGePoint3d pt0(AcGePoint3d::kOrigin);
		AcGePoint3d pt1(pt0 - X * dR * .5);
		AcGePoint3d pt2(pt1 + Y * dh);
		AcGePoint3d pt3(pt2 - X * (dR * .5 - dh));
		AcGePoint3d pt4(pt3 + Y * dh);
		pt4 -= X * dh;
		AcGePoint3d pt5(pt4 + Y * (dL - 3 * dh));
		AcGePoint3d pt6(pt5 + Y * dh);
		pt6 += X * dh;
		AcGePoint3d pt7(pt6 + X * (dR - dh));

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbArc(pt4 + X * dh, Z, dh, PI, 1.5 * PI));
		ar.append(new AcDbLine(pt4, pt5));
		ar.append(new AcDbArc(pt5 + X * dh, Z, dh, .5 * PI, PI));
		ar.append(new AcDbLine(pt6, pt7));
		ar.append(new AcDbLine(pt7, pt0));

		AcDbRegion *pReg = CoreTools::createRegion(ar);
		if (pReg)
		{
			AcDb3dSolid *pSolid = drawRevolved(pReg, AcGePoint3d::kOrigin, Y);
			if (pSolid)
			{
				AcGeVector3d vt = vtDir.crossProduct(Y);
				if (vt == AcGeVector3d::kIdentity)
					vt = X;
				double a = Y.angleTo(vtDir, vt);
				AcGeMatrix3d mat;
				mat.setToRotation(a, vt);
				pSolid->transformBy(mat);
				mat.setToIdentity();
				mat.setToTranslation(ptO - AcGePoint3d::kOrigin);
				pSolid->transformBy(mat);
				ar3d.append(pSolid);
			}
			DELETE_PTR(pReg);
		}
		else
		{
			for (int i = 0; i < ar.length(); i++)
			{
				CoreTools::CloneAndAddToModelSpace((AcDbEntity*)ar[i]);
			}
		}

		deleteArrayVoidPtrs< AcDbEntity>(ar);
		
	}

	AcDb3dSolid* drawBox(const AcGePoint3d &pt, const AcGeVector3d &vtZ, const AcGeVector3d &vtX, const double &L, const double &W)
	{
		AcGePoint3d pt0, pt1, pt2, pt3;
		getRect(pt, vtX, L, W, pt0, pt1, pt2, pt3, vtZ);
		return makeSolid(vtZ, 4, pt0, pt1, pt2, pt3);
	}

	// 以 pt 为中心 L长 W宽 上面布栏杆
	void drawLanGan(const AcGePoint3d &pt, const AcGeVector3d &vtX, const double &L, const double &W, AcDbVoidPtrArray &ar3d)
	{
		AcDb3dSolid *pSolid(NULL);
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5;
		AcGeVector3d Z(AcGeVector3d::kZAxis);
		getRect(pt, vtX, L, W, pt0, pt1, pt2, pt3);
		pt4 = CoreTools::MidPt(pt0, pt1);
		pt5 = CoreTools::MidPt(pt2, pt3);

		double dH(1000), r(10);

		pSolid = drawCylinder(Z * dH, pt0, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dH, pt1, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dH, pt2, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dH, pt3, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dH, pt4, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dH, pt5, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(vtX * L, pt0 + Z * (dH - r), r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(vtX * L, pt0 + Z * (dH * .5 - r), r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(vtX * L, pt3 + Z * (dH - r), r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(vtX * L, pt3 + Z * (dH * .5 - r), r);
		if (pSolid) ar3d.append(pSolid);
	}

	// 画泵 沿 vtZ画 dH 泵高 dR 半径
	void drawPump(const AcGePoint3d &pt, const AcGeVector3d &vtZ, AcDbVoidPtrArray &ar3d, const double &dH = 500/*, const double &dR = 125*/)
	{
		AcDb3dSolid *pSolid(NULL);
		AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);

		double dR = dH * .25;
		double dr(dR * .5);
		AcGePoint3d pt0(AcGePoint3d::kOrigin);
		AcGePoint3d pt1(pt0 - X * dR);
		AcGePoint3d pt2(pt1 + Y * dH / 8);
		AcGePoint3d pt3(pt2 + Y * 2 * dr);
		AcGePoint3d pt4(pt3 + Y * (dH - dR - (2 * dr) - (dH / 8)));
		AcGePoint3d pt5(pt4 + X * dR);
		pt5 += Y * dR;

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbArc(pt2 + Y * dr, Z, dR * .5, PI * .5, 1.5 * PI));
		ar.append(new AcDbLine(pt3, pt4));
		ar.append(new AcDbArc(pt5 - Y * dR, Z, dR, PI * .5, PI));
		ar.append(new AcDbLine(pt5, pt0));

		AcDbRegion *pReg = CoreTools::createRegion(ar);
		if (pReg)
		{
			AcDb3dSolid *pSolid = drawRevolved(pReg, AcGePoint3d::kOrigin, Y);
			if (pSolid)
			{
				AcGeVector3d vt = vtZ.crossProduct(Y);
				double a = Y.angleTo(vtZ, vt);
				AcGeMatrix3d mat;
				mat.setToRotation(a, vt);
				pSolid->transformBy(mat);
				mat.setToIdentity();
				mat.setToTranslation(pt - AcGePoint3d::kOrigin);
				pSolid->transformBy(mat);
				ar3d.append(pSolid);
			}
			DELETE_PTR(pReg);
		}
		else
		{
			for (int i = 0; i < ar.length(); i++)
			{
				CoreTools::CloneAndAddToModelSpace((AcDbEntity*)ar[i]);
			}
		}
	}

	AcDb3dSolid* drawTorus(const AcGePoint3d &pt, const AcGeVector3d &vtZ, const double &R, const double &r)
	{
		AcDb3dSolid *pSolid(NULL);
		AcGeVector3d vtN(vtZ);
		vtN.normalize();

		AcDbCircle *pPath = new AcDbCircle(pt, vtN, (R + r) * .5);

		AcGePoint3d ptFirst;
		pPath->getPointAtDist(0, ptFirst);
		AcGeVector3d tangent;
		pPath->getFirstDeriv(ptFirst, tangent);

		AcDbCircle *pSection = new AcDbCircle(ptFirst, tangent, (R - r) * .5);
		AcDbRegion *pReg = CoreTools::createRegion(pSection);
		if (pReg)
		{
			pSolid = new AcDb3dSolid();
			if (pSolid->extrudeAlongPath(pReg, pPath) != Acad::eOk)
				DELETE_PTR(pSolid);
			DELETE_PTR(pReg);
		}

		DELETE_PTR(pPath);
		DELETE_PTR(pSection);

		return pSolid;
	}

	AcDb3dSolid* cloneAndTransform(AcDb3dSolid *pSolid, const AcGeMatrix3d &mat)
	{
		AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
		p->transformBy(mat);
		return p;
	}
}
#pragma endregion

namespace GESHAN
{
#pragma region XHG
	IMP_XDATA_KEY(XHG,H1);
	IMP_XDATA_KEY(XHG,H2);
	IMP_XDATA_KEY(XHG,H3);
	IMP_XDATA_KEY(XHG,H4);

	IMP_XDATA_KEY(XHG,w);
	IMP_XDATA_KEY(XHG,a);

	IMP_XDATA_KEY(XHG,L1);
	IMP_XDATA_KEY(XHG,L2);

	IMP_XDATA_KEY(XHG,B);
	IMP_XDATA_KEY(XHG,B1);
	IMP_XDATA_KEY(XHG,B2);
	IMP_XDATA_KEY(XHG,B3);
	IMP_XDATA_KEY(XHG,B6);
	IMP_XDATA_KEY(XHG,b);

	IMP_XDATA_KEY(XHG,Pos);
	IMP_XDATA_KEY(XHG,Dir);

	void XHG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;
		double L1(GetL1())
			, L2(GetL2())
			, H1(GetH1())
			, H2(GetH2())
			, H3(GetH3())
			, H4(GetH4())
			, B(GetB())
			, B1(GetB1())
			, B2(GetB2())
			, B3(GetB3())
			, B6(GetB6())
			, a(Geta())
			, w(Getw())
			, b(Getb());
		double t((B - B1) * .5);

		AcGePoint3d ptPos(GetPos());
		AcGeVector3d Xdir(-1 * GetDir()), X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis), vt;
		AcGeVector3d Ydir(Xdir);
		Ydir.rotateBy(PI * .5, Z);
		AcGeMatrix3d mat2Pos;
		mat2Pos.setToAlignCoordSys( AcGePoint3d::kOrigin
			, X
			, Y
			, Z
			, ptPos
			, Xdir
			, Ydir
			, Z);

		AcGePoint3d ptO(AcGePoint3d::kOrigin);
		ptO -= Y * B * .5;

		AcGePoint3d pt0 = ptO;
		pt0 -= X * L2;
		pt0 -= Z * H1;

		AcGePoint3d pt1 = pt0;
		pt1 += X * w / sin(a);

		vt = ptO - pt1;
		vt.normalize();
		vt *= (H1 / sin(a) + H2 / sin(a));
		AcGePoint3d pt2 = pt1 + vt;

		AcGePoint3d pt3 = pt2;
		pt3 += X * (L1 - L2 - H2 / tan(a));

		AcGePoint3d pt4 = pt3 + Z * H3;

		vt.normalize();
		vt *= (H1 + H2 + H3) / sin(a);

		AcGePoint3d pt5 = pt0 + vt;

		AcGePoint3d _pt0(pt0 + Y * B)
			, _pt1(pt1 + Y * B)
			, _pt2(pt2 + Y * B)
			, _pt3(pt3 + Y * B)
			, _pt4(pt4 + Y * B)
			, _pt5(pt5 + Y * B);
		AcDb3dSolid *pSolid(NULL);

		// 主体
		{
			pSolid =makeSolid(Y * t, 6, pt0, pt1, pt2, pt3, pt4, pt5);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}

			pSolid = makeSolid(-Y * t, 6, _pt0, _pt1, _pt2, _pt3, _pt4, _pt5);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}

			pSolid = makeSolid(-Z * t, 4, pt4, pt5, _pt5, _pt4);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}

			pSolid = makeSolid(-X * t, 4, pt3, pt4, _pt4, _pt3);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}

			pSolid = makeSolid(Z * t, 4, pt0, pt1, _pt1, _pt0);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
		}

		// 电机传动带
		AcGePoint3d ptDjCen(AcGePoint3d::kOrigin);
		double dDjR(.0);
		{
			double R(H3 * .25), r(H3 * .25 * .5);
			dDjR = r * .25;
			double len = (H3 + H4 - R - r) / cos(PI / 6);
			AcGePoint3d ptC(AcGePoint3d::kOrigin);
			vt = X;
			vt.rotateBy(4 * PI / 6, Z);
			AcGePoint3d ptc(ptC + vt * len);
			vt.rotateBy(PI * .5, Z);
			AcGePoint3d pt6 = ptC + vt * R;
			AcGePoint3d pt7 = ptc + vt * r;
			AcGePoint3d pt8 = ptc - vt * r;
			AcGePoint3d pt9 = ptC - vt * R;

			AcDbPolyline *pPoly = new AcDbPolyline();
			pPoly->addVertexAt(0, pt6.convert2d(AcGePlane::kXYPlane));
			pPoly->addVertexAt(1, pt7.convert2d(AcGePlane::kXYPlane), -1);
			pPoly->addVertexAt(2, pt8.convert2d(AcGePlane::kXYPlane));
			pPoly->addVertexAt(3, pt9.convert2d(AcGePlane::kXYPlane), -1);
			pPoly->setClosed(true);
			AcDbRegion *pReg = CoreTools::createRegion(pPoly);
			DELETE_PTR(pPoly);
			if (pReg)
			{
				AcGeMatrix3d xz;
				xz.setToAlignCoordSys(AcGePoint3d::kOrigin, X, Y, Z, AcGePoint3d::kOrigin, X, Z, Y);
				pReg->transformBy(xz);
				ptC.transformBy(xz);
				ptc.transformBy(xz);
				AcGePoint3d _ptC(CoreTools::MidPt(pt2, pt3));
				_ptC.z += R;
				vt = _ptC - ptC;
				xz.setToIdentity();
				xz.setToTranslation(vt);
				pReg->transformBy(xz);
				ptc.transformBy(xz);
				ptDjCen = ptc;

				pSolid = makeSolid(pReg, -Y * B3);
				DELETE_PTR(pReg);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
			}
		}

		// 电机
		{
			AcDbCircle *pCir = new AcDbCircle(ptDjCen, Y, dDjR);
			AcDbRegion *pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			pSolid = makeSolid(pReg, Y * t);
			DELETE_PTR(pReg);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}

			pCir = new AcDbCircle(ptDjCen + Y * t, Y, dDjR * 4.);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			pSolid = makeSolid(pReg, Y * B * .5);
			DELETE_PTR(pReg);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
		}

		// 格栅
		{
			// B1 宽 H1高
			//AcGePoint3d pt10(CoreTools::MidPt(pt0, pt1) + Y * t);
			AcGePoint3d pt10(pt0 + Y * t);
			pt10 += X * t;
			AcGePoint3d pt11(pt10 + Y * B1);
			AcGePoint3d pt12(pt11 + X * ((H1+ H2) / sin(a)));
			AcGePoint3d pt13(pt12 - Y * B1);

			AcGeVector3d _X(X), _Z(X);
			_Z.rotateBy(PI * .5 + a, -Y);
			_X.rotateBy(a, -Y);
			AcGeMatrix3d m;
			m.setToAlignCoordSys(pt10, X, Y, Z, pt10, _X, Y, _Z);
			X = AcGeVector3d::kXAxis;

			// 面
			pSolid = makeSolid(Z * 1, 4, pt10, pt11, pt12, pt13);
			if (pSolid)
			{
				pSolid->transformBy(m);
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
			pt12.transformBy(m);
			pt13.transformBy(m);
			pSolid = makeSolid(Z * 1, 4, pt12, pt13, pt3 + Y * t, _pt3 - Y * t);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
			// 栅条
			AcGePoint3d pt14, pt15, pt16, pt17;
			int num = (int)(B1/(B6 + b));
			double y((B1 - (B6 + b) * num) * .5 + b * .5);
			for (int i = 0; i < num; ++i)
			{
				pt14 = pt10 + Y * y;
				pt15 = pt14 + X * ((H1 + H2) / sin(a));
				pt16 = pt15 + Y * B6;
				pt17 = pt14 + Y * B6;
				y += B6 + b;
				pSolid = makeSolid(Z * B6, 4, pt14, pt15, pt16, pt17);
				if (pSolid)
				{
					pSolid->transformBy(m);
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
			}
			// 横条
			int count(4);
			pt14 = pt10 + X * ((((H1 + H2)/sin(a)) / count) - B6 * .5);
			pt15 = pt14 + X * B6;
			pt16 = pt15 + Y * B1;
			pt17 = pt14 + Y * B1;
			for (int i = 0; i < count - 1; ++i)
			{
				pSolid = makeSolid(Z * 2 * B6, 4, pt14, pt15, pt16, pt17);
				if (pSolid)
				{
					pSolid->transformBy(m);
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}	
				pt14 = pt14 + X * (((H1 / sin(a)) / 3) - B6 * .5);
				pt15 = pt14 + X * B6;
				pt16 = pt15 + Y * B1;
				pt17 = pt14 + Y * B1;
			}
		}

		return;
	}

	void XHG::draw2d(AcDbVoidPtrArray &ar2d)
	{
		draw3d(ar2d);
	}
#pragma endregion

#pragma region SG
	IMP_XDATA_KEY(SG, H);
	IMP_XDATA_KEY(SG, H1);
	IMP_XDATA_KEY(SG, H2);
	IMP_XDATA_KEY(SG, H3);
	IMP_XDATA_KEY(SG, H4);

	IMP_XDATA_KEY(SG, a);

	IMP_XDATA_KEY(SG, L1);
	IMP_XDATA_KEY(SG, L);

	IMP_XDATA_KEY(SG, B);
	IMP_XDATA_KEY(SG, B1);
	IMP_XDATA_KEY(SG, B6);
	IMP_XDATA_KEY(SG, b);

	IMP_XDATA_KEY(SG, Dir);
	IMP_XDATA_KEY(SG, Pos);

	void SG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;
		AcDb3dSolid *pSolid(NULL);

		AcGeVector3d vt(AcGeVector3d::kIdentity)
			, X(AcGeVector3d::kXAxis)
			, Y(AcGeVector3d::kYAxis)
			, Z(AcGeVector3d::kZAxis);
		AcGeMatrix3d mat, mat2Pos;

		double L1(GetL1())
			, L(GetL())
			, H(GetH())
			, H1(GetH1())
			, H2(GetH2())
			, H3(GetH3())
			, H4(GetH4())
			, B(GetB())
			, B1(GetB1())
			, B6(GetB6())
			, a(Geta())
			, b(Getb());
		double t((B - B1) * .5);

		AcGePoint3d ptPos(GetPos());
		AcGeVector3d Xdir(-1 * GetDir());
		AcGeVector3d Ydir(Xdir);
		Ydir.rotateBy(PI * .5, Z);
		mat2Pos.setToAlignCoordSys( AcGePoint3d::kOrigin
			, X
			, Y
			, Z
			, ptPos
			, Xdir
			, Ydir
			, Z);

		// 电机上需要有顶棚
		double H5 = 500;
		double _H4 = H4 - H5;
		double L2 = 800;	// 除污推杆长

		AcGePoint3d ptO(AcGePoint3d::kOrigin), pt(AcGePoint3d::kOrigin), _pt(AcGePoint3d::kOrigin);

		AcGePoint3d pt0(ptO - Y * B * .5);
		AcGePoint3d pt1(pt0 + X * L1);
		AcGePoint3d pt2(pt1 + Z * _H4);
		AcGePoint3d pt3(pt2 - X * (L1 - (_H4 / tan(a))));

		double l1(L1 - t / tan(a * .5) - t), h4(_H4 - 2 * t);
		vt = X;
		vt.rotateBy(a * .5, -Y);
		AcGePoint3d pt4(pt0 + vt * (t / sin(a * .5)));
		AcGePoint3d pt5(pt4 + X * l1);
		AcGePoint3d pt6(pt5 + Z * h4);
		AcGePoint3d pt7(pt6 - X *(l1 - (h4 / tan(a))));

		// 池上部分
		{
			// 两侧框架
			{
				AcDbRegion *pReg1 = makeRegion2(4, pt0, pt1, pt2, pt3);
				AcDbRegion *pReg2 = makeRegion2(4, pt4, pt5, pt6, pt7);
				if (!pReg1 || !pReg2)
				{
					DELETE_PTR(pReg1);
					DELETE_PTR(pReg2);
					return;
				}

				if (pReg1->booleanOper(AcDb::kBoolSubtract, pReg2) == Acad::eOk)
					DELETE_PTR(pReg2);
				else
					return;

				pReg2 = (AcDbRegion*)pReg1->clone();
				mat.setToTranslation(Y * B);
				pReg2->transformBy(mat);

				pSolid = makeSolid(pReg1, Y * t);
				if (pSolid)
				{
					DELETE_PTR(pReg1);
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				pSolid = makeSolid(pReg2, -Y * t);
				if (pSolid)
				{
					DELETE_PTR(pReg2);
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
			}

			// 电机平台及顶棚
			{
				pSolid = makeSolid(Y * B
					, 4
					, pt7 - X * (t / sin(a))
					, pt3
					, pt2
					, pt6 + X * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
				vt = Z * H5;
				mat.setToTranslation(vt);
				pSolid = (AcDb3dSolid*)pSolid->clone();
				if (pSolid)
				{
					pSolid->transformBy(mat);
					//pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
			}

			// 电机平台四个柱子
			{
				pSolid = makeSolid(Z * (H5 - t)
					, 4
					, pt2
					, pt2 + Y * t
					, (pt2 + Y * t) - X * t
					, pt2 - X * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				vt = Ydir * (B - t);
				mat.setToTranslation(vt);
				pSolid = (AcDb3dSolid*)pSolid->clone();
				if (pSolid)
				{
					pSolid->transformBy(mat);
					ar3d.append(pSolid);
				}

				pSolid = makeSolid(Z * (H5 - t)
					, 4
					, pt7 + Z * t
					, (pt7 + Z * t) + Y * t
					, ((pt7 + Z * t) + Y * t) + X * t
					, (pt7 + Z * t) + X * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				vt = Ydir * (B - t);
				mat.setToTranslation(vt);
				pSolid = (AcDb3dSolid*)pSolid->clone();
				if (pSolid)
				{
					pSolid->transformBy(mat);
					ar3d.append(pSolid);
				}
			}

			// 横梁
			{
				vt = X;
				vt.rotateBy(a, -Y);
				pSolid = makeSolid(Y * t
					, 4
					, CoreTools::MidPt(pt6, pt5) - Z * t * .5
					, CoreTools::MidPt(pt6, pt5) + Z * t * .5
					, CoreTools::MidPt(pt4, pt7) + vt * (t * .5 / sin(a))
					, CoreTools::MidPt(pt4, pt7) - vt * (t * .5 / sin(a)));
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				vt = Ydir * (B - t);
				mat.setToTranslation(vt);
				pSolid = (AcDb3dSolid*)pSolid->clone();
				if (pSolid)
				{
					pSolid->transformBy(mat);
					//pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				pSolid = makeSolid(Y * B
					, 4
					, CoreTools::MidPt(pt6, pt5) - Z * t * .5
					, CoreTools::MidPt(pt6, pt5) + Z * t * .5
					, (CoreTools::MidPt(pt6, pt5) + Z * t * .5) + X * t
					, (CoreTools::MidPt(pt6, pt5) - Z * t * .5) + X * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				pSolid = makeSolid(Y * B
					, 4
					, pt5
					, pt5 - Z * t
					, pt1
					, pt1 + Z * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
			}

			// 除污推杆
			{
				pt = CoreTools::MidPt(pt0, pt3);
				pt = CoreTools::MidPt(pt, pt3);
				vt = X;
				vt.rotateBy(a, -Y);
				pSolid = makeSolid(-X * L2
					, 4
					, pt + vt * (t * .5 / sin(a))
					, (pt + vt * (t * .5 / sin(a))) + Y * t
					, ((pt + vt * (t * .5 / sin(a))) + Y * t) - Z * t
					, (pt + vt * (t * .5 / sin(a))) - Z * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
				vt = Ydir * (B - t);
				mat.setToTranslation(vt);
				pSolid = (AcDb3dSolid*)pSolid->clone();
				if (pSolid)
				{
					pSolid->transformBy(mat);
					//pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				pt -= X * L2;
				pSolid = makeSolid(Y * B
					, 4
					, pt + Z * t * .5
					, pt - Z * t * .5
					, (pt - Z * t * .5) + X * t
					, (pt + Z * t * .5) + X * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}

				vt = X;
				vt.rotateBy(a, -Y);
				pt = CoreTools::MidPt(pt0, pt3);
				_pt = CoreTools::MidPt(pt, pt3);
				double d = pt.distanceTo(_pt);
				_pt -= X * d;
				pSolid = makeSolid(_pt - pt
					, 4
					, pt + vt * .5 * t
					, pt - vt * .5 * t
					, (pt - vt * .5 * t) + Y * t
					, (pt + vt * .5 * t) + Y * t );
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
				vt = Ydir * (B - t);
				mat.setToTranslation(vt);
				pSolid = (AcDb3dSolid*)pSolid->clone();
				if (pSolid)
				{
					pSolid->transformBy(mat);
					//pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
			}
		}

		// 水下格栅
		{
			// 两根柱子
			{
				double l = H / tan(a);
				vt = X;
				vt.rotateBy(a, -Y);
				vt *= -1;
				pSolid = makeSolid(vt * l
					, 4
					, pt0
					, pt0 + X * (t / sin(a))
					, (pt0 + X * (t / sin(a))) + Y * t
					, pt0 + Y * t);
				if (pSolid)
				{
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
				vt = Ydir * (B - t);
				mat.setToTranslation(vt);
				if (pSolid)
				{
					pSolid = (AcDb3dSolid*)pSolid->clone();
					if (pSolid)
					{
						pSolid->transformBy(mat);
						//pSolid->transformBy(mat2Pos);
						ar3d.append(pSolid);
					}
				}
			}
			// 格栅
			{
				double l = H / tan(a);
				vt = X;
				vt.rotateBy(a, -Y);
				vt *= -1;
				// B1 宽 H1高
				AcGePoint3d pt10((pt0 + vt * l) + Y * t);
				pt10 += X * t;
				AcGePoint3d pt11(pt10 + Y * B1);
				AcGePoint3d pt12(pt11 + X * l);
				AcGePoint3d pt13(pt12 - Y * B1);

				AcGeVector3d _X(X), _Z(X);
				_Z.rotateBy(PI * .5 + a, -Y);
				_X.rotateBy(a, -Y);
				AcGeMatrix3d m;
				m.setToAlignCoordSys(pt10, X, Y, Z, pt10, _X, Y, _Z);
				X = AcGeVector3d::kXAxis;

				// 面
				pSolid = makeSolid(Z * 1, 4, pt10, pt11, pt12, pt13);
				if (pSolid)
				{
					pSolid->transformBy(m);
					pSolid->transformBy(mat2Pos);
					ar3d.append(pSolid);
				}
				// 栅条
				AcGePoint3d pt14, pt15, pt16, pt17;
				int num = (int)(B1/(B6 + b));
				double y((B1 - (B6 + b) * num) * .5 + b * .5);
				for (int i = 0; i < num; ++i)
				{
					pt14 = pt10 + Y * y;
					pt15 = pt14 + X * (H1 / sin(a));
					pt16 = pt15 + Y * B6;
					pt17 = pt14 + Y * B6;
					y += B6 + b;
					pSolid = makeSolid(Z * B6, 4, pt14, pt15, pt16, pt17);
					if (pSolid)
					{
						pSolid->transformBy(m);
						pSolid->transformBy(mat2Pos);
						ar3d.append(pSolid);
					}
				}
				// 横条
				int count(4);
				pt14 = pt10 + X * (((H1/sin(a)) / count) - B6 * .5);
				pt15 = pt14 + X * B6;
				pt16 = pt15 + Y * B1;
				pt17 = pt14 + Y * B1;
				for (int i = 0; i < count - 1; ++i)
				{
					pSolid = makeSolid(Z * 2 * B6, 4, pt14, pt15, pt16, pt17);
					if (pSolid)
					{
						pSolid->transformBy(m);
						pSolid->transformBy(mat2Pos);
						ar3d.append(pSolid);
					}	
					pt14 = pt14 + X * (((H1 / sin(a)) / 3) - B6 * .5);
					pt15 = pt14 + X * B6;
					pt16 = pt15 + Y * B1;
					pt17 = pt14 + Y * B1;
				}	
			}
		}
	}

	void SG::draw2d(AcDbVoidPtrArray &ar2d)
	{
		draw3d(ar2d);
	}
#pragma endregion

#pragma region ZG
	IMP_XDATA_KEY(ZG,H1);
	IMP_XDATA_KEY(ZG,H2);
	IMP_XDATA_KEY(ZG,H3);

	IMP_XDATA_KEY(ZG,a);
	IMP_XDATA_KEY(ZG,A);
	IMP_XDATA_KEY(ZG,B);

	IMP_XDATA_KEY(ZG,D);
	IMP_XDATA_KEY(ZG,d);
	IMP_XDATA_KEY(ZG,L);
	IMP_XDATA_KEY(ZG,l);

	IMP_XDATA_KEY(ZG,Pos);
	IMP_XDATA_KEY(ZG,Dir);

	void ZG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;
		AcDb3dSolid *pSolid(NULL);
		AcDbCircle *pCir(NULL);
		AcDbRegion *pReg(NULL);

		AcGeVector3d vt(AcGeVector3d::kIdentity)
			, X(AcGeVector3d::kXAxis)
			, Y(AcGeVector3d::kYAxis)
			, Z(AcGeVector3d::kZAxis);
		AcGeMatrix3d mat, mat2Pos;

		double L(GetL())
			, l(Getl())
			, H1(GetH1())
			, H2(GetH2())
			, H3(GetH3())
			, B(GetB())
			, A(GetA())
			, a(Geta())
			, D(GetD())
			, d(Getd());

		AcGePoint3d ptPos(GetPos());
		AcGeVector3d Xdir(-1 * GetDir());
		AcGeVector3d Ydir(Xdir);
		Ydir.rotateBy(PI * .5, Z);
		mat2Pos.setToAlignCoordSys( AcGePoint3d::kOrigin
			, X
			, Y
			, Z
			, ptPos
			, Xdir
			, Ydir
			, Z);

		// 20 为
		double L1(L - l), L2(H2 / tan(a));
		vt = X;
		vt.rotateBy(a + PI * .5, -Y);
		AcGePoint3d ptO(AcGePoint3d::kOrigin);

		AcGePoint3d pt0(ptO + vt * d * .5);

		// 传动轴
		{
			vt = X;
			vt.rotateBy(a, -Y);
			vt *= L1;

			pCir = new AcDbCircle(pt0, vt, d * .5);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (!pReg) return;

			pSolid = makeSolid(pReg, vt);
			if (pSolid)
			{
				DELETE_PTR(pReg);
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
		}

		// 细轴
		{
			//vt.normalize();
			//vt *= -(L - L1);
			//pCir = new AcDbCircle(pt0, vt, d * .25);
			//pReg = CoreTools::createRegion(pCir);
			//DELETE_PTR(pCir);
			//if (!pReg) return Acad::eInvalidInput;

			//pSolid = GeShTools::makeSolid(pReg, vt);
			//if (pSolid)
			//{
			//	pSolid->transformBy(mat2Pos);
			//	dc.DrawEntity(*pSolid);
			//	Add3DBuffer(pSolid);
			//}
		};

		// 栅网
		{
			//vt.normalize();
			//vt *= delta;
			//pt0 += vt;
			vt.normalize();
			vt *= -l;

			pCir = new AcDbCircle(pt0, vt, D * .5);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (!pReg) return;
			pSolid = makeSolid(pReg, vt);
			if (pSolid)
			{
				DELETE_PTR(pReg);
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
		}

		// 出料口
		{
			vt.normalize();
			AcGeVector3d _vt(-vt);
			AcGePoint3d pt1(pt0 - vt * (H2 / sin(a)));
			pt1 -= Y * d * .5;
			pSolid = makeSolid(Y * d
				, 4
				, pt1
				, pt1 + _vt * 1.5 * d
				, (pt1 + _vt * 1.5 * d) + X * (d * .5 / sin(a))
				, pt1 + X * (1.5 * d * cos(a) + (d * .5 / sin(a))));
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
		}

		// 柱子
		{
			vt.normalize();
			AcGeVector3d _vt(-vt);
			_vt.rotateBy(PI * .5, -Y);
			pCir = new AcDbCircle(((pt0 - _vt * d * .5 ) + X * (L2 * .5)), Z, d * .25);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			pSolid = makeSolid(pReg, Z * (L2 * .5 * tan(a) + d * .5));
			if (pSolid)
			{
				DELETE_PTR(pReg);
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
			AcGePoint3d pt1(pt0);
			pt1 -= vt * ((H2 * .5 / tan(a) - d * .25) / cos(a));
			pt1 -= Y * d * .5;
			pt1 -= _vt * d * .5;
			AcGePoint3d pt2(pt1 + Y * d);
			AcGePoint3d pt3(pt2 + _vt * d);
			AcGePoint3d pt4(pt3 - Y * d);
			pSolid = makeSolid(-vt * (d * .5 / cos(a)), 4, pt1, pt2, pt3, pt4);
			if (pSolid)
			{
				pSolid->transformBy(mat2Pos);
				ar3d.append(pSolid);
			}
		}
	}

	void ZG::draw2d(AcDbVoidPtrArray &ar2d)
	{
		draw3d(ar2d);
	}
#pragma endregion
}

namespace BAOQIQI
{
	IMP_XDATA_KEY(BaoQiQi,_L1);
	IMP_XDATA_KEY(BaoQiQi,_L4);
	IMP_XDATA_KEY(BaoQiQi,_H3);
	IMP_XDATA_KEY(BaoQiQi,_h);
	IMP_XDATA_KEY(BaoQiQi,_r);
	IMP_XDATA_KEY(BaoQiQi,_Type);
	IMP_XDATA_KEY(BaoQiQi,Pos);
	IMP_XDATA_KEY(BaoQiQi,Dir);

	void BaoQiQi::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;
		AcDb3dSolid *pSolid(NULL);
		AcDbCircle *pCir(NULL);
		AcDbRegion *pReg(NULL);

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

		AcGePoint3d ptPos(GetPos());

		int iType(Get_Type());

		if (iType == 0)	// 盘式
		{
			double L1(Get_L1()), L4(Get_L4()), h(Get_h()), r(Get_r());

			pCir = new AcDbCircle(ptPos, Z, r);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (!pReg) return;
			pSolid = makeSolid(pReg, Z * h);
			if (pSolid)
			{
				DELETE_PTR(pReg);
				ar3d.append(pSolid);
			}

			pCir = new AcDbCircle(ptPos + Z * h, Z, L1 * .5);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (!pReg) return;
			pSolid = makeSolid(pReg, Z * L4);
			if (pSolid)
			{
				DELETE_PTR(pReg);
				ar3d.append(pSolid);
			}
		}
		else if (iType == 1) // 管式
		{
			double L1(Get_L1()), H3(Get_H3());
			AcGeVector3d vtDir(GetDir());
			pCir = new AcDbCircle(ptPos, vtDir, H3 * .5);
			pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (!pReg) return;
			pSolid = makeSolid(pReg, vtDir * L1);
			if (pSolid)
			{
				DELETE_PTR(pReg);
				ar3d.append(pSolid);
			}
		}
		else
			return;
	}

	void BaoQiQi::draw2d(AcDbVoidPtrArray &ar2d)
	{
		draw3d(ar2d);
	}
}

namespace SHASHUIFENLI
{
#pragma region XCS
	void XCS::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		BOOL hasBr(false);
		double fai, fai1, h, h1, W;
		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(fai);
		GETXDATA(fai1);
		GETXDATA(h);
		GETXDATA(h1);
		GETXDATA(W);
		GETXDATA(Pos);
		GETXDATA(Dir);
		GETXDATA(hasBr);

		TESTXDATA(XCS);

		AcDb3dSolid *pSolid(NULL);

		AcGeVector3d Z(AcGeVector3d::kZAxis), X(Dir);
		AcGeVector3d Y = Z.crossProduct(X);

		W = fai * .25;

		double dWh(.0);
		if (hasBr)
		{
			dWh = 50;	// 顶板厚10cm
			// 画顶板
			pSolid = drawBox(Pos, Z * dWh, Dir, fai, W);
			if (pSolid) ar3d.append(pSolid);

			// 栏杆
			drawLanGan(Pos, X, fai, W, ar3d);
		}

		// 电机
		drawDianJi(Pos + Z * dWh, Z, 200, ar3d);

		// 传动轴
		pSolid = drawCylinder(Z * -1 * h, Pos, 50);
		if (pSolid) ar3d.append(pSolid);

		// 桨叶
		double l(fai1 * .8);
		AcGePoint3d pt0(Pos - Z * h);
		AcGePoint3d pt1(pt0 - X * 2 * l / 3);
		AcGePoint3d pt3(pt0 + Z * h / 4);
		AcGePoint3d pt2(pt3 - X * l);

		AcDbRegion *pReg = makeRegion2(4, pt0, pt1, pt2, pt3);
		if (pReg) ar3d.append(pReg);

		AcGeMatrix3d mat;
		mat.setToRotation(PI * .5, Z, Pos);

		pReg = (AcDbRegion*)pReg->clone();
		pReg->transformBy(mat);
		if (pReg) ar3d.append(pReg);

		pReg = (AcDbRegion*)pReg->clone();
		pReg->transformBy(mat);
		if (pReg) ar3d.append(pReg);

		pReg = (AcDbRegion*)pReg->clone();
		pReg->transformBy(mat);
		if (pReg) ar3d.append(pReg);

		// 外壁
		/*
		AcGePoint3d pt0(Pos);
		AcGePoint3d pt1(pt0 - Dir * fai * .5);
		AcGePoint3d pt2(pt1 - Z * 2 * (h / 3));
		AcGePoint3d pt3(pt2 - Z * (h / 3));
		pt3 += X * (fai - fai1) * .5;
		AcGePoint3d pt4(pt3 - Z * 2 * (h1 / 3));
		AcGePoint3d pt5(pt4 - Z * (h1 / 3));
		pt5 += X * fai1 * .25;
		AcGePoint3d pt6(Pos - Z * (h + h1));
		
		AcDbRegion *pReg = makeRegion2(7, pt0, pt1, pt2, pt3, pt4, pt5, pt6);
		if (pReg)
		{
			pSolid = drawRevolved(pReg, Pos, Z);
			if (pSolid)
			{
				double dt(10);
				double dFai(fai - dt), dFai1(fai1 - dt);
				pt0 = Pos;
				pt1 = (pt0 - Dir * (dFai * .5));
				pt2 = (pt1 - Z * 2 * (h / 3));
				pt3 = (pt2 - Z * (h / 3));
				pt3 += X * (dFai - dFai1) * .5;
				pt4 = (pt3 - Z * 2 * (h1 / 3));
				pt5 = (pt4 - Z * (h1 / 3 -10));
				pt5 += X * dFai1 * .25;
				pt6 = (Pos - Z * (h + h1 - 10));
				AcDbRegion *pReg1 = makeRegion2(7, pt0, pt1, pt2, pt3, pt4, pt5, pt6);
				if (pReg1)
				{
					AcDb3dSolid *pSolid1 = drawRevolved(pReg1, Pos, Z);
					if (pSolid1)
					{
						if (pSolid->booleanOper(AcDb::kBoolSubtract, pSolid1) != Acad::eOk)
							DELETE_PTR(pSolid1);
						ar3d.append(pSolid);
					}

					DELETE_PTR(pReg1);
				}
			}
			DELETE_PTR(pReg);
		}*/
	}
	void XCS::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
#pragma endregion

#pragma region HXS
	void HXS::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double H, L, L1, L2, W;
		int Single;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(L);
		GETXDATA(L1);
		GETXDATA(L2);
		GETXDATA(Single);
		GETXDATA(W);
		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(HXS);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		AcDb3dSolid *pSolid(NULL);

		// 向上提，下面是轨道轮子,半径 W/8
		Pos += Z * W / 4;

		// 顶板
		double dWh(100);
		pSolid = drawBox(Pos, Z * dWh, X, L, W);
		if (pSolid) ar3d.append(pSolid);

		// 轮子
		{
			double dr(W / 16);
			AcGePoint3d pt0, pt1, pt2, pt3;
			getRect(Pos, X, L, W, pt0, pt1, pt2, pt3);

			pt0 += Y * dr; pt0 -= Z * dr;
			pt3 -= Y * dr; pt3 -= Z * dr;
			pt1 += Y * dr; pt1 -= Z * dr;
			pt2 -= Y * dr; pt2 -= Z * dr;

			pSolid = drawCylinder(-X * 100, pt0, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt1, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt2, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-X * 100, pt3, dr);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt0.distanceTo(pt1), pt0, dr * .25);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt3.distanceTo(pt2), pt3, dr * .25);
			if (pSolid) ar3d.append(pSolid);
		}

		// 栏杆
		drawLanGan(Pos, X, L, W, ar3d);

		// 吸管
		{
			double dr(100), dPumpH(500);
			double len((W / 4) + H), distPump((W / 4) + dPumpH);
			AcGePoint3d pt1(Pos + X * ((L *.5) - L1));
			AcGePoint3d pt2(pt1 - X * L2);

			AcGePoint3d pt11(pt1 - Z * distPump);
			AcGePoint3d pt22(pt2 - Z * distPump);

			pSolid = drawCylinder(-Z * len, pt1, dr);
			if (pSolid) ar3d.append(pSolid);
			drawPump(pt11, Z, ar3d, dPumpH);

			if (!Single)
			{
				pSolid = drawCylinder(-Z * len, pt2, dr);
				if (pSolid) ar3d.append(pSolid);
				drawPump(pt22, Z, ar3d, dPumpH);
			}
		}

		//drawPump(Pos, Z, ar3d);
	}
	void HXS::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
#pragma endregion

#pragma region LCS
	void LCS::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double H, L, W, L1, L2, L3, H1, H2, H3, a;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(L);
		GETXDATA(W);
		GETXDATA(L1);
		GETXDATA(L2);
		GETXDATA(L3);
		GETXDATA(H1);
		GETXDATA(H2);
		GETXDATA(H3);
		GETXDATA(a);
		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(LCS);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		AcDb3dSolid *pSolid(NULL);

		double dr(H3 * .5);
		double B1(H / tan(a));
		double B2(L - B1);

		// 画第一个轴
		AcGePoint3d pt1, pt2, pt3;
		AcGePoint3d pt(Pos + Z * H2);
		pt += Y * W * .5;
		pSolid = drawCylinder(-Y * W, pt, dr);
		if (pSolid) ar3d.append(pSolid);
		pt1 = pt;

		// 第二个轴
		pt = Pos;
		pt -= Z * H;
		pt += X * B1;
		pt += Z * H3;
		pt += Y * W * .5;
		pSolid = drawCylinder(-Y * W, pt, dr);
		if (pSolid) ar3d.append(pSolid);
		pt2 = pt;

		// 第三个轴
		pt += X * (B2 - L3);
		pSolid = drawCylinder(-Y * W, pt, dr);
		if (pSolid) ar3d.append(pSolid);
		pt3 = pt;

		// 卸料管
		pt = Pos;
		pt += Z * H2 * .5;
		pSolid = drawCylinder(-Z * (H1 + H2 * .5), pt, L2 * .25);
		if (pSolid) ar3d.append(pSolid);

		// 传送带
		AcGeVector3d vtX(pt2 - pt1);
		AcGeVector3d vtZ(vtX);
		vtZ.rotateBy(-PI * .5, Y);
		vtZ.normalize();
		vtZ *= 1;
		pSolid = drawBox(CoreTools::MidPt(pt1, pt2) - Y * W * .5, vtZ, vtX, pt2.distanceTo(pt1), W);
		if (pSolid)
		{
			vtZ.normalize();
			AcGeMatrix3d mat;
			mat.setToTranslation(vtZ * dr);
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			mat.setToIdentity();
			mat.setToTranslation(-vtZ * 2 * dr);
			pSolid->transformBy(mat);
			ar3d.append(pSolid);
		}

		pSolid = drawBox(CoreTools::MidPt(pt2, pt3) - Y * W * .5, Z, X, pt2.distanceTo(pt3), W);
		if (pSolid)
		{
			AcGeMatrix3d mat;
			mat.setToTranslation(Z * dr);
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			mat.setToIdentity();
			mat.setToTranslation(-Z * 2 * dr);
			pSolid->transformBy(mat);
			ar3d.append(pSolid);
		}

		// 罩子
		{
			double r = L2 * .5, dW(W * 1.5);
			double dH2(H2 + r * 1.5);
			AcGePoint3d pt0(Pos);
			pt0 -= X * r;
			AcGePoint3d pt1 = pt0 + X * 2 * r;
			AcGePoint3d pt2 = pt1 + Z * dH2;
			AcGePoint3d pt3 = pt2 - X * r;
			AcGePoint3d pt4 = pt0 + Z * (dH2 - r);
			AcDbVoidPtrArray ar;
			ar.append(new AcDbLine(pt0, pt1));
			ar.append(new AcDbLine(pt1, pt2));
			ar.append(new AcDbLine(pt2, pt3));
			ar.append(new AcDbLine(pt0, pt4));
			ar.append(new AcDbArc(Pos + Z * (dH2 - r), -Y, r, PI * .5, PI));

			AcDbRegion *pReg = CoreTools::createRegion(ar);
			deleteArrayVoidPtrs< AcDbEntity>(ar);
			if (pReg)
			{
				AcGeMatrix3d mat;
				mat.setToTranslation(-Y * dW * .5);
				pReg->transformBy(mat);
				pSolid = drawExtruded(pReg, Y * dW);
				if (pSolid)
				{
					ar.removeAll();
					r -= 2; dW -= 2; dH2 -= 2;
					pt0 = Pos;
					pt0 -= X * r;
					pt1 = pt0 + X * (r + r + 2);
					pt2 = pt1 + Z * dH2;
					pt3 = pt2 - X * (r + 2);
					pt4 = pt0 + Z * (dH2 - r);
					ar.append(new AcDbLine(pt0, pt1));
					ar.append(new AcDbLine(pt1, pt2));
					ar.append(new AcDbLine(pt2, pt3));
					ar.append(new AcDbLine(pt0, pt4));
					ar.append(new AcDbArc(Pos + Z * (dH2 - r), -Y, r, PI * .5, PI));
					AcDbRegion *pReg1 = CoreTools::createRegion(ar);
					deleteArrayVoidPtrs< AcDbEntity>(ar);
					if (pReg1)
					{
						mat.setToIdentity();
						mat.setToTranslation(-Y * dW * .5);
						pReg1->transformBy(mat);
						AcDb3dSolid *pSolid1 = drawExtruded(pReg1, Y * dW);
						if (pSolid1)
						{
							if (!pSolid->booleanOper(AcDb::kBoolSubtract, pSolid1) == Acad::eOk)
								DELETE_PTR(pSolid1);
							ar3d.append(pSolid);
						}
						DELETE_PTR(pReg1);
					}
				}
				DELETE_PTR(pReg);
			}

		}

	}
	void LCS::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion
}

namespace LUOXUANBENG
{
#pragma region LXB
	void LXB::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, d, seta, L1, L2, L3, P;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(d);
		GETXDATA(P);
		GETXDATA(L1);
		GETXDATA(L2);
		GETXDATA(L3);
		GETXDATA(seta);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(LXB);

		AcGeVector3d X(Dir), Y(AcGeVector3d::kYAxis);
		X.rotateBy(seta, Y);
		AcGeVector3d Z(X);
		Z.rotateBy(PI * .5, -Y);

		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		Pos += Z * D * .5;

		// 传动轴
		pSolid = drawCylinder(X * (200 + L1 + L2 + L3), Pos - X * 200, d * .25);
		if (pSolid) ar3d.append(pSolid);
		// 电机
		drawDianJi(Pos - X * 200, -X, 150, ar3d);

		// 套轴
		pSolid = drawCylinder(X * (L1 + L2 + L3 * .5), Pos + X * L3 * .5, d * .5);
		if (pSolid) ar3d.append(pSolid);
		
		// 支架
		pSolid = drawCylinder(-AcGeVector3d::kZAxis * (D * .5 / cos(seta)), Pos, d * .25);
		if (pSolid) ar3d.append(pSolid);

		// 螺纹
		int count = 10;
		int delta = (int)(L2 / count);
		double a(CoreTools::A2R(30));
		double r(D * .5 / cos(a));
		AcGeVector3d vtN(Z);
		vtN.rotateBy((PI * .5 - a), Y);
		AcGePoint3d pt(Pos + X * L3);
		AcDbCircle *pCir = new AcDbCircle(pt, vtN, r);
		AcDbRegion *pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);
		if (pReg)
		{
			pSolid = drawExtruded(pReg, X * 1);
			if (pSolid)
			{
				ar3d.append(pSolid);
				AcGeMatrix3d mat;
				mat.setToTranslation(X * delta);
				for (int i = 1; i < count; ++i)
				{
					pSolid = (AcDb3dSolid*)pSolid->clone();
					pSolid->transformBy(mat);
					ar3d.append(pSolid);
				}
			}
			DELETE_PTR(pReg);
		}

	}
	void LXB::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion
}

namespace ZHAMEN
{

#pragma region RectZhaMen
	void RectZhaMen::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double A, H, T;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(A);
		GETXDATA(T);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(RectZhaMen);

		AcDb3dSolid *pSolid(NULL);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		
		pSolid = drawBox(Pos, Z * A, X, A - 2 * T, T);
		if (pSolid) ar3d.append(pSolid);

		AcGePoint3d pt1(Pos + X * .5 * (A - T)), pt2(Pos - X * .5 * (A - T));
		pSolid = drawBox(pt1, Z * H, X, T, T);
		if (pSolid) ar3d.append(pSolid);
		pSolid = drawBox(pt2, Z * H, X, T, T);
		if (pSolid) ar3d.append(pSolid);
	}
	void RectZhaMen::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region CircleZhaMen
	void CircleZhaMen::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double A, H, I, C, T;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(A);
		GETXDATA(I);
		GETXDATA(C);
		GETXDATA(T);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(RectZhaMen);

		AcDb3dSolid *pSolid(NULL);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);

		double R(H - C - I);
		double r(R / 3);

		AcGePoint3d pt0(AcGePoint3d::kOrigin - AcGeVector3d::kXAxis * A * .5);
		pt0 += AcGeVector3d::kYAxis * r;
		AcGePoint3d pt1(pt0 + AcGeVector3d::kYAxis * (C + (R - r)));
		AcGePoint3d pt2(pt1 + AcGeVector3d::kYAxis * I);
		pt2 += AcGeVector3d::kXAxis * I;

		AcGeMatrix3d mat;
		mat.setToMirroring(AcGeLine3d(AcGePoint3d::kOrigin, AcGePoint3d::kOrigin + AcGeVector3d::kYAxis * H));

		AcGePoint3d pt3(pt2);
		pt3.transformBy(mat);

		AcGePoint3d pt4(pt1);
		pt4.transformBy(mat);

		AcGePoint3d pt5(pt0);
		pt5.transformBy(mat);

		AcGePoint3d pt6(AcGePoint3d::kOrigin);

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbArc(pt1 + AcGeVector3d::kYAxis * I, AcGeVector3d::kZAxis, I, PI * 1.5, 0));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbArc(pt4 + AcGeVector3d::kYAxis * I, AcGeVector3d::kZAxis, I, PI, 1.5 * PI));
		ar.append(new AcDbLine(pt4, pt5));
		double alpha(asin((R - r) / R));
		AcDbArc *arc = new AcDbArc(AcGePoint3d::kOrigin + AcGeVector3d::kYAxis * R, AcGeVector3d::kZAxis, R, PI + alpha, - alpha);
		ar.append(arc);
		AcGePoint3d pts, pte;
		arc->getStartPoint(pts);
		arc->getEndPoint(pte);
		ar.append(new AcDbLine(pt0, pts));
		ar.append(new AcDbLine(pt5, pte));

		AcDbRegion *pReg = CoreTools::createRegion(ar);
		if (!pReg)
		{
#ifndef NDEBUG
			for (int i = 0; i < ar.length(); ++i)
			{
				CoreTools::CloneAndAddToModelSpace((AcDbEntity*)ar[i]);
			}
#endif
			deleteArrayVoidPtrs< AcDbEntity>(ar);
			acutPrintf(_T("\n创建截面失败，请检查参数!"));
			return;
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);

		pSolid = drawExtruded(pReg, AcGeVector3d::kZAxis * T);
		DELETE_PTR(pReg);
		if (!pSolid)
		{
			DELETE_PTR(pSolid);
			return;
		}

		AcDb3dSolid *pSubSolid = drawCylinder(AcGeVector3d::kZAxis * T, AcGePoint3d::kOrigin + AcGeVector3d::kYAxis * R, R);
		if (pSubSolid)
		{
			if (pSolid->booleanOper(AcDb::kBoolSubtract, pSubSolid) != Acad::eOk)
				DELETE_PTR(pSubSolid);
		}

		AcGeMatrix3d mat1;
		mat1.setToAlignCoordSys(AcGePoint3d::kOrigin, AcGeVector3d::kXAxis, AcGeVector3d::kYAxis, AcGeVector3d::kZAxis, Pos, X, Z, Y);

		pSubSolid = drawCylinder(AcGeVector3d::kZAxis * T, AcGePoint3d::kOrigin + AcGeVector3d::kYAxis * R, R);
		if (pSubSolid)
		{
			// 闸门 绕Y转45度
			mat.setToIdentity();
			mat.setToRotation(CoreTools::A2R(10), AcGeVector3d::kYAxis);
			pSubSolid->transformBy(mat);
			pSubSolid->transformBy(mat1);
			ar3d.append(pSubSolid);
		}

		pSolid->transformBy(mat1);
		ar3d.append(pSolid);

	}
	void CircleZhaMen::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region ShengNiFa
	void ShengNiFa::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double h, H, DN, D3, T;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(h);
		GETXDATA(DN);
		GETXDATA(D3);
		GETXDATA(T);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(RectZhaMen);

		AcDb3dSolid *pSolid(NULL);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);

		double R(D3 * .5), r(DN * .5);
		AcGePoint3d pt0(Pos - Z * h);
		pt0 -= X * R;
		AcGePoint3d pt1(pt0 + Z * T);
		AcGePoint3d pt2(pt1 + X * (R - r - T));
		AcGePoint3d pt3(pt2 + Z * (h - 2 * T));
		AcGePoint3d pt4(pt3 - X * (R - r - T));
		AcGePoint3d pt5(pt4 + Z * T);
		AcGePoint3d pt6(pt5 + X * (R - r));
		AcGePoint3d pt7(pt6 - Z * h);

		AcDbRegion *pReg = makeRegion2(8, pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7);
		if (!pReg) return;

		pSolid = drawRevolved(pReg, Pos, Z);
		DELETE_PTR(pReg);
		if (pSolid) ar3d.append(pSolid);

		double hh(H - h);
		pt0 = Pos - X * R;
		pt1 = pt0 + Z * (hh - R);
		pt2 = pt1 + X * (R- r);
		pt3 = pt2 + X * 2 * r;
		pt4 = pt3 + X * (R - r);
		pt5 = pt4 - Z * (hh - R);
		pt6 = pt5 - X * (R - r);
		pt7 = pt0 + X * (R - r);

		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt7, pt0));
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbLine(pt7, pt2));
		ar.append(new AcDbLine(pt6, pt3));
		ar.append(new AcDbLine(pt6, pt5));
		ar.append(new AcDbLine(pt5, pt4));
		ar.append(new AcDbArc(Pos + Z * (hh - R), Y, r, 0, PI));
		ar.append(new AcDbArc(Pos + Z * (hh - R), Y, R, 0, PI));

		pReg = CoreTools::createRegion(ar);
		if (!pReg)
		{
#ifndef NDEBUG
			for (int i = 0; i < ar.length(); ++i)
			{
				CoreTools::CloneAndAddToModelSpace((AcDbEntity*)ar[i]);
			}
#endif
			deleteArrayVoidPtrs< AcDbEntity>(ar);
			return;
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);

		AcGeMatrix3d mat;
		mat.setToTranslation(-Y * (R - r) * .5);
		pReg->transformBy(mat);
		pSolid = drawExtruded(pReg, Y * (R - r));
		DELETE_PTR(pReg);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(-Z * h * .25, Pos - Z * .25 * h, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(-Z * (h * .25 + hh), Pos + Z * hh, (R - r) * .5);
		if (pSolid) ar3d.append(pSolid);
	}
	void ShengNiFa::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion
}

namespace GUANIJI
{
#pragma region XZG
	void XZG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double fai, H, W, a;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(fai);
		GETXDATA(H);
		GETXDATA(W);
		GETXDATA(a);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(XZG);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 顶板
		pSolid = drawBox(Pos, Z * 100, X, fai, W);
		if (pSolid) ar3d.append(pSolid);

		// 栏杆
		drawLanGan(Pos, X, fai, W, ar3d);

		// 电机
		drawDianJi(Pos + Z * 100, Z, 200, ar3d);

		double dL(500), dW(250);	// 刮泥板尺寸
		H -= dW;

		// 传动轴
		pSolid = drawCylinder(-Z * H, Pos, 50);
		if (pSolid) ar3d.append(pSolid);

		// 刮臂
		AcGePoint3d pt, pt1, pt2; // 刮臂端点
		{
			double len(fai * .5 / cos(a));
			AcDbLine line1, line2; // 两条刮臂路径直线
			pt = Pos - Z * (H - 10);
			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			line1.setStartPoint(pt);
			line1.setEndPoint(pt + (vt * len));
			pt1 = pt + (vt * fai * .25);

			vt = -X;
			vt.rotateBy(a, Y);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			line2.setStartPoint(pt);
			line2.setEndPoint(pt + (vt * len));
			pt2 = pt + (vt * fai * .25);
		}

		// 吊线
		{
			AcGePoint3d ptM = Pos - Z * H * .5;
			pSolid = drawCylinder(pt1 - ptM, ptM, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt2 - ptM, ptM, 1);
			if (pSolid) ar3d.append(pSolid);
		}

		// 刮泥板

		double dSp(((dL * .5) / sin(PI * .25)) * 2);
		int num(int((fai - dSp) / dSp));
		pt = Pos - Z * (H + dW * .5);
		//pt += X * (fai * .5 - dSp * .5);
		pSolid = drawBox(pt, X * 1, Y, dL, dW);
		if (pSolid)
		{
			AcGeMatrix3d mat, mat1;
			mat.setToRotation(PI * .25, Z, pt);
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);
			int count((int)(fai * .5 * cos(a) / dSp));

			double dist(dSp);
			for (int i = 0; i < count; ++i)
			{
				AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
				mat.setToIdentity();
				mat.setToTranslation(vt * (dist / cos(a)));
				p->transformBy(mat);
				ar3d.append(p);
				dist += dSp;
			}
			vt = -X;
			vt.rotateBy(a, Y);
			dist = dSp;
			for (int i = 0; i < count; ++i)
			{
				AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
				mat.setToIdentity();
				mat.setToTranslation(vt * (dist / cos(a)));
				p->transformBy(mat);
				ar3d.append(p);
				dist += dSp;
			}
		}
	}
	void XZG::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region CZG
	void CZG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double fai, H, W, a;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(fai);
		GETXDATA(H);
		GETXDATA(W);
		GETXDATA(a);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(CZG);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 顶板
		pSolid = drawBox(Pos + X * fai *.25, Z * 100, X, fai * .5, W);
		if (pSolid) ar3d.append(pSolid);
		// 栏杆
		drawLanGan(Pos + X * fai *.25, X, fai * .5, W, ar3d);
		// 电机
		drawDianJi(Pos + Z * 100, Z, 200, ar3d);
		// 轴
		pSolid = drawCylinder(-Z * H, Pos, 50);
		if (pSolid) ar3d.append(pSolid);

		// 臂
		AcGePoint3d pt;
		double dSlabW(100), dSlabH(100);// 刮泥板 和 撇渣板 相同尺寸
		{
			double len(fai * .5 / cos(a));
			pt = Pos - Z * (H - dSlabH);
			AcGeVector3d vt(X), vt1(Z);
			vt.rotateBy(a, -Y);
			vt1.rotateBy(a, -Y);
			pSolid = drawBox(pt + vt * len * .5, vt1 * 10, vt, len, W * .5);
			if (pSolid) ar3d.append(pSolid);

			vt = -X;
			vt.rotateBy(a, Y);
			vt1 = Z;
			vt1.rotateBy(a, Y);
			pSolid = drawBox(pt + vt * len * .5, vt1 * 10, vt, len, W * .5);
			if (pSolid) ar3d.append(pSolid);
		}

		// 刮板
		{
			double len(fai * .5 / cos(a));
			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);
			pt = Pos - Z * (H - dSlabH *.5);
			pSolid = drawBox(pt + vt * len * .5, Y * 1, vt, len, dSlabW);
			if (pSolid) ar3d.append(pSolid);

			vt = -X;
			vt.rotateBy(a, Y);
			pSolid = drawBox(pt + vt * len * .5, Y * 1, vt, len, dSlabW);
			if (pSolid) ar3d.append(pSolid);
		}
		// 筒
		double dh(250);
		{
			pSolid = drawCylinder(-Z * H * .5, Pos - Z * dh, fai / 8);
			if (pSolid)
			{
				AcDb3dSolid *pSolid1 = drawCylinder(-Z * H * .5, Pos - Z * dh, fai / 8 - 10);
				if (pSolid1)
				{
					if (pSolid->booleanOper(AcDb::kBoolSubtract, pSolid1) != Acad::eOk)
						DELETE_PTR(pSolid1);
					ar3d.append(pSolid);
				}
			}
		}
		// 撇渣
		double dl = (3 * fai) / 8;
		{
			pt = Pos - Z * dh;
			pt -= X * (fai / 8);
			pt -= X * dl * .5;
			pSolid = drawBox(pt, Y * 5, X, dl, dSlabW);
			if (pSolid) ar3d.append(pSolid);
		}
		// 支架
		{
			pt = Pos - Z * (dh + dSlabH * .5);
			pt -= X * (fai / 8);
			double dHH(H - dh - 1.5 * dSlabH); // 画到刮板上沿
			double dSp(3 * fai / 8 / 4);
			double dist(dSp);
			for (int i = 0; i < 3; ++i)
			{
				pSolid = drawCylinder(-Z * (dHH - (dist + fai / 8) * tan(a)), pt - X * dist, 1);
				if (pSolid) ar3d.append(pSolid);
				dist += dSp;
			}

		}
	}
	void CZG::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region ZG
	void ZG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double fai, H, W, a;
		int Half;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(fai);
		GETXDATA(H);
		GETXDATA(W);
		GETXDATA(a);
		GETXDATA(Half);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(ZG);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 顶板
		{
			double dL(fai);
			AcGePoint3d pt(Pos);
			if (Half)
			{
				pt = Pos + X * fai * .25;
				dL = fai * .5;
			}
			pSolid = drawBox(pt, Z * 100, X, dL, W);
			if (pSolid) ar3d.append(pSolid);
		// 栏杆
			drawLanGan(pt, X, dL, W, ar3d);
		}
		// 电机
		drawDianJi(Pos + Z * 100, Z, 200, ar3d);

		double dL(500), dW(250);	// 刮板数据
		H -= dW;
		// 轴
		pSolid = drawCylinder(-Z * H, Pos, 50);
		if (pSolid) ar3d.append(pSolid);
		// 臂
		double len(fai * .5 / cos(a));
		AcGeVector3d vt(X);
		vt.rotateBy(a, -Y);
		AcGePoint3d pt(Pos - Z * (H - 10));

		pSolid = drawCylinder(vt * len, pt, 10);
		if (pSolid) ar3d.append(pSolid);

		vt = -X;
		vt.rotateBy(a, Y);
		pSolid = drawCylinder(vt * len, pt, 10);
		if (pSolid) ar3d.append(pSolid);
		

		// 刮板
		{
			double dSp(((dL * .5) / sin(PI * .25)) * 2);
			int num(int((fai - dSp) / dSp));
			pt = Pos - Z * (H + dW * .5);
			pSolid = drawBox(pt, X * 1, Y, dL, dW);
			if (pSolid) ar3d.append(pSolid);

			AcGeMatrix3d mat;
			mat.setToRotation(PI * .25, Z, pt);
			pSolid->transformBy(mat);

			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);
			int count((int)(fai * .5 * cos(a) / dSp));

			double dist(dSp);
			for (int i = 0; i < count; ++i)
			{
				AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
				mat.setToIdentity();
				mat.setToTranslation(vt * (dist / cos(a)));
				p->transformBy(mat);
				ar3d.append(p);
				dist += dSp;
			}
			vt = -X;
			vt.rotateBy(a, Y);
			dist = dSp;
			for (int i = 0; i < count; ++i)
			{
				AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
				mat.setToIdentity();
				mat.setToTranslation(vt * (dist / cos(a)));
				p->transformBy(mat);
				ar3d.append(p);
				dist += dSp;
			}
		}

		// 筒
		double dSlabW(100);
		double dh(250);
		{
			pSolid = drawCylinder(-Z * H * .5, Pos - Z * dh, fai / 8);
			if (pSolid)
			{
				AcDb3dSolid *pSolid1 = drawCylinder(-Z * H * .5, Pos - Z * dh, fai / 8 - 10);
				if (pSolid1)
				{
					if (pSolid->booleanOper(AcDb::kBoolSubtract, pSolid1) != Acad::eOk)
						DELETE_PTR(pSolid1);
					ar3d.append(pSolid);
				}
			}
		}
		// 撇渣
		{
			AcGeLine3d line(Pos, Pos - Z * H);
			AcGeMatrix3d rot;
			rot.setToMirroring(line);

			double dl = (3 * fai) / 8;
			pt = Pos - Z * dh;
			pt -= X * (fai / 8);
			pt -= X * dl * .5;
			pSolid = drawBox(pt, Y * 5, X, dl, dSlabW);
			if (pSolid) ar3d.append(pSolid);

			if (!Half && pSolid != NULL)
			{
				pSolid = (AcDb3dSolid*)pSolid->clone();
				pSolid->transformBy(rot);
				if (pSolid) ar3d.append(pSolid);
			}
			
			// 支架
			pt = Pos - Z * (dh + dSlabW * .5);
			pt -= X * (fai / 8);
			double dHH(H - dh - dSlabW * .5);
			double dSp(3 * fai / 8 / 4);
			double dist(dSp);
			for (int i = 0; i < 3; ++i)
			{
				pSolid = drawCylinder(-Z * (dHH - (dist + fai / 8) * tan(a)), pt - X * dist, 1);
				if (pSolid) ar3d.append(pSolid);
				
				dist += dSp;
			}

			if (!Half)
			{
				pt = Pos - Z * (dh + dSlabW * .5);
				pt += X * (fai / 8);
				double dHH(H - dh - dSlabW * .5);
				double dSp(3 * fai / 8 / 4);
				double dist(dSp);
				for (int i = 0; i < 3; ++i)
				{
					pSolid = drawCylinder(-Z * (dHH - (dist + fai / 8) * tan(a)), pt + X * dist, 1);
					if (pSolid) ar3d.append(pSolid);

					dist += dSp;
				}
			}
		}
	}
	void ZG::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region QG
	void QG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double G, W, W1;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(W);
		GETXDATA(W1);
		GETXDATA(G);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(QG);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 板
		double dr(150);
		pSolid = drawBox(Pos + Z * 2 * dr, Z * 100, X, W, W1);
		if (pSolid) ar3d.append(pSolid);
		
		// 轮子 半径 W/8 厚 100
		{
			AcGePoint3d pt0, pt1, pt2, pt3;
			getRect(Pos + Z * dr * 2, X, W, W1, pt0, pt1, pt2, pt3);

			pt0 += Y * dr; pt0 -= Z * dr;
			pt3 -= Y * dr; pt3 -= Z * dr;
			pt1 += Y * dr; pt1 -= Z * dr;
			pt2 -= Y * dr; pt2 -= Z * dr;

			pSolid = drawCylinder(-X * 100, pt0, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt1, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt2, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-X * 100, pt3, dr);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt0.distanceTo(pt1), pt0, dr * .25);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt3.distanceTo(pt2), pt3, dr * .25);
			if (pSolid) ar3d.append(pSolid);
		}

		// 刮泥板
		AcGePoint3d pt(Pos + Z * dr * 2);
		pt -= Z * G * .5;
		pSolid = drawBox(pt, Y * 1, X, W, G);
		if (pSolid) ar3d.append(pSolid);
	}
	void QG::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region PJ
	void PJ::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double H, W, W1;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(W);
		GETXDATA(W1);
		GETXDATA(H);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(PJ);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 板
		double dr(150);
		pSolid = drawBox(Pos + Z * 2 * dr, Z * 100, X, W, W1);
		if (pSolid) ar3d.append(pSolid);

		// 栏杆
		drawLanGan(Pos + Z * 2 * dr, X, W, W1, ar3d);

		// 轮子
		{
			AcGePoint3d pt0, pt1, pt2, pt3;
			getRect(Pos + Z * dr * 2, X, W, W1, pt0, pt1, pt2, pt3);

			pt0 += Y * dr; pt0 -= Z * dr;
			pt3 -= Y * dr; pt3 -= Z * dr;
			pt1 += Y * dr; pt1 -= Z * dr;
			pt2 -= Y * dr; pt2 -= Z * dr;

			pSolid = drawCylinder(-X * 100, pt0, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt1, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt2, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-X * 100, pt3, dr);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt0.distanceTo(pt1), pt0, dr * .25);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt3.distanceTo(pt2), pt3, dr * .25);
			if (pSolid) ar3d.append(pSolid);
		}

		// 撇渣
		{
			AcGePoint3d pt0(Pos + Z * dr * 2);
			pt0 -= X * W * .5;
			pt0 += X * W / 3;
			AcGePoint3d pt1(pt0);
			pt1 += X * W / 3;

			pSolid = drawCylinder(-Z * dr * 4, pt0, 5);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(-Z * dr * 4, pt1, 5);
			if (pSolid) ar3d.append(pSolid);
			
			pt0 -= Z * 4 * dr;
			pt1 -= Z * 4 * dr;

			pSolid = drawCylinder(Y * dr * 6, pt0, 5);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(Y * dr * 6, pt1, 5);
			if (pSolid) ar3d.append(pSolid);

			pt0 += Y * dr * 6;

			pt1 += Y * dr * 6;

			AcGePoint3d pt(CoreTools::MidPt(pt0, pt1));
			pSolid = drawBox(pt, Y* 1, X, W, 200);
			if (pSolid)
			{
				AcGeMatrix3d mat;
				mat.setToRotation(-PI / 4, pt0 - pt1, pt0);
				pSolid->transformBy(mat);
				ar3d.append(pSolid);
			}
		}

		// 刮泥
		{
			AcGePoint3d pt0(Pos + Z * dr * 2);
			pt0 -= X * W * .5;
			pt0 += X * W / 3;
			AcGePoint3d pt1(pt0);
			pt1 += X * W / 3;

			pt0 -= Y * W1 / 4;
			pt1 -= Y * W1 / 4;

			pSolid = drawCylinder(-Z * dr * 4, pt0, 5);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(-Z * dr * 4, pt1, 5);
			if (pSolid) ar3d.append(pSolid);
			
			pt0 -= Z * 4 * dr;
			pt1 -= Z * 4 * dr;

			double dh(200);
			AcGeVector3d vt(Y);
			vt.rotateBy(PI / 4, -X);
			vt.normalize();
			vt *= (H - dh - 2 * dr) / cos(PI / 4);

			pSolid = drawCylinder(vt, pt0, 5);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(vt, pt1, 5);
			if (pSolid) ar3d.append(pSolid);
			
			pt0 += vt;
			pt1 += vt;

			pSolid = drawCylinder(Y * dh, pt0, 5);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * dh, pt1, 5);
			if (pSolid) ar3d.append(pSolid);

			pt0 += Y * dh;
			pt0 -= Z * dh * .5;
			pt1 += Y * dh;
			pt1 -= Z * dh * .5;

			AcGePoint3d pt(CoreTools::MidPt(pt0, pt1));
			pSolid = drawBox(pt, Y * 1, X, W, 200);
			if (pSolid) ar3d.append(pSolid);
		}

		{
			AcGePoint3d pt(Pos + Z * (2 * dr + 100));
			pt += Z * 100;
			pt += X * 500;
			drawDianJi(pt, X, 100, ar3d);
			pt -= X * 500;

			pt -= Y * W1 / 4;
			pt -= X * 500;
			drawDianJi(pt, -X, 100, ar3d);
			//drawDianJi();
		}
	}
	void PJ::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region SX
	void SX::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double L, H, Lk, W1;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(L);
		GETXDATA(Lk);
		GETXDATA(W1);
		GETXDATA(H);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(SX);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 板
		double dr(150);
		pSolid = drawBox(Pos + Z * 2 * dr, Z * 100, X, L, W1);
		if (pSolid) ar3d.append(pSolid);

		// 栏杆
		drawLanGan(Pos + Z * 2 * dr, X, L, W1, ar3d);

		// 轮子
		{
			AcGePoint3d pt0, pt1, pt2, pt3;
			getRect(Pos + Z * dr * 2, X, Lk, W1, pt0, pt1, pt2, pt3);

			pt0 += Y * dr; pt0 -= Z * dr;
			pt3 -= Y * dr; pt3 -= Z * dr;
			pt1 += Y * dr; pt1 -= Z * dr;
			pt2 -= Y * dr; pt2 -= Z * dr;

			pSolid = drawCylinder(-X * 100, pt0, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt1, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt2, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-X * 100, pt3, dr);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt0.distanceTo(pt1), pt0, dr * .25);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt3.distanceTo(pt2), pt3, dr * .25);
			if (pSolid) ar3d.append(pSolid);
		}
		
		// 横向主管 半径 100
		{
			AcGePoint3d pt(Pos + Z * (2 * dr - 100));
			pt -= X * L * .5;
			pSolid = drawCylinder(X * L, pt, 100);
			if (pSolid) ar3d.append(pSolid);
		}

		// 吸盘 80 x 30 cm 间距 1m 半径 50
		{
			double  dL(800), dW(300), dS(1000), r(50);
			int count = int((Lk - 1 * dS) / 1000);
			AcGePoint3d pt(Pos + Z * 2 * dr);
			pt -= X * Lk * .5;
			pt += X * dS;
			for (int i = 0; i < count; ++i)
			{
				pSolid = drawCylinder(-Z * H, pt, r);
				if (pSolid) ar3d.append(pSolid);
				pSolid = drawBox(pt - Z * H, Z * 100, X, dL, dW);
				if (pSolid) ar3d.append(pSolid);
				pt += X * dS;
			}
		}
	}
	void SX::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region SB
	void SB::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double L, H, Lk, W1;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(L);
		GETXDATA(Lk);
		GETXDATA(W1);
		GETXDATA(H);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(SB);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 板
		double dr(150);
		pSolid = drawBox(Pos + Z * 2 * dr, Z * 100, X, L, W1);
		if (pSolid) ar3d.append(pSolid);

		// 栏杆
		drawLanGan(Pos + Z * 2 * dr, X, L, W1, ar3d);

		// 轮子
		{
			AcGePoint3d pt0, pt1, pt2, pt3;
			getRect(Pos + Z * dr * 2, X, Lk, W1, pt0, pt1, pt2, pt3);

			pt0 += Y * dr; pt0 -= Z * dr;
			pt3 -= Y * dr; pt3 -= Z * dr;
			pt1 += Y * dr; pt1 -= Z * dr;
			pt2 -= Y * dr; pt2 -= Z * dr;

			pSolid = drawCylinder(-X * 100, pt0, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt1, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(X * 100, pt2, dr);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-X * 100, pt3, dr);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt0.distanceTo(pt1), pt0, dr * .25);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(X * pt3.distanceTo(pt2), pt3, dr * .25);
			if (pSolid) ar3d.append(pSolid);
		}

		// 电机
		AcGePoint3d ptDJ0, ptDJ1;
		{
			AcGePoint3d pt0(Pos + Z * (2 * dr + 100)), pt1(Pos + Z * (2 * dr + 100));
			pt0 -= X * Lk * .25;
			pt1 += X * Lk * .25;
			drawDianJi(pt0, Z, 200, ar3d);
			drawDianJi(pt1, Z, 200, ar3d);
			ptDJ0 = pt0;
			ptDJ1 = pt1;
		}

		// 横向主管 半径 100
		{
			AcGePoint3d pt(Pos + Z * (2 * dr - 100));
			pt -= X * L * .25;
			pSolid = drawCylinder(X * L * .75, pt, 100);
			if (pSolid) ar3d.append(pSolid);
		}

		// 竖管 + 泵
		{
			pSolid = drawCylinder(-Z * H, ptDJ0, 50);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Z * H, ptDJ1, 50);
			if (pSolid) ar3d.append(pSolid);
			drawPump(ptDJ0 - Z * H * .5, Z, ar3d);
			drawPump(ptDJ1 - Z * H * .5, Z, ar3d);
		}

		// 吸盘
		{
			AcGePoint3d pt0(ptDJ0 - Z * H), pt1(ptDJ1 - Z * H);
			double dl(Lk * .5 * .8);
			pSolid = drawBox(pt0, Z * 200, X, dl, 500);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawBox(pt1, Z * 200, X, dl, 500);
			if (pSolid) ar3d.append(pSolid);
		}

		// 支架
		{
			AcGePoint3d pt0(ptDJ0 - X * Lk / 8);
			AcGePoint3d pt1(pt0 + X * Lk / 4);
			AcGePoint3d pt2(pt1 + X * Lk / 4);
			AcGePoint3d pt3(pt2 + X * Lk / 4);
			
			pSolid = drawCylinder(-Z * H, pt0, 5);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Z * H, pt1, 5);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Z * H, pt2, 5);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Z * H, pt3, 5);
			if (pSolid) ar3d.append(pSolid);
		}
	}
	void SB::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region LIANTIAO
	void LIANTIAO::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE), LEFT(FALSE), DianJi(FALSE);

		double L, L1, L2, L3, B, R, H, H1, W;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(L);
		GETXDATA(L1);
		GETXDATA(L2);
		GETXDATA(B);
		GETXDATA(R);
		GETXDATA(H);
		GETXDATA(H1);
		GETXDATA(W);
		GETXDATA(L3);
		GETXDATA(LEFT);
		GETXDATA(DianJi);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(LIANTIAO);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();

		AcDb3dSolid *pSolid(NULL), *pSolid1(NULL), *pSolid2(NULL);
		
		AcGePoint3d pt1(Pos - X * (L * .5 - L1));
		pt1 += Z * (B + R);
		AcGePoint3d pt2(Pos + X * (L * .5 - L2));
		pt2 += Z * (B + R);
		AcGePoint3d pt3(pt2 + Z * (H1 - (B + R)));
		AcGePoint3d pt4(pt1 + Z * (H1 - (B + R)));

		AcGeMatrix3d mat;
		// 四个转动轴
		{
			pSolid = drawCylinder(-Y * L3, pt1 + Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Y * L3, pt2 + Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Y * L3, pt3 + Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(-Y * L3, pt4 + Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(Y * L3, pt1 - Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * L3, pt2 - Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * L3, pt3 - Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * L3, pt4 - Y * (W * .5), R);
			if (pSolid) ar3d.append(pSolid);

			pSolid = drawCylinder(Y * W, pt1 - Y * W * .5, R * .25);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * W, pt2 - Y * W * .5, R * .25);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * W, pt3 - Y * W * .5, R * .25);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(Y * W, pt4 - Y * W * .5, R * .25);
			if (pSolid) ar3d.append(pSolid);
		}
		// 传动带
		{
			// 横四条
			pSolid = drawBox(pt1 - Y * (W * .5 - L3 * .5), X * (pt1.distanceTo(pt2)), Y, L3 * .5, 1);
			mat.setToTranslation(-Z * (R - .5));
			pSolid->transformBy(mat);
			if (pSolid) ar3d.append(pSolid);

			//pSolid1 = (AcDb3dSolid*)pSolid->clone();
			mat.setToTranslation(Z * (H1 - B + R - 1));
			pSolid1 = cloneAndTransform(pSolid, mat);
			if (pSolid1) ar3d.append(pSolid1);

			mat.setToTranslation(Y * (W - L3));
			ar3d.append(cloneAndTransform(pSolid, mat));
			ar3d.append(cloneAndTransform(pSolid1, mat));

			// 竖四条
			pSolid = drawBox(pt1 - Y * (W * .5 - L3 * .5), Z * (pt1.distanceTo(pt4)), Y, L3 * .5, 1);
			mat.setToTranslation(-X * (R - .5));
			pSolid->transformBy(mat);
			if (pSolid) ar3d.append(pSolid);

			mat.setToTranslation(X * (2 * R + pt1.distanceTo(pt2) - 1));
			pSolid1 = cloneAndTransform(pSolid, mat);
			if (pSolid1) ar3d.append(pSolid1);
			
			mat.setToTranslation(Y * (W - L3));
			ar3d.append(cloneAndTransform(pSolid, mat));
			ar3d.append(cloneAndTransform(pSolid1, mat));
		}

		// 刮泥板
		{
			double dS(pt1.distanceTo(pt2) - 2 * R);
			dS *= .5;

			pSolid = drawBox(pt1, -Z * B, Y, W - L3 * .5, 1);
			mat.setToTranslation(-Z * (R - .5));
			pSolid->transformBy(mat);
			mat.setToTranslation(X * R);
			pSolid->transformBy(mat);
			if (pSolid) ar3d.append(pSolid);

			mat.setToTranslation(X * dS);
			pSolid1 = cloneAndTransform(pSolid, mat);
			ar3d.append(pSolid1);
			pSolid2 = cloneAndTransform(pSolid1, mat);
			ar3d.append(pSolid2);

			mat.setToTranslation(Z * (pt1.distanceTo(pt4) + 2 * R + B));
			ar3d.append(cloneAndTransform(pSolid, mat));
			ar3d.append(cloneAndTransform(pSolid1, mat));
			ar3d.append(cloneAndTransform(pSolid2, mat));
		}

		// 电机
		if (DianJi)
		{
			double dDjL(500);	// 电机长
			double dR(250);		// 电机半径
			AcGePoint3d pt((LEFT ? pt4 : pt3) + Y * (W * .5 + dDjL));
			pt += Z * (H - H1 + dR);
			drawDianJi(pt, -Y, dR, ar3d, dDjL);
			// 传动轴
			pt += -Y * dDjL;
			pSolid = drawCylinder(-Y * (L3 * .25), pt, R);
			if (pSolid) ar3d.append(pSolid);
			// 传动带
			double dW(L3 * .25);	// 带宽
			pt -= Y * dW * .5;
			pSolid = drawBox(pt - (X * (R - .5)), -Z * (H - H1 + dR), Y, dW, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawBox(pt + (X * (R - .5)), -Z * (H - H1 + dR), Y, dW, 1);
			if (pSolid) ar3d.append(pSolid);
		}
	}
	void LIANTIAO::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

}

namespace NONGSUOJI
{
#pragma region NC
	void NC::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, W, a;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(W);
		GETXDATA(a);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(NC);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 顶板
		{
			double dL(D);
			AcGePoint3d pt(Pos);
			pSolid = drawBox(pt, Z * 100, X, dL, W);
			if (pSolid) ar3d.append(pSolid);
			// 栏杆
			drawLanGan(pt, X, dL, W, ar3d);
		}
		// 电机
		drawDianJi(Pos + Z * 100, Z, 200, ar3d);
		
		double dL(500), dW(250);	// 刮板尺寸
		H -= dW;
		// 轴
		pSolid = drawCylinder(-Z * H, Pos, 50);
		if (pSolid) ar3d.append(pSolid);
		// 臂
		{
			double len(D * .5 * cos(a));

			AcGePoint3d pt(Pos - Z * (H - 10));
			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);

			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

			pt = Pos - Z * (H - 10);
			vt = -X;
			vt.rotateBy(a, Y);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

			pt = Pos - Z * (H - 10);
			vt = Y;
			vt.rotateBy(a, X);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

			pt = Pos - Z * (H - 10);
			vt = -Y;
			vt.rotateBy(a, -X);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

		}
		// 刮板
		{
			AcGePoint3d pt;
			{
				double dSp(((dL * .5) / sin(PI * .25)) * 2);
				int num(int((D - dSp) / dSp));
				pt = Pos - Z * (H + dW * .5);
				//pt += X * (D * .5 - dSp * .5);
				pSolid = drawBox(pt, X * 1, Y, dL, dW);
				if (pSolid)
				{
					ar3d.append(pSolid);

					AcGeMatrix3d mat;
					mat.setToRotation(PI * .25, Z, pt);
					pSolid->transformBy(mat);

					AcGeVector3d vt(X);
					vt.rotateBy(a, -Y);
					int count((int)(D * .5 * cos(a) / dSp));

					double dist(dSp);
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
					vt = -X;
					vt.rotateBy(a, Y);
					dist = dSp;
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
				}
			}
			{
				double dL(500), dW(250);
				double dSp(((dL * .5) / sin(PI * .25)) * 2);
				int num(int((D - dSp) / dSp));
				pt = Pos - Z * (H + dW * .5);
				//pt += Y * (D * .5 - dSp * .5);
				pSolid = drawBox(pt, Y * 1, X, dL, dW);
				if (pSolid)
				{
					ar3d.append(pSolid);

					AcGeMatrix3d mat;
					mat.setToRotation(PI * .25, Z, pt);
					pSolid->transformBy(mat);

					AcGeVector3d vt(Y);
					vt.rotateBy(a, X);
					int count((int)(D * .5 * cos(a) / dSp));

					double dist(dSp);
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
					vt = -Y;
					vt.rotateBy(a, -X);
					dist = dSp;
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
				}
			}
		}

		double dh(250);
		// 吊线
		{
			double len(D * .5 * cos(a));
			AcGePoint3d pt = Pos - Z * (H * .5 + dh);
			AcGePoint3d pt0 = Pos - Z * H;
			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);
			AcGePoint3d pt1 = pt0 + vt * len;

			vt = -X;
			vt.rotateBy(a, Y);
			AcGePoint3d pt2 = pt0 + vt * len;

			vt = Y;
			vt.rotateBy(a, X);
			AcGePoint3d pt3 = pt0 + vt * len;

			vt = -Y;
			vt.rotateBy(a, -X);
			AcGePoint3d pt4 = pt0 + vt * len;

			pSolid = drawCylinder(pt1 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt2 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt3 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt4 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);

		}

		// 筒
		double dSlabW(100);
		{
			pSolid = drawCylinder(-Z * H / 3, Pos - Z * dh, D / 8);
			if (pSolid)
			{
				AcDb3dSolid *pSolid1 = drawCylinder(-Z * H * .5, Pos - Z * dh, D / 8 - 10);
				if (pSolid1)
				{
					if (pSolid->booleanOper(AcDb::kBoolSubtract, pSolid1) != Acad::eOk)
						DELETE_PTR(pSolid1);
					ar3d.append(pSolid);
				}
			}
		}
	}
	void NC::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region NB
	void NB::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, W, a;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(W);
		GETXDATA(a);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(NC);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 顶板
		{
			double dL(D * .5);
			AcGePoint3d pt(Pos + X * dL * .5);
			pSolid = drawBox(pt, Z * 100, X, dL, W);
			if (pSolid) ar3d.append(pSolid);
			// 栏杆
			drawLanGan(pt, X, dL, W, ar3d);
		}
		// 电机
		drawDianJi(Pos + Z * 100, Z, 200, ar3d);
		double dL(500), dW(250);	// 刮板尺寸
		H -= dW;
		// 轴
		pSolid = drawCylinder(-Z * H, Pos, 50);
		if (pSolid) ar3d.append(pSolid);
		// 臂
		{
			double len(D * .5 * cos(a));

			AcGePoint3d pt(Pos - Z * (H - 10));
			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);

			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

			pt = Pos - Z * (H - 10);
			vt = -X;
			vt.rotateBy(a, Y);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

			pt = Pos - Z * (H - 10);
			vt = Y;
			vt.rotateBy(a, X		);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);

			pt = Pos - Z * (H - 10);
			vt = -Y;
			vt.rotateBy(a, -X);
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			pt -= Z * 250;
			pSolid = drawCylinder(vt * len, pt, 10);
			if (pSolid) ar3d.append(pSolid);
			
		}
		// 刮板
		{
			AcGePoint3d pt;
			{
				double dSp(((dL * .5) / sin(PI * .25)) * 2);
				int num(int((D - dSp) / dSp));
				pt = Pos - Z * (H + dW * .5);
				//pt += X * (D * .5 - dSp * .5);
				pSolid = drawBox(pt, X * 1, Y, dL, dW);
				if (pSolid)
				{
					ar3d.append(pSolid);

					AcGeMatrix3d mat;
					mat.setToRotation(PI * .25, Z, pt);
					pSolid->transformBy(mat);

					AcGeVector3d vt(X);
					vt.rotateBy(a, -Y);
					int count((int)(D * .5 * cos(a) / dSp));

					double dist(dSp);
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
					vt = -X;
					vt.rotateBy(a, Y);
					dist = dSp;
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
				}
			}
			{
				double dL(500), dW(250);
				double dSp(((dL * .5) / sin(PI * .25)) * 2);
				int num(int((D - dSp) / dSp));
				pt = Pos - Z * (H + dW * .5);
				//pt += Y * (D * .5 - dSp * .5);
				pSolid = drawBox(pt, Y * 1, X, dL, dW);
				if (pSolid)
				{
					ar3d.append(pSolid);

					AcGeMatrix3d mat;
					mat.setToRotation(PI * .25, Z, pt);
					pSolid->transformBy(mat);
					AcGeVector3d vt(Y);
					vt.rotateBy(a, X);
					int count((int)(D * .5 * cos(a) / dSp));

					double dist(dSp);
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
					vt = -Y;
					vt.rotateBy(a, -X);
					dist = dSp;
					for (int i = 0; i < count; ++i)
					{
						AcDb3dSolid *p = (AcDb3dSolid*)pSolid->clone();
						mat.setToIdentity();
						mat.setToTranslation(vt * (dist / cos(a)));
						p->transformBy(mat);
						ar3d.append(p);
						dist += dSp;
					}
				}
			}
		}

		// 吊线
		{
			double len(D * .5 * cos(a));
			AcGePoint3d pt = Pos - Z * (H / 3);
			AcGePoint3d pt0 = Pos - Z * H;
			AcGeVector3d vt(X);
			vt.rotateBy(a, -Y);
			AcGePoint3d pt1 = pt0 + vt * len;

			vt = -X;
			vt.rotateBy(a, Y);
			AcGePoint3d pt2 = pt0 + vt * len;

			vt = Y;
			vt.rotateBy(a, X);
			AcGePoint3d pt3 = pt0 + vt * len;

			vt = -Y;
			vt.rotateBy(a, -X);
			AcGePoint3d pt4 = pt0 + vt * len;

			pSolid = drawCylinder(pt1 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt2 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt3 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawCylinder(pt4 - pt, pt, 1);
			if (pSolid) ar3d.append(pSolid);

		}

		// 筒
		//double dSlabW(100);
		//double dh(250);
		//{
		//	pSolid = drawCylinder(-Z * H * .5, Pos - Z * dh, D / 8);
		//	if (pSolid)
		//	{
		//		AcDb3dSolid *pSolid1 = drawCylinder(-Z * H * .5, Pos - Z * dh, D / 8 - 10);
		//		if (pSolid1)
		//		{
		//			if (pSolid->booleanOper(AcDb::kBoolSubtract, pSolid1) != Acad::eOk)
		//				DELETE_PTR(pSolid1);
		//			ar3d.append(pSolid);
		//		}
		//	}
		//}
	}
	void NB::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion
}

namespace BAOQIJI
{
#pragma region YHG
	void YHG::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, L, L1, L2;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(L);
		GETXDATA(L1);
		GETXDATA(L2);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(YHG);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);
		// 主轴
		AcGePoint3d pt(Pos + Z * D * .5);
		pt += X * (L * .5 + L2);
		pSolid = drawCylinder(-X * (L1 + L + L2), pt, D / 4);
		if (pSolid) ar3d.append(pSolid);

		// 电机
		double dr(L1 * .5);
		pt = Pos + Z * D * .5;
		pt -= X * (L * .5 + L1 * .5);
		pt += Z * D / 4;
		drawDianJi(pt, Z, dr, ar3d);

		// 刷子
		double sp(100);
		int count(int(L / sp) - 1);
		pt = Pos + Z * D * .5;
		pt -= X * L * .5;
		pt += X * sp;
		AcGeVector3d vt(Z);
		double a(PI * .25);
		for (int i = 0; i < count; ++i)
		{
			for (int j = 0; j < 8; ++j)
			{
				vt.rotateBy(j * a, X);
				pSolid = drawBox(pt, vt * D * .5, X, 5, D * PI / 16);
				if (pSolid) ar3d.append(pSolid);
			}

			pt += X * sp;
		}
	}
	void YHG::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region AD
	void AD::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, L, L1, L2;
		int DJ(false);

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(L);
		GETXDATA(L1);
		GETXDATA(L2);
		GETXDATA(DJ);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(AD);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);
		// 主轴
		AcGePoint3d pt(Pos + Z * D * .5);
		pt += X * (L * .5 + L2);
		pSolid = drawCylinder(-X * (L1 + L + L2), pt, D / 4);
		if (pSolid) ar3d.append(pSolid);

		// 电机
		double dr(L1 * .5);
		pt = Pos + Z * D * .5;
		pt -= X * (L * .5 + L1 * .5);
		pt += Z * D / 4;
		if (DJ)
			drawDianJi(pt, Z, dr, ar3d);

		// 刷子
		double sp(100);
		int count(int(L / sp) - 1);
		pt = Pos + Z * D * .5;
		pt -= X * L * .5;
		pt += X * sp;
		AcGeVector3d vt(Z);
		double a(PI * .25);
		for (int i = 0; i < count; ++i)
		{
			pSolid = drawCylinder(X * 5, pt, D * .5);
			if (pSolid) ar3d.append(pSolid);
			pt += X * sp;
		}
	}
	void AD::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion
}

namespace JIAYAOHUNHE
{
#pragma region GJ
	void GJ::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, SP;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(SP);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(GJ);

		double d(D * .5);
		double R(D * .5), r(d * .5);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		pSolid = drawCylinder(Z * 200, Pos, r);
		if (pSolid) ar3d.append(pSolid);

		AcGePoint3d pt(Pos + Z * 100);
		pSolid = drawCylinder(-X * SP, pt, r);
		if (pSolid) ar3d.append(pSolid);

		pt -= X * (SP + R);
		pt += Z * 100;
		drawDianJi(pt, Z, 100, ar3d);

		pSolid = drawCylinder(-Z * H * .5, pt, R);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(-Z * H, pt, r);
		if (pSolid) ar3d.append(pSolid);

		pt -= Z * (H - 50);
		pSolid = drawBox(pt, Y * 1, X, D, 100);
		if (pSolid) ar3d.append(pSolid);

		pSolid = (AcDb3dSolid*)pSolid->clone();
		AcGeMatrix3d mat;
		mat.setToRotation(PI * .5, Z, pt);
		pSolid->transformBy(mat);
		if (pSolid) ar3d.append(pSolid);
		
	}
	void GJ::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region PJ
	void PJ::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, L, W, E, W1;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(L);
		GETXDATA(W);
		GETXDATA(E);
		GETXDATA(W1);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(PJ);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 桥
		//pSolid = drawBox(Pos, Z * 10, X, L, 200);
		//if (pSolid) ar3d.append(pSolid);

		// 电机
		drawDianJi(Pos + Z * 10, Z, 100, ar3d, 200, 25);
		
		// 轴
		pSolid = drawCylinder(-Z * (H - E), Pos, 10);
		if (pSolid) ar3d.append(pSolid);

		// 桨
		double dH(H/8);
		AcGePoint3d pt(Pos - Z * (H - E));
		pt += Z * dH * .5;
		pSolid = drawBox(pt, Y, X, D, dH);
		if (pSolid) ar3d.append(pSolid);
		pSolid = (AcDb3dSolid*)pSolid->clone();
		AcGeMatrix3d mat;
		mat.setToRotation(PI * .5, Z, pt);
		pSolid->transformBy(mat);
		if (pSolid) ar3d.append(pSolid);

	}
	void PJ::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region TJ
	void TJ::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, fai, W1, H1, E(100);

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(H1);
		GETXDATA(fai);
		GETXDATA(W1);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(TJ);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 桥
		//pSolid = drawBox(Pos, Z * H1, X, fai, 200);
		//if (pSolid) ar3d.append(pSolid);

		// 电机
		drawDianJi(Pos + Z * 10, Z, 100, ar3d, 200, 25);

		// 轴
		pSolid = drawCylinder(-Z * (H - E), Pos, 10);
		if (pSolid) ar3d.append(pSolid);

		// 桨
		double dH(H / 8);
		AcGePoint3d pt(Pos - Z * (H - E));
		pt += Z * dH * .5;
		pSolid = drawBox(pt, Y, X, D, dH);
		if (pSolid) ar3d.append(pSolid);
		pSolid = (AcDb3dSolid*)pSolid->clone();
		AcGeMatrix3d mat;
		mat.setToRotation(PI * .5, Z, pt);
		pSolid->transformBy(mat);
		if (pSolid) ar3d.append(pSolid);
	}
	void TJ::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

#pragma region LJF
	void LJF::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, W1, L, h, h1, h0;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(L);
		GETXDATA(W1);
		GETXDATA(h);
		GETXDATA(h0);
		GETXDATA(h1);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(LJF);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcDb3dSolid *pSolid(NULL);

		// 桥
		//pSolid = drawBox(Pos, Z * h, X, L, 200);
		//if (pSolid) ar3d.append(pSolid);

		// 电机
		drawDianJi(Pos + Z * 10, Z, 100, ar3d, 200, 25);

		// 轴
		pSolid = drawCylinder(-Z * H, Pos, 10);
		if (pSolid) ar3d.append(pSolid);

		// 桨
		AcGePoint3d pt(Pos - Z * (h + h1 + h0 / 3));
		pt -= X * D * .5;
		pSolid = drawCylinder(X * D, pt, 5);
		if (pSolid) ar3d.append(pSolid);
		pt -= Z * h0 / 3;
		pSolid = drawCylinder(X * D, pt, 5);
		if (pSolid) ar3d.append(pSolid);

		pt = Pos - Z * (h + h1 + h0 / 3);
		pt -= Y * D * .5;
		pSolid = drawCylinder(Y * D, pt, 5);
		if (pSolid) ar3d.append(pSolid);
		pt -= Z * h0 / 3;
		pSolid = drawCylinder(Y * D, pt, 5);
		if (pSolid) ar3d.append(pSolid);

		pt = Pos - Z * (h + h1);
		pt -= X * D * .5;
		pSolid = drawCylinder(-Z * h0, pt, 5);
		if (pSolid)
		{
			ar3d.append(pSolid);
			
			AcGeMatrix3d mat;
			mat.setToTranslation(X * 40);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);
		}

		pt += X * D;
		pSolid = drawCylinder(-Z * h0, pt, 5);
		if (pSolid)
		{
			ar3d.append(pSolid);
			
			AcGeMatrix3d mat;
			mat.setToTranslation(-X * 40);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);
		}

		pt = Pos - Z * (h + h1);
		pt -= Y * D * .5;
		pSolid = drawCylinder(-Z * h0, pt, 5);
		if (pSolid)
		{
			ar3d.append(pSolid);

			AcGeMatrix3d mat;
			mat.setToTranslation(Y * 40);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);
		}

		pt += Y * D;
		pSolid = drawCylinder(-Z * h0, pt, 5);
		if (pSolid)
		{
			ar3d.append(pSolid);
			
			AcGeMatrix3d mat;
			mat.setToTranslation(-Y * 40);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);

			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			ar3d.append(pSolid);
		}
	}
	void LJF::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion
}

namespace LVBUJI
{
#pragma region ZHUANPAN
	void ZHUANPAN::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE), LEFT(FALSE), DianJi(FALSE);

		double L, D, H, L1, L2, S, T;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(L);
		GETXDATA(D);
		GETXDATA(H);
		GETXDATA(L1);
		GETXDATA(L2);
		GETXDATA(T);
		GETXDATA(S);
		GETXDATA(LEFT);
		GETXDATA(DianJi);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(ZHUANPAN);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();

		AcDb3dSolid *pSolid(NULL);

		double R(D * .5);	// 盘半径
		double r(R * .25);	// 轴半径
		AcGePoint3d ptL(Pos);
		ptL += Z * R;
		ptL -= X * L * .5;
		// 传动轴
		{
			pSolid = drawCylinder(X * L , ptL, r);
			if (pSolid) ar3d.append(pSolid);
		}
		// 滤片
		{
			double dL(L - L1 - L2);
			double d(.0);
			AcGePoint3d pt(ptL);
			pt += X * L1;
			while (d < dL)
			{
				pSolid = drawCylinder(X * T, pt, R);
				if (pSolid) ar3d.append(pSolid);
				pt += X * (T + S);
				d += (T + S);
			}
		}
		// 电机
		if (DianJi)
		{
			double dDjL(500);	// 电机长
			double dR(250);		// 电机半径
			AcGePoint3d pt(Pos + X * (LEFT ? (-L * .5 - dDjL) : (L * .5 + dDjL)));
			pt += Z * (dR + H);
			AcGeVector3d vt(LEFT ? X : -X);
			drawDianJi(pt, vt, dR, ar3d, dDjL);
			// 传动轴
			pt += vt * dDjL;
			pSolid = drawCylinder(vt * ((LEFT ? L1 : L2) * .5), pt, r);
			if (pSolid) ar3d.append(pSolid);
			// 传动带
			double dW(100);	// 带宽
			pt += vt * ((LEFT ? L1 : L2) * .5);
			pt -= vt * dW * .5;
			pSolid = drawBox(pt + Y * (r - .5), -Z * (H - R + dR), vt, dW, 1);
			if (pSolid) ar3d.append(pSolid);
			pSolid = drawBox(pt - Y * (r - .5), -Z * (H - R + dR), vt, dW, 1);
			if (pSolid) ar3d.append(pSolid);
		}
	}
	void ZHUANPAN::draw2d(AcDbVoidPtrArray &ar2d){draw3d(ar2d);}
#pragma endregion

}

namespace QIBIJI
{
#pragma region QS_I_P
	void QS_I_P::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, D1, d, H, H1, L, LL;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(D1);
		GETXDATA(d);
		GETXDATA(H);
		GETXDATA(H1);
		GETXDATA(L);
		GETXDATA(LL);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(QS - I - P);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		L *= .5;

		double dHPan(100);
		AcDb3dSolid *pSolid = (AcDb3dSolid*)GiDrawUtility::DrawCone(Pos, Z, L * .5, L, H - dHPan, .0);
		if (pSolid) ar3d.append(pSolid);

		AcGePoint3d pt(Pos + Z * (H - dHPan));
		pSolid = drawCylinder(Z * dHPan, pt, d * .5);
		if (pSolid) ar3d.append(pSolid);

		pt = Pos + Z * H;
		double R(D * .5), fai(5);
		double r(R - 2 * fai);
		pSolid = drawTorus(pt, Z, R, r);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(X * D, pt - X * D * .5, fai);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Y * D, pt - Y * D * .5, fai);
		if (pSolid) ar3d.append(pSolid);

		// 螺杆
		pSolid = drawCylinder(-Z * LL, Pos, d * .5);
		if (pSolid) ar3d.append(pSolid);

	}
	void QS_I_P::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
#pragma endregion

#pragma region QS_I_Y
	void QS_I_Y::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D1, d, H, H1, H2, L, L1, LL;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D1);
		GETXDATA(d);
		GETXDATA(H);
		GETXDATA(H1);
		GETXDATA(H2);
		GETXDATA(L);
		GETXDATA(L1);
		GETXDATA(LL);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(QS - I - Y);

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		L1 *= .5;

		double dHPan(150);
		AcDb3dSolid *pSolid = (AcDb3dSolid*)GiDrawUtility::DrawCone(Pos, Z, L1 * .5, L1, H - dHPan, .0);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dHPan, Pos + Z * (H - dHPan), L1);
		if (pSolid) ar3d.append(pSolid);

		pSolid = (AcDb3dSolid*)GiDrawUtility::DrawCone(Pos + Z * H, Z, D1 * .5, L1, 50, .0);
		if (pSolid) ar3d.append(pSolid);

		// 摇柄
		double dl(20);
		AcGePoint3d pt(Pos + Z * H);
		pt += X * L1;
		pSolid = drawCylinder(X * dl, pt - Z * 5, 5);
		if (pSolid) ar3d.append(pSolid);
		pt += X * dl;
		pSolid = drawCylinder(-Z * (H1 + 5), pt, 5);
		if (pSolid) ar3d.append(pSolid);
		pt -= Z * 300;
		pSolid = drawCylinder(X * (L - L1 - dl), pt, 5);
		if (pSolid) ar3d.append(pSolid);

		// 螺杆
		pSolid = drawCylinder(-Z * LL, Pos, d * .5);
		if (pSolid) ar3d.append(pSolid);
	}
	void QS_I_Y::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
#pragma endregion

#pragma region QS_I_L
	void QS_I_L::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double D, H, H1, L, F, LL, M;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(D);
		GETXDATA(M);
		GETXDATA(H1);
		GETXDATA(F);
		GETXDATA(L);
		GETXDATA(H);
		GETXDATA(LL);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(QS - I - L);

		F *= .5;

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);

		AcDb3dSolid *pSolid = (AcDb3dSolid*)GiDrawUtility::DrawCone(Pos, Z, F * .5, F, H1 - (F * .5), .0);
		if (pSolid) ar3d.append(pSolid);

		// 方台
		AcGePoint3d pt(Pos + Z * (H1 - (F * .5)));
		pSolid = drawBox(pt, Z * F, X, F, F);
		if (pSolid) ar3d.append(pSolid);

		// 电机
		pt = Pos + Z * H1;
		pt -= X * F * .5;
		pSolid = drawCylinder(-X * F, pt, F * .25);
		if (pSolid) ar3d.append(pSolid);

		// 摇杆轴
		pt = Pos + Z * H1;
		pt += X * F * .5;
		pSolid = drawCylinder(X * F * .5, pt, F * .125);
		if (pSolid) ar3d.append(pSolid);

		// 摇杆
		pt = Pos + Z * H1;
		pt += X * F * .75;
		pSolid = drawCylinder(-Z * 200, pt, 5);
		if (pSolid) ar3d.append(pSolid);

		pt -= Z * 200;
		pSolid = (AcDb3dSolid*)GiDrawUtility::DrawSphere(pt, 10);
		if (pSolid) ar3d.append(pSolid);

		// 天线
		double seta(PI / 6);
		AcGeVector3d vt(X);
		vt.rotateBy(seta, -Y);
		vt.normalize();
		double dl((D * .5) / cos(seta));
		pt = Pos + Z * (H1 + F * .5);
		pt += X * F * .5;
		pSolid = drawCylinder(vt * dl, pt, 5);
		if (pSolid) ar3d.append(pSolid);

		AcGeMatrix3d mat;
		mat.setToRotation(PI / 3, Z, Pos);

		for (size_t i = 1; i < 6; ++i)
		{
			pSolid = (AcDb3dSolid*)pSolid->clone();
			pSolid->transformBy(mat);
			if (pSolid) ar3d.append(pSolid);
		}

		// 手盘
		double dr((dl * .5 * cos(seta)) + F * .5);
		pt = Pos + Z * (H1 + F * .5 + dl * .5 * sin(seta));
		pSolid = drawTorus(pt, Z, dr + 2.5, dr - 2.5);
		if (pSolid) ar3d.append(pSolid);

		// 螺杆
		pSolid = drawCylinder(-Z * LL, Pos, M * .5);
		if (pSolid) ar3d.append(pSolid);
	}
	void QS_I_L::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
#pragma endregion

#pragma region QS_II_L
	void QS_II_L::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double H, M, L3, L, G, F, LL;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(F);
		GETXDATA(G);
		GETXDATA(M);
		GETXDATA(L3);
		GETXDATA(L);
		GETXDATA(LL);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(QS - II - L);

		L *= .5;

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();


		AcDb3dSolid *pSolid = drawBox(Pos + X * L3 * .5, Z * G, X, L3 + 2 * L, F);
		if (pSolid) ar3d.append(pSolid);

		Pos += Z * G;
		QS_II_Y::drawQBJ(Pos, Dir, H, M, L, ar3d);
		QS_II_Y::drawQBJ(Pos + X * L3, Dir, H, M, L, ar3d);
		AcGePoint3d pt(Pos + Z * H);
		pSolid = drawCylinder(X * L3, pt, M * .5);
		if (pSolid) ar3d.append(pSolid);

		double dL((L3 - 2 * L) / 3);
		pt = Pos + X * L;
		pt += X * dL * .5;
		pSolid = drawBox(pt, Z * (H + 150), X, dL, F);
		if (pSolid) ar3d.append(pSolid);
		// 螺杆
		pSolid = drawCylinder(-Z * LL, Pos, M * .5);
		if (pSolid) ar3d.append(pSolid);
		pSolid = drawCylinder(-Z * LL, Pos + X * L3, M * .5);
		if (pSolid) ar3d.append(pSolid);
	}
	void QS_II_L::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
#pragma endregion

#pragma region QS_II_Y
	void QS_II_Y::draw3d(AcDbVoidPtrArray &ar3d)
	{
		if (!m_pXDataMap) return;

		BOOL bRel(FALSE);

		double H, M, L3, L, LL;

		AcGePoint3d Pos;
		AcGeVector3d Dir;

		GETXDATA(H);
		GETXDATA(M);
		GETXDATA(L3);
		GETXDATA(L);
		GETXDATA(LL);

		GETXDATA(Pos);
		GETXDATA(Dir);

		TESTXDATA(QS - II - Y);

		L *= .5;

		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		drawQBJ(Pos, Dir, H, M, L, ar3d);
		drawQBJ(Pos + X * L3, Dir, H, M, L, ar3d);

		AcGePoint3d pt(Pos + Z * H);
		AcDb3dSolid *pSolid = drawCylinder(X * L3, pt, M * .5);
		if (pSolid) ar3d.append(pSolid);

		double H1(300);
		double L1(450);
		// 摇柄
		double dl(20);
		pt = Pos + Z * H;
		pt += X * (L3 + L);
		pSolid = drawCylinder(X * dl, pt - Z * 5, 5);
		if (pSolid) ar3d.append(pSolid);
		pt += X * dl;
		pSolid = drawCylinder(-Z * (H1 + 5), pt, 5);
		if (pSolid) ar3d.append(pSolid);
		pt -= Z * H1;
		pSolid = drawCylinder(X * (L1 - L - dl), pt, 5);
		if (pSolid) ar3d.append(pSolid);
		// 螺杆
		pSolid = drawCylinder(-Z * LL, Pos, M * .5);
		if (pSolid) ar3d.append(pSolid);
		pSolid = drawCylinder(-Z * LL, Pos + X * L3, M * .5);
		if (pSolid) ar3d.append(pSolid);
	}
	void QS_II_Y::draw2d(AcDbVoidPtrArray &ar2d) { draw3d(ar2d); }
	void QS_II_Y::drawQBJ(const AcGePoint3d & Pos
		, const AcGeVector3d &Dir
		, const double &H
		, const double &M
		, const double &L
		, AcDbVoidPtrArray &ar3d)
	{
		AcGeVector3d X(Dir), Z(AcGeVector3d::kZAxis);
		AcGeVector3d Y = Z.crossProduct(X);
		X.normalize();
		Y.normalize();
		Z.normalize();

		AcGePoint3d pt;

		double dHPan(200);
		AcDb3dSolid *pSolid = (AcDb3dSolid*)GiDrawUtility::DrawCone(Pos, Z, L * .5, L, H - dHPan * .5, .0);
		if (pSolid) ar3d.append(pSolid);

		pSolid = drawCylinder(Z * dHPan, Pos + Z * (H - dHPan * .5), L);
		if (pSolid) ar3d.append(pSolid);

		pSolid = (AcDb3dSolid*)GiDrawUtility::DrawCone(Pos + Z * (H + dHPan * .5), Z, L * .5, L, 50, .0);
		if (pSolid) ar3d.append(pSolid);

		pt = Pos + Z * (H + dHPan * .5 + 50);
		pSolid = drawCylinder(Z * 500, pt, M * .5);
		if (pSolid) ar3d.append(pSolid);
	}
#pragma endregion

}

void CParamEquImplBase::transformBy(const AcGeMatrix3d & xform)
{
	// 只移动X Y
	if (!m_pXDataMap) return;
	AcGePoint3d pt;
	if (m_pXDataMap->GetAt(_T("Pos"), pt))
	{
		double z = pt.z;
		pt.transformBy(xform);
		//pt.z = z;
		m_pXDataMap->SetAt(_T("Pos"), pt);
	}
	
}

void CParamEquImplBase::setElev(const double &dElev)
{
	if (m_pXDataMap)
	{
		AcGePoint3d pt;
		if (m_pXDataMap->GetAt(_T("Pos"), pt))
		{
			pt.z = dElev;
			m_pXDataMap->SetAt(_T("Pos"), pt);
		}
	}
}

AcGePoint3d CParamEquImplBase::getPos()
{
	if (m_pXDataMap)
	{
		AcGePoint3d pt;
		if (m_pXDataMap->GetAt(_T("Pos"), pt))
		{
			return pt;
		}
	}
	return AcGePoint3d::kOrigin;
}

AcGeVector3d CParamEquImplBase::getDir()
{
	if (m_pXDataMap)
	{
		AcGeVector3d vt;
		if (m_pXDataMap->GetAt(_T("Dir"), vt))
		{
			return vt;
		}
	}
	return AcGeVector3d::kIdentity;
}