envi-code/SourceCode/Code2026/CoreLibrary/AecDbWeir.cpp

#include "stdafx.h"
#include "AecDbWeir.h"
#include <map>
#include "acdbx3dsolid.h"
#include "AecDbX3dPart.h"
#include "CoreTools.h"

namespace
{
	Acad::ErrorStatus moveTo(AcDbEntity *pEnt, const AcGeVector3d &vt, const double &dist)
	{
		AcGeVector3d v(vt);
		v.normalize();
		v *= dist;
		AcGeMatrix3d mat;
		mat.setToTranslation(v);
		return pEnt->transformBy(mat);
	}

	CString getSolidTypeName(const AcDbX3dSolid::Primitive &type)
	{
		switch (type)
		{
		case AcDbX3dSolid::kExtrude2:
			return _T("拉伸体");
		case AcDbX3dSolid::kRevolve2:
			return _T("旋转体");
		case AcDbX3dSolid::kLoft:
			return _T("放样体");
		case AcDbX3dSolid::kSweep:
			return _T("扫掠体");
		case AcDbX3dSolid::kCone:
			return _T("圆台体");
		case AcDbX3dSolid::kSpere:
			return _T("球体");
		default:
			return _T("未知形状");
		}
		return _T("");
	}

	void transfromRegion(AcDbRegion *pRegion
		, const AcGePoint3d &ptOnRegion
		, const AcGeVector3d &vtNormal
		, const AcGePoint3d &ptOnPlan)
	{
		AcGePlane plan;
		plan.set(ptOnPlan, vtNormal);
		AcGePoint3d pt0, pt1, pt2;
		plan.get(pt0, pt1, pt2);

		AcGeMatrix3d xform;
		xform.setToPlaneToWorld(plan);

		// 把region转到此面上
		pRegion->transformBy(xform);

		// 把 region 上的点也转到面上
		AcGePoint3d pt(ptOnRegion);
		pt.transformBy(xform);

		// 再把region在面上平移
		xform.setToIdentity();
		xform.setToTranslation(ptOnPlan - pt);
		pRegion->transformBy(xform);
	}
}

ACRX_DXF_DEFINE_MEMBERS(AecDbWeir, AecDbBDPipeBase,
	AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
	AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
	AEC_DBWEIR,
	"AecDbWeir"
	"|Product Desc:     shanghua earthworm app obj"
	"|Company:          shanghua inc"
	"|WEB Address:      www.shanghuasoft.com")

	Adesk::UInt32 AecDbWeir::kCurrentVersionNumber = 1;

IMP_XDATA_KEY(AecDbWeir, _START_PT_);
IMP_XDATA_KEY(AecDbWeir, _END_PT_);
IMP_XDATA_KEY(AecDbWeir, _W_);
IMP_XDATA_KEY(AecDbWeir, _H_);
IMP_XDATA_KEY(AecDbWeir, _T_);
IMP_XDATA_KEY(AecDbWeir, _TYPE_);
IMP_XDATA_KEY(AecDbWeir, _NORMAL_);
IMP_XDATA_KEY(AecDbWeir, _RADIUS_);
IMP_XDATA_KEY(AecDbWeir, _ANGLE_);
IMP_XDATA_KEY(AecDbWeir, _HEAD_SPACING_C_);
IMP_XDATA_KEY(AecDbWeir, _TAIL_SPACING_C_);
IMP_XDATA_KEY(AecDbWeir, _HEAD_SPACING_T_);
IMP_XDATA_KEY(AecDbWeir, _TAIL_SPACING_T_);
IMP_XDATA_KEY(AecDbWeir, _WEIR_H_1);
IMP_XDATA_KEY(AecDbWeir, _SPACING_1);
IMP_XDATA_KEY(AecDbWeir, _WEIR_H_2);
IMP_XDATA_KEY(AecDbWeir, _SPACING_2);
IMP_XDATA_KEY(AecDbWeir, _WALL_MODE_);
IMP_XDATA_KEY(AecDbWeir, _HOLE_MODE_);

