4494 lines
137 KiB
C++
4494 lines
137 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbParaLlelStair.h"
|
|
#include "AecDbParaLlelStairDraw.h"
|
|
#include "AecDbEarthWorm.h"
|
|
#include "AcDbX3dSolid.h"
|
|
#include "EarThwormDef.h"
|
|
#include "CoreTools.h"
|
|
#include "gpc.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(AecDbParaLlelStairDraw, AecDbXDraw, 0);
|
|
|
|
namespace
|
|
{
|
|
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);
|
|
pText->setColorIndex(1);
|
|
|
|
dc.DrawEntity(pText);
|
|
dc.Add2dBuffer(pText);
|
|
}
|
|
}
|
|
|
|
AecDbParaLlelStairDraw::AecDbParaLlelStairDraw(void)
|
|
{
|
|
}
|
|
|
|
AecDbParaLlelStairDraw::~AecDbParaLlelStairDraw(void)
|
|
{
|
|
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
|
AcDbEntity* pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbParaLlelStair* pParlStair = AecDbParaLlelStair::cast(pEntReal);
|
|
if (pParlStair == 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);
|
|
}
|
|
|
|
SFPXStair data;
|
|
memset(&data, 0, sizeof(SFPXStair));
|
|
pParlStair->GetSFPXStair(data);
|
|
|
|
//.....
|
|
AcDbVoidPtrArray arEntPtrs;
|
|
AcDbCurve* pBaseCurve = pParlStair->GetBaseCurve();
|
|
if (pBaseCurve != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta, ptEnd;
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
ptSta.z = ptEnd.z = 0.0;
|
|
|
|
AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
|
|
vtSEDir = (ptSta - ptEnd).normalize();
|
|
vtSE = vtSEDir;
|
|
vtSE.rotateBy(PI / 2.0, Z);
|
|
vtSE.normalize();
|
|
|
|
if (data.nRestShape == 0)
|
|
{
|
|
DrawRestPlatRect2d(dc, ptSta, vtSE, vtSEDir, data);
|
|
}
|
|
else if (data.nRestShape == 1)
|
|
{
|
|
DrawRestPlatCir2d(dc, ptSta, vtSE, vtSEDir, data);
|
|
}
|
|
|
|
DrawWithin(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawStairSpace2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
if (data.nSteepMs == data.nSteepsS)
|
|
{
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
DrawStair2d(dc, ptSta - vtSE * (data.dStairTW - data.dStairMW) * .5, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
|
|
|
|
DrawStair2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
else
|
|
{
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
DrawStair2d(dc, ptSta - vtSE * (data.dStairTW - data.dStairMW) * .5, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepMs, data);
|
|
}
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
|
|
}
|
|
|
|
DrawStair2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
ptSta += vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
|
|
|
|
ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepMs, data);
|
|
|
|
ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptSta -= vtSE * data.dStairTW;
|
|
DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
|
|
ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
ptSta -= vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
|
|
|
|
ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
ptSta += vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
|
|
ptSta -= vtSE * data.dStairTW;
|
|
DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
ptSta += vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
|
|
ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepMs, data);
|
|
|
|
ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptSta -= vtSE * data.dStairTW;
|
|
DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
|
|
DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
|
|
ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
ptSta -= vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
|
|
DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
|
|
|
|
ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
|
|
ptSta += vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
|
|
ptSta -= vtSE * data.dStairTW;
|
|
DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
|
|
DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////
|
|
dc.SetColor(nCrBk);
|
|
dc.SetLayer(idCurLay);
|
|
dc.SetLineType(idCurLty);
|
|
dc.Add2dBuffer(arEntPtrs);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
del3DCache<AecDbParaLlelStair>();
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
|
AcDbEntity *pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbParaLlelStair *pParlStair = AecDbParaLlelStair::cast(pEntReal);
|
|
if (pParlStair == 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));
|
|
pParlStair->GetSFPXStair(data);
|
|
|
|
AcDbCurve *pBaseCurve = pParlStair->GetBaseCurve();
|
|
if (pBaseCurve != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
if (data.nSteepsS == 15)
|
|
{
|
|
data.nSteepMs = 5;
|
|
}
|
|
else if (data.nSteepsS == 5)
|
|
{
|
|
data.nSteepMs = 15;
|
|
}
|
|
else if (data.nSteepsS == 10)//边梯步数
|
|
{
|
|
data.nSteepMs = 10;//中梯步数
|
|
}
|
|
|
|
AcGePoint3d ptSta, ptEnd, ptPathSta, ptPathEnd;
|
|
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();
|
|
|
|
DrawRestPlatform(dc, ptSta, vtSE, vtSEDir, data);
|
|
|
|
//踏步取齐
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
if (data.nUpSide == 0)
|
|
{
|
|
DrawAlignPlatMid(dc, ptSta, vtSE, vtSEDir, 0, data.nSteepMs * data.dSteepH, data);
|
|
}
|
|
else
|
|
{
|
|
DrawAlignPlatSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
|
|
}
|
|
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
if (data.nUpSide == 0)
|
|
{
|
|
DrawAlignCenMid(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
else
|
|
{
|
|
DrawAlignCenSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
}
|
|
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
if (data.nUpSide == 0)
|
|
{
|
|
DrawAlignFloorMid(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
else
|
|
{
|
|
DrawAlignFloorSide(dc, ptSta, vtSE, vtSEDir, data.nSteepsS * data.dSteepH, data);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawRestPlatRect2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptS
|
|
, const AcGeVector3d& vtL
|
|
, const AcGeVector3d& vtW
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptGe[13];
|
|
AcGePoint3d ptOrg(ptS);
|
|
AcDbPolyline* pPl(NULL);
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3 || data.nSteepMs == data.nSteepsS)
|
|
{
|
|
ptGe[0] = ptOrg;
|
|
ptGe[1] = ptGe[0] - vtW * data.dRestPtW;
|
|
ptGe[2] = ptGe[1] - vtL * data.dStairTW;
|
|
ptGe[3] = ptGe[2] + vtW * data.dRestPtW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
pPl = (AcDbPolyline*)FormatPolyline(ptGe, 5);
|
|
if (!pPl) return Acad::eOk;
|
|
pPl->setColorIndex(2);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
ptGe[0] = ptOrg;
|
|
ptGe[1] = ptGe[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[3] = ptGe[2] + vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5 + data.dGarSize[0]);
|
|
ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[5] = ptGe[4] - vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
|
|
ptGe[7] = ptGe[6] + vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[9] = ptGe[8] - vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5 + data.dGarSize[0]);
|
|
ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[11] = ptGe[10] + vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
ptGe[12] = ptGe[0];
|
|
}
|
|
|
|
if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
ptGe[0] = ptOrg;
|
|
ptGe[1] = ptGe[0] - vtW * data.dRestPtW;
|
|
ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[3] = ptGe[2] + vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[5] = ptGe[4] - vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5 + data.dGarSize[0]);
|
|
|
|
ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
|
|
ptGe[7] = ptGe[6] + vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5 + data.dGarSize[0]);
|
|
|
|
ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[9] = ptGe[8] - vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[11] = ptGe[10] + vtW * data.dRestPtW;
|
|
ptGe[12] = ptGe[0];
|
|
}
|
|
|
|
pPl = (AcDbPolyline*)FormatPolyline(ptGe, 13);
|
|
if (!pPl) return Acad::eOk;
|
|
pPl->setColorIndex(2);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
ptGe[0] = ptOrg;
|
|
ptGe[1] = ptGe[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[3] = ptGe[2] + vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW + data.dGarSize[0]);
|
|
ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[5] = ptGe[4] - vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
|
|
ptGe[7] = ptGe[6] + vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[9] = ptGe[8] - vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW + data.dGarSize[0]);
|
|
ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[11] = ptGe[10] + vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
ptGe[12] = ptGe[0];
|
|
}
|
|
|
|
if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
ptGe[0] = ptOrg;
|
|
ptGe[1] = ptGe[0] - vtW * data.dRestPtW;
|
|
ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[3] = ptGe[2] + vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[5] = ptGe[4] - vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW + data.dGarSize[0]);
|
|
ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
|
|
ptGe[7] = ptGe[6] + vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW + data.dGarSize[0]);
|
|
ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
|
|
ptGe[9] = ptGe[8] - vtW * (data.dGarExt + data.dGarSize[0]);
|
|
ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
|
|
ptGe[11] = ptGe[10] + vtW * data.dRestPtW;
|
|
ptGe[12] = ptGe[0];
|
|
}
|
|
|
|
pPl = (AcDbPolyline*)FormatPolyline(ptGe, 13);
|
|
if (!pPl) return Acad::eOk;
|
|
pPl->setColorIndex(2);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawRestPlatCir2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGeVector3d& vtL
|
|
, const AcGeVector3d& vtW
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptGeL[2];
|
|
AcGePoint3d ptGeR[2];
|
|
|
|
AcGePoint3d ptOrg(ptSta), pt, ptS, ptE, ptS1, ptE1;
|
|
AcDbPolyline *pPl(NULL), *pPl1(NULL);
|
|
|
|
AcDbVoidPtrArray ar;
|
|
AcDbRegion *pReg(NULL);
|
|
|
|
pt = ptOrg - vtL * data.dStairTW;
|
|
AcDbPolyline* pPoly = new AcDbPolyline();
|
|
pPoly->addVertexAt(0, ptOrg.convert2d(AcGePlane::kXYPlane), -1);
|
|
pPoly->addVertexAt(1, pt.convert2d(AcGePlane::kXYPlane));
|
|
if (!pPoly) return Acad::eOk;
|
|
|
|
pPoly->getStartPoint(ptS);
|
|
pPoly->getEndPoint(ptE);
|
|
ptS1 = ptS - vtW * data.dRestPtW;
|
|
ptE1 = ptE - vtW * data.dRestPtW;
|
|
|
|
ar.append(new AcDbLine(ptS, ptS1));
|
|
ar.append(new AcDbLine(ptS1, ptE1));
|
|
ar.append(new AcDbLine(ptE1, ptE));
|
|
ar.append(pPoly);
|
|
|
|
pReg = CoreTools::createRegion(ar);
|
|
if (pReg == NULL) return Acad::eOk;
|
|
|
|
pReg->setColorIndex(2);
|
|
dc.DrawEntity(pReg);
|
|
dc.Add2dBuffer(pReg);
|
|
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
ptGeL[0] = ptS;
|
|
ptGeL[1] = ptGeL[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
|
|
pPl = (AcDbPolyline*)FormatPolyline(ptGeL, 2);
|
|
if (!pPl) return Acad::eOk;
|
|
pPl->setColorIndex(2);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeR[0] = ptS - vtL * data.dStairTW;
|
|
ptGeR[1] = ptGeR[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
|
|
pPl1 = (AcDbPolyline*)FormatPolyline(ptGeR, 2);
|
|
if (!pPl1) return Acad::eOk;
|
|
pPl1->setColorIndex(2);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
|
|
{
|
|
ptGeL[0] = ptS;
|
|
ptGeL[1] = ptGeL[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
|
|
pPl = (AcDbPolyline*)FormatPolyline(ptGeL, 2);
|
|
if (!pPl) return Acad::eOk;
|
|
pPl->setColorIndex(2);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeR[0] = ptS - vtL * data.dStairTW;
|
|
ptGeR[1] = ptGeR[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
|
|
pPl1 = (AcDbPolyline*)FormatPolyline(ptGeR, 2);
|
|
if (!pPl1) return Acad::eOk;
|
|
pPl1->setColorIndex(2);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawStair2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGePoint3d& ptEnd
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const double& dist
|
|
, const int& num
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptS(ptSta), ptE;
|
|
AcGePoint3d ptGe[5];
|
|
AcDbPolyline *pPoly(NULL);
|
|
AcDbLine *pLine(NULL);
|
|
|
|
ptGe[0] = ptS - vtDir * data.dRestPtW;
|
|
ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
|
|
ptGe[2] = ptGe[1] - vt * dist;
|
|
ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl = NULL;
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptS -= vtDir * data.dRestPtW;
|
|
for (int i(0); i < num; ++i)
|
|
{
|
|
ptGe[0] = ptS - vtDir * data.dSteepW * i;
|
|
ptGe[1] = ptGe[0] - vt * dist;
|
|
pPoly = (AcDbPolyline*)FormatPolyline(ptGe, 2);
|
|
if (!pPoly) return Acad::eOk;
|
|
pPoly->setColorIndex(2);
|
|
dc.DrawEntity(pPoly);
|
|
dc.Add2dBuffer(pPoly);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawStairSpace2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGePoint3d& ptEnd
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptS(ptSta);
|
|
AcGePoint3d ptGe[5];
|
|
int num;
|
|
|
|
if (data.nSteepMs == data.nSteepsS || data.nSteepMs > data.nSteepsS)
|
|
{
|
|
num = data.nSteepMs;
|
|
}
|
|
else
|
|
{
|
|
num = data.nSteepsS;
|
|
}
|
|
|
|
ptGe[0] = ptS - vtDir * data.dRestPtW;
|
|
ptGe[0] -= vt * data.dStairSW;
|
|
ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
|
|
ptGe[2] = ptGe[1] - vt * (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5;
|
|
ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl = NULL;
|
|
pPl = FormatPolyline(ptGe, 5);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGe[0] = ptS - vtDir * data.dRestPtW;
|
|
ptGe[0] -= vt * (data.dStairTW - data.dStairSW - (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5);
|
|
ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
|
|
ptGe[2] = ptGe[1] - vt * (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5;
|
|
ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl1 = NULL;
|
|
pPl1 = FormatPolyline(ptGe, 5);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawBeam2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGePoint3d& ptEnd
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptS(ptSta);
|
|
AcGePoint3d ptGeL[5];
|
|
AcGePoint3d ptGeR[5];
|
|
AcGePoint3d ptGeL1[5];
|
|
AcGePoint3d ptGeR1[5];
|
|
|
|
double dSidet = 120;
|
|
|
|
if (data.bLBeam)
|
|
{
|
|
ptGeL[0] = ptS - vtDir * data.dRestPtW;
|
|
ptGeL[0] -= vt * (data.dStairSW - dSidet);
|
|
ptGeL[1] = ptGeL[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeL[2] = ptGeL[1] - vt * dSidet;
|
|
ptGeL[3] = ptGeL[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeL[4] = ptGeL[0];
|
|
|
|
AcDbPolyline* pPl = NULL;
|
|
pPl = FormatPolyline(ptGeL, 5);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 1)
|
|
{
|
|
ptGeL[0] += vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
}
|
|
if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 2)
|
|
{
|
|
ptGeL[0] += vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
}
|
|
if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 1)
|
|
{
|
|
ptGeL[0] -= vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
|
|
}
|
|
if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 2)
|
|
{
|
|
ptGeL[0] -= vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
|
|
}
|
|
ptGeR[0] = ptGeL[0] - vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + dSidet);
|
|
ptGeR[1] = ptGeR[0] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
|
|
ptGeR[2] = ptGeR[1] - vt * dSidet;
|
|
ptGeR[3] = ptGeR[2] + vtDir * (data.nSteepMs - 1) * data.dSteepW;
|
|
ptGeR[4] = ptGeR[0];
|
|
|
|
AcDbPolyline* pPl1 = NULL;
|
|
pPl1 = FormatPolyline(ptGeR, 5);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
ptGeL1[0] = ptGeR[0] - vt * (data.dStairMW - dSidet);
|
|
ptGeL1[1] = ptGeL1[0] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
|
|
ptGeL1[2] = ptGeL1[1] - vt * dSidet;
|
|
ptGeL1[3] = ptGeL1[2] + vtDir * (data.nSteepMs - 1) * data.dSteepW;
|
|
ptGeL1[4] = ptGeL1[0];
|
|
|
|
AcDbPolyline* pPl2 = NULL;
|
|
pPl2 = FormatPolyline(ptGeL1, 5);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 1)
|
|
{
|
|
ptGeL[0] -= vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
}
|
|
if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 2)
|
|
{
|
|
ptGeL[0] -= vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
}
|
|
if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 1)
|
|
{
|
|
ptGeL[0] += vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
|
|
}
|
|
if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 2)
|
|
{
|
|
ptGeL[0] += vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
|
|
}
|
|
ptGeR1[0] = ptGeL[0] - vt * (data.dStairTW - data.dStairSW * 2 + dSidet);
|
|
ptGeR1[1] = ptGeR1[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeR1[2] = ptGeR1[1] - vt * dSidet;
|
|
ptGeR1[3] = ptGeR1[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeR1[4] = ptGeR1[0];
|
|
|
|
AcDbPolyline* pPl3 = NULL;
|
|
pPl3 = FormatPolyline(ptGeR1, 5);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
}
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
ptGeL[0] = ptS - vtDir * data.dRestPtW;
|
|
ptGeL[1] = ptGeL[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeL[2] = ptGeL[1] - vt * dSidet;
|
|
ptGeL[3] = ptGeL[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeL[4] = ptGeL[0];
|
|
|
|
AcDbPolyline* pPl = NULL;
|
|
pPl = FormatPolyline(ptGeL, 5);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeR[0] = ptGeL[0] - vt * (data.dStairTW - dSidet);
|
|
ptGeR[1] = ptGeR[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeR[2] = ptGeR[1] - vt * dSidet;
|
|
ptGeR[3] = ptGeR[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
|
|
ptGeR[4] = ptGeR[0];
|
|
|
|
AcDbPolyline* pPl1 = NULL;
|
|
pPl1 = FormatPolyline(ptGeR, 5);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawOutHandRail2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGePoint3d& ptEnd
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptOrg(ptSta);
|
|
AcGePoint3d pt0, pt1, pt2, pt3;
|
|
AcGePoint3d ptGe[5];
|
|
|
|
if (data.bOutSideHRail)
|
|
{
|
|
ptOrg -= vtDir * (data.dRestPtW + (data.nSteepsS - 1) * data.dSteepW * .5);
|
|
ptOrg -= vt * (data.dBarSide + data.dGarSize[0] * .5);
|
|
if (data.nSteepMs == data.nSteepsS)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
}
|
|
|
|
else if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
}
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
}
|
|
}
|
|
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
}
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
|
|
pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt2 = pt1 - vt * data.dGarSize[0];
|
|
pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
}
|
|
}
|
|
|
|
ptGe[0] = pt0;
|
|
ptGe[1] = pt1;
|
|
ptGe[2] = pt2;
|
|
ptGe[3] = pt3;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGe, 5);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawInHandRail2d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const AcGePoint3d& ptEnd
|
|
, const AcGeVector3d& vt
|
|
, const AcGeVector3d& vtDir
|
|
, const double& dBarL
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptOrg(ptSta);
|
|
AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7;
|
|
AcGePoint3d ptGeL[5];
|
|
AcGePoint3d ptGeR[5];
|
|
|
|
ptOrg -= vtDir * (data.dRestPtW + (dBarL- 1) * data.dSteepW * .5);
|
|
ptOrg -= vt * (data.dStairSW + (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 * .5);
|
|
|
|
pt0 = ptOrg + vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 * .5 + data.dBarSide);
|
|
pt0 += vtDir * ((dBarL - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt1 = pt0 - vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt2 = pt1 - vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dBarSide * 2);
|
|
pt3 = pt2 + vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
|
|
ptGeL[0] = pt0;
|
|
ptGeL[1] = pt1;
|
|
ptGeL[2] = pt2;
|
|
ptGeL[3] = pt3;
|
|
ptGeL[4] = ptGeL[0];
|
|
|
|
AcDbPolyline *pPl = FormatPolyline(ptGeL, 5);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
AcDbVoidPtrArray ar;
|
|
pPl->getOffsetCurves(60, ar);
|
|
if (ar.isEmpty()) return Acad::eOk;
|
|
AcDbPolyline* pNewPoly = (AcDbPolyline*)(((AcDbEntity*)ar.first())->clone());
|
|
deleteArrayVoidPtrs<AcDbEntity>(ar);
|
|
if (pNewPoly == NULL) return Acad::eOk;
|
|
pNewPoly->setColorIndex(2);
|
|
dc.DrawEntity(pNewPoly);
|
|
dc.Add2dBuffer(pNewPoly);
|
|
|
|
ptOrg -= vt * (data.dStairMW + (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5);
|
|
pt4 = ptOrg + vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 * .5 + data.dBarSide);
|
|
pt4 += vtDir * ((dBarL - 1) * data.dSteepW * .5 + data.dGarExt);
|
|
pt5 = pt4 - vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
pt6 = pt5 - vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dBarSide * 2);
|
|
pt7 = pt6 + vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
|
|
|
|
ptGeR[0] = pt4;
|
|
ptGeR[1] = pt5;
|
|
ptGeR[2] = pt6;
|
|
ptGeR[3] = pt7;
|
|
ptGeR[4] = ptGeR[0];
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeR, 5);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
AcDbVoidPtrArray ar1;
|
|
pPl1->getOffsetCurves(60, ar1);
|
|
if (ar1.isEmpty()) return Acad::eOk;
|
|
AcDbPolyline* pNewPoly1 = (AcDbPolyline*)(((AcDbEntity*)ar1.first())->clone());
|
|
deleteArrayVoidPtrs<AcDbEntity>(ar1);
|
|
if (pNewPoly1 == NULL) return Acad::eOk;
|
|
pNewPoly1->setColorIndex(2);
|
|
dc.DrawEntity(pNewPoly1);
|
|
dc.Add2dBuffer(pNewPoly1);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawWithin(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, pt11, pt12, pt13, pt14;
|
|
AcGePoint3d ptGeIn[3];
|
|
AcGePoint3d ptGeOut[4];
|
|
double dCir;
|
|
double dScale = CoreTools::getPScaleForSymb();
|
|
double dW(dScale * .8);
|
|
double dH(dScale * 3);
|
|
double dTextH(dScale * 3.5);
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
double angle = vtDir.angleTo(AcGeVector3d::kXAxis) - PI * .5;
|
|
|
|
if (data.nRestShape == 1)
|
|
{
|
|
dCir = data.dRestPtW;
|
|
}
|
|
else
|
|
{
|
|
dCir = 0;
|
|
}
|
|
|
|
if (!data.nUpSide)
|
|
{
|
|
if (data.nSteepMs == data.nSteepsS || data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt5 = pt4 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeIn[0] = pt3;
|
|
ptGeIn[1] = pt4;
|
|
ptGeIn[2] = pt5;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
|
|
pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt8 = pt7 - vtDir * dH;
|
|
|
|
ptGeIn[0] = pt6;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
pPl2->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
|
|
ptGeOut[0] = pt3;
|
|
ptGeOut[1] = pt9;
|
|
ptGeOut[2] = pt10;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
}
|
|
|
|
else if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
|
|
pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt5 = pt4 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeIn[0] = pt3;
|
|
ptGeIn[1] = pt4;
|
|
ptGeIn[2] = pt5;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
|
|
pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt8 = pt7 - vtDir * dH;
|
|
|
|
ptGeIn[0] = pt6;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
pPl2->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
|
|
|
|
ptGeOut[0] = pt3;
|
|
ptGeOut[1] = pt9;
|
|
ptGeOut[2] = pt10;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
|
|
pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt5 = pt4 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeIn[0] = pt3;
|
|
ptGeIn[1] = pt4;
|
|
ptGeIn[2] = pt5;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
|
|
pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt8 = pt7 - vtDir * dH;
|
|
|
|
ptGeIn[0] = pt6;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
pPl2->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
|
|
|
|
ptGeOut[0] = pt3;
|
|
ptGeOut[1] = pt9;
|
|
ptGeOut[2] = pt10;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
}
|
|
}
|
|
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps + (data.nSteepsS - data.nSteepMs) * .5) * data.dSteepW + dCir);
|
|
pt5 = pt4 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeIn[0] = pt3;
|
|
ptGeIn[1] = pt4;
|
|
ptGeIn[2] = pt5;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
|
|
pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt8 = pt7 - vtDir * dH;
|
|
|
|
ptGeIn[0] = pt6;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
pPl2->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
|
|
ptGeOut[0] = pt3;
|
|
ptGeOut[1] = pt9;
|
|
ptGeOut[2] = pt10;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps + (data.nSteepsS - data.nSteepMs)) * data.dSteepW + dCir);
|
|
pt5 = pt4 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
ptGeIn[0] = pt3;
|
|
ptGeIn[1] = pt4;
|
|
ptGeIn[2] = pt5;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
|
|
pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt8 = pt7 - vtDir * dH;
|
|
|
|
ptGeIn[0] = pt6;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
pPl2->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
|
|
ptGeOut[0] = pt3;
|
|
ptGeOut[1] = pt9;
|
|
ptGeOut[2] = pt10;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
}
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
if (data.nSteepMs == data.nSteepsS || data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
pPl->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt4;
|
|
ptGeOut[1] = pt5;
|
|
ptGeOut[2] = pt6;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5) * data.dSteepW + dCir);
|
|
|
|
ptGeIn[0] = pt4;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
|
|
ptGeIn[0] = pt7;
|
|
ptGeIn[1] = pt9;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt11 = pt10 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt9;
|
|
ptGeOut[1] = pt10;
|
|
ptGeOut[2] = pt11;
|
|
|
|
AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl4 == NULL) return Acad::eOk;
|
|
pPl4->setColorIndex(3);
|
|
pPl4->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl4);
|
|
dc.Add2dBuffer(pPl4);
|
|
|
|
pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt14 = pt13 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt12;
|
|
ptGeOut[1] = pt13;
|
|
ptGeOut[2] = pt14;
|
|
|
|
AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl5 == NULL) return Acad::eOk;
|
|
pPl5->setColorIndex(3);
|
|
pPl5->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl5);
|
|
dc.Add2dBuffer(pPl5);
|
|
}
|
|
|
|
else if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
pPl->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
|
|
pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt4;
|
|
ptGeOut[1] = pt5;
|
|
ptGeOut[2] = pt6;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5) * data.dSteepW + dCir);
|
|
|
|
ptGeIn[0] = pt4;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
|
|
ptGeIn[0] = pt7;
|
|
ptGeIn[1] = pt9;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
|
|
pt11 = pt10 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt9;
|
|
ptGeOut[1] = pt10;
|
|
ptGeOut[2] = pt11;
|
|
|
|
AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl4 == NULL) return Acad::eOk;
|
|
pPl4->setColorIndex(3);
|
|
pPl4->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl4);
|
|
dc.Add2dBuffer(pPl4);
|
|
|
|
pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
|
|
pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt14 = pt13 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt12;
|
|
ptGeOut[1] = pt13;
|
|
ptGeOut[2] = pt14;
|
|
|
|
AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl5 == NULL) return Acad::eOk;
|
|
pPl5->setColorIndex(3);
|
|
pPl5->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl5);
|
|
dc.Add2dBuffer(pPl5);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
pPl->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
|
|
pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt4;
|
|
ptGeOut[1] = pt5;
|
|
ptGeOut[2] = pt6;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5) * data.dSteepW + dCir);
|
|
|
|
ptGeIn[0] = pt4;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
|
|
ptGeIn[0] = pt7;
|
|
ptGeIn[1] = pt9;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
|
|
pt11 = pt10 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt9;
|
|
ptGeOut[1] = pt10;
|
|
ptGeOut[2] = pt11;
|
|
|
|
AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl4 == NULL) return Acad::eOk;
|
|
pPl4->setColorIndex(3);
|
|
pPl4->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl4);
|
|
dc.Add2dBuffer(pPl4);
|
|
|
|
pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
|
|
pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt14 = pt13 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt12;
|
|
ptGeOut[1] = pt13;
|
|
ptGeOut[2] = pt14;
|
|
|
|
AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl5 == NULL) return Acad::eOk;
|
|
pPl5->setColorIndex(3);
|
|
pPl5->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl5);
|
|
dc.Add2dBuffer(pPl5);
|
|
}
|
|
}
|
|
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
pPl->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt4;
|
|
ptGeOut[1] = pt5;
|
|
ptGeOut[2] = pt6;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5 + (data.nSteepsS - data.nSteepMs) * .5) * data.dSteepW + dCir);
|
|
|
|
ptGeIn[0] = pt4;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
|
|
ptGeIn[0] = pt7;
|
|
ptGeIn[1] = pt9;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt11 = pt10 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt9;
|
|
ptGeOut[1] = pt10;
|
|
ptGeOut[2] = pt11;
|
|
|
|
AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl4 == NULL) return Acad::eOk;
|
|
pPl4->setColorIndex(3);
|
|
pPl4->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl4);
|
|
dc.Add2dBuffer(pPl4);
|
|
|
|
pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt14 = pt13 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt12;
|
|
ptGeOut[1] = pt13;
|
|
ptGeOut[2] = pt14;
|
|
|
|
AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl5 == NULL) return Acad::eOk;
|
|
pPl5->setColorIndex(3);
|
|
pPl5->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl5);
|
|
dc.Add2dBuffer(pPl5);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt1 -= vt * data.dStairSW * .5;
|
|
pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
|
|
pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt3 = pt2 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt1;
|
|
ptGeOut[1] = pt2;
|
|
ptGeOut[2] = pt3;
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
|
|
if (pPl == NULL) return Acad::eOk;
|
|
pPl->setColorIndex(3);
|
|
pPl->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
|
|
pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt6 = pt5 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt4;
|
|
ptGeOut[1] = pt5;
|
|
ptGeOut[2] = pt6;
|
|
|
|
AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl1 == NULL) return Acad::eOk;
|
|
pPl1->setColorIndex(3);
|
|
pPl1->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl1);
|
|
dc.Add2dBuffer(pPl1);
|
|
|
|
pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5 + (data.nSteepsS - data.nSteepMs)) * data.dSteepW + dCir);
|
|
|
|
ptGeIn[0] = pt4;
|
|
ptGeIn[1] = pt7;
|
|
ptGeIn[2] = pt8;
|
|
|
|
AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
|
|
if (pPl2 == NULL) return Acad::eOk;
|
|
pPl2->setColorIndex(3);
|
|
dc.DrawEntity(pPl2);
|
|
dc.Add2dBuffer(pPl2);
|
|
|
|
pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;
|
|
|
|
ptGeIn[0] = pt7;
|
|
ptGeIn[1] = pt9;
|
|
|
|
AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
|
|
if (pPl3 == NULL) return Acad::eOk;
|
|
pPl3->setColorIndex(3);
|
|
dc.DrawEntity(pPl3);
|
|
dc.Add2dBuffer(pPl3);
|
|
|
|
pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
|
|
pt11 = pt10 + vtDir * dH;
|
|
|
|
ptGeOut[0] = pt9;
|
|
ptGeOut[1] = pt10;
|
|
ptGeOut[2] = pt11;
|
|
|
|
AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl4 == NULL) return Acad::eOk;
|
|
pPl4->setColorIndex(3);
|
|
pPl4->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl4);
|
|
dc.Add2dBuffer(pPl4);
|
|
|
|
pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
|
|
pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
|
|
pt14 = pt13 - vtDir * dH;
|
|
|
|
ptGeOut[0] = pt12;
|
|
ptGeOut[1] = pt13;
|
|
ptGeOut[2] = pt14;
|
|
|
|
AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
|
|
if (pPl5 == NULL) return Acad::eOk;
|
|
pPl5->setColorIndex(3);
|
|
pPl5->setWidthsAt(1, 0, dW);
|
|
dc.DrawEntity(pPl5);
|
|
dc.Add2dBuffer(pPl5);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawSide3d(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const SFPXStair& data
|
|
, const double& dW) const
|
|
{
|
|
if (data.bLBeam || data.bRBeam)
|
|
{
|
|
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 - 1;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总长
|
|
double dSteepL = (dW/* - 2.0 * data.dSidet*/);//无论左右有无梁
|
|
|
|
AcGePoint3d ptV, ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
//插入楼板的点 [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;
|
|
if (i == (nCount - 2))//只需最后踏步上位点
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0, vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1, AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if (ln3d.intersectWith(lnEnd, ptInt))
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
//闭合
|
|
arSecPts.append(arSecPts.first());
|
|
|
|
AcGePoint3d ptGe[5];
|
|
|
|
ptGe[0] = arSecPts.at(0);
|
|
ptGe[1] = arSecPts.at(1);
|
|
|
|
vtUp = ptGe[1] - ptGe[0];
|
|
ptGe[2] = ptInt + vtUp;
|
|
ptGe[3] = ptInt;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
double dSidet = 120;
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe[1]);
|
|
ln.setEndPoint(ptGe[1] + vtW * dSidet);
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pReg != NULL)
|
|
{
|
|
//TEST
|
|
//AcDbEntity* pRegCln = (AcDbEntity*)pReg->clone();
|
|
//pRegCln->setColorIndex(4);
|
|
//CoreTools::CloneAndAddToModelSpace(pRegCln);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if (xSolid.CreateExtrude(pReg, ln))
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
if (data.bLBeam)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbParaLlelStair>(&xSolid);
|
|
}
|
|
|
|
AcGeMatrix3d xform;
|
|
vtW *= (dW - dSidet);
|
|
xform.setTranslation(vtW);
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
AcDb3dSolid* pOtherSide = (AcDb3dSolid*)pSolid->clone();
|
|
if (pOtherSide != NULL)
|
|
{
|
|
pOtherSide->transformBy(xform);
|
|
dc.DrawEntity(pOtherSide);
|
|
dc.Add3dBuffer(pOtherSide);
|
|
xSolid.TransformBy(xform);
|
|
add3DCache<AecDbParaLlelStair>(&xSolid);
|
|
}
|
|
}
|
|
|
|
if (!data.bLBeam && pSolid != NULL)
|
|
delete pSolid;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::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<AecDbParaLlelStair>(&xSolid);
|
|
return Acad::eOk;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawPlatform(AcGiDraw& dc
|
|
, const AcGePoint3d& ptSta
|
|
, const double& dL
|
|
, const double& dW
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const int& bRect, const SFSPStair& data) const
|
|
{
|
|
AcDbRegion *pReg(NULL);
|
|
AcGePoint3d ptOrg(ptSta), pt;
|
|
AcDbLine ln;
|
|
|
|
if (!bRect)
|
|
{
|
|
ptOrg -= vtSE * dL * .5;
|
|
ptOrg -= vtSEDir * dW * .5;
|
|
pReg = makeRectRegion(ptOrg, dL, dW, vtSE, vtSEDir);
|
|
if (pReg == NULL) return Acad::eOk;
|
|
}
|
|
else
|
|
{
|
|
AcDbVoidPtrArray ar;
|
|
AcGePoint3d ptS, ptE, ptS1, ptE1;
|
|
|
|
pt = ptOrg - vtSE * data.dStairTW;
|
|
AcDbPolyline* pPoly = new AcDbPolyline();
|
|
pPoly->addVertexAt(0, ptOrg.convert2d(AcGePlane::kXYPlane), -1);
|
|
pPoly->addVertexAt(1, pt.convert2d(AcGePlane::kXYPlane));
|
|
if (!pPoly) return Acad::eOk;
|
|
|
|
pPoly->getStartPoint(ptS);
|
|
pPoly->getEndPoint(ptE);
|
|
ptS1 = ptS - vtSEDir * dW;
|
|
ptE1 = ptE - vtSEDir * dW;
|
|
|
|
ar.append(new AcDbLine(ptS, ptS1));
|
|
ar.append(new AcDbLine(ptS1, ptE1));
|
|
ar.append(new AcDbLine(ptE1, ptE));
|
|
ar.append(pPoly);
|
|
|
|
pReg = CoreTools::createRegion(ar);
|
|
if (pReg == NULL) return Acad::eOk;
|
|
|
|
deleteArrayVoidPtrs<AcDbEntity>(ar);
|
|
|
|
AcDbExtents ext;
|
|
pReg->getGeomExtents(ext);
|
|
AcGePoint3d ptCen(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
|
|
ptOrg = ptCen;
|
|
}
|
|
|
|
ln.setStartPoint(ptOrg);
|
|
ln.setEndPoint(ptOrg - AcGeVector3d::kZAxis * data.dSbThick);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
AcGeMatrix3d mat;
|
|
double dH(.0);
|
|
if (xSolid.CreateExtrude(pReg, ln))
|
|
{
|
|
AcDb3dSolid *pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
if (data.nUpSide == 0)
|
|
{
|
|
dH = data.nSteepMs * data.dSteepH + data.dBomEl;
|
|
}
|
|
else
|
|
{
|
|
dH = data.nSteepsS * data.dSteepH + data.dBomEl;
|
|
}
|
|
|
|
if (data.nRestShape == 0)
|
|
{
|
|
dH -= data.dBomEl;
|
|
}
|
|
|
|
mat.setTranslation(AcGeVector3d::kZAxis * dH);
|
|
pSolid->transformBy(mat);
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
xSolid.TransformBy(mat);
|
|
add3DCache<AecDbParaLlelStair>(&xSolid);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignPlatMid(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const double& dCenter
|
|
, const double& dSide
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr), ptEnd;
|
|
SFSPStair data1(data);
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d ptGeL[4];
|
|
AcGePoint3d ptGeR[4];
|
|
|
|
ptSta += Z * dCenter;
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepMs - 1) * data1.dSteepW);
|
|
ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairMW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairMW);
|
|
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptSta;
|
|
ptGeL[1] = ptEnd;
|
|
|
|
ptGeR[0] = ptSta;
|
|
ptGeR[1] = ptEnd;
|
|
|
|
ptSta += Z * dSide;
|
|
ptEnd += Z * dSide;
|
|
|
|
ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptEnd += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptSta -= vtSEDir * data.dSteepW;
|
|
ptEnd -= vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptEnd;
|
|
ptGeL[3] = ptSta;
|
|
|
|
ptSta -= vtSE * (data.dStairTW - data.dStairSW);
|
|
ptEnd -= vtSE * (data.dStairTW - data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptEnd;
|
|
ptGeR[3] = ptSta;
|
|
|
|
DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignCenMid(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
|
|
SFPXStair data1(data);
|
|
AcGePoint3d ptGeL[4];
|
|
AcGePoint3d ptGeR[4];
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
if (data1.nSteepMs > data1.nSteepsS)
|
|
{
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepMs - 1) * data1.dSteepW);
|
|
ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptSta;
|
|
ptGeL[1] = ptEnd;
|
|
|
|
ptGeR[0] = ptSta;
|
|
ptGeR[1] = ptEnd;
|
|
|
|
ptSta += Z * data1.nSteepMs * data1.dSteepH;
|
|
ptEnd += Z * data1.nSteepMs * data1.dSteepH;
|
|
ptSta -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
|
|
ptEnd -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
|
|
ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptEnd += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptSta -= vtSEDir * data.dSteepW;
|
|
ptEnd -= vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptEnd;
|
|
ptGeL[3] = ptSta;
|
|
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptEnd;
|
|
ptGeR[3] = ptSta;
|
|
|
|
DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS)
|
|
{
|
|
//中梯
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepsS - data1.nSteepMs - 2) * data1.dSteepW * .5);
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairMW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairMW);
|
|
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptEnd;
|
|
ptGeL[1] = ptSta;
|
|
|
|
ptGeR[0] = ptEnd;
|
|
ptGeR[1] = ptSta;
|
|
|
|
ptSta += Z * data1.nSteepMs * data1.dSteepH;
|
|
ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
|
|
ptSta -= vtSEDir * data.dSteepW;
|
|
ptEnd -= vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptSta;
|
|
ptGeL[3] = ptEnd;
|
|
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptSta;
|
|
ptGeR[3] = ptEnd;
|
|
|
|
DrawHandRail3d(dc, ptGeL, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if(data1.nSteepMs == data1.nSteepsS)
|
|
{
|
|
DrawAlignPlatMid(dc, ptSta, vtSE, vtSEDir, 0, data.nSteepMs* data.dSteepH, data);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignFloorMid(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
|
|
SFPXStair data1(data);
|
|
AcGePoint3d ptGeL[4] ;
|
|
AcGePoint3d ptGeR[4];
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
if (data1.nSteepMs > data1.nSteepsS)
|
|
{
|
|
//中梯
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepMs - 1) * data1.dSteepW);
|
|
ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
data1.nSteepS = data1.nSteepMs;
|
|
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptSta;
|
|
ptGeL[1] = ptEnd;
|
|
|
|
ptGeR[0] = ptSta;
|
|
ptGeR[1] = ptEnd;
|
|
|
|
//边梯
|
|
ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptEnd += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptSta += Z * data1.nSteepMs * data1.dSteepH;
|
|
ptEnd += Z * data1.nSteepMs * data1.dSteepH;
|
|
ptSta -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW);
|
|
ptEnd -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW);
|
|
ptSta -= vtSEDir * data.dSteepW;
|
|
ptEnd -= vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptEnd;
|
|
ptGeL[3] = ptSta;
|
|
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
data1.nSteepS = data1.nSteepsS;
|
|
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptEnd;
|
|
ptGeR[3] = ptSta;
|
|
|
|
DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);
|
|
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS)
|
|
{
|
|
//中梯
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
ptSta -= vtSEDir * ((data1.nSteepsS - data1.nSteepMs - 1) * data1.dSteepW);
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairMW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairMW);
|
|
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptEnd;
|
|
ptGeL[1] = ptSta;
|
|
|
|
ptGeR[0] = ptEnd;
|
|
ptGeR[1] = ptSta;
|
|
|
|
ptSta += Z * data1.nSteepMs * data1.dSteepH;
|
|
ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
|
|
ptSta -= vtSEDir * data.dSteepW;
|
|
ptEnd -= vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptSta;
|
|
ptGeL[3] = ptEnd;
|
|
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptSta;
|
|
ptGeR[3] = ptEnd;
|
|
|
|
DrawHandRail3d(dc, ptGeL, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if (data1.nSteepMs == data1.nSteepsS)
|
|
{
|
|
DrawAlignPlatMid(dc, ptSta, vtSE, vtSEDir, 0, data.nSteepMs * data.dSteepH, data);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignPlatSide(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
|
|
SFPXStair data1(data);
|
|
AcGePoint3d ptGeL[4];
|
|
AcGePoint3d ptGeR[4];
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
ptSta += Z * data1.nSteepsS * data1.dSteepH;
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairMW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptSta;
|
|
ptGeL[1] = ptEnd;
|
|
|
|
ptGeR[0] = ptSta;
|
|
ptGeR[1] = ptEnd;
|
|
|
|
ptSta -= Z * data1.nSteepsS * data1.dSteepH;
|
|
ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
|
|
ptSta += vtSEDir * data.dSteepW;
|
|
ptEnd += vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptEnd;
|
|
ptGeL[3] = ptSta;
|
|
|
|
ptSta -= vtSE * (data.dStairTW - data.dStairSW);
|
|
ptEnd -= vtSE * (data.dStairTW - data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptEnd;
|
|
ptGeR[3] = ptSta;
|
|
|
|
DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignCenSide(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const SFPXStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
|
|
SFPXStair data1(data);
|
|
AcGePoint3d ptGeL[4];
|
|
AcGePoint3d ptGeR[4];
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
if (data1.nSteepMs > data1.nSteepsS)
|
|
{
|
|
ptSta += Z * data1.nSteepsS * data1.dSteepH;
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptSta;
|
|
ptGeL[1] = ptEnd;
|
|
|
|
ptGeR[0] = ptSta;
|
|
ptGeR[1] = ptEnd;
|
|
|
|
ptSta -= Z * data1.nSteepsS * data1.dSteepH;
|
|
ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
|
|
ptSta -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
|
|
ptEnd -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
|
|
ptSta += vtSEDir * data.dSteepW;
|
|
ptEnd += vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptEnd;
|
|
ptGeL[3] = ptSta;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptEnd;
|
|
ptGeR[3] = ptSta;
|
|
|
|
DrawHandRail3d(dc, ptGeL, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS)
|
|
{
|
|
ptSta += Z * data1.nSteepsS * data1.dSteepH;
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5);
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptSta;
|
|
ptGeL[1] = ptEnd;
|
|
|
|
ptGeR[0] = ptSta;
|
|
ptGeR[1] = ptEnd;
|
|
|
|
ptSta -= Z * data1.nSteepsS * data1.dSteepH;
|
|
ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5;
|
|
ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
|
|
ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
|
|
ptSta += vtSEDir * data.dSteepW;
|
|
ptEnd += vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptEnd;
|
|
ptGeL[3] = ptSta;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptEnd;
|
|
ptGeR[3] = ptSta;
|
|
|
|
DrawHandRail3d(dc, ptGeL, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if (data1.nSteepMs == data1.nSteepsS)
|
|
{
|
|
DrawAlignPlatSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignFloorSide(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const double& dCenter
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr), ptEnd;
|
|
SFSPStair data1(data);
|
|
AcGePoint3d ptGeL[4];
|
|
AcGePoint3d ptGeR[4];
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
if (data1.nSteepMs > data1.nSteepsS)
|
|
{
|
|
ptSta += Z * dCenter;
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + data1.nSteepsS * data1.dSteepW);
|
|
ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW;
|
|
ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairMW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptEnd;
|
|
ptGeL[1] = ptSta;
|
|
|
|
ptGeR[0] = ptEnd;
|
|
ptGeR[1] = ptSta;
|
|
|
|
ptSta -= Z * dCenter;
|
|
ptEnd -= Z * dCenter;
|
|
ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptEnd += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptSta += vtSEDir * data.dSteepW;
|
|
ptEnd += vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptSta;
|
|
ptGeL[3] = ptEnd;
|
|
|
|
ptSta -= vtSE * (data.dStairTW - data.dStairSW);
|
|
ptEnd -= vtSE * (data.dStairTW - data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptSta;
|
|
ptGeR[3] = ptEnd;
|
|
|
|
DrawHandRail3d(dc, ptGeL, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS)
|
|
{
|
|
ptSta += Z * dCenter;
|
|
ptSta -= vtSE * data1.dStairTW * .5;
|
|
ptSta -= vtSEDir * (data1.dRestPtW + data1.nSteepsS * data1.dSteepW);
|
|
ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepMs;
|
|
DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairMW);
|
|
DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairMW);
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
|
|
}
|
|
|
|
ptGeL[0] = ptEnd;
|
|
ptGeL[1] = ptSta;
|
|
|
|
ptGeR[0] = ptEnd;
|
|
ptGeR[1] = ptSta;
|
|
|
|
ptSta -= Z * dCenter;
|
|
ptEnd -= Z * dCenter;
|
|
ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptEnd += vtSE * (data.dStairTW - data.dStairSW) * .5;
|
|
ptSta += vtSEDir * data.dSteepW;
|
|
ptEnd += vtSEDir * data.dSteepW;
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeL[2] = ptSta;
|
|
ptGeL[3] = ptEnd;
|
|
|
|
ptSta -= vtSE * (data.dStairTW - data.dStairSW);
|
|
ptEnd -= vtSE * (data.dStairTW - data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
if (data.bInsideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
|
|
}
|
|
if (data.bOutSideRail)
|
|
{
|
|
DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
|
|
}
|
|
|
|
ptGeR[2] = ptSta;
|
|
ptGeR[3] = ptEnd;
|
|
|
|
DrawHandRail3d(dc, ptGeL, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 0, data1);
|
|
DrawHandRail3d(dc, ptGeR, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 1, data1);
|
|
}
|
|
|
|
else if (data1.nSteepMs == data1.nSteepsS)
|
|
{
|
|
DrawAlignPlatSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawRestPlatform(AcGiDraw& dc
|
|
, const AcGePoint3d& ptFr
|
|
, const AcGeVector3d& vtSE
|
|
, const AcGeVector3d& vtSEDir
|
|
, const SFSPStair& data) const
|
|
{
|
|
AcGePoint3d ptSta(ptFr);
|
|
SFSPStair data1(data);
|
|
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
|
|
|
if (data1.nRestShape == 0)
|
|
{
|
|
DrawPlatform(dc, ptSta, data.dStairTW, data.dRestPtW, vtSE, vtSEDir, 0, data);
|
|
}
|
|
else if (data1.nRestShape == 1)
|
|
{
|
|
ptSta -= Z * data.dBomEl;
|
|
DrawPlatform(dc, ptSta, data.dStairTW, data.dRestPtW, vtSE, vtSEDir, 1, data);
|
|
}
|
|
|
|
if (data1.nSteepMs > data1.nSteepsS && data1.nSteepAlign == 1)
|
|
{
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5, vtSE, vtSEDir, 0, data);
|
|
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5, vtSE, vtSEDir, 0, data);
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS && data1.nSteepAlign == 1)
|
|
{
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairMW) * .5;
|
|
DrawPlatform(dc, ptSta, data.dStairMW, (data.nSteepsS - data.nSteepMs)* data.dSteepW * .5, vtSE, vtSEDir, 0, data);
|
|
}
|
|
|
|
else if (data1.nSteepMs > data1.nSteepsS && data1.nSteepAlign == 2)
|
|
{
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW, vtSE, vtSEDir, 0, data);
|
|
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
|
|
DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW, vtSE, vtSEDir, 0, data);
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS && data1.nSteepAlign == 2)
|
|
{
|
|
ptSta -= vtSEDir * data1.dRestPtW;
|
|
ptSta -= vtSE * (data1.dStairTW - data1.dStairMW) * .5;
|
|
DrawPlatform(dc, ptSta, data.dStairMW, (data.nSteepsS - data.nSteepMs) * data.dSteepW, vtSE, vtSEDir, 0, data);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//栏杆
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawGuard(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.dGarSize[0]) * .5 - data.dBarSide);
|
|
ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
|
|
}
|
|
else
|
|
{
|
|
ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
|
|
ptSta += vtLDir * ((dW - data.dGarSize[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; 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<AecDbParaLlelStair>(&xSolid);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//扶手
|
|
AcDbLine* AecDbParaLlelStairDraw::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;
|
|
|
|
if (data.nUpSide == 0)
|
|
{
|
|
ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
|
|
ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
|
|
}
|
|
else
|
|
{
|
|
ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
|
|
ptSta += vtLDir * ((dW - data.dGarSize[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 AecDbParaLlelStairDraw::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<AecDbParaLlelStair>(&xSolid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbParaLlelStairDraw::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, pt;
|
|
SFSPStair data1(data);
|
|
AcDbLine* pLine1(NULL);
|
|
AcGePoint3dArray ptGeIn, ptGeOut;
|
|
|
|
AcGeVector3d vtM, vtS;
|
|
double dTanAngle = data.dSteepH / data.dSteepW;
|
|
double dOutStr = sqrt(data.dSteepH * data.dSteepH + data.dSteepW * data.dSteepW);
|
|
double dSinAngle = data.dSteepH / dOutStr;
|
|
double dCosAngle = data.dSteepW / dOutStr;
|
|
|
|
AcGePoint3d ptGe[4];
|
|
AcDbLine* pLineM(NULL), * pLineS(NULL);
|
|
|
|
if (data.nSteepMs > data.nSteepsS)
|
|
{
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
ptGe[2] = ptGe[2] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGe[3] = ptGe[3] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
ptGe[2] = ptGe[2] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGe[3] = ptGe[3] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2];
|
|
ptGe[3] = ptGe[3];
|
|
}
|
|
|
|
/*ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);*/
|
|
}
|
|
else if (data.nSteepMs < data.nSteepsS)
|
|
{
|
|
ptGe[0] = ptGe[0];
|
|
ptGe[1] = ptGe[1];
|
|
|
|
/*ptGe[0] = ptGe[0] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);
|
|
ptGe[1] = ptGe[1] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);*/
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
ptGe[0] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW * .5;
|
|
ptGe[1] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW * .5;
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
ptGe[0] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW;
|
|
ptGe[1] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW;
|
|
}
|
|
}
|
|
|
|
if (data1.nSteepMs == data1.nSteepsS)
|
|
{
|
|
if (data.nUpSide == 0)
|
|
{
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
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);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
ptGe[0] = ptGeIn[0];
|
|
ptGe[1] = ptGeIn[1];
|
|
ptGe[2] = ptGeIn[2];
|
|
ptGe[3] = ptGeIn[3];
|
|
|
|
ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
|
|
pLineM = new AcDbLine(ptGe[0], ptGe[1]);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
}
|
|
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
data1.nSteepS = data1.nSteepsS;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
//转角伸出
|
|
if (UP_ZERO(data1.dGarExt))
|
|
{
|
|
ptE = ptGeIn.at(2) + vtDir * data.dGarExt;
|
|
ptGeIn.append(ptE);
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data1.nSteepS = data1.nSteepMs;
|
|
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);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
ptGe[0] = ptGeIn[0];
|
|
ptGe[1] = ptGeIn[1];
|
|
ptGe[2] = ptGeIn[2];
|
|
ptGe[3] = ptGeIn[3];
|
|
|
|
ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
|
|
pLineM = new AcDbLine(ptGe[0], ptGe[1]);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
|
|
/*pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);*/
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
/*pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);*/
|
|
}
|
|
}
|
|
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
//转角伸出
|
|
if (UP_ZERO(data1.dGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptE = ptGeIn.at(2) - vtDir * data.dZGarExt;
|
|
ptGeIn.append(ptE);
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (data1.nSteepMs > data1.nSteepsS)
|
|
{
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
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);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
ptGe[0] = ptGeIn[0];
|
|
ptGe[1] = ptGeIn[1];
|
|
ptGe[2] = ptGeIn[2];
|
|
ptGe[3] = ptGeIn[3];
|
|
|
|
ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
|
|
pLineM = new AcDbLine(ptGe[0], ptGe[1]);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
pt += vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
/*pt = ptGe[2] + vtDir * data.dZGarExt;
|
|
ptGeIn.insertAt(4, pt);*/
|
|
}
|
|
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt -= vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
/*pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGeIn.insertAt(5, pt);*/
|
|
|
|
pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
/*ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGeIn.insertAt(5, pt);*/
|
|
|
|
pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
pt -= vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
if (data.nSteepAlign == 0)
|
|
{
|
|
/*pt = ptGe[2] + vtDir * data.dZGarExt;
|
|
ptGeIn.insertAt(4, pt);*/
|
|
}
|
|
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
|
|
pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt -= vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
else if (data.nSteepAlign == 1)
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
if (num == 0)
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
}
|
|
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
data1.nSteepS = data1.nSteepsS;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
// 转角伸出
|
|
if (UP_ZERO(data1.dGarExt))
|
|
{
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 1)
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 2)
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
|
|
{
|
|
ptS = ptGeIn.at(1) + vtDir * data.dGarExt;
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 1)
|
|
{
|
|
ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 2)
|
|
{
|
|
ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
}
|
|
}
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
ptS = ptGeIn.at(2) - vtDir * data.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else
|
|
{
|
|
ptE = ptGeIn.at(0) - vtDir * data.dZGarExt;
|
|
ptGeIn.insertAt(0, ptE);
|
|
}
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data1.nSteepS = data1.nSteepMs;
|
|
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
ptGe[0] = ptGeIn[0];
|
|
ptGe[1] = ptGeIn[1];
|
|
ptGe[2] = ptGeIn[2];
|
|
ptGe[3] = ptGeIn[3];
|
|
|
|
ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
|
|
pLineM = new AcDbLine(ptGe[0], ptGe[1]);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
/*pt -= vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);*/
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
/*pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
ptGeIn.insertAt(4, pt);*/
|
|
/* AcDbLine* pLine = new AcDbLine(pt, pt - vtDir * data.dStairMW);
|
|
pLine->setColorIndex(10);
|
|
CoreTools::AddToModelSpace(pLine);*/
|
|
|
|
/*pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
|
|
ptGeIn.insertAt(5, pt);*/
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
|
|
if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
|
|
{
|
|
pt -= vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
///*pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
//ptGeIn.insertAt(4, pt);*/
|
|
//
|
|
//else
|
|
|
|
//else if (data.nSteepAlign == 2)
|
|
//{
|
|
// pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
|
|
// ptGeIn.insertAt(5, pt);
|
|
//}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
}
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
if (num == 0)
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
}
|
|
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
// 转角伸出
|
|
if (UP_ZERO(data1.dGarExt))
|
|
{
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 1)
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 2)
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
|
|
{
|
|
ptS = ptGeIn.at(1) + vtDir * data.dGarExt;
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 1)
|
|
{
|
|
ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else if (data1.nSteepAlign == 2)
|
|
{
|
|
ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
}
|
|
}
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
ptS = ptGeIn.at(2) - vtDir * data.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else
|
|
{
|
|
ptE = ptGeIn.at(0) - vtDir * data.dZGarExt;
|
|
ptGeIn.insertAt(0, ptE);
|
|
}
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (data1.nSteepMs < data1.nSteepsS)
|
|
{
|
|
if (data1.nUpSide == 0)
|
|
{
|
|
data1.nSteepS = data1.nSteepMs - 1;
|
|
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);
|
|
|
|
data1.nSteepS = data1.nSteepsS;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
|
|
ptGe[0] = ptGeIn[0];
|
|
ptGe[1] = ptGeIn[1];
|
|
ptGe[2] = ptGeIn[2];
|
|
ptGe[3] = ptGeIn[3];
|
|
|
|
ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
|
|
pLineM = new AcDbLine(ptGe[0], ptGe[1]);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt += vt * data.dGarExt;
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
pt += vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt += vt * data.dGarExt;
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
pt += vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
if (data.nSteepAlign == 1)
|
|
{
|
|
pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt -= vt * data.dGarExt;
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
pt -= vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
else if (data.nSteepAlign == 2)
|
|
{
|
|
pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
|
|
ptGeIn.insertAt(3, pt);
|
|
|
|
pt -= vt * data.dGarExt;
|
|
ptGeIn.insertAt(4, pt);
|
|
|
|
pt -= vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGeIn.insertAt(5, pt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
}
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
data1.nSteepS = data1.nSteepsS;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
// 转角伸出
|
|
if (UP_ZERO(data1.dGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptE = ptGeIn.at(2) - vtDir * data.dZGarExt;
|
|
ptGeIn.append(ptE);
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data1.nSteepS = data1.nSteepMs;
|
|
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);
|
|
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.append(ptE);
|
|
ptGeIn.append(ptS);
|
|
|
|
ptGe[0] = ptGeIn[0];
|
|
ptGe[1] = ptGeIn[1];
|
|
ptGe[2] = ptGeIn[2];
|
|
ptGe[3] = ptGeIn[3];
|
|
|
|
ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
|
|
ptGeIn.append(ptS);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
else
|
|
{
|
|
ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.append(ptS);
|
|
}
|
|
|
|
pLineM = new AcDbLine(ptGe[0], ptGe[1]);
|
|
|
|
if (num == 0)
|
|
{
|
|
ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
|
|
pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
|
|
pLineS = new AcDbLine(ptGe[2], ptGe[3]);
|
|
|
|
double dLXY(.0), dLX(.0);
|
|
AcGePoint3dArray pts;
|
|
pts.removeAll();
|
|
pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
|
|
if (pts.length() == 1)
|
|
{
|
|
dLXY = ptGe[1].distanceTo(pts.first());
|
|
dLX = dLXY * dCosAngle;
|
|
}
|
|
|
|
if (data.dGarExt <= dLX)
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
|
|
ptGeIn.insertAt(2, pt);
|
|
}
|
|
else
|
|
{
|
|
vtM = (ptGe[0] - ptGe[1]).normalize();
|
|
pt = ptGe[1] - vtM * dLXY;
|
|
ptGeIn.insertAt(2, pt);
|
|
|
|
if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
|
|
{
|
|
pt += vtDir * data.dGarSize[0] * .5;
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
else
|
|
{
|
|
pt += vtDir * (data.dGarExt - dLX);
|
|
ptGeIn.insertAt(3, pt);
|
|
}
|
|
|
|
pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
|
|
ptGeIn.insertAt(4, pt);
|
|
}
|
|
}
|
|
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
|
|
if (data1.bOutSideHRail)
|
|
{
|
|
data1.nSteepS = data1.nSteepsS - 1;
|
|
pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
|
|
pLine1->getStartPoint(ptS);
|
|
pLine1->getEndPoint(ptE);
|
|
ptGeIn.removeAll();
|
|
ptGeIn.append(ptS);
|
|
ptGeIn.append(ptE);
|
|
// 层间伸出
|
|
if (UP_ZERO(data1.dZGarExt))
|
|
{
|
|
ptS = ptGeIn.at(0) - vtDir * data.dZGarExt;
|
|
ptGeIn.insertAt(0, ptS);
|
|
}
|
|
// 转角伸出
|
|
if (UP_ZERO(data1.dGarExt))
|
|
{
|
|
ptE = ptGeIn.at(2) + vtDir * data.dGarExt;
|
|
ptGeIn.append(ptE);
|
|
}
|
|
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
} |