1014 lines
23 KiB
C++
1014 lines
23 KiB
C++
#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);
|
|
}
|