IMP_XDATA_KEY(AecDbWeir, _HAS_BOTTOM_HOLE_);
IMP_XDATA_KEY(AecDbWeir, _BOTTOM_HEAD_);
IMP_XDATA_KEY(AecDbWeir, _BOTTOM_TAIL_);
IMP_XDATA_KEY(AecDbWeir, _BOTTOM_R_);
IMP_XDATA_KEY(AecDbWeir, _BOTTOM_SPACE_);
IMP_XDATA_KEY(AecDbWeir, _HAS_BOTTOM_);

AecDbWeir::AecDbWeir()
{
	SetWidth(100.);
	SetHeight(100.);
	SetThick(5.);
	SetType(eCircle);
	SetStartPt(AcGePoint3d::kOrigin);
	SetEndPt(AcGePoint3d(100., 0., 0.));
	SetNormal(AcGeVector3d::kZAxis);

	SetRadius(25.);
	SetAngle(PI * .5);

	SetHeadSpaC(100);
	SetTailSpaC(0.);

	SetSpacingC(150.);
	SetWeirHC(25.);

	SetHeadSpaT(0.);
	SetTailSpaT(0.);

	SetSpacingT(150.);
	SetWeirHT(50.);

	m_mapSpecXData.SetAt(KEY_NAME, _T("集水槽"));
}

AecDbWeir::~AecDbWeir() { }

void AecDbWeir::subList() const
{
	assertReadEnabled();
	AecDbBDPipeBase::subList();

	Type tt = (Type)GetType();
	CString str(_T("圆孔"));
	if (tt == eTriangle)
		str = _T("三角");
	else if (tt == eCAndT)
		str = _T("三角&圆孔");

	acutPrintf(_T("\n槽类型：%s"), str);
	acutPrintf(_T("\n槽宽：%.1f mm"), GetWidth());
	acutPrintf(_T("\n槽高：%.1f mm"), GetHeight());
	acutPrintf(_T("\n槽板厚：%.1f mm"), GetThick());
	acutPrintf(_T("\n槽长:%.1f mm"), GetStartPt().distanceTo(GetEndPt()));

	AcGeVector3d v(GetNormal());
	acutPrintf(_T("\n法向：(%.3f,%.3f,%.3f)"), v.x, v.y, v.z);

	AcGePoint3d pt(GetStartPt());
	acutPrintf(_T("\n起点：(%.3f,%.3f,%.3f)"), pt.x, pt.y, pt.z);

	pt = GetEndPt();
	acutPrintf(_T("\n终点：(%.3f,%.3f,%.3f)"), pt.x, pt.y, pt.z);

	if (tt == eCircle || tt == eCAndT)
	{
		acutPrintf(_T("圆孔径：%.1f mm"), GetRadius());
		acutPrintf(_T("圆孔距：%.1f mm"), GetSpacingC());
		acutPrintf(_T("圆孔距顶面高：%.1f mm"), GetWeirHC());
		acutPrintf(_T("圆孔头部安装距离：%.1f mm"), GetHeadSpaC());
		acutPrintf(_T("圆孔尾部安装距离：%.1f mm"), GetTailSpaC());
	}
	else if (tt == eTriangle || tt == eCAndT)
	{

		acutPrintf(_T("三角角度：%.1f mm"), GetRadius());
		acutPrintf(_T("三角距：%.1f mm"), GetSpacingT());
		acutPrintf(_T("三角距顶面高：%.1f mm"), GetWeirHT());
		acutPrintf(_T("三角头部安装距离：%.1f mm"), GetHeadSpaT());
		acutPrintf(_T("三角尾部安装距离：%.1f mm"), GetTailSpaT());
	}
}

Acad::ErrorStatus AecDbWeir::copyFrom(const AcRxObject * pSrc)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbWeir::subTransformBy(const AcGeMatrix3d & xform)
{
	return AecDbBDPipeBase::subTransformBy(xform);
}

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

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEwPipeBase::dwgInFields(pFiler);
	if (es != Acad::eOk)
		return (es);

	int nParentVersion(-1);
	if (m_mapSpecXData.GetAt(_T("&FOR&WEIR&"), nParentVersion))
	{
		AecDbBDPipeBase::_dwgInFields_for_DBWeir(pFiler);
	}

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

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

	return Acad::eOk;
}

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

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEwPipeBase::dwgOutFields(pFiler);
	if (es != Acad::eOk)
		return (es);

	AecDbBDPipeBase::_dwgOutFields_for_DBWeir(pFiler);

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

	return Acad::eOk;
}

