1261 lines
29 KiB
C++
1261 lines
29 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbMRPLineStair.h"
|
|
#include "KTSetting.h"
|
|
#include "AcDbX3dSolid.h"
|
|
#include "AcGiExplodeDraw.h"
|
|
#include "AcGiViewDraw.h"
|
|
#include "ImpMD5.h"
|
|
|
|
static const Adesk::UInt16 kColorByBlock = 0;
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
static const Adesk::UInt16 kCyan = 4;
|
|
static const Adesk::UInt16 kBlue = 5;
|
|
static const Adesk::UInt16 kMagenta = 6;
|
|
static const Adesk::UInt16 kWhite = 7;
|
|
static const Adesk::UInt16 kColorByLayer = 256;
|
|
|
|
extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
|
|
extern BOOL GetDocScale(double& dPScale);
|
|
extern void SortPoints(AcGePoint3dArray& points,AcDbCurve* pLine);
|
|
extern AcDbRegion* CreatePolygonRegionOnly(AcGePoint3d* pPoints,int nSize);
|
|
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
|
|
extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
|
|
extern AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);
|
|
|
|
Adesk::UInt32 AecDbMRPLineStair::kCurrentVersionNumber = 1;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbMRPLineStair, AecDbEwPipeBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBMRPSTAIR,
|
|
"AecDbMRPLineStair"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbMRPLineStair::AecDbMRPLineStair(void)
|
|
{
|
|
}
|
|
|
|
AecDbMRPLineStair::~AecDbMRPLineStair(void)
|
|
{
|
|
deleteContainerOfStd(m_solids);
|
|
deleteContainerOfStd(m_pipes);
|
|
}
|
|
|
|
void AecDbMRPLineStair::SetStairData(const MRPLineStair& data)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//set section; 底层设置section,用于绘制管子
|
|
//路径单独设置
|
|
//bar数据key方式保存,只是占位用
|
|
if (data.nGShape == 0)
|
|
{
|
|
//Circle
|
|
SetSection(data.dGarSize[0],5.0);//5mm厚
|
|
}
|
|
else
|
|
{
|
|
//Rect
|
|
SetSection(data.dGarSize[0],data.dGarSize[1],5.0);//5mm厚
|
|
}
|
|
|
|
m_mapSpecXData.SetAt(KEY_KIND,data.nKind);
|
|
m_mapSpecXData.SetAt(KEY_STEEPH,data.dSteepH);
|
|
m_mapSpecXData.SetAt(KEY_STEEPW,data.dSteepW);
|
|
|
|
CString snSteeps,sTemp;
|
|
for (int i = 0;i < data.nSteepSize;i++)
|
|
{
|
|
sTemp.Format(_T("%d;"),data.nSteeps[i]);
|
|
snSteeps += sTemp;
|
|
}
|
|
snSteeps.TrimRight(_T(';'));
|
|
m_mapSpecXData.SetAt(KEY_STEEPS1,snSteeps);
|
|
|
|
m_mapSpecXData.SetAt(KEY_STAIRSW,data.dStairW);
|
|
m_mapSpecXData.SetAt(KEY_BOMEL,data.dBomEl);
|
|
|
|
m_mapSpecXData.SetAt(KEY_RESTPTW,data.dRestPtW);
|
|
m_mapSpecXData.SetAt(KEY_STIFFNH,data.dStiffnH);
|
|
m_mapSpecXData.SetAt(KEY_STIFFNW,data.dStiffnW);
|
|
m_mapSpecXData.SetAt(KEY_SLABT,data.dSbThick);
|
|
|
|
m_mapSpecXData.SetAt(KEY_BARH,data.dBarH);
|
|
m_mapSpecXData.SetAt(KEY_GARSIZE0,data.dGarSize[0]);
|
|
m_mapSpecXData.SetAt(KEY_GARSIZE1,data.dGarSize[1]);
|
|
|
|
m_mapSpecXData.SetAt(KEY_GSHAPE,data.nGShape);
|
|
m_mapSpecXData.SetAt(KEY_GAREXT,data.dGarExt);
|
|
m_mapSpecXData.SetAt(KEY_GARMAT,data.szGarMat);
|
|
|
|
m_mapSpecXData.SetAt(KEY_BARSP,data.dBarSp);
|
|
m_mapSpecXData.SetAt(KEY_BARSIZE0,data.dBarSize[0]);
|
|
m_mapSpecXData.SetAt(KEY_BARSIZE1,data.dBarSize[1]);
|
|
m_mapSpecXData.SetAt(KEY_BSHAPE,data.nBShape);
|
|
m_mapSpecXData.SetAt(KEY_BARMAT,data.szBarMat);
|
|
|
|
m_mapSpecXData.SetAt(KEY_HASRPLT, data.bHasResetPLF);
|
|
m_mapSpecXData.SetAt(KEY_HASGBAR, data.bHasGarBar);
|
|
m_mapSpecXData.SetAt(KEY_GBARLR, data.nGarBarLR);
|
|
m_mapSpecXData.SetAt(KEY_GBRSTPLF, data.bGBResetPLF);
|
|
m_mapSpecXData.SetAt(KEY_HASSTFN, data.bHasStiffn);
|
|
}
|
|
|
|
void AecDbMRPLineStair::GetStairData(MRPLineStair& data) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
CString sTemp;
|
|
m_mapSpecXData.GetAt(KEY_KIND,data.nKind);
|
|
m_mapSpecXData.GetAt(KEY_STEEPH,data.dSteepH);
|
|
m_mapSpecXData.GetAt(KEY_STEEPW,data.dSteepW);
|
|
|
|
m_mapSpecXData.GetAt(KEY_STEEPS1,sTemp);
|
|
if (!sTemp.IsEmpty())
|
|
{
|
|
CStringArray arVals;
|
|
SplitStrintToArray(sTemp,arVals,_T(';'));
|
|
|
|
data.nSteepSize = arVals.GetSize();
|
|
for (int i = 0;i < data.nSteepSize;i++)
|
|
{
|
|
data.nSteeps[i] = _ttoi(arVals.GetAt(i));
|
|
}
|
|
}
|
|
|
|
m_mapSpecXData.GetAt(KEY_STAIRSW,data.dStairW);
|
|
m_mapSpecXData.GetAt(KEY_BOMEL,data.dBomEl);
|
|
|
|
m_mapSpecXData.GetAt(KEY_RESTPTW,data.dRestPtW);
|
|
m_mapSpecXData.GetAt(KEY_STIFFNH,data.dStiffnH);
|
|
m_mapSpecXData.GetAt(KEY_STIFFNW,data.dStiffnW);
|
|
m_mapSpecXData.GetAt(KEY_SLABT,data.dSbThick);
|
|
|
|
m_mapSpecXData.GetAt(KEY_BARH,data.dBarH);
|
|
m_mapSpecXData.GetAt(KEY_GARSIZE0,data.dGarSize[0]);
|
|
m_mapSpecXData.GetAt(KEY_GARSIZE1,data.dGarSize[1]);
|
|
|
|
m_mapSpecXData.GetAt(KEY_GSHAPE,data.nGShape);
|
|
m_mapSpecXData.GetAt(KEY_GAREXT,data.dGarExt);
|
|
|
|
m_mapSpecXData.GetAt(KEY_GARMAT,sTemp);
|
|
_tcscpy(data.szGarMat,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_BARSP,data.dBarSp);
|
|
m_mapSpecXData.GetAt(KEY_BARSIZE0,data.dBarSize[0]);
|
|
m_mapSpecXData.GetAt(KEY_BARSIZE1,data.dBarSize[1]);
|
|
m_mapSpecXData.GetAt(KEY_BSHAPE,data.nBShape);
|
|
m_mapSpecXData.GetAt(KEY_BARMAT,sTemp);
|
|
_tcscpy(data.szBarMat,(LPCTSTR)sTemp);
|
|
data.bHasResetPLF = TRUE;
|
|
data.bHasGarBar = TRUE;
|
|
m_mapSpecXData.GetAt(KEY_HASRPLT, data.bHasResetPLF);
|
|
m_mapSpecXData.GetAt(KEY_HASGBAR, data.bHasGarBar);
|
|
data.nGarBarLR = 2;//默认左右都有
|
|
m_mapSpecXData.GetAt(KEY_GBARLR, data.nGarBarLR);
|
|
m_mapSpecXData.GetAt(KEY_HASSTFN, data.bHasStiffn);
|
|
m_mapSpecXData.GetAt(KEY_GBRSTPLF,data.bGBResetPLF);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus 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 > AecDbMRPLineStair::kCurrentVersionNumber )
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = AecDbEwPipeBase::dwgOutFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ( (es =pFiler->writeUInt32 (AecDbMRPLineStair::kCurrentVersionNumber)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbMRPLineStair::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
acutPrintf(_T("\n多段楼梯"));
|
|
AecDbEwPipeBase::subList();
|
|
}
|
|
|
|
//AEC 派生
|
|
Acad::ErrorStatus AecDbMRPLineStair::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
Adesk::UInt16 nCrBk = colorIndex();
|
|
|
|
dc.SetLayer(layerId());
|
|
|
|
//二维缓存,未知出错!
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar2D.at(i);
|
|
|
|
dc.SetColor(colorIndex());
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
dc.SetColor(colorIndex());
|
|
|
|
AcDbCurve* pBaseCrv = GetBaseCurve(true);
|
|
if (pBaseCrv != NULL)
|
|
{
|
|
MRPLineStair data;
|
|
memset(&data,0,sizeof(MRPLineStair));
|
|
|
|
GetStairData(data);
|
|
|
|
AcDbObjectId idLayOld = dc.GetLayerId();
|
|
AcDbObjectId idLay = layerId();
|
|
dc.SetLayer(idLay);
|
|
|
|
AcDbVoidPtrArray arEntDrawPtrs;
|
|
|
|
//跑步方向
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCrv);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGeVector3d vtDir = pLn->endPoint() - pLn->startPoint();
|
|
vtDir.normalize();
|
|
|
|
//一跑步数
|
|
AcGePoint3d ptBase = pLn->startPoint();
|
|
|
|
AcGePoint3d ptFr = ptBase;
|
|
AcGePoint3d ptS[5],ptDir[2];
|
|
|
|
AcGeVector3d vtLR;
|
|
|
|
vtLR = vtDir;
|
|
vtLR.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
//2D 侧进一个扶手宽度
|
|
ptFr += data.dGarSize[0] * vtLR;
|
|
|
|
//踏步线宽度
|
|
double dLen = data.dStairW;
|
|
dLen -= 2.0 * data.dGarSize[0];
|
|
|
|
//绘制踏步线 踏步数
|
|
AcGePoint3d ptTo;
|
|
for (int i = 0;i < data.nSteepSize;i++)
|
|
{
|
|
for (int j = 0;j < data.nSteeps[i];j++)
|
|
{
|
|
ptTo = ptFr;
|
|
ptTo += vtLR * dLen;
|
|
|
|
AcDbLine* pLnX = new AcDbLine;
|
|
pLnX->setStartPoint(ptFr);
|
|
pLnX->setEndPoint(ptTo);
|
|
pLnX->setLayer(idLay);
|
|
|
|
//dc.DrawEntity(pLnX);
|
|
//Add2DBuffer(pLnX);
|
|
arEntDrawPtrs.append(pLnX);
|
|
|
|
//步进一个台阶
|
|
if (j == data.nSteeps[i] - 1)
|
|
break;
|
|
|
|
ptFr += vtDir * data.dSteepW;
|
|
}
|
|
|
|
if (i == data.nSteepSize - 1)
|
|
{
|
|
if (data.bHasResetPLF)
|
|
{
|
|
ptFr += data.dRestPtW * vtDir;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptFr += data.dRestPtW * vtDir;
|
|
}
|
|
|
|
if (i == (data.nSteepSize - 1) )
|
|
{
|
|
ptTo = ptFr;
|
|
ptTo += vtLR * dLen;
|
|
|
|
AcDbLine* pLnX = new AcDbLine;
|
|
pLnX->setStartPoint(ptFr);
|
|
pLnX->setEndPoint(ptTo);
|
|
pLnX->setLayer(idLay);
|
|
|
|
//dc.DrawEntity(pLnX);
|
|
//Add2DBuffer(pLnX);
|
|
arEntDrawPtrs.append(pLnX);
|
|
}
|
|
}
|
|
|
|
//绘制扶手投影
|
|
ptS[0] = ptBase;
|
|
ptS[0] -= data.dGarExt * vtDir;//转角扶手伸出
|
|
|
|
ptS[1] = ptS[0];
|
|
ptS[1] += data.dGarSize[0] * vtLR;
|
|
|
|
ptS[2] = ptFr;
|
|
ptS[2] += data.dGarExt * vtDir;//转角扶手伸出
|
|
|
|
ptS[3] = ptS[2];
|
|
ptS[3] -= data.dGarSize[0] * vtLR;
|
|
ptS[4] = ptS[0];
|
|
|
|
AcDbPolyline* pL = FormatPolyline(ptS,5);
|
|
//dc.DrawEntity(pL);
|
|
//Add2DBuffer(pL);
|
|
arEntDrawPtrs.append(pL);
|
|
|
|
//右侧
|
|
ptS[0] = ptBase;
|
|
ptS[0] -= data.dGarExt * vtDir;//转角扶手伸出
|
|
ptS[0] += data.dGarSize[0] * vtLR;
|
|
ptS[0] += dLen * vtLR;
|
|
|
|
ptS[1] = ptS[0];
|
|
ptS[1] += data.dGarSize[0] * vtLR;
|
|
|
|
ptS[2] = ptTo;
|
|
ptS[2] += data.dGarSize[0] * vtLR;
|
|
ptS[2] += data.dGarExt * vtDir;//转角扶手伸出
|
|
|
|
ptS[3] = ptS[2];
|
|
ptS[3] -= data.dGarSize[0] * vtLR;
|
|
ptS[4] = ptS[0];
|
|
|
|
pL = FormatPolyline(ptS,5);
|
|
//dc.DrawEntity(pL);
|
|
//Add2DBuffer(pL);
|
|
arEntDrawPtrs.append(pL);
|
|
|
|
//绘制向上指引线
|
|
ptDir[0] = ptBase;
|
|
ptDir[0] -= data.dGarExt * vtDir;//转角扶手伸出
|
|
ptDir[0] += data.dGarSize[0] * vtLR;
|
|
ptDir[0] += 0.5 * dLen * vtLR;
|
|
|
|
ptDir[1] = ptFr;
|
|
ptDir[1] += data.dGarExt * vtDir;//转角扶手伸出
|
|
ptDir[1] += 0.5 * dLen * vtLR;
|
|
|
|
pL = FormatPolyline(ptDir,2);
|
|
pL->setColorIndex(kGreen);
|
|
//dc.DrawEntity(pL);
|
|
//Add2DBuffer(pL);
|
|
arEntDrawPtrs.append(pL);
|
|
|
|
DrawLeader(dc,ptDir[0],ptDir[1],kGreen);
|
|
|
|
DrawUporDown(dc,ptDir[0],-vtDir,1);
|
|
}
|
|
|
|
//统一绘制
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int j = 0;j < arEntDrawPtrs.length();j++)
|
|
{
|
|
pEnt = (AcDbEntity*)arEntDrawPtrs.at(j);
|
|
dc.DrawEntity(pEnt);
|
|
Add2DBuffer(pEnt);
|
|
}
|
|
|
|
delete pBaseCrv;
|
|
dc.SetLayer(idLayOld);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::DrawUporDown(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGeVector3d& vtOff,int nUporDown) const
|
|
{
|
|
double dDocScale = 100.0;
|
|
GetDocScale(dDocScale);
|
|
|
|
AcGePoint3d ptOff = ptFr + vtOff * 1.5 * dDocScale;
|
|
ptOff += vtOff * 3.5 * dDocScale;
|
|
|
|
LPCTSTR pszText = nUporDown < 0 ? _T("下") : _T("上");
|
|
|
|
AcGeVector3d vtT = vtOff;
|
|
vtT.negate();
|
|
vtT.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtT.normalize();
|
|
|
|
double dRot = AcGeVector3d::kXAxis.angleTo(vtT);
|
|
ptOff -= 1.75 * dDocScale * vtT;
|
|
|
|
AcDbText* pText = new AcDbText;
|
|
pText->setPosition(ptOff);
|
|
pText->setHeight(3.5 * dDocScale);
|
|
pText->setWidthFactor(0.75);
|
|
pText->setNormal(AcGeVector3d::kZAxis);
|
|
pText->setTextString(pszText);
|
|
pText->setRotation(dRot);
|
|
|
|
AcDbObjectId idSt = KTSetting::InitTextStyle(_T("Pipe_Dim"));
|
|
pText->setTextStyle(idSt);
|
|
pText->setLayer(layerId());
|
|
pText->setColorIndex(kWhite);
|
|
|
|
dc.DrawEntity(pText);
|
|
Add2DBuffer(pText);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::DrawLeader(AcGiDraw &dc,AcGePoint3d& pt0,AcGePoint3d& pt1,int nColor) const
|
|
{
|
|
double dAL = 3.0;
|
|
double dAW = 0.8;
|
|
double dDocScale = 100.0;
|
|
GetDocScale(dDocScale);
|
|
|
|
AcGeVector3d vt = pt1 - pt0;
|
|
vt.normalize();
|
|
|
|
AcGePoint3d ptA = pt1 - vt * dAL * dDocScale;
|
|
|
|
AcDbPolyline* pPl = new AcDbPolyline;
|
|
pPl->addVertexAt(0,pt0.convert2d(AcGePlane::kXYPlane));
|
|
pPl->addVertexAt(1,ptA.convert2d(AcGePlane::kXYPlane),0,dAW*dDocScale);
|
|
pPl->addVertexAt(2,pt1.convert2d(AcGePlane::kXYPlane),0,0);
|
|
pPl->setColorIndex(nColor);
|
|
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
//样子参照 PDMS 的样子
|
|
assertReadEnabled();
|
|
|
|
//管线系统屏蔽掉
|
|
if ( dc.IsDragging() )
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
return Acad::eInvalidInput;
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
|
|
int nCrBk = dc.GetColor();
|
|
|
|
if (Has3DBuffer())
|
|
{
|
|
//Clean3DBuffer();
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
dc.SetColor(colorIndex());
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
dc.SetColor(colorIndex());
|
|
|
|
MRPLineStair data;
|
|
memset(&data,0,sizeof(MRPLineStair));
|
|
GetStairData(data);
|
|
|
|
if (m_pBaseCurve != NULL)//路径
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptEnd;
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
deleteContainerOfStd(m_solids);
|
|
deleteContainerOfStd(m_pipes);
|
|
DrawSteep3d(dc,ptSta,ptEnd,data);
|
|
}
|
|
}
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::DrawSteep3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,MRPLineStair& data) const
|
|
{
|
|
AcGePoint3d ptBase = ptFr;
|
|
ptBase.z = data.dBomEl;
|
|
|
|
AcGeVector3d vtDir = ptTo - ptFr;
|
|
vtDir.z = 0.0;
|
|
vtDir.normalize();
|
|
|
|
AcGeVector3d vtUp;
|
|
|
|
AcGeVector3d vtLR;
|
|
vtLR = vtDir;
|
|
vtLR.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3dArray arPts,arBarPos;
|
|
AcGePoint3d ptPos = ptBase;
|
|
AcGePoint3d ptBar,ptPos2,ptE;
|
|
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
int nCrBk = dc.GetColor();
|
|
|
|
for (int i = 0;i < data.nSteepSize;i++)
|
|
{
|
|
for (int j = 0;j < data.nSteeps[i];j++)
|
|
{
|
|
arPts.append(ptPos);
|
|
|
|
ptPos.z += data.dSteepH;
|
|
arPts.append(ptPos);
|
|
|
|
if (arPts.length() == 4)
|
|
{
|
|
vtUp = arPts.last() - arPts.at(1);
|
|
}
|
|
|
|
ptPos += vtDir * data.dSteepW;
|
|
ptBar = MidPoint(ptPos,arPts.last());
|
|
|
|
ptBar += vtLR * data.dGarSize[0];
|
|
arBarPos.append(ptBar);
|
|
}
|
|
|
|
if (i == data.nSteepSize - 1)
|
|
{
|
|
if (!data.bHasResetPLF)
|
|
{
|
|
ptPos2 = ptPos;
|
|
arPts.append(ptPos2);
|
|
ptPos = ptPos2;
|
|
|
|
ptBar = ptPos;
|
|
ptBar -= vtDir * 0.5 * data.dSteepW;
|
|
ptBar += vtLR * data.dGarSize[0];
|
|
arBarPos.append(ptBar);
|
|
}
|
|
else
|
|
{
|
|
ptPos2 = ptPos;
|
|
ptPos2 += vtDir * (data.dRestPtW - data.dSteepW);
|
|
arPts.append(ptPos2);
|
|
ptPos = ptPos2;
|
|
|
|
ptBar = ptPos;
|
|
ptBar -= vtDir * 0.5 * data.dSteepW;
|
|
ptBar += vtLR * data.dGarSize[0];
|
|
arBarPos.append(ptBar);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptPos2 = ptPos;
|
|
ptPos2 += vtDir * (data.dRestPtW - data.dSteepW);
|
|
arPts.append(ptPos2);
|
|
ptPos = ptPos2;
|
|
|
|
ptBar = ptPos;
|
|
ptBar -= vtDir * 0.5 * data.dSteepW;
|
|
ptBar += vtLR * data.dGarSize[0];
|
|
arBarPos.append(ptBar);
|
|
}
|
|
|
|
AcDbLine ln1;
|
|
if (data.bHasStiffn)
|
|
{
|
|
//创建一段
|
|
ptPos2.z -= data.dSbThick;
|
|
ptPos2.z -= data.dStiffnH;
|
|
arPts.append(ptPos2);
|
|
|
|
ptPos2 -= data.dStiffnW * vtDir;
|
|
arPts.append(ptPos2);
|
|
|
|
if (i == data.nSteepSize - 1)
|
|
{
|
|
if (data.bHasResetPLF)
|
|
{
|
|
ptPos2.z += data.dStiffnH;
|
|
arPts.append(ptPos2);
|
|
|
|
}
|
|
else
|
|
{
|
|
ptPos2.z += data.dStiffnH;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptPos2.z += data.dStiffnH;
|
|
arPts.append(ptPos2);
|
|
}
|
|
|
|
if (i == data.nSteepSize - 1)
|
|
{
|
|
if (data.bHasResetPLF)
|
|
{
|
|
ptPos2 -= vtDir * (data.dRestPtW - 2.0 * data.dStiffnW);
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptPos2 -= vtDir * (data.dRestPtW - 2.0 * data.dStiffnW);
|
|
}
|
|
|
|
ln1.setStartPoint(arPts.last());
|
|
ln1.setEndPoint(ptPos2);
|
|
|
|
AcGeVector3d vtD = -AcGeVector3d::kZAxis;
|
|
vtD = vtD.orthoProject(vtUp);
|
|
vtD.normalize();
|
|
|
|
AcDbXline xLn;
|
|
ptE = arPts.at(2);
|
|
ptE += vtD * data.dSbThick;
|
|
xLn.setBasePoint(ptE);
|
|
xLn.setUnitDir(vtUp);
|
|
|
|
AcGePoint3dArray arPtInt;
|
|
xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);
|
|
|
|
if (arPtInt.isEmpty())
|
|
{
|
|
arPts.append(ptPos2);
|
|
}
|
|
else
|
|
{
|
|
arPts.append(arPtInt.first());
|
|
}
|
|
|
|
if (i == data.nSteepSize - 1 && !data.bHasResetPLF)
|
|
{
|
|
//...
|
|
arPts.append(arPts.first());
|
|
}
|
|
else
|
|
{
|
|
ln1.setStartPoint(ptPos2);
|
|
ptPos2.z -= data.dStiffnH;
|
|
ln1.setEndPoint(ptPos2);
|
|
|
|
arPtInt.removeAll();
|
|
xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);
|
|
|
|
if (arPtInt.isEmpty())
|
|
{
|
|
arPts.append(ln1.startPoint());
|
|
}
|
|
else
|
|
{
|
|
arPts.append(arPtInt.first());
|
|
}
|
|
|
|
arPts.append(ptPos2);
|
|
|
|
ptPos2 -= vtDir * data.dStiffnW;
|
|
arPts.append(ptPos2);
|
|
|
|
ln1.setStartPoint(ptPos2);
|
|
ptE = ptPos2;
|
|
ptE.z += data.dStiffnH;
|
|
ln1.setEndPoint(ptE);
|
|
|
|
arPtInt.removeAll();
|
|
xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);
|
|
|
|
if (!arPtInt.isEmpty())
|
|
{
|
|
arPts.append(arPtInt.first());
|
|
}
|
|
else
|
|
{
|
|
arPts.append(ptPos2);
|
|
}
|
|
|
|
ptPos2 = arPts.first();
|
|
ptPos2.z -= data.dStiffnH;
|
|
|
|
if (i == 0)
|
|
{
|
|
ptPos2 += vtDir * data.dStiffnW;
|
|
}
|
|
|
|
ln1.setStartPoint(ptPos2);
|
|
ptE = ptPos2;
|
|
|
|
ptE.z += data.dStiffnH;
|
|
ln1.setEndPoint(ptE);
|
|
|
|
arPtInt.removeAll();
|
|
xLn.intersectWith(&ln1, AcDb::kExtendArg, arPtInt);
|
|
|
|
if (!arPtInt.isEmpty())
|
|
{
|
|
arPts.append(arPtInt.first());
|
|
}
|
|
else
|
|
{
|
|
arPts.append(ptPos2);
|
|
}
|
|
|
|
if (i == 0)
|
|
{
|
|
ptPos2 = arPts.first();
|
|
if (data.bHasStiffn)
|
|
{
|
|
ptPos2.z -= data.dStiffnH;
|
|
|
|
ptPos2 += vtDir * data.dStiffnW;
|
|
arPts.append(ptPos2);
|
|
|
|
ptPos2 -= vtDir * data.dStiffnW;
|
|
arPts.append(ptPos2);
|
|
|
|
ptPos2.z += data.dStiffnH;
|
|
arPts.append(ptPos2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arPts.append(arPts.first());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptPos2.z -= data.dSbThick;
|
|
arPts.append(ptPos2);
|
|
|
|
AcGeVector3d vtD = -AcGeVector3d::kZAxis;
|
|
vtD = vtD.orthoProject(vtUp);
|
|
vtD.normalize();
|
|
|
|
AcDbXline xLn;
|
|
ptE = arPts.at(2);
|
|
ptE += vtD * data.dSbThick;
|
|
xLn.setBasePoint(ptE);
|
|
xLn.setUnitDir(vtUp);
|
|
|
|
ln1.setStartPoint(arPts.last());
|
|
|
|
if (i == data.nSteepSize - 1)
|
|
{
|
|
if (data.bHasResetPLF)
|
|
{
|
|
ptPos2 -= vtDir * data.dRestPtW;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptPos2 -= vtDir * data.dRestPtW;
|
|
}
|
|
ln1.setEndPoint(ptPos2);
|
|
|
|
AcGePoint3dArray arPtInt;
|
|
xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);
|
|
|
|
if (!arPtInt.isEmpty())
|
|
{
|
|
arPts.append(arPtInt.first());
|
|
}
|
|
|
|
AcDbXline xLn2;
|
|
if (i > 0)
|
|
{
|
|
ptE = arPts.first();
|
|
ptE.z -= data.dSbThick;
|
|
xLn2.setBasePoint(ptE);
|
|
xLn2.setUnitDir(vtDir);
|
|
}
|
|
else
|
|
{
|
|
xLn2.setBasePoint(arPts.first());
|
|
xLn2.setUnitDir(vtDir);
|
|
}
|
|
|
|
arPtInt.removeAll();
|
|
xLn.intersectWith(&xLn2, AcDb::kOnBothOperands, arPtInt);
|
|
|
|
if (!arPtInt.isEmpty())
|
|
{
|
|
arPts.append(arPtInt.first());
|
|
}
|
|
if (i > 0) arPts.append(ptE);
|
|
arPts.append(arPts.first());
|
|
}
|
|
|
|
AcDbRegion* pReg = CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
|
|
if (pReg != NULL)
|
|
{
|
|
ln1.setStartPoint(arPts.first());
|
|
ptE = arPts.first() + data.dStairW * vtLR;
|
|
ln1.setEndPoint(ptE);
|
|
|
|
AcDbX3dSolid x3dSolid;
|
|
if ( x3dSolid.CreateExtrude(pReg,ln1) )
|
|
{
|
|
m_solids.push_back(x3dSolid.Clone());
|
|
AcDb3dSolid* pSolid = (AcDb3dSolid*)x3dSolid.GetNative3dSolid()->clone();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(transparency());
|
|
pSolid->setLayer(layerId());
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
delete pReg;
|
|
}
|
|
arPts.removeAll();
|
|
|
|
//扶手护栏
|
|
if (data.bHasGarBar)
|
|
{
|
|
if (data.bGBResetPLF == 0)
|
|
arBarPos.removeLast();//休息平台不画栏杆
|
|
|
|
DrawGuarBar3d(dc, arBarPos, vtLR, data);
|
|
arBarPos.removeAll();
|
|
}
|
|
dc.SetLayer(layerId());
|
|
dc.SetColor(nCrBk);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::DrawGuarBar3d(AcGiDraw &dc,AcGePoint3dArray& arBarPos,const AcGeVector3d& vtLR,MRPLineStair& data) const
|
|
{
|
|
int nCrbk = dc.GetColor();
|
|
|
|
AcGePoint3d pt,pt2;
|
|
AcDbLine ln;
|
|
AecDbEwPipeBase pipe;
|
|
AcDbVoidPtrArray ar3DSoldPtrs;
|
|
AcGiExplodeDraw dc2(ar3DSoldPtrs);
|
|
|
|
AcGePoint3dArray arTop1,arTop2;
|
|
for (int i = 0;i < arBarPos.length();i++)
|
|
{
|
|
pt = arBarPos.at(i);
|
|
pt2 = pt;
|
|
pt2.z += data.dBarH;
|
|
arTop1.append(pt2);
|
|
|
|
if (data.nBShape == 0)
|
|
pipe.SetSection(data.dBarSize[0],data.dBarSize[1],0.0);
|
|
else
|
|
pipe.SetSection(data.dBarSize[0],0.0);
|
|
|
|
ln.setStartPoint(pt);
|
|
ln.setEndPoint(pt2);
|
|
pipe.SetBaseCurve(&ln);
|
|
|
|
if (data.nGarBarLR != 1)//左有
|
|
{
|
|
pipe.Draw3d(dc2);
|
|
m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
|
|
pipe.Clean3DBufferNoDel();
|
|
}
|
|
|
|
//对称位置
|
|
pt += (data.dStairW - 2.0 * data.dGarSize[0]) * vtLR;
|
|
pt2 += (data.dStairW - 2.0 * data.dGarSize[0]) * vtLR;
|
|
arTop2.append(pt2);
|
|
|
|
ln.setStartPoint(pt);
|
|
ln.setEndPoint(pt2);
|
|
pipe.SetBaseCurve(&ln);
|
|
|
|
if (data.nGarBarLR > 0)//右有
|
|
{
|
|
pipe.Draw3d(dc2);
|
|
m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
|
|
pipe.Clean3DBufferNoDel();
|
|
}
|
|
}
|
|
|
|
//两头延长,扶手伸出
|
|
AcGeVector3d vt = arTop1.at(0) - arTop1.at(1);
|
|
vt.z = 0.0;//水平
|
|
vt.normalize();
|
|
|
|
pt = arTop1.first() + vt * data.dGarExt;
|
|
arTop1.insertAt(0,pt);
|
|
|
|
pt = arTop2.first() + vt * data.dGarExt;
|
|
arTop2.insertAt(0,pt);
|
|
|
|
pt = arTop1.last() - vt * data.dGarExt;
|
|
arTop1.append(pt);
|
|
|
|
pt = arTop2.last() - vt * data.dGarExt;
|
|
arTop2.append(pt);
|
|
|
|
AcDb3dPolyline* pPl = Format3dPolyline(arTop1);
|
|
if (pPl != NULL)
|
|
{
|
|
if (data.nGShape == 0)
|
|
pipe.SetSection(data.dGarSize[0], data.dGarSize[1], 0.0);
|
|
else
|
|
pipe.SetSection(data.dGarSize[0], 0.0);
|
|
|
|
pipe.SetBaseCurve(pPl);
|
|
|
|
if (data.nGarBarLR != 1)//左有
|
|
{
|
|
pipe.Draw3d(dc2);
|
|
m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
|
|
pipe.Clean3DBufferNoDel();
|
|
}
|
|
delete pPl;
|
|
}
|
|
|
|
pPl = Format3dPolyline(arTop2);
|
|
if (pPl != NULL)
|
|
{
|
|
if (data.nGShape == 0)
|
|
pipe.SetSection(data.dGarSize[0], data.dGarSize[1], 0.0);
|
|
else
|
|
pipe.SetSection(data.dGarSize[0], 0.0);
|
|
|
|
pipe.SetBaseCurve(pPl);
|
|
|
|
if (data.nGarBarLR > 0)//右有
|
|
{
|
|
pipe.Draw3d(dc2);
|
|
m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
|
|
pipe.Clean3DBufferNoDel();
|
|
}
|
|
|
|
delete pPl;
|
|
}
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0;i < ar3DSoldPtrs.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3DSoldPtrs.at(i);
|
|
pEnt->setColorIndex(kCyan);
|
|
pEnt->setTransparency(transparency());
|
|
dc.SetColor(kCyan);
|
|
dc.DrawEntity(pEnt);
|
|
Add3DBuffer(pEnt);
|
|
}
|
|
|
|
dc.SetColor(nCrbk);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbMRPLineStair::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
AecDbEwPipeBase::subTransformBy(xform);
|
|
|
|
double dBomEl = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_BOMEL,dBomEl);
|
|
|
|
AcGePoint3d pt(0,0,dBomEl);
|
|
pt.transformBy(xform);
|
|
|
|
m_mapSpecXData.SetAt(KEY_BOMEL,pt.z);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int AecDbMRPLineStair::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray& arRegPtrs) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtLn = ptTo - ptFr;
|
|
AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);
|
|
|
|
AcGePlane plan;
|
|
plan.set(ptFr,vtNorm);
|
|
|
|
AcGeMatrix3d xform;
|
|
xform.setToPlaneToWorld(plan);
|
|
xform.invert();
|
|
|
|
if (Get3DBuffer().length() == 0)
|
|
{
|
|
AcGiViewDraw dc(NULL,NULL);
|
|
Draw3d(dc);
|
|
}
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
AcDbVoidPtrArray arRegPtrsT;
|
|
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
|
|
pSolid = AcDb3dSolid::cast(pEnt);
|
|
if (pSolid != NULL)
|
|
{
|
|
//投影法
|
|
OrthoProjected3DSolid(pSolid,plan,xform,arRegPtrsT);
|
|
}
|
|
}
|
|
|
|
for (int i = 0;i < arRegPtrsT.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arRegPtrsT.at(i);
|
|
pEnt->setLayer(layerId());
|
|
pEnt->setColorIndex(kColorByLayer);
|
|
arRegPtrs.append(pEnt);
|
|
}
|
|
|
|
return arRegPtrs.length();
|
|
}
|
|
|
|
CString AecDbMRPLineStair::getUniqueName() const
|
|
{
|
|
assertReadEnabled();
|
|
CString str(_T(""));
|
|
MRPLineStair data;
|
|
::memset(&data, 0, sizeof(MRPLineStair));
|
|
GetStairData(data);
|
|
|
|
::memset(data.szGarMat, 0, 256 * sizeof(TCHAR));
|
|
::memset(data.szBarMat, 0, 256 * sizeof(TCHAR));
|
|
::memset(&data.dBomEl, 0, sizeof(double));
|
|
|
|
return ImpMD5(&data, sizeof(MRPLineStair)).toString16W().c_str();
|
|
}
|
|
|
|
SHJson::WValue & AecDbMRPLineStair::ToJson(bool bExprotGeo) const
|
|
{
|
|
assertReadEnabled();
|
|
using namespace SHJson;
|
|
WValue &v = AecDbEwPipeBase::ToJson(bExprotGeo);
|
|
|
|
if (bExprotGeo)
|
|
{
|
|
AecDbMRPLineStair *pNew = (AecDbMRPLineStair*)clone();
|
|
AcDbCurve *pCurve = pNew->GetNativeCurve();
|
|
if (pCurve)
|
|
{
|
|
AcGePoint3d ptS(AcGePoint3d::kOrigin);
|
|
AcGePoint3d ptE(ptS);
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
AcGeMatrix3d mat;
|
|
|
|
mat.setToTranslation(-ptS.asVector());
|
|
pCurve->transformBy(mat);
|
|
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
AcGeVector3d vt(ptE - ptS);
|
|
if (!vt.isCodirectionalTo(AcGeVector3d::kXAxis))
|
|
{
|
|
double dAngle = AcGeVector3d::kXAxis.angleTo(vt, AcGeVector3d::kZAxis);
|
|
mat.setToRotation(-dAngle, AcGeVector3d::kZAxis, ptS);
|
|
pCurve->transformBy(mat);
|
|
}
|
|
}
|
|
pNew->Clean3DBuffer();
|
|
AcGiViewDraw dc;
|
|
pNew->Draw3d(dc);
|
|
|
|
WValue ar;
|
|
ar.SetArray();
|
|
|
|
for (size_t i(0); i < pNew->m_solids.size(); ++i)
|
|
{
|
|
AcDbX3dSolid *pSolid(pNew->m_solids[i]);
|
|
if (!pSolid) continue;
|
|
WValue &x = pSolid->ToJson();
|
|
pushBack(ar, x);
|
|
}
|
|
if (!pNew->m_solids.empty())
|
|
addMember(v, _T("__solids__"), ar);
|
|
|
|
ar.SetArray();
|
|
for (size_t i(0); i < pNew->m_pipes.size(); ++i)
|
|
{
|
|
AecDbEwPipeBase *pPipe(pNew->m_pipes[i]);
|
|
if (!pPipe) continue;
|
|
WValue &x = pPipe->ToJson();
|
|
pushBack(ar, x);
|
|
}
|
|
if (!pNew->m_pipes.empty())
|
|
addMember(v, _T("__pipes__"), ar);
|
|
DELETE_PTR(pNew);
|
|
}
|
|
|
|
/*
|
|
int nKind; //0 钢筋混凝土 1 钢梯
|
|
double dSteepH; //踏步高度
|
|
double dSteepW; //踏步宽度
|
|
|
|
int nSteepSize; //踏步段数
|
|
int nSteeps[20]; //最多20段
|
|
|
|
double dStairW; //梯段宽度 单宽
|
|
|
|
double dBomEl; //底部标高
|
|
|
|
//平台参数
|
|
double dRestPtW; //休息平台宽
|
|
double dStiffnW; //加强筋宽 钢梯无效
|
|
double dStiffnH; //加强筋高 钢梯无效
|
|
double dSbThick; //平台板厚
|
|
|
|
//边梁
|
|
double dSideBeamW; //边梁宽 60 预留
|
|
double dSideBeamH; //边梁高 60 预留
|
|
|
|
//扶手护栏
|
|
double dBarH; //扶手高度
|
|
double dGarSize[2]; //扶手截面尺寸
|
|
double dGarExt; //转角扶手伸出 60 默认
|
|
|
|
int nGShape; //截面类型0 Rect 1 C
|
|
TCHAR szGarMat[256];//材质
|
|
|
|
double dBarSp; //护栏间距 预留
|
|
double dBarSize[2]; //护栏截面尺寸
|
|
|
|
int nBShape; //护栏截面类型0 Rect 1 C
|
|
TCHAR szBarMat[256];//材质
|
|
*/
|
|
|
|
MRPLineStair data;
|
|
memset(&data, 0, sizeof(MRPLineStair));
|
|
GetStairData(data);
|
|
WValue vData;
|
|
|
|
addMember(vData, _T("__nKind__"), data.nKind);
|
|
addMember(vData, _T("__dSteepH__"), data.dSteepH);
|
|
addMember(vData, _T("__dSteepW__"), data.dSteepW);
|
|
|
|
addMember(vData, _T("__nSteepSize__"), data.nSteepSize);
|
|
|
|
WValue ar;
|
|
ar.SetArray();
|
|
for (int i(0); i < sizeof(data.nSteeps) / sizeof(data.nSteeps[0]); ++i)
|
|
pushBack(ar, data.nSteeps[i]);
|
|
addMember(vData, _T("__nSteeps__"), ar);
|
|
|
|
addMember(vData, _T("__dStairW__"), data.dStairW);
|
|
|
|
addMember(vData, _T("__dBomEl__"), data.dBomEl);
|
|
|
|
//平台参数
|
|
addMember(vData, _T("__dRestPtW__"), data.dRestPtW);
|
|
addMember(vData, _T("__dStiffnW__"), data.dStiffnW);
|
|
addMember(vData, _T("__dStiffnH__"), data.dStiffnH);
|
|
addMember(vData, _T("__dSbThick__"), data.dSbThick);
|
|
|
|
//边梁
|
|
addMember(vData, _T("__dSideBeamW__"), data.dSideBeamW);
|
|
addMember(vData, _T("__dSideBeamH__"), data.dSideBeamH);
|
|
|
|
//扶手护栏
|
|
addMember(vData, _T("__dBarH__"), data.dBarH);
|
|
|
|
ar.SetArray();
|
|
for (int i(0); i < sizeof(data.dGarSize) / sizeof(data.dGarSize[0]); ++i)
|
|
pushBack(ar, data.dGarSize[i]);
|
|
addMember(vData, _T("__dGarSize__"), ar);
|
|
|
|
addMember(vData, _T("__dGarExt__"), data.dGarExt);
|
|
|
|
addMember(vData, _T("__nGShape__"), data.nGShape);
|
|
addMember(vData, _T("__szGarMat__"), data.szGarMat);
|
|
|
|
addMember(vData, _T("__dBarSp__"), data.dBarSp);
|
|
|
|
ar.SetArray();
|
|
for (int i(0); i < sizeof(data.dBarSize) / sizeof(data.dBarSize[0]); ++i)
|
|
pushBack(ar, data.dBarSize[i]);
|
|
addMember(vData, _T("__dBarSize__"), ar);
|
|
|
|
addMember(vData, _T("__nBShape__"), data.nBShape);
|
|
addMember(vData, _T("__szBarMat__"), data.szBarMat);
|
|
|
|
addMember(v, _T("_MRPLineStair_data_"), vData);
|
|
|
|
return v;
|
|
}
|
|
|
|
#include "HlrCutOption.h"
|
|
void AecDbMRPLineStair::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
|
|
, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
|
|
, AcArray<AcDbEntity *> &output) const
|
|
{
|
|
HlrCutOption::ProcessHlrResult(this
|
|
, FALSE
|
|
, .0
|
|
, HlrCutOption::getHlrBLK_STAIR()
|
|
, ar
|
|
, preAr
|
|
, output);
|
|
}
|