567 lines
14 KiB
C++
567 lines
14 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbRiverGroove.h"
|
|
#include "GiDrawUtility.h"
|
|
#include "CoreTools.h"
|
|
|
|
extern double PixelToWcs(int nPixel);
|
|
extern BOOL Is2DView();
|
|
extern AcGeVector3d GetUcsZvt();
|
|
extern void PushGripMessage(GripMessage&);
|
|
|
|
namespace
|
|
{
|
|
AcDbRegion* getSection(const double &w
|
|
, const double &h
|
|
, const AcGePoint3d &ptOrg
|
|
, const AcGeVector3d &vtNormal)
|
|
{
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Z(AcGeVector3d::kZAxis), vtN(vtNormal);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin), pt1(AcGePoint3d::kOrigin), pt2(AcGePoint3d::kOrigin), pt3(AcGePoint3d::kOrigin);
|
|
|
|
vtN.rotateBy(PI * .5, Z);
|
|
|
|
pt0 = ptOrg - vtN * (w * .5);
|
|
pt1 = pt0 + Z * h;
|
|
pt2 = pt1 + vtN * w;
|
|
pt3 = pt2 - Z * h;
|
|
|
|
AcDbVoidPtrArray arr;
|
|
arr.append(new AcDbLine(pt0, pt1));
|
|
arr.append(new AcDbLine(pt1, pt2));
|
|
arr.append(new AcDbLine(pt2, pt3));
|
|
arr.append(new AcDbLine(pt3, pt0));
|
|
|
|
AcDbRegion *pReg = CoreTools::createRegion(arr);
|
|
|
|
for (int i = 0; i < arr.length(); ++i)
|
|
DELETE_PTR(arr[i]);
|
|
arr.removeAll();
|
|
|
|
if (!pReg) return NULL;
|
|
|
|
return pReg;
|
|
}
|
|
|
|
AcDb3dSolid* makeSolid(const double &w1
|
|
, const double &h1
|
|
, const AcGePoint3d &pt1
|
|
, const double &w2
|
|
, const double &h2
|
|
, const AcGePoint3d &pt2
|
|
, const double &t
|
|
, const AcGeVector3d &vtN
|
|
, AcDbLine *pL
|
|
)
|
|
{
|
|
AcDbRegion *pReg1(NULL), *pReg2(NULL) // 内腔
|
|
, *pReg11(NULL), *pReg22(NULL); // 外腔
|
|
|
|
// 四个截面起点
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt11(pt1 - Z * t), pt22(pt2 - Z * t);
|
|
|
|
pReg1 = getSection(w1, h1, pt1, vtN);
|
|
pReg2 = getSection(w2, h2, pt2, vtN);
|
|
|
|
pReg11 = getSection(w1 + 2 * t, h1 + 2 * t, pt11, vtN);
|
|
pReg22 = getSection(w2 + 2 * t, h2 + 2 * t, pt22, vtN);
|
|
|
|
if (!pReg1 || !pReg2 || !pReg11 || !pReg22)
|
|
{
|
|
DELETE_PTR(pReg1);
|
|
DELETE_PTR(pReg2);
|
|
DELETE_PTR(pReg11);
|
|
DELETE_PTR(pReg22);
|
|
return NULL;
|
|
}
|
|
|
|
AcDb3dSolid *pSolid(NULL), *pSolid1(NULL);
|
|
|
|
pSolid = (AcDb3dSolid*)GiDrawUtility::DrawLoft(pReg1, pReg2, NULL);
|
|
pSolid1 = (AcDb3dSolid*)GiDrawUtility::DrawLoft(pReg11, pReg22, NULL);
|
|
|
|
DELETE_PTR(pReg1);
|
|
DELETE_PTR(pReg2);
|
|
DELETE_PTR(pReg11);
|
|
DELETE_PTR(pReg22);
|
|
|
|
if (pSolid && pSolid1 && pSolid1->booleanOper(AcDb::kBoolSubtract, pSolid) == Acad::eOk)
|
|
return pSolid1;
|
|
|
|
DELETE_PTR(pSolid);
|
|
DELETE_PTR(pSolid1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
AcDb3dSolid* makeLookupHold(const AcGePoint3d &pt0
|
|
, const AcGeVector3d &vt
|
|
, const double &len
|
|
, const double &D1
|
|
, const double &D2
|
|
, const double &T
|
|
, const double &h
|
|
, const double &b )
|
|
{
|
|
double dLong(len - b * .5 - T), dShort(len - b * .5);
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt1 = pt0 + vt * len;
|
|
AcGePoint3d pt2 = pt1 + Z * T;
|
|
AcGePoint3d pt3 = pt2 - vt * dShort;
|
|
AcGePoint3d pt4 = pt3 + Z * (h - 2 * T);
|
|
AcGePoint3d pt5 = pt4 - vt * b;
|
|
AcGePoint3d pt6 = pt5 - Z * (h - 2 * T);
|
|
AcGePoint3d pt7 = pt6 - vt * dShort;
|
|
AcGePoint3d pt8 = pt7 - Z * T;
|
|
AcGePoint3d pt9 = pt8 + vt * dLong;
|
|
AcGePoint3d pt10 = pt9 + Z * h;
|
|
AcGePoint3d pt11 = pt10 + vt * (b + 2 * T);
|
|
AcGePoint3d pt12 = pt11 - Z * h;
|
|
|
|
AcDbVoidPtrArray ar(0);
|
|
ar.append(new AcDbLine(pt1, pt2));
|
|
ar.append(new AcDbLine(pt2, pt3));
|
|
ar.append(new AcDbLine(pt3, pt4));
|
|
ar.append(new AcDbLine(pt4, pt5));
|
|
ar.append(new AcDbLine(pt5, pt6));
|
|
ar.append(new AcDbLine(pt6, pt7));
|
|
ar.append(new AcDbLine(pt7, pt8));
|
|
ar.append(new AcDbLine(pt8, pt9));
|
|
ar.append(new AcDbLine(pt9, pt10));
|
|
ar.append(new AcDbLine(pt10, pt11));
|
|
ar.append(new AcDbLine(pt11, pt12));
|
|
ar.append(new AcDbLine(pt12, pt1));
|
|
|
|
AcDbRegion *pReg = CoreTools::createRegion(ar);
|
|
|
|
#ifndef NDEBUG
|
|
if (!pReg)
|
|
{
|
|
for (int i = 0; i < ar.length(); ++i)
|
|
{
|
|
CoreTools::CloneAndAddToModelSpace((AcDbEntity*)ar[i], i+1);
|
|
}
|
|
}
|
|
#endif
|
|
deleteArrayVoidPtrs< AcDbEntity>(ar);
|
|
|
|
if (!pReg) return NULL;
|
|
|
|
AcGeVector3d v(vt);
|
|
v.rotateBy(-PI * .5, AcGeVector3d::kZAxis);
|
|
v.normalize();
|
|
v *= D1;
|
|
|
|
AcDb3dSolid *p = new AcDb3dSolid();
|
|
AcDbSweepOptions op;
|
|
if (p->createExtrudedSolid(pReg, v, op) != Acad::eOk)
|
|
{
|
|
DELETE_PTR(p);
|
|
DELETE_PTR(pReg);
|
|
return NULL;
|
|
}
|
|
DELETE_PTR(pReg);
|
|
|
|
// 开观察孔
|
|
v.normalize();
|
|
pt1 = pt0 + Z * h;
|
|
pt1 += v * D1 * .5;
|
|
AcDbCircle *pCir = new AcDbCircle(pt1, Z, D2 * .5);
|
|
pReg = CoreTools::createRegion(pCir);
|
|
DELETE_PTR(pCir);
|
|
if (!pReg) return p;
|
|
|
|
AcDb3dSolid *p2 = new AcDb3dSolid();
|
|
if (p2->createExtrudedSolid(pReg, Z * T, op) != Acad::eOk)
|
|
{
|
|
DELETE_PTR(p2);
|
|
DELETE_PTR(pReg);
|
|
return p;
|
|
}
|
|
if (p->booleanOper(AcDb::kBoolSubtract, p2) != Acad::eOk)
|
|
{
|
|
DELETE_PTR(p2);
|
|
DELETE_PTR(pReg);
|
|
return p;
|
|
}
|
|
|
|
DELETE_PTR(pReg);
|
|
return p;
|
|
}
|
|
|
|
}
|
|
|
|
Adesk::UInt32 AecDbRiverGroove::kCurrentVersionNumber = 1;
|
|
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _D_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _N_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _K_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _L1_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _L_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _L2_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _T_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _j_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _b_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _B1_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _B2_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _La_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _h_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _D1_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _D2_);
|
|
IMP_XDATA_KEY(AecDbRiverGroove, _X_);
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbRiverGroove, AecDbEwPipeBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_RIVERGROOVE,
|
|
"AecDbRiverGroove"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
|
|
AecDbRiverGroove::AecDbRiverGroove(void)
|
|
{
|
|
m_pGripAppData = new AecGripData[GRIP_LENGTH];
|
|
m_mapSpecXData.SetAt(KEY_NAME,_T("巴歇尔槽"));
|
|
}
|
|
|
|
AecDbRiverGroove::~AecDbRiverGroove(void)
|
|
{
|
|
DELETE_ARR_(m_pGripAppData);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEwPipeBase::dwgInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version(0);
|
|
if ((es = pFiler->readUInt32(&version)) != Acad::eOk)
|
|
return (es);
|
|
|
|
if (version > AecDbRiverGroove::kCurrentVersionNumber)
|
|
return Acad::eMakeMeProxy;
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::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);
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ((es = pFiler->writeUInt32(AecDbRiverGroove::kCurrentVersionNumber)) != Acad::eOk)
|
|
return (es);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::subExplode(AcDbVoidPtrArray& entitySet) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbRiverGroove::subList() const
|
|
{}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbRiverGroove::GetGripText(int nPos, CString& sText)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int clr(256), oldclr;
|
|
m_mapSpecXData.GetAt(_T("COLOR"), clr);
|
|
oldclr = dc.GetColor();
|
|
dc.SetColor(clr);
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
Draw2DBuffers(dc);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
double D(GetD()), B1(GetB1()), B2(GetB2()), b(Getb()), N(GetN()), K(GetK());
|
|
double L1(GetL1()), L(GetL()), L2(GetL2()), t(GetT());
|
|
double La(GetLa()), D1(GetD1()), D2(GetD2()), h(Geth());
|
|
|
|
AcDbCurve *pCurve = GetBaseCurve();
|
|
AcGePoint3d ptS(AcGePoint3d::kOrigin), ptE(AcGePoint3d::kOrigin);
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
ptS.z = ptE.z = .0;
|
|
AcGeVector3d vt(ptE - ptS), vtN(ptE - ptS);
|
|
vtN.rotateBy(PI * .5, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
vtN.normalize();
|
|
DELETE_PTR(pCurve);
|
|
|
|
AcGeVector2d vt2d(vtN.convert2d(AcGePlane::kXYPlane));
|
|
vt2d.normalize();
|
|
|
|
AcDbPolyline *pPoly = new AcDbPolyline();
|
|
|
|
if (CoreTools::getFlume2DStyle() == 1)
|
|
{
|
|
B1 += 2 * t;
|
|
b += 2 * t;
|
|
B2 += 2 * t;
|
|
}
|
|
AcGePoint3d pt(ptS);
|
|
AcGePoint3d pt0(pt + vtN * (B1 * .5));
|
|
AcGePoint3d pt7(pt - vtN * (B1 * .5));
|
|
pt += vt * L1;
|
|
AcGePoint3d pt1(pt + vtN * (b * .5));
|
|
AcGePoint3d pt6(pt - vtN * (b * .5));
|
|
pt += vt * L;
|
|
AcGePoint3d pt2(pt + vtN * (b * .5));
|
|
AcGePoint3d pt5(pt - vtN * (b * .5));
|
|
pt += vt * L2;
|
|
AcGePoint3d pt3(pt + vtN * (B2 * .5));
|
|
AcGePoint3d pt4(pt - vtN * (B2 * .5));
|
|
|
|
pPoly->addVertexAt(0, pt0.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(1, pt1.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(2, pt2.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(3, pt3.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(4, pt4.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(5, pt5.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(6, pt6.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->addVertexAt(7, pt7.convert2d(AcGePlane::kXYPlane));
|
|
pPoly->setClosed(true);
|
|
|
|
Add2DBuffer(pPoly);
|
|
|
|
Add2DBuffer(new AcDbLine(pt1, pt6));
|
|
Add2DBuffer(new AcDbLine(pt2, pt5));
|
|
|
|
if (!EQUAL_ZERO(La))
|
|
{
|
|
double tanA = ((B1 - b) * .5) / L1;
|
|
double l1 = ((B1 * .5) / tanA - L1 + La + D1 * .5) * tanA;
|
|
double l2 = ((B1 * .5) / tanA - L1 + La - D1 * .5) * tanA;
|
|
pt = ptS + vt * (L1 - La - D1 * .5);
|
|
Add2DBuffer(new AcDbLine(pt + vtN * l1, pt - vtN * l1));
|
|
pt = ptS + vt * (L1 - La + D1 * .5);
|
|
Add2DBuffer(new AcDbLine(pt + vtN * l2, pt - vtN * l2));
|
|
pt = ptS + vt * (L1 - La);
|
|
Add2DBuffer(new AcDbCircle(pt, AcGeVector3d::kZAxis, D2 * .5));
|
|
}
|
|
|
|
Draw2DBuffers(dc);
|
|
|
|
dc.SetColor(oldclr);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbRiverGroove::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int clr(256), oldclr;
|
|
m_mapSpecXData.GetAt(_T("COLOR"), clr);
|
|
oldclr = dc.GetColor();
|
|
dc.SetColor(clr);
|
|
|
|
if (Has3DBuffer())
|
|
{
|
|
Draw3DBuffers(dc);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 画四个主要部分，分别是 收缩段L1 喉道段L 扩散段L2 观察孔
|
|
// 两个次要部分 前固定板 后固定板
|
|
|
|
double D(GetD()), B1(GetB1()), B2(GetB2()), b(Getb()), N(GetN()), K(GetK());
|
|
double L1(GetL1()), L(GetL()), L2(GetL2()), t(GetT());
|
|
double La(GetLa()), D1(GetD1()), D2(GetD2()), h(Geth());
|
|
|
|
AcDbCurve *pCurve = GetBaseCurve();
|
|
AcGePoint3d ptS(AcGePoint3d::kOrigin), ptE(AcGePoint3d::kOrigin);
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
AcGeVector3d vt(ptE - ptS);
|
|
vt.normalize();
|
|
AcGeVector3d vtN(AcGeVector3d::kIdentity);
|
|
pCurve->getFirstDeriv(ptS, vtN);
|
|
vtN.normalize();
|
|
DELETE_PTR(pCurve);
|
|
|
|
// 四个截面起点
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(ptS), pt1(ptS + vt * L1), pt2(ptS + vt *(L1 + L)), pt3(ptS + vt *(L1 + L + L2));
|
|
pt2 -= Z * N;
|
|
pt3 -= Z * K;
|
|
|
|
AcDbLine line(ptS, ptE);
|
|
|
|
AcDb3dSolid *p = makeSolid(B1, D, pt0, b, D, pt1, t, vtN, &line);
|
|
if (p)
|
|
{
|
|
p->setTransparency(transparency());
|
|
Add3DBuffer(p);
|
|
}
|
|
|
|
p = makeSolid(b, D, pt1, b, D + N, pt2, t, vtN, &line);
|
|
if (p)
|
|
{
|
|
p->setTransparency(transparency());
|
|
Add3DBuffer(p);
|
|
}
|
|
|
|
p = makeSolid(b, D + N, pt2, B2, D + K, pt3, t, vtN, &line);
|
|
if (p)
|
|
{
|
|
p->setTransparency(transparency());
|
|
Add3DBuffer(p);
|
|
}
|
|
|
|
// 观察孔
|
|
// 通过 La 得到 宽度
|
|
if (!EQUAL_ZERO(La))
|
|
{
|
|
double len = ((La + D1 * .5) * B1) / (2 * L1);
|
|
ptS += Z * D;
|
|
pt0 = ptS + vt * (L1 - (La + D1 * .5));
|
|
vt.rotateBy(PI * .5, AcGeVector3d::kZAxis);
|
|
p = makeLookupHold(pt0, vt, len, D1, D2, t, h, b);
|
|
if (p)
|
|
{
|
|
p->setTransparency(transparency());
|
|
Add3DBuffer(p);
|
|
}
|
|
}
|
|
|
|
Draw3DBuffers(dc);
|
|
dc.SetColor(oldclr);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
bool AecDbRiverGroove::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
LPCTSTR AecDbRiverGroove::GetGripCmd() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void AecDbRiverGroove::SetDashLayer(AcDbObjectId& idLayer)
|
|
{
|
|
}
|
|
|
|
AcDbObjectId AecDbRiverGroove::GetDashLayer() const
|
|
{
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
|
|
void AecDbRiverGroove::SetCenterLayer(AcDbObjectId& idLayer)
|
|
{
|
|
|
|
}
|
|
|
|
AcDbObjectId AecDbRiverGroove::GetCenterLayer() const
|
|
{
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
|
|
bool AecDbRiverGroove::GetSrcString(CString &src)
|
|
{
|
|
assertReadEnabled();
|
|
return m_mapSpecXData.GetAt(_T("_SRC_STRING_"), src) == 0 ? false : true;
|
|
}
|
|
|
|
void AecDbRiverGroove::SetSrcString(LPCTSTR src)
|
|
{
|
|
assertWriteEnabled();
|
|
if (src && !CString(src).IsEmpty())
|
|
m_mapSpecXData.SetAt(_T("_SRC_STRING_"), src);
|
|
}
|
|
|
|
SHJson::WValue& AecDbRiverGroove::ToJson(bool bExprotGeo) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEwPipeBase::ToJson(bExprotGeo);
|
|
}
|
|
|
|
bool AecDbRiverGroove::ByJson(const SHJson::WValue &v)
|
|
{
|
|
AssertWriteEnabled();
|
|
return AecDbEwPipeBase::ByJson(v);
|
|
}
|
|
|
|
#include "HlrCutOption.h"
|
|
void AecDbRiverGroove::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);
|
|
}
|