Acad::ErrorStatus AecDbWeir::dxfInFields(AcDbDxfFiler * pFiler)
{
	return AecDbBDPipeBase::dxfInFields(pFiler);
}

Acad::ErrorStatus AecDbWeir::dxfOutFields(AcDbDxfFiler * pFiler) const
{
	return AecDbBDPipeBase::dxfOutFields(pFiler);
}

void AecDbWeir::GetGripText(int nPos, CString & sText)
{
	switch (nPos)
	{
	case 0:
		sText = _T("移动起点");
		break;
	case 1:
		sText = _T("平移");
		break;
	case 2:
		sText = _T("移动终点");
	default:
		break;
	}
}

Acad::ErrorStatus AecDbWeir::subGetGripPoints(AcDbGripDataPtrArray & grips
	, const double curViewUnitSize
	, const int gripSize
	, const AcGeVector3d & curViewDir
	, const int bitflags) const
{
	//return Acad::eNotImplementedYet;
	return AecDbBDPipeBase::subGetGripPoints(grips,curViewUnitSize,gripSize,curViewDir,bitflags);
}

Acad::ErrorStatus AecDbWeir::subGetGripPoints(AcGePoint3dArray & gripPoints, AcDbIntArray & osnapModes, AcDbIntArray & geomIds) const
{
	return AecDbBDPipeBase::subGetGripPoints(gripPoints, osnapModes,	geomIds);
}

