979 lines
23 KiB
C++
979 lines
23 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbCrossStair.h"
|
|
#include "AecDbCrossStairDraw.h"
|
|
#include "AecDbEarthWorm.h"
|
|
#include "AcDbX3dSolid.h"
|
|
#include "CoreTools.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;
|
|
|
|
DLLIMPEXP AcDbPolyline *FormatPolyline(AcGePoint3d *ppPts, int nCount);
|
|
DLLIMPEXP AcDb3dPolyline *Format3dPolyline(const AcGePoint3dArray &arPts);
|
|
|
|
ACRX_CONS_DEFINE_MEMBERS(AecDbCrossStairDraw, AecDbXDraw, 0);
|
|
|
|
namespace
|
|
{
|
|
AcDbRegion* makeRegion(const AcGePoint3d& ptOrg
|
|
, const double& dL
|
|
, const double& dW
|
|
, const AcGeVector3d& vecL
|
|
, const AcGeVector3d& vecW)
|
|
{
|
|
AcGePoint3d ptGe[5];
|
|
AcGePoint3d pt1(ptOrg), pt2, pt3, pt4;
|
|
|
|
pt2 = pt1 - vecW * dW;
|
|
pt3 = pt2 - vecL * dL;
|
|
pt4 = pt3 + vecW * dW;
|
|
|
|
ptGe[0] = pt1;
|
|
ptGe[1] = pt2;
|
|
ptGe[2] = pt3;
|
|
ptGe[3] = pt4;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (!pReg) return NULL;
|
|
|
|
return pReg;
|
|
}
|
|
|
|
AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
|
|
, const double& dL
|
|
, const double& dW
|
|
, const AcGeVector3d& vecL
|
|
, const AcGeVector3d& vecW)
|
|
{
|
|
AcGePoint3d ptGe[5];
|
|
AcGePoint3d pt1(ptOrg), pt2, pt3, pt4;
|
|
|
|
pt1 += vecW * dW * .5;
|
|
pt1 += vecL * dL * .5;
|
|
pt2 = pt1 - vecW * dW;
|
|
pt3 = pt2 - vecL * dL;
|
|
pt4 = pt3 + vecW * dW;
|
|
|
|
ptGe[0] = pt1;
|
|
ptGe[1] = pt2;
|
|
ptGe[2] = pt3;
|
|
ptGe[3] = pt4;
|
|
ptGe[4] = ptGe[0];
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (!pReg) return NULL;
|
|
return pReg;
|
|
}
|
|
|
|
AcDbRegion* makeCircleRegion(const AcGePoint3d& ptOrg
|
|
, const AcGeVector3d& vtZ
|
|
, const double& dR
|
|
)
|
|
{
|
|
AcDbCircle* pCir(new AcDbCircle(ptOrg, vtZ, dR));
|
|
AcDbRegion* pReg = CoreTools::createRegion(pCir);
|
|
DELETE_PTR(pCir);
|
|
return pReg;
|
|
}
|
|
|
|
void drawText(AcGiDraw& dc
|
|
, const ACHAR* text
|
|
, const double& dTextH
|
|
, const AcGePoint3d& ptAlign
|
|
, const double& dAngle
|
|
, const AcGeVector3d& vtTrans
|
|
, AcDb::TextHorzMode nHorMode
|
|
, AcDb::TextVertMode nVerMode
|
|
, AcGiDraw::TextAlignment nAlign)
|
|
{
|
|
AcDbText* pText = new AcDbText();
|
|
if (pText == NULL) return;
|
|
|
|
pText->setTextString(text);
|
|
pText->setHeight(dTextH);
|
|
|
|
AcDbExtents ext;
|
|
pText->getGeomExtents(ext);
|
|
pText->setHorizontalMode(nHorMode);
|
|
pText->setVerticalMode(nVerMode);
|
|
pText->setAlignmentPoint(ptAlign);
|
|
AcGeMatrix3d mat;
|
|
mat.setToRotation(dAngle, vtTrans, ptAlign);
|
|
pText->setPosition(dc.Align2Base(nAlign, ptAlign, ext.maxPoint()));
|
|
pText->transformBy(mat);
|
|
|
|
dc.DrawEntity(pText);
|
|
dc.Add2dBuffer(pText);
|
|
|
|
}
|
|
}
|
|
|
|
AecDbCrossStairDraw::AecDbCrossStairDraw(void)
|
|
{
|
|
}
|
|
|
|
AecDbCrossStairDraw::~AecDbCrossStairDraw(void)
|
|
{
|
|
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
|
AcDbEntity *pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbCrossStair *pStair = AecDbCrossStair::cast(pEntReal);
|
|
if (pStair == NULL)
|
|
return Acad::eOk;
|
|
|
|
Adesk::UInt16 nCrBk = 256;
|
|
nCrBk = pEntReal->colorIndex();
|
|
dc.SetLayer(pEntReal->layerId());
|
|
|
|
int nColor = nCrBk;
|
|
if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
|
|
dc.SetColor(nColor);
|
|
else
|
|
dc.SetColor(pEntReal->colorIndex());
|
|
|
|
SFPXStair data;
|
|
memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
|
|
AcDbCurve* pBaseCurve = pStair->GetBaseCurve();
|
|
if (pBaseCurve != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta, ptEnd;
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
|
|
AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
|
|
vtSEDir = (ptSta - ptEnd).normalize();
|
|
vtSE = vtSEDir;
|
|
vtSE.rotateBy(PI / 2.0, Z);
|
|
vtSE.normalize();
|
|
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawHandRail2d(dc, ptSta, vtSE, vtSEDir, data);
|
|
DrawWithin2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
}
|
|
|
|
//.....
|
|
AcDbVoidPtrArray arEntPtrs;
|
|
//
|
|
|
|
|
|
dc.SetColor(nCrBk);
|
|
dc.SetLayer(idCurLay);
|
|
dc.SetLineType(idCurLty);
|
|
dc.Add2dBuffer(arEntPtrs);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
del3DCache<AecDbCrossStair>();
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
|
AcDbEntity *pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbCrossStair *pStair = AecDbCrossStair::cast(pEntReal);
|
|
if (pStair == NULL)
|
|
return Acad::eOk;
|
|
|
|
Adesk::UInt16 nCrBk = pEntReal->colorIndex();
|
|
dc.SetLayer(pEntReal->layerId());
|
|
|
|
int nColor = nCrBk;
|
|
if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
SFPXStair data;
|
|
memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
|
|
AcDbCurve* pBaseCurve = pStair->GetBaseCurve();
|
|
if (pBaseCurve != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta, ptEnd;
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
|
|
AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
|
|
|
|
ptSta += Z * data.dBomEl;
|
|
ptEnd += Z * data.dBomEl;
|
|
|
|
vtSEDir = (ptSta - ptEnd).normalize();
|
|
vtSE = vtSEDir;
|
|
vtSE.rotateBy(PI / 2.0, Z);
|
|
vtSE.normalize();
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
ptSta -= vtSE * data.dStairTW;
|
|
DrawStair3d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
else
|
|
{
|
|
DrawStair3d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawStair2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptS(ptFr);
|
|
AcDbPolyline* pPoly(NULL);
|
|
AcGePoint3d ptGe[5];
|
|
|
|
ptGe[0] = ptS - vtDir * 1200;
|
|
ptGe[1] = ptGe[0] - vtDir * (data.nSteepS - 1) * data.dSteepW;
|
|
ptGe[2] = ptGe[1] - vt * data.dStairMW;
|
|
ptGe[3] = ptGe[2] + vtDir * (data.nSteepS - 1) * data.dSteepW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl = NULL;
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptS -= vtDir * 1200;
|
|
for (int i(0); i < data.nSteepS; ++i)
|
|
{
|
|
ptGe[0] = ptS - vtDir * data.dSteepW * i;
|
|
ptGe[1] = ptGe[0] - vt * data.dStairMW;
|
|
pPoly = (AcDbPolyline*)FormatPolyline(ptGe, 2);
|
|
if (!pPoly) return Acad::eOk;
|
|
dc.DrawEntity(pPoly);
|
|
dc.Add2dBuffer(pPoly);
|
|
}
|
|
|
|
ptGe[0] = ptS - vt * (data.dStairMW + data.dWell);
|
|
ptGe[1] = ptGe[0] - vtDir * (data.nSteepS - 1) * data.dSteepW;
|
|
ptGe[2] = ptGe[1] - vt * data.dStairMW;
|
|
ptGe[3] = ptGe[2] + vtDir * (data.nSteepS - 1) * data.dSteepW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl1 = NULL;
|
|
pPl1 = FormatPolyline(ptGe, 5);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
ptS -= vt * (data.dStairMW + data.dWell);
|
|
for (int i(0); i < data.nSteepS; ++i)
|
|
{
|
|
ptGe[0] = ptS - vtDir * data.dSteepW * i;
|
|
ptGe[1] = ptGe[0] - vt * data.dStairMW;
|
|
pPoly = (AcDbPolyline*)FormatPolyline(ptGe, 2);
|
|
if (!pPoly) return Acad::eOk;
|
|
dc.DrawEntity(pPoly);
|
|
dc.Add2dBuffer(pPoly);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawHandRail2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptS(ptFr);
|
|
|
|
ptS -= vt * (data.dStairMW - data.dBarSide - data.dGarSize[0]);
|
|
ptS -= vtDir * 1200;
|
|
ptS += vtDir * data.dZGarExt;
|
|
AcDbRegion* pReg = makeRegion(ptS, data.dGarSize[0], (data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2, vt, vtDir);
|
|
dc.DrawEntity(pReg);
|
|
dc.Add2dBuffer(pReg);
|
|
|
|
ptS -= vt * (data.dBarSide * 2 + data.dGarSize[0] + data.dWell);
|
|
AcDbRegion* pReg1 = makeRegion(ptS, data.dGarSize[0], (data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2, vt, vtDir);
|
|
dc.DrawEntity(pReg1);
|
|
dc.Add2dBuffer(pReg1);
|
|
|
|
if (data.bOutSideHRail)
|
|
{
|
|
ptS = ptFr;
|
|
ptS -= vt * data.dBarSide;
|
|
ptS -= vtDir * 1200;
|
|
ptS += vtDir * data.dZGarExt;
|
|
AcDbRegion* pReg = makeRegion(ptS, data.dGarSize[0], (data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2, vt, vtDir);
|
|
dc.DrawEntity(pReg);
|
|
dc.Add2dBuffer(pReg);
|
|
|
|
ptS -= vt * (data.dStairTW - data.dBarSide * 2 - data.dGarSize[0]);
|
|
AcDbRegion* pReg1 = makeRegion(ptS, data.dGarSize[0], (data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2, vt, vtDir);
|
|
dc.DrawEntity(pReg1);
|
|
dc.Add2dBuffer(pReg1);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawWithin2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGePoint3d& ptEnd
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d pt1(ptSta), pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9, pt10;
|
|
AcGePoint3d ptGe[4];
|
|
double dScale = CoreTools::getPScaleForSymb();
|
|
double dW(dScale * .8);
|
|
double dH(dScale * 3);
|
|
double dTextH(dScale * 3.5);
|
|
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
|
double angle = vtDir.angleTo(AcGeVector3d::kXAxis) - PI * .5;
|
|
|
|
pt1 -= vtDir * (1200 + (data.nSteepS - 1) * data.dSteepW);
|
|
pt1 -= vt * data.dStairMW * .5;
|
|
pt1 -= vtDir * data.dSteepW * .5;
|
|
pt2 = pt1 + vtDir * ((data.nSSteeps - .5) * data.dSteepW);
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGe[0] = pt1;
|
|
ptGe[1] = pt2;
|
|
ptGe[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGe, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
else
|
|
{
|
|
drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
|
|
pt4 = pt2 + vtDir * (data.nSteepS + 1 - data.nSSteeps) * data.dSteepW;
|
|
pt5 = pt4 - vtDir * (data.nSteepS - data.nSSteeps) * data.dSteepW;
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGe[0] = pt4;
|
|
ptGe[1] = pt5;
|
|
ptGe[2] = pt6;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGe, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
else
|
|
{
|
|
drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
|
|
pt1 -= vt * (data.dStairMW + data.dWell);
|
|
pt2 = pt1 + vtDir * ((data.nSSteeps - .5) * data.dSteepW);
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGe[0] = pt1;
|
|
ptGe[1] = pt2;
|
|
ptGe[2] = pt3;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGe, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
else
|
|
{
|
|
drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
|
|
pt4 = pt2 + vtDir * (data.nSteepS + 1 - data.nSSteeps) * data.dSteepW;
|
|
pt5 = pt4 - vtDir * (data.nSteepS - data.nSSteeps) * data.dSteepW;
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGe[0] = pt4;
|
|
ptGe[1] = pt5;
|
|
ptGe[2] = pt6;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGe, 3);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
else
|
|
{
|
|
drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawSteep3d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const SFPXStair& data
|
|
, const double& dW) const
|
|
{
|
|
AcGePoint3d ptSta = ptFr;
|
|
AcGeVector3d vtL = ptTo - ptFr;
|
|
vtL.normalize();
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGePoint3d ptEnd = ptSta + vtL * dL;
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总宽
|
|
double dSteepL = dW;
|
|
|
|
AcGePoint3d ptV, ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
//if (data.bLBeam)
|
|
//ptV += vtW * 120.0;//变量宽,国家标准120
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptV.z -= (data.dSteepW - data.dSteepH);
|
|
|
|
ptV0 = ptV;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptV);
|
|
|
|
for (int i = 0; i < nCount - 1; i++)
|
|
{
|
|
ptV += vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepH;
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0, vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
int nLast = arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1, AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if (ln3d.intersectWith(lnEnd, ptInt))
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
AcGePoint3d& ptT = arSecPts.first();
|
|
|
|
//闭合
|
|
arSecPts.append(ptT);
|
|
|
|
//测试
|
|
//AcDb3dPolyline* pPl = Format3dPolyline(arSecPts);
|
|
//pPl->setColorIndex(3);
|
|
//CoreTools::AddToModelSpace(pPl);
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts.asArrayPtr(), arSecPts.length());
|
|
if (pReg != NULL)
|
|
{
|
|
AcDbLine lnPath;
|
|
lnPath.setStartPoint(ptV0);
|
|
|
|
/*if (data.bLBeam)
|
|
ptV = ptV0 + vtW * (dSteepL - 120.0);
|
|
else*/
|
|
ptV = ptV0 + vtW * dSteepL;
|
|
|
|
//if (data.bRBeam)
|
|
// ptV -= vtW * 120.0;//变梁宽,国标120
|
|
|
|
lnPath.setEndPoint(ptV);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if (xSolid.CreateExtrude(pReg, lnPath))
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbCrossStair>(&xSolid);
|
|
return Acad::eOk;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawGuard3d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const int& num
|
|
, const double& dW
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcDbEntity* pEntReal = GetAttach();
|
|
if (pEntReal == NULL) return Acad::eOk;
|
|
|
|
AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
|
|
if (pBaseStair == NULL) return Acad::eOk;
|
|
AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
|
|
AcGeVector3d vtL = (ptFr - ptTo).normalize();
|
|
vtL.z = 0.0;
|
|
|
|
AcGeVector3d vtLDir(vtL);
|
|
vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtLDir.normalize();
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
AcGePoint3dArray arSecPts;
|
|
double dSidet(120);
|
|
|
|
if (data.nUpSide == 0)
|
|
{
|
|
ptSta += vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide);
|
|
ptSta -= vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide) * 2 * num;
|
|
}
|
|
else
|
|
{
|
|
ptSta -= vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide);
|
|
ptSta += vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide) * 2 * num;
|
|
}
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptSta.z -= (data.dSteepW - data.dSteepH);
|
|
ptSta.z += data.dSteepW;//第一层等边直角
|
|
|
|
arSecPts.removeAll();
|
|
for (int i = 0; i < nCount - 1; i++)
|
|
{
|
|
ptSta -= vtL * data.dSteepW * .5;
|
|
arSecPts.append(ptSta);
|
|
|
|
ptSta -= vtL * data.dSteepW * .5;
|
|
ptSta.z += data.dSteepH;
|
|
}
|
|
|
|
AcDbX3dSolid xSolid;
|
|
AcDbRegion* pReg(NULL);
|
|
|
|
for (int i = 0; i < arSecPts.length(); i++)
|
|
{
|
|
if (!data.nBShape)
|
|
{
|
|
pReg = makeRectRegion(arSecPts.at(i), data.dBarSize[0], data.dBarSize[1], vtL, vtLDir);
|
|
}
|
|
else
|
|
{
|
|
pReg = makeCircleRegion(arSecPts.at(i), AcGeVector3d::kZAxis, data.dBarSize[0] * .5);
|
|
}
|
|
if (pReg == NULL) return Acad::eOk;
|
|
AcDbLine line(arSecPts.at(i), arSecPts.at(i) + AcGeVector3d::kZAxis * data.dBarH);
|
|
if (xSolid.CreateExtrude(pReg, line))
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbCrossStair>(&xSolid);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawStair3d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptS(ptFr), ptE(ptTo);
|
|
AcGePoint3d pt1(ptS), pt2, pt3, pt4;
|
|
AcGePoint3d ptGe1[4];
|
|
AcGePoint3d ptGe2[4];
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
AcDbRegion* pReg = makeRegion(ptS, data.dStairTW, 1200, vt, vtDir);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptS);
|
|
ln.setEndPoint(ptS + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if (xSolid.CreateExtrude(pReg, ln))
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (!pSolid)
|
|
{
|
|
DELETE_PTR(pReg);
|
|
return Acad::eOk;
|
|
}
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbCrossStair>(&xSolid);
|
|
}
|
|
|
|
ptS += Z * 120;
|
|
ptS -= vt * data.dStairMW * .5;
|
|
ptS -= vtDir * 1200;
|
|
ptE = ptS - vtDir * data.nSteepS * data.dSteepW;
|
|
DrawSteep3d(dc, ptS, ptE, data, data.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard3d(dc, ptS, ptE, 1, data.dStairMW, data);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard3d(dc, ptS, ptE, 0, data.dStairMW, data);
|
|
}
|
|
|
|
ptGe1[0] = ptS;
|
|
ptGe1[1] = ptE;
|
|
|
|
ptS += Z * 0;
|
|
ptS += vt * data.dStairMW * .5;
|
|
ptS -= vtDir * data.nSteepS * data.dSteepW;
|
|
AcDbRegion* pReg1 = makeRegion(ptS, data.dStairTW, 1200, vt, vtDir);
|
|
|
|
AcDbLine ln1;
|
|
ln1.setStartPoint(ptS);
|
|
ln1.setEndPoint(ptS + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
|
|
|
AcDbX3dSolid xSolid1;
|
|
if (xSolid1.CreateExtrude(pReg1, ln1))
|
|
{
|
|
AcDb3dSolid* pSolid1 = xSolid1.GetDraw3dSolid();
|
|
if (!pSolid1)
|
|
{
|
|
DELETE_PTR(pReg1);
|
|
return Acad::eOk;
|
|
}
|
|
dc.DrawEntity(pSolid1);
|
|
dc.Add3dBuffer(pSolid1);
|
|
add3DCache<AecDbCrossStair>(&xSolid);
|
|
}
|
|
|
|
ptS += Z * 120;
|
|
ptS -= vt * (data.dStairTW - data.dStairMW * .5);
|
|
ptE = ptS + vtDir * data.nSteepS * data.dSteepW;
|
|
DrawSteep3d(dc, ptS, ptE, data, data.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard3d(dc, ptS, ptE, 1, data.dStairMW, data);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard3d(dc, ptS, ptE, 0, data.dStairMW, data);
|
|
}
|
|
|
|
ptGe2[0] = ptS;
|
|
ptGe2[1] = ptE;
|
|
|
|
DrawHandRail3d(dc, ptGe1, 0, vt, -vtDir, 0, data);
|
|
DrawHandRail3d(dc, ptGe2, 0, vt, vtDir, 0, data);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcDbLine* AecDbCrossStairDraw::DrawHandRail(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const int& num
|
|
, const double& dW
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr);
|
|
AcGeVector3d vtL = (ptFr - ptTo).normalize();
|
|
vtL.z = 0.0;
|
|
|
|
AcGeVector3d vtLDir(vtL);
|
|
vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtLDir.normalize();
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
//踏步左右总长
|
|
double dSteepL = (dW/* - 2.0 * data.dSidet*/);//无论左右有无梁
|
|
|
|
AcGePoint3d ptV, ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
double dSidet(120);
|
|
|
|
if (data.nUpSide == 0)
|
|
{
|
|
ptSta += vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide);
|
|
ptSta -= vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide) * 2 * num;
|
|
}
|
|
else
|
|
{
|
|
ptSta -= vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide);
|
|
ptSta += vtLDir * ((dW - data.dBarSize[0]) * .5 - data.dBarSide) * 2 * num;
|
|
}
|
|
|
|
ptSta.z += (data.dBarH - data.dSteepH * .5);
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptSta.z -= (data.dSteepW - data.dSteepH);
|
|
ptV0 = ptSta;
|
|
arSecPts.append(ptSta);
|
|
|
|
ptSta.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptSta);
|
|
|
|
for (int i = 0; i < nCount - 1; i++)
|
|
{
|
|
ptSta -= vtL * data.dSteepW;
|
|
ptSta.z += data.dSteepH;
|
|
|
|
if (i == (nCount - 2))//只需最后踏步上位点
|
|
arSecPts.append(ptSta);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0, vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptSta - vtL * data.dSteepW;
|
|
arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1, AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if (ln3d.intersectWith(lnEnd, ptInt))
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
AcGePoint3d ptGe[4];
|
|
ptGe[0] = arSecPts.at(0);
|
|
ptGe[1] = arSecPts.at(1);
|
|
|
|
vtUp = ptGe[1] - ptGe[0];
|
|
ptGe[2] = ptInt + vtUp;
|
|
ptGe[3] = ptInt;
|
|
|
|
AcDbLine* pLine = new AcDbLine(ptGe[1], ptGe[2]);
|
|
return pLine;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawHandRailPath3d(AcGiDraw& dc
|
|
, const AcGePoint3dArray& arPts
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcDbRegion* pReg(NULL);
|
|
AcGeVector3d vec = (arPts.at(0) - arPts.at(1)).normalize();
|
|
|
|
if (!data.nBShape)
|
|
{
|
|
vec.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
|
vec.normalize();
|
|
pReg = makeRectRegion(arPts.at(0), data.dGarSize[0], data.dGarSize[1], vec, AcGeVector3d::kZAxis);
|
|
}
|
|
else
|
|
{
|
|
pReg = makeCircleRegion(arPts.at(0), vec, data.dGarSize[0] * .5);
|
|
}
|
|
|
|
if (pReg == NULL) return Acad::eOk;
|
|
AcDbPolyline* pPoly = (AcDbPolyline*)Format3dPolyline(arPts);
|
|
AcDbX3dSolid xSolid;
|
|
if (xSolid.CreateSweep(pReg, pPoly))
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbCrossStair>(&xSolid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbCrossStairDraw::DrawHandRail3d(AcGiDraw& dc
|
|
, const AcGePoint3d* ptAr
|
|
, const double& dRestL
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const int& num
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
SFSPStair data1(data);
|
|
AcDbLine* pLine1(NULL), * pLine2(NULL);
|
|
AcGePoint3dArray ptGeIn, ptGeOut;
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
//扶手伸出距离
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0);
|
|
ptGeIn.insertAt(0, ptS);
|
|
ptS += vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
ptE = ptGeIn.at(3);
|
|
ptGeIn.insertAt(3, ptE);
|
|
ptE -= vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptE);
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
ptS = ptGeIn.at(0);
|
|
ptGeIn.insertAt(0, ptS);
|
|
ptS += vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
ptE = ptGeIn.at(3);
|
|
ptGeIn.insertAt(3, ptE);
|
|
ptE -= vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptE);
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0);
|
|
ptGeIn.insertAt(0, ptS);
|
|
ptS -= vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
ptE = ptGeIn.at(3);
|
|
ptGeIn.insertAt(3, ptE);
|
|
ptE += vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptE);
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
ptS = ptGeIn.at(0);
|
|
ptGeIn.insertAt(0, ptS);
|
|
ptS -= vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
ptE = ptGeIn.at(3);
|
|
ptGeIn.insertAt(3, ptE);
|
|
ptE += vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptE);
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
} |