Acad::ErrorStatus AecDbWeir::subMoveGripPointsAt(const AcDbIntArray & indices, const AcGeVector3d & offset)
{
	AssertWriteEnabled();

	return AecDbBDPipeBase::subMoveGripPointsAt(indices,offset);

	AcGeMatrix3d mat;
	mat.setToTranslation(offset);
	subTransformBy(mat);
	return Acad::eOk;
}

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

	if (dc.IsDragging())
		return Acad::eOk;

	int clr(256), oldclr;
	m_mapSpecXData.GetAt(_T("COLOR"), clr);
	oldclr = dc.GetColor();
	dc.SetColor(clr);

	if (Has2DBuffer())
	{
		AcDbEntity *pEnt = NULL;
		for (int i = 0; i < Get2DBuffer().length(); ++i)
		{
			pEnt = (AcDbEntity *)Get2DBuffer()[i];
			pEnt->setLayer(dc.GetLayerId());
			dc.DrawEntity(*pEnt);
		}

		return Acad::eOk;
	}

	Type type((Type)GetType());
	if (type == eNone)
	{
		AecDbBDPipeBase::Draw2d(dc);
		return Acad::eOk;
	}

	AcDbCurve *pCurve = GetNativeCurve();
	if (pCurve->isA() != AcDbPolyline::desc()) return Acad::eInvalidInput;
	AcDbPolyline *pPoly = (AcDbPolyline *)pCurve;

	AcGePoint3d pt1, pt2, pt3, pt4;
	double w(GetWidth()), t(GetThick());
	wallMode wm = (wallMode)GetWallMode();
	AcDbVoidPtrArray ar;
	Acad::ErrorStatus es;

	// 只要有底板，左右边线就要画
	if (GetHasBottom())
	{
		// 左边线
		es = pPoly->getOffsetCurves(-w * .5, ar);
		if (!ar.isEmpty())
		{
			AcDbPolyline *p((AcDbPolyline *)ar.first());
			p->setColorIndex(clr);
			dc.DrawPolyline(*p);
			Add2DBuffer(p);
			p->getStartPoint(pt3);
			p->getEndPoint(pt4);
			ar.removeFirst();
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);

		// 右边线
		es = pPoly->getOffsetCurves(w * .5, ar);
		if (!ar.isEmpty())
		{
			AcDbPolyline *p((AcDbPolyline *)ar.first());
			p->setColorIndex(clr);
			dc.DrawPolyline(*p);
			Add2DBuffer(p);
			p->getStartPoint(pt1);
			p->getEndPoint(pt2);
			ar.removeFirst();
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);
	}

	// 左边厚度线
	if ((wm == eWallAll || wm == eWallLeft) && GetHasBottom())
	{
		es = pPoly->getOffsetCurves(-w * .5 + t, ar);
		if (!ar.isEmpty())
		{
			AcDbPolyline *p((AcDbPolyline *)ar.first());
			p->setColorIndex(1);
			dc.DrawPolyline(*p);
			Add2DBuffer(p);
			ar.removeFirst();
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);
	}

	// 右边厚度线
	if ((wm == eWallAll || wm == eWallRight) && GetHasBottom())
	{
		es = pPoly->getOffsetCurves(w * .5 - t, ar);
		if (!ar.isEmpty())
		{
			AcDbPolyline *p((AcDbPolyline *)ar.first());
			p->setColorIndex(clr);
			dc.DrawPolyline(*p);
			Add2DBuffer(p);
			ar.removeFirst();
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);
	}

	// 没有底板，画中心线，带厚度
	if (!GetHasBottom())
	{
		es = pPoly->getOffsetCurves(t * .5, ar);
		if (!ar.isEmpty())
		{
			AcDbPolyline *p((AcDbPolyline *)ar.first());
			p->setColorIndex(clr);
			dc.DrawPolyline(*p);
			Add2DBuffer(p);
			p->getStartPoint(pt1);
			p->getEndPoint(pt2);
			ar.removeFirst();
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);

		es = pPoly->getOffsetCurves(-t * .5, ar);
		if (!ar.isEmpty())
		{
			AcDbPolyline *p((AcDbPolyline *)ar.first());
			p->setColorIndex(clr);
			dc.DrawPolyline(*p);
			Add2DBuffer(p);
			p->getStartPoint(pt3);
			p->getEndPoint(pt4);
			ar.removeFirst();
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);
	}


	AcDbLine *pL1 = new AcDbLine(pt1, pt3);
	AcDbLine *pL2 = new AcDbLine(pt2, pt4);
	dc.DrawEntity(pL1);
	dc.DrawEntity(pL2);


	Add2DBuffer(pL1);
	Add2DBuffer(pL2);

	if (GetHasBottomHole() == 0 && GetHasBottom())
	{
		double r(GetBottomR());
		double space(GetBottomSpace())
			, headSpc(GetBottomHead())
			, tailSpc(GetBottomTail())
			, dEndPara(.0)
			, dLen(.0);
		AcDbCurve *pCurve = GetNativeCurve();
		pCurve->getEndParam(dEndPara);
		pCurve->getDistAtParam(dEndPara, dLen);
		dLen -= (headSpc + tailSpc);
		AcGePoint3d ptFst(AcGePoint3d::kOrigin);
		pCurve->getPointAtDist(headSpc, ptFst);

		double diameter = 2 * r, dist(dLen);
		AcGePoint3d ptS(ptFst), ptCen(AcGePoint3d::kOrigin);
		while (UPEQUAL(dist, diameter))
		{
			double d(.0);
			pCurve->getDistAtPoint(ptS, d);
			d += r;
			pCurve->getPointAtDist(d, ptCen);

			AcDbCircle *pCir = new AcDbCircle(ptCen, AcGeVector3d::kZAxis, r);
			dc.DrawEntity(*pCir);
			Add2DBuffer(pCir);

			d += (space - r);
			pCurve->getPointAtDist(d, ptS);
			dist -= space;
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbWeir::Draw3d(AcGiDraw & dc) const
{
	if (dc.IsDragging())
		return Acad::eOk;
	return AecDbBDPipeBase::Draw3d(dc);
}

AcDbLine* AecDbWeir::GetSubSolidPath(const AcGePoint3d &pt, const AcGeVector3d vt) const
{
	AcGeVector3d vtLeft(vt), vtRight(vt);
	vtLeft.rotateBy(PI * .5, AcGeVector3d::kZAxis);
	vtRight.rotateBy(-PI * .5, AcGeVector3d::kZAxis);
	vtLeft.normalize();
	vtRight.normalize();
	double dL(2 * GetWidth() * 1.1);
	int holeMode = GetHoleMode();
	if (holeMode == eHoleLeft)
	{
		vtLeft *= dL;
		return new AcDbLine(pt + vtRight * GetThick() , pt + vtLeft);
	}
	else if (holeMode == eHoleRight)
	{
		vtRight *= dL;
		return new AcDbLine(pt + vtLeft * GetThick(), pt + vtRight);
	}
	else
	{
		vtLeft *= dL;
		vtRight *= dL;
		return new AcDbLine(pt + vtLeft, pt + vtRight);
	}
	return NULL;
}

void AecDbWeir::setWeirSection()
{
	double w(GetWidth()), h(GetHeight()), t(GetThick());

	if (w < t)
		w = t;

	int iHasBottom(1);
	GetSpecialtyData()->GetAt(_HAS_BOTTOM_, iHasBottom);

	AcGeVector3d vtX(AcGeVector3d::kXAxis);
	AcGeVector3d vtY(AcGeVector3d::kYAxis);
	AcGePoint3d ptO(AcGePoint3d::kOrigin);

	AcDbPolyline *pl = new AcDbPolyline;

	int wallMode = GetWallMode();
	if (wallMode == eWallAll && iHasBottom)
	{
		/*
		 pt7 _ pt6    pt3 _	pt2
			| |		     | |
			| |		     | |
			| |pt5    pt4| |
			| |__________| |
			|______________|
		   pt0		O		pt1

			O - 原点
			pt0->pt1 w
			pt1->pt2 h
			pt2->pt3 t
		*/
		AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7;

		pt0 = ptO - vtX * (.5 * w);
		pt1 = pt0 + vtX * w;
		pt2 = pt1 + vtY * h;
		pt3 = pt2 - vtX * t;
		pt4 = pt3 - vtY * (h - t);
		pt5 = pt4 - vtX * (w - 2 * t);
		pt6 = pt5 + vtY * (h - t);
		pt7 = pt6 - vtX * t;

		pl->addVertexAt(0, pt0.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(1, pt1.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(2, pt2.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(3, pt3.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(4, pt4.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(5, pt5.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(6, pt6.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(7, pt7.convert2d(AcGePlane::kXYPlane));
		pl->setClosed(true);
	}
	else if (wallMode == eWallRight && iHasBottom)
	{
		/*
		 pt3 _ pt2
			| |
			| |
			| |pt1
			| |______ pt0
			|_______|
		  pt4		O

			O - 原点
			pt3->pt4 h
			pt3->pt2 t
			ptO->pt4 w
		*/
		AcGePoint3d pt0, pt1, pt2, pt3, pt4;
		pt0 = ptO + vtY * t;
		pt1 = pt0 - vtX * (w - t);
		pt2 = pt1 + vtY * (h - t);
		pt3 = pt2 - vtX * t;
		pt4 = pt3 - vtY * h;

		pl->addVertexAt(0, ptO.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(1, pt0.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(2, pt1.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(3, pt2.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(4, pt3.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(5, pt4.convert2d(AcGePlane::kXYPlane));
		pl->setClosed(true);
		AcGeMatrix3d mat;
		mat.setToTranslation(AcGeVector3d::kXAxis * w * .5);
		pl->transformBy(mat);
	}
	else if (wallMode == eWallLeft && iHasBottom)
	{
		/*
				  pt2 _	pt1
					 | |
					 | |
				  pt3| |
			pt4 _____| |
				|______|
				O		pt0

			O - 原点
			pt0->pt1 h
			pt1->pt2 t
			ptO->pt0 w
		*/
		AcGePoint3d pt0, pt1, pt2, pt3, pt4;
		pt0 = ptO + vtX * w;
		pt1 = pt0 + vtY * h;
		pt2 = pt1 - vtX * t;
		pt3 = pt2 - vtY * (h - t);
		pt4 = pt3 - vtX * (w - t);

		pl->addVertexAt(0, ptO.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(1, pt0.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(2, pt1.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(3, pt2.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(4, pt3.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(5, pt4.convert2d(AcGePlane::kXYPlane));
		pl->setClosed(true);
		AcGeMatrix3d mat;
		mat.setToTranslation(-AcGeVector3d::kXAxis * w * .5);
		pl->transformBy(mat);
	}
	else if (iHasBottom == 0 && wallMode != eWallAll)
	{
		/*
		       pt2   pt1
                .___.
                |   |
                |   |
                |   |
                |   |
                |   |
                |___|
			  pt3 O  pt0
		*/
		AcGePoint3d pt0, pt1, pt2, pt3;
		pt0 = ptO + vtX * (.5 * t);
		pt1 = pt0 + vtY * h;
		pt2 = pt1 - vtX * t; 
		pt3 = pt2 - vtY * h;
		pl->addVertexAt(0, pt0.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(1, pt1.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(2, pt2.convert2d(AcGePlane::kXYPlane));
		pl->addVertexAt(3, pt3.convert2d(AcGePlane::kXYPlane));
		pl->setClosed(true);
	}

	AcDbRegion *pReg = CoreTools::createRegion(pl);
	DELETE_PTR(pl);
	if (pReg)
	{
		SetSection(pReg, AcGePoint3d::kOrigin);
		DELETE_PTR(pReg);
	}

	return;
}

double AecDbWeir::getHeadSpace() const
{
	Type type = (Type)GetType();
	if (type == eCircle)
	{
		return GetHeadSpaC();
	}
	else if (type == eTriangle)
	{
		return GetHeadSpaT();
	}
	else
		return 0.0;
}

double AecDbWeir::getSpace() const
{
	Type type = (Type)GetType();
	if (type == eCircle)
	{
		return GetSpacingC();
	}
	else if (type == eTriangle)
	{
		return GetSpacingT();
	}
	else
		return 0.0;
}

double AecDbWeir::getWeirH() const
{
	Type type = (Type)GetType();
	if (type == eCircle)
	{
		return GetWeirHC();
	}
	else if (type == eTriangle)
	{
		return GetWeirHT();
	}
	else
		return 0.0;
}

double AecDbWeir::getTailSpace() const
{
	Type type = (Type)GetType();
	if (type == eCircle)
	{
		return GetTailSpaC();
	}
	else if (type == eTriangle)
	{
		return GetTailSpaT();
	}
	else
		return 0.0;
}

double AecDbWeir::GetWidth() const
{
	assertReadEnabled();
	double v;
	m_mapSpecXData.GetAt(_W_, v);
	if (CoreTools::getFlume2DStyle() == 1)
		v += 2 * GetThick();
	return v;
}

double AecDbWeir::GetHeight() const
{
	assertReadEnabled();
	double v;
	m_mapSpecXData.GetAt(_H_, v);
	if (CoreTools::getFlume2DStyle() == 1)
		v += GetThick();
	return v;
}

bool AecDbWeir::SetWidth(const double &v)
{
	AssertWriteEnabled();
	return m_mapSpecXData.SetAt(_W_, v) == TRUE ? true : false;
}

bool AecDbWeir::SetHeight(const double &v)
{
	AssertWriteEnabled();
	return m_mapSpecXData.SetAt(_H_, v) == TRUE ? true : false;
}

bool AecDbWeir::GetSrcString(CString &src)
{
	assertReadEnabled();
	return m_mapSpecXData.GetAt(_T("_SRC_STRING_"), src) == 0 ? false : true;
}

void AecDbWeir::SetSrcString(LPCTSTR src)
{
	assertWriteEnabled();
	if (src && !CString(src).IsEmpty())
		m_mapSpecXData.SetAt(_T("_SRC_STRING_"), src);
}

SHJson::WValue& AecDbWeir::ToJson(bool bExprotGeo) const
{
	using namespace SHJson;
	return AecDbBDPipeBase::ToJson();
}

bool AecDbWeir::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbBDPipeBase::ByJson(v);
}

double AecDbWeir::getElevation()
{
	assertReadEnabled();
	double dElev(.0);
	AcDbCurve *pCurve = GetNativeCurve();
	if (!pCurve) return dElev;
	return ((AcDbPolyline*)pCurve)->elevation();
}

bool AecDbWeir::setElevation(const double &dEle)
{
	AssertWriteEnabled();
	bool bRel(false);
	AcDbCurve *pCurve = GetNativeCurve();
	if (!pCurve) return bRel;
	((AcDbPolyline*)pCurve)->setElevation(dEle);
	return true;
}

void AecDbWeir::makeX3DSolids()
{
	RemoveAllX3dPart();

	Type type((Type)GetType());

	AcDbCurve *pCurve = GetNativeCurve();
	double dEndPara(.0), dLen(.0);
	pCurve->getEndParam(dEndPara);
	pCurve->getDistAtParam(dEndPara, dLen);
	double headSpc(getHeadSpace()), weirH(getWeirH())
		, space(getSpace()), tailSpc(getTailSpace())
		, dH(GetHeight()), dW(GetWidth());
	dLen -= (headSpc + tailSpc);
	AcGePoint3d ptFst(AcGePoint3d::kOrigin);
	pCurve->getPointAtDist(headSpc, ptFst);

	if (dLen < 0)
	{
		acutPrintf(_T("\n路径长度小于头部距离。"));
		return;
	}

	int iHasBottom(1);
	GetSpecialtyData()->GetAt(_HAS_BOTTOM_, iHasBottom);

	std::vector<AcDbX3dSolid*> ss;
	if (type == eTriangle)
	{
		double dist(dLen);
		double angle = GetAngle();
		double dL = 2 * tan(.5 * angle) * weirH;
		AcGePoint3d ptS(ptFst), ptE(AcGePoint3d::kOrigin)
			, pt1(AcGePoint3d::kOrigin), pt2(AcGePoint3d::kOrigin)
			, pt3(AcGePoint3d::kOrigin);

		while (UPEQUAL(dist, dL))
		{
			double d(.0);
			pCurve->getDistAtPoint(ptS, d);
			d += dL;
			pCurve->getPointAtDist(d, ptE);
			// make solid
			pt1 = ptS;
			pt2 = ptE;
			pt3 = CoreTools::MidPt(pt1, pt2);
			pt1.z += dH;
			pt2.z += dH;
			pt3.z += dH - weirH;

			AcDbVoidPtrArray ar;
			ar.append(new AcDbLine(pt1, pt2));
			ar.append(new AcDbLine(pt2, pt3));
			ar.append(new AcDbLine(pt3, pt1));
			std::vector<AcDbPolyline*> polys;
			CoreTools::MakePolyline(ar, polys);
			deleteArrayVoidPtrs< AcDbEntity>(ar);

			if (!polys.empty())
			{
				AcDbRegion *pReg = CoreTools::createRegion(polys[0]);
				deleteContainerOfStd(polys);
				if (pReg)
				{
					AcDbLine *pLine = GetSubSolidPath(pt3, pt2 - pt1);
					if (pLine)
					{
						AcGeMatrix3d mat;
						mat.setToTranslation(pLine->startPoint() - pt3);
						pReg->transformBy(mat);
						AcDbX3dSolid *pSubSolid = new AcDbX3dSolid();
						if (!pSubSolid->CreateExtrude(pReg, *pLine))
							DELETE_PTR(pSubSolid);
						else
							ss.push_back(pSubSolid);
					}
					DELETE_PTR(pReg);
					DELETE_PTR(pLine);
				}
			}

			// end
			d += (space - dL);
			pCurve->getPointAtDist(d, ptS);
			dist -= space;
		}

	}
	else if (type == eCircle)
	{
		double radius = GetRadius();
		double diameter = 2 * radius;
		double dist(dLen);
		AcGePoint3d ptS(ptFst), ptCen(AcGePoint3d::kOrigin);
		AcGeVector3d vt1, vt2;
		while (UPEQUAL(dist, diameter))
		{
			double d(.0);
			pCurve->getDistAtPoint(ptS, d);
			d += radius;
			pCurve->getPointAtDist(d, ptCen);
			pCurve->getFirstDeriv(ptCen, vt1);
			vt2 = vt1;
			vt1.rotateBy(PI * .5, AcGeVector3d::kZAxis);
			ptCen.z += weirH;
			AcDbCircle *pCir = new AcDbCircle(ptCen, vt1, radius);
			AcDbRegion *pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (pReg)
			{
				AcDbLine *pLine = GetSubSolidPath(ptCen, vt2);
				if (pLine)
				{
					AcGeMatrix3d mat;
					mat.setToTranslation(pLine->startPoint() - ptCen);
					pReg->transformBy(mat);
					AcDbX3dSolid *pSubSolid = new AcDbX3dSolid();
					if (!pSubSolid->CreateExtrude(pReg, *pLine))
					{
						CoreTools::CloneAndAddToModelSpace(pReg);
						CoreTools::CloneAndAddToModelSpace(pLine);
						DELETE_PTR(pSubSolid);
					}
					else
						ss.push_back(pSubSolid);
				}
				DELETE_PTR(pReg);
				DELETE_PTR(pLine);
			}
			d += (space - radius);
			pCurve->getPointAtDist(d, ptS);
			dist -= space;
		}
	}

	// 底部是否开洞
	if (GetHasBottomHole() == 0 && iHasBottom)
	{
		double r(GetBottomR());
		space = GetBottomSpace();
		headSpc = GetBottomHead();
		tailSpc = GetBottomTail();
		pCurve->getEndParam(dEndPara);
		pCurve->getDistAtParam(dEndPara, dLen);
		dLen -= (headSpc + tailSpc);
		AcGePoint3d ptFst(AcGePoint3d::kOrigin);
		pCurve->getPointAtDist(headSpc, ptFst);

		double diameter = 2 * r, dist(dLen);
		AcGePoint3d ptS(ptFst), ptCen(AcGePoint3d::kOrigin);
		while (UPEQUAL(dist, diameter))
		{
			double d(.0);
			pCurve->getDistAtPoint(ptS, d);
			d += r;
			pCurve->getPointAtDist(d, ptCen);

			AcDbCircle *pCir = new AcDbCircle(ptCen, AcGeVector3d::kZAxis, r);
			AcDbRegion *pReg = CoreTools::createRegion(pCir);
			DELETE_PTR(pCir);
			if (pReg)
			{
				AcDbX3dSolid *pSubSolid = new AcDbX3dSolid();
				if (!pSubSolid->CreateExtrude(
					pReg
					, AcDbLine(ptCen, ptCen + AcGeVector3d::kZAxis * GetThick()))
					)
					DELETE_PTR(pSubSolid);
				else
					ss.push_back(pSubSolid);
				DELETE_PTR(pReg);
			}

			d += (space - r);
			pCurve->getPointAtDist(d, ptS);
			dist -= space;
		}
	}

	AcGeVector3d vtX = acdbCurDwg()->ucsxdir();
	AcGeVector3d vtY = acdbCurDwg()->ucsydir();
	AcGeVector3d vtZ = vtX.crossProduct(vtY);
	for (size_t i = 0; i < ss.size(); ++i)
	{
		AcDbX3dSolid *pXSolid(ss[i]);
		AecDbX3dPart *pPart = new AecDbX3dPart();
		AcDbX3dSolid::Primitive solidType = pXSolid->GetSolidType();
		pPart->GetSpecialtyData()->SetAt(_T("DTYG_TYPE"), getSolidTypeName(solidType));
		pPart->AddX3dSolid(pXSolid);
		pPart->SetName(_T("堰口"));
		pPart->SetOrgPoint(pXSolid->GetCentoridPoint());
		pPart->SetAxis(0, vtX);
		pPart->SetAxis(1, vtY);
		pPart->SetAxis(2, vtZ);
		AddX3dPart(pPart, AcDb::kBoolSubtract);
	}
}

#include "HlrCutOption.h"
void AecDbWeir::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
	, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
	, AcArray<AcDbEntity *> &output) const
{
	HlrCutOption::ProcessHlrResult(this
		, FALSE
		, .0
		, HlrCutOption::getHlrBLK_PARAEQU()
		, ar
		, preAr
		, output);
}