envi-code/SourceCode/Code2026/ArchCmd/AecDbRectCornerStairDraw.cpp

#include "stdafx.h"
#include "AecDbRectCornerStair.h"
#include "AecDbRectCornerStairDraw.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.h"
#include "CoreTools.h"

static const Adesk::UInt16 kColorByBlock = 0;
static const Adesk::UInt16 kRed = 1;
static const Adesk::UInt16 kYellow = 2;
static const Adesk::UInt16 kGreen = 3;
static const Adesk::UInt16 kCyan = 4;
static const Adesk::UInt16 kBlue = 5;
static const Adesk::UInt16 kMagenta = 6;
static const Adesk::UInt16 kWhite = 7;
static const Adesk::UInt16 kColorByLayer = 256;

DLLIMPEXP AcDbPolyline *FormatPolyline(AcGePoint3d *ppPts, int nCount);
DLLIMPEXP AcDb3dPolyline *Format3dPolyline(const AcGePoint3dArray &arPts);

ACRX_CONS_DEFINE_MEMBERS(AecDbRectCornerStairDraw, AecDbXDraw, 0);

namespace 
{
	AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
		, const double& dL
		, const double& dW
		, const AcGeVector3d& vecL
		, const AcGeVector3d& vecW
	)
	{
		AcGePoint3d ptGe[5];

		ptGe[0] = ptOrg + vecW * dW * .5;
		ptGe[0] += vecL * dL * .5;
		ptGe[1] = ptGe[0] - vecW * dW;
		ptGe[2] = ptGe[1] - vecL * dL;
		ptGe[3] = ptGe[2] + vecW * dW;
		ptGe[4] = ptGe[0];

		return AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
	}

	AcDbRegion* makeCircleRegion(const AcGePoint3d& ptOrg
		, const AcGeVector3d& vtZ
		, const double& dR)
	{
		AcDbCircle* pCir(new AcDbCircle(ptOrg, vtZ, dR));
		if (!pCir) return NULL;

		return CoreTools::createRegion(pCir);
	}

	AcDbPolyline* DrawRect2d(const AcGePoint3d& ptFr
		, const double& dL
		, const double& dW
		, const AcGeVector3d& vecL
		, const AcGeVector3d& vecW)
	{
		AcGePoint3d ptGe[5];
		ptGe[0] = ptFr;
		ptGe[1] = ptGe[0] - vecL * dL;
		ptGe[2] = ptGe[1] + vecW * dW;
		ptGe[3] = ptGe[2] + vecL * dL;
		ptGe[4] = ptGe[0];
		return FormatPolyline(ptGe, 5);
	}

	AcDbPolyline* drawOutHandRail2d(AcGePoint3d* ppPts
		, int nCount
		, const double& dOffset
		, const AcGeVector3d& vt)
	{
		AcDbPolyline* pPoly = FormatPolyline(ppPts, nCount);
		if (!pPoly) return NULL;
		int len(pPoly->numVerts());
		if (len < 2) return NULL;

		AcDbVoidPtrArray ar;
		pPoly->getOffsetCurves(dOffset, ar);
		if (ar.isEmpty()) return NULL;

		AcDbPolyline* pOffPoly = (AcDbPolyline*)(((AcDbEntity*)ar.first())->clone());
		deleteArrayVoidPtrs<AcDbEntity>(ar);

		AcGePoint3d pt;
		AcGePoint3dArray ptAr;
		ptAr.removeAll();
		int i(0);
		for (i = 0; i < len; ++i)
		{
			pPoly->getPointAt(i, pt);
			ptAr.append(pt);
		}

		len = pOffPoly->numVerts();
		for (i = len - 1; i >= 0; --i)
		{
			pOffPoly->getPointAt(i, pt);
			ptAr.append(pt);
		}

		pPoly->getStartPoint(pt);
		ptAr.append(pt);

		DELETE_PTR(pOffPoly);
		return FormatPolyline(ptAr.asArrayPtr(), ptAr.length());
	}

	void drawInHandRail2d(AcGiDraw& dc
		, const AcGePoint3d& ptFr
		, const double& dL
		, const double& dW
		, const double& dOffset
		, const AcGeVector3d& vecL
		, const AcGeVector3d& vecW)
	{
		AcDbVoidPtrArray ar;

		AcDbPolyline* pPoly = DrawRect2d(ptFr, dL, dW, vecL, vecW);
		if (pPoly == NULL) return;

		pPoly->getOffsetCurves(dOffset, ar);
		if (ar.isEmpty())
		{
			DELETE_PTR(pPoly);
			return;
		}
		AcDbPolyline* pNewPoly = (AcDbPolyline*)(((AcDbEntity*)ar.first())->clone());
		if (pNewPoly == NULL)
		{
			DELETE_PTR(pPoly);
			return;
		}
		deleteArrayVoidPtrs<AcDbEntity>(ar);

		dc.DrawEntity(pPoly);
		dc.Add2dBuffer(pPoly);

		dc.DrawEntity(pNewPoly);
		dc.Add2dBuffer(pNewPoly);

		return;
	}

	void drawSolid(AcGiDraw& dc
		, const AcDbRegion* pReg
		, const double& dThick
		, const double& dH
		, const AcGeVector3d& vtThick
		, const AcGeVector3d& vtH)
	{
		if (!pReg) return;

		AcDbExtents ext;
		pReg->getGeomExtents(ext);
		AcGePoint3d ptCen(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
		AcDbLine ln(ptCen, ptCen + vtThick * -dThick);

		AcDbX3dSolid xSolid;
		AcGeMatrix3d mat;
		if (xSolid.CreateExtrude(pReg, ln) == FALSE) return;
		AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
		if (!pSolid) return;
		mat.setTranslation(vtH * dH);
		pSolid->transformBy(mat);
		dc.DrawEntity(pSolid);
		dc.Add3dBuffer(pSolid);
	}

	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)
	{
		int nOldClr = dc.GetColor();
		dc.SetColor(5);

		AcDbText* pText = new AcDbText();
		if (pText == NULL) return;

		pText->setTextString(text);
		pText->setHeight(dTextH);

		AcDbExtents ext;
		pText->getGeomExtents(ext);
		pText->setHorizontalMode(nHorMode);
		pText->setVerticalMode(nVerMode);
		pText->setAlignmentPoint(ptAlign);
		AcGeMatrix3d mat;
		mat.setToRotation(dAngle, vtTrans, ptAlign);
		pText->setPosition(dc.Align2Base(nAlign, ptAlign, ext.maxPoint()));
		pText->transformBy(mat);

		dc.DrawEntity(pText);
		dc.Add2dBuffer(pText);

		dc.SetColor(nOldClr);
	}

	AcDbPolyline* makeRestPlatform2d(AcGiDraw& dc
		, const AcGePoint3d& ptSta
		, const double& dL
		, const double& dW
		, const AcGeVector3d& vecL
		, const AcGeVector3d& vecW
		, const double& dStairsWidthL// 长度方向的楼梯宽带
		, const double& dStairsWidthW// 宽度方向的楼梯宽带
		, const SFPXStair& data)
	{
		AcGePoint3d ptGe[7];

		int nOldClr = dc.GetColor();
		dc.SetColor(3);

		ptGe[0] = ptSta;
		ptGe[1] = ptGe[0] - vecW * dW;
		ptGe[2] = ptGe[1] - vecL * dStairsWidthL;
		ptGe[3] = ptGe[2] + vecW * (dW - dStairsWidthW);
		ptGe[4] = ptGe[3] - vecL * (dL - dStairsWidthL);
		ptGe[5] = ptGe[4] + vecW * dStairsWidthW;
		ptGe[6] = ptGe[0];

		return FormatPolyline(ptGe, 7);
	}
}

AecDbRectCornerStairDraw::AecDbRectCornerStairDraw(void)
{
}

AecDbRectCornerStairDraw::~AecDbRectCornerStairDraw(void)
{
}

Acad::ErrorStatus AecDbRectCornerStairDraw::Draw2d(AcGiDraw &dc) const
{
	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	AcDbEntity *pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbRectCornerStair *pStair = AecDbRectCornerStair::cast(pEntReal);
	if (pStair == NULL)
		return Acad::eOk;

	Adesk::UInt16 nCrBk = 256;
	nCrBk = pEntReal->colorIndex();
	dc.SetLayer(pEntReal->layerId());

	int nColor = nCrBk;
	if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));
	pStair->GetSFPXStair(data);

	//.....
	AcDbVoidPtrArray arEntPtrs;
	AcDbCurve* pBaseCurve = pStair->GetBaseCurve();//路径
	if (!pBaseCurve) return Acad::eOk;
	AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
	if (!pLn) return Acad::eOk;

	AcGePoint3d ptS, ptE;
	ptS = pLn->startPoint();
	ptE = pLn->endPoint();

	AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);

	ptS += Z * data.dBomEl;
	ptE += Z * data.dBomEl;

	vtSE = (ptS - ptE).normalize();
	vtSEDir = vtSE;
	vtSEDir.rotateBy(-PI / 2.0, Z);
	vtSEDir.normalize();

	ptE = ptS - vtSE * data.dStairTW;
	DrawUpStairs2d(dc, ptS, ptE, vtSE, vtSEDir, data);

	dc.SetColor(nCrBk);
	dc.SetLayer(idCurLay);
	dc.SetLineType(idCurLty);
	dc.Add2dBuffer(arEntPtrs);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::Draw3d(AcGiDraw &dc) const
{
	del3DCache<AecDbRectCornerStair>();
	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	AcDbEntity *pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbRectCornerStair *pStair = AecDbRectCornerStair::cast(pEntReal);
	if (pStair == NULL)
		return Acad::eOk;

	Adesk::UInt16 nCrBk = pEntReal->colorIndex();
	dc.SetLayer(pEntReal->layerId());

	int nColor = nCrBk;
	if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));
	pStair->GetSFPXStair(data);


	//.....
	AcDbCurve* pBaseCurve = pStair->GetBaseCurve();//路径
	if (pBaseCurve == NULL) return Acad::eOk;
	AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
	if (pLn == NULL) return Acad::eOk;

	AcGePoint3d ptS, ptE;
	ptS = pLn->startPoint();
	ptE = pLn->endPoint();

	/*AcDbCircle* pCirS = new AcDbCircle(ptS, AcGeVector3d::kZAxis, 25);
	pCirS->setColorIndex(3);
	CoreTools::AddToModelSpace(pCirS);

	AcDbCircle* pCirE = new AcDbCircle(ptE, AcGeVector3d::kZAxis, 25);
	pCirE->setColorIndex(6);
	CoreTools::AddToModelSpace(pCirE);*/

	AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);

	ptS += Z * data.dBomEl;
	ptE += Z * data.dBomEl;

	vtSE = (ptS - ptE).normalize();
	vtSEDir = vtSE;
	vtSEDir.rotateBy(-PI / 2.0, Z);
	vtSEDir.normalize();

	/*if (data.nSteepS == 2)
	{
		if (data.dStairSW < (data.dSteepW * (data.n1SteepS - 1) + data.d2SteepW))
		{
			AfxMessageBox(_T("宽度太小！"));
			return Acad::eOk;
		}
		if (data.dStairTW < (data.dSteepW * (data.nSteep2s - 1) + data.d1SteepW))
		{
			AfxMessageBox(_T("长度太小！"));
			return Acad::eOk;
		}
	}
	else if (data.nSteepS == 3)
	{
		if (data.dStairSW < (data.dSteepW * (data.n1SteepS - 1) + data.d2SteepW))
		{
			AfxMessageBox(_T("宽度太小！"));
			return Acad::eOk;
		}
		if (data.dStairTW < (data.dSteepW * (data.nSteep2s - 1) + data.d1SteepW + data.d3SteepW))
		{
			AfxMessageBox(_T("长度太小！"));
			return Acad::eOk;
		}
		if (data.dStairSW < (data.dSteepW * (data.nSteep3s - 1) + data.d2SteepW))
		{
			AfxMessageBox(_T("宽度太小！"));
			return Acad::eOk;
		}
	}
	else if (data.nSteepS == 4)
	{
		if (data.dStairSW < (data.dSteepW * (data.n1SteepS - 1) + data.d2SteepW + data.d4SteepW))
		{
			AfxMessageBox(_T("宽度太小！"));
			return Acad::eOk;
		}
		if (data.dStairTW < (data.dSteepW * (data.nSteep2s - 1) + data.d1SteepW + data.d3SteepW))
		{
			AfxMessageBox(_T("长度太小！"));
			return Acad::eOk;
		}
		if (data.dStairSW < (data.dSteepW * (data.nSteep3s - 1) + data.d2SteepW + data.d4SteepW))
		{
			AfxMessageBox(_T("宽度太小！"));
			return Acad::eOk;
		}
		if (data.dStairTW < (data.dSteepW * (data.nSteep4s - 1) + data.d1SteepW + data.d3SteepW))
		{
			AfxMessageBox(_T("长度太小！"));
			return Acad::eOk;
		}
	}*/

	ptE = ptS - vtSE * data.dStairTW;
	if (data.nUpSide == 0)
	{
		DrawUpStairsClockWise3d(dc, ptS, ptE, vtSE, vtSEDir, data);
	}
	else
	{
		DrawUpStairsAntiClockWise3d(dc, ptS, ptE, vtSE, vtSEDir, data);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawUpStairsDir2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d pt(AcGePoint3d::kOrigin);
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	AcDbPolyline* pPoly(NULL);
	AcGePoint3d ptGe[10];
	double dLPlatform(.0), dWPlatform(.0);
	SFPXStair data1(data);
	int nOldClr = dc.GetColor();
	dc.SetColor(3);

	//绘制增高方向线 ----->
	double dScale = CoreTools::getPScaleForSymb();
	double dW(dScale * .8);
	double dH(dScale * 3);
	double dTextH(dScale * 3.5);

	double angle = vtDir.angleTo(AcGeVector3d::kXAxis) - PI * .5;
	if (data.nUpSide == 0)
	{
		// ClockWise
		if (data.nSteepS == 2)
		{
			ptGe[0] = ptSta - vt * data.d1SteepW * .5;
			ptGe[0] -= vtDir * (data.dStairSW + data.dSteepW);
			ptGe[1] = ptGe[0] + vtDir * (data.nSSteeps * data.dSteepW);
			ptGe[2] = ptGe[1] - vtDir * dH;
			pPoly = FormatPolyline(ptGe, 3);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

			ptGe[0] = ptEnd - vt * data.dSteepW;
			ptGe[0] -= vtDir * data.d2SteepW * .5;
			ptGe[1] = ptSta - vt * data.d1SteepW * .5;
			ptGe[1] -= vtDir * data.d2SteepW * .5;
			ptGe[2] = ptSta - vtDir * (data.dStairSW - (data.n1SteepS - 1 - data.nSSteeps) * data.dSteepW - data.dSteepW);
			ptGe[2] -= vt * data.d1SteepW * .5;
			ptGe[3] = ptGe[2] + vtDir * dH;
			pPoly = FormatPolyline(ptGe, 4);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(2, 0, dW);
			pPoly->setColorIndex(3);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextLeft, AcDb::kTextVertMid, AcGiDraw::kMiddleLeft);
		}
		else if (data.nSteepS == 3)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;
			}

			ptGe[0] = ptSta - vt * data.d1SteepW * .5;
			ptGe[0] -= vtDir * (data.dStairSW + data.dSteepW);
			ptGe[1] = ptGe[0] + vtDir * (data.nSSteeps * data.dSteepW);
			ptGe[2] = ptGe[1] - vtDir * dH;
			pPoly = FormatPolyline(ptGe, 3);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

			ptGe[0] = ptEnd + vt * data1.d3SteepW * .5;
			ptGe[0] -= vtDir * (data.dStairSW + data.dSteepW);
			ptGe[1] = ptEnd + vt * data1.d3SteepW * .5;
			ptGe[1] -= vtDir * data.d2SteepW * .5;
			ptGe[2] = ptSta - vt * data.d1SteepW * .5;
			ptGe[2] -= vtDir * data.d2SteepW * .5;
			ptGe[3] = ptSta - vt * data.d1SteepW * .5;
			ptGe[3] -= vtDir * (data.dStairSW - (data.n1SteepS - 1 - data.nSSteeps) * data.dSteepW - data.dSteepW);
			ptGe[4] = ptGe[3] + vtDir * dH;
			pPoly = FormatPolyline(ptGe, 5);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(3, 0, dW);
			pPoly->setColorIndex(3);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
		}
		else if (data.nSteepS == 4)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;

				data1.nSteep4s = data1.nSteep2s;
				data1.d4SteepW = data1.d2SteepW;
			}

			dLPlatform = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;
			dWPlatform = (data.dStairSW - data.d2SteepW - data1.d4SteepW) * .5;

			ptGe[0] = ptSta - vt * data.d1SteepW * .5;
			ptGe[0] -= vtDir * (dWPlatform + (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW + data.dSteepW);
			ptGe[1] = ptGe[0] + vtDir * data.nSSteeps * data.dSteepW;
			ptGe[2] = ptGe[1] - vtDir * dH;
			pPoly = FormatPolyline(ptGe, 3);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

			ptGe[0] = ptEnd - vtDir * (data.dStairSW - data1.d4SteepW * .5);
			ptGe[0] += vt * (dLPlatform + (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW + data.dSteepW);
			ptGe[1] = ptEnd - vtDir * (data.dStairSW - data1.d4SteepW * .5);
			ptGe[1] += vt * data1.d3SteepW * .5;
			ptGe[2] = ptEnd - vtDir * data.d2SteepW * .5;
			ptGe[2] += vt * data1.d3SteepW * .5;
			ptGe[3] = ptSta - vt * data.d1SteepW * .5;
			ptGe[3] -= vtDir * data.d2SteepW * .5;
			ptGe[4] = ptSta - vt * data.d1SteepW * .5;
			ptGe[4] -= vtDir * (dWPlatform - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW + (data.n1SteepS - 1 - data.nSSteeps) * data.dSteepW);
			ptGe[5] = ptGe[4] + vtDir * dH;
			pPoly = FormatPolyline(ptGe, 6);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(4, 0, dW);
			pPoly->setColorIndex(3);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextRight, AcDb::kTextVertMid, AcGiDraw::kMiddleRight);
		}
	}
	else
	{
		// AntiClockWise
		if (data.nSteepS == 2)
		{
			ptGe[0] = ptEnd - vt * data.dSteepW;
			ptGe[0] -= vtDir * data.d1SteepW * .5;
			ptGe[1] = ptGe[0] + vt * (data.nSSteeps * data.dSteepW);
			ptGe[2] = ptGe[1] - vt * dH;
			pPoly = FormatPolyline(ptGe, 3);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextLeft, AcDb::kTextVertMid, AcGiDraw::kMiddleLeft);

			ptGe[0] = ptSta - vt * data.d2SteepW * .5;
			ptGe[0] -= vtDir * (data.dStairSW + data.dSteepW);
			ptGe[1] = ptSta - vt * data.d2SteepW * .5;
			ptGe[1] -= vtDir * data.d1SteepW * .5;
			ptGe[2] = ptSta - vt * (data.dStairTW - (data.n1SteepS - 1 - data.nSSteeps) * data.dSteepW - data.dSteepW);
			ptGe[2] -= vtDir * data.d1SteepW * .5;
			ptGe[3] = ptGe[2] + vt * dH;
			pPoly = FormatPolyline(ptGe, 4);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(2, 0, dW);
			pPoly->setColorIndex(3);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
		}
		else if (data.nSteepS == 3)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;
			}

			ptGe[0] = ptEnd + vt * data.d1SteepW * .5;
			ptGe[0] -= vtDir * (data.dStairSW + data.dSteepW);
			ptGe[1] = ptGe[0] + vtDir * (data.nSSteeps * data.dSteepW);
			ptGe[2] = ptGe[1] - vtDir * dH;
			pPoly = FormatPolyline(ptGe, 3);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

			ptGe[0] = ptSta - vt * data1.d3SteepW * .5;
			ptGe[0] -= vtDir * (data.dStairSW + data.dSteepW);
			ptGe[1] = ptSta - vt * data1.d3SteepW * .5;
			ptGe[1] -= vtDir * data.d2SteepW * .5;
			ptGe[2] = ptEnd + vt * data.d1SteepW * .5;
			ptGe[2] -= vtDir * data.d2SteepW * .5;
			ptGe[3] = ptEnd + vt * data.d1SteepW * .5;
			ptGe[3] -= vtDir * (data.dStairSW - (data.n1SteepS - 1 - data.nSSteeps) * data.dSteepW - data.dSteepW);
			ptGe[4] = ptGe[3] + vtDir * dH;
			pPoly = FormatPolyline(ptGe, 5);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(3, 0, dW);
			pPoly->setColorIndex(3);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
		}
		else if (data.nSteepS == 4)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;

				data1.nSteep4s = data1.nSteep2s;
				data1.d4SteepW = data1.d2SteepW;
			}

			dLPlatform = (data.dStairTW - data.d2SteepW - data1.d4SteepW) * .5;
			dWPlatform = (data.dStairSW - data.d1SteepW - data1.d3SteepW) * .5;

			ptGe[0] = ptEnd - vtDir * (data.dStairSW - data.d1SteepW * .5);
			ptGe[0] += vt * (data.d2SteepW + dLPlatform + (data.n1SteepS - 1) * data.dSteepW * .5 + data.dSteepW);
			ptGe[1] = ptGe[0] - vt * data.nSSteeps * data.dSteepW;
			ptGe[2] = ptGe[1] + vt * dH;
			pPoly = FormatPolyline(ptGe, 3);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextRight, AcDb::kTextVertMid, AcGiDraw::kMiddleRight);

			ptGe[0] = ptSta - vt * data1.d4SteepW * .5;
			ptGe[0] -= vtDir * (data1.d3SteepW + dWPlatform + (data1.nSteep4s - 1) * data.dSteepW * .5 + data.dSteepW);
			ptGe[1] = ptSta - vt * data1.d4SteepW * .5;
			ptGe[1] -= vtDir * data1.d3SteepW * .5;
			ptGe[2] = ptEnd + vt * data.d2SteepW * .5;
			ptGe[2] -= vtDir * data1.d3SteepW * .5;
			ptGe[3] = ptEnd + vt * data.d2SteepW * .5;
			ptGe[3] -= vtDir * (data.dStairSW - data.d1SteepW * .5);
			ptGe[4] = ptEnd - vtDir * (data.dStairSW - data.d1SteepW * .5);
			ptGe[4] += vt * (data.d2SteepW + dLPlatform - (data.n1SteepS - 1) * data.dSteepW * .5 + (data.n1SteepS - 1 - data.nSSteeps) * data.dSteepW);
			ptGe[5] = ptGe[4] - vt * dH;
			pPoly = FormatPolyline(ptGe, 6);
			if (pPoly == NULL) return Acad::eOk;
			pPoly->setWidthsAt(4, 0, dW);
			pPoly->setColorIndex(3);
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawUpStairs2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d pt(AcGePoint3d::kOrigin);
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	AcGePoint3d ptGe[15];
	AcDbPolyline* pPoly(NULL);
	double dSidet(120);
	int i(0);
	SFPXStair data1(data);
	double dL(.0), dW(.0);

	if (DOWN_ZERO(data.dZGarExt)) return Acad::eOk;
	if (DOWN_ZERO(data.dGarExt)) return Acad::eOk;

	if (data.nUpSide == 0)
	{
		// ClockWise
		if (data.nSteepS == 2)
		{
			pPoly = makeRestPlatform2d(dc, ptSta
				, data.dStairTW - (data.nSteep2s - 1) * data.dSteepW
				, data.dStairSW - (data.n1SteepS - 1) * data.dSteepW
				, vt, vtDir, data.d1SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i; i < data.n1SteepS - 1; ++i)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt += vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.d1SteepW, data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			for (i = 0; i < data.nSteep2s - 1; ++i)
			{
				pt = ptSta - vt * data.dStairTW;
				pt += vt * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.dSteepW, data.d2SteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//内边梁
			if (data.bLBeam)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt -= vt * data.d1SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * data.d2SteepW;
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//外边梁
			if (data.bRBeam)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pPoly = DrawRect2d(ptEnd, (data.nSteep2s - 1) * data.dSteepW, dSidet, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			// 内侧扶手
			pt = ptSta - vtDir * (data.d2SteepW - data.dBarSide);
			pt -= vt * (data.d1SteepW - data.dBarSide);
			drawInHandRail2d(dc, pt
				, data.dStairTW - data.d1SteepW + data.dBarSide + (data.dGarExt - data.dGarSize[0])
				, data.dStairSW - data.d2SteepW + data.dBarSide + (data.dZGarExt - data.dGarSize[0])
				, -data.dGarSize[0], vt, -vtDir);

			// 外侧扶手
			if (data.bOutSideHRail)
			{
				ptGe[0] = ptEnd - vtDir * data.dBarSide;
				ptGe[0] -= vt * data.dGarExt;
				ptGe[1] = ptSta - vt * data.dBarSide;
				ptGe[1] -= vtDir * data.dBarSide;
				ptGe[2] = ptSta - vtDir * (data.dStairSW + data.dZGarExt);
				ptGe[2] -= vt * data.dBarSide;
				pPoly = drawOutHandRail2d(ptGe, 3, -data.dGarSize[0], vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}
		}
		else if (data.nSteepS == 3)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;
			}

			dL = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;

			pPoly = makeRestPlatform2d(dc, ptSta
				, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
				, data.dStairSW - (data.n1SteepS - 1) * data.dSteepW
				, vt, vtDir, data.d1SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data.n1SteepS - 1; ++i)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt += vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.d1SteepW, data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			for (i = 0; i < data.nSteep2s - 1; ++i)
			{
				pt = ptSta - vt * ((data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5 - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pt -= vt * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.dSteepW, data.d2SteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pPoly = makeRestPlatform2d(dc, ptEnd
				, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
				, data.dStairSW - (data1.nSteep3s - 1) * data.dSteepW
				, -vt, vtDir, data1.d3SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data1.nSteep3s - 1; ++i)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pt += vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data1.d3SteepW, data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//内边梁
			if (data.bLBeam)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt -= vt * data.d1SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pt -= vtDir * data.d2SteepW;
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * data.dStairSW;
				pt += vt * data1.d3SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep3s - 1) * data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//外边梁
			if (data.bRBeam)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * data.dStairSW;
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep3s - 1) * data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			// 内侧扶手
			pt = ptSta - vtDir * (data.d2SteepW - data.dBarSide);
			pt -= vt * (data.d1SteepW - data.dBarSide);
			drawInHandRail2d(dc, pt
				, data.dStairTW - (data.d1SteepW - data.dBarSide) - (data1.d3SteepW - data.dBarSide)
				, data.dStairSW - (data.d2SteepW - data.dBarSide) + (data.dZGarExt - data.dGarSize[0])
				, -data.dGarSize[0], vt, -vtDir);

			// 外侧扶手
			if (data.bOutSideHRail)
			{
				ptGe[0] = ptEnd - vtDir * (data.dStairSW + data.dGarExt);
				ptGe[0] += vt * data.dGarExt;
				ptGe[1] = ptEnd + vt * data.dBarSide;
				ptGe[1] -= vtDir * data.dBarSide;
				ptGe[2] = ptSta - vtDir * data.dBarSide;
				ptGe[2] -= vt * data.dBarSide;
				ptGe[3] = ptSta - vtDir * (data.dStairSW + data.dZGarExt);
				ptGe[3] -= vt * data.dBarSide;
				pPoly = drawOutHandRail2d(ptGe, 4, -data.dGarSize[0], vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}
		}
		else if (data.nSteepS == 4)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;

				data1.nSteep4s = data1.nSteep2s;
				data1.d4SteepW = data1.d2SteepW;
			}

			dL = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;
			dW = (data.dStairSW - data.d2SteepW - data1.d4SteepW) * .5;

			pPoly = makeRestPlatform2d(dc, ptSta
				, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
				, dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW
				, vt, vtDir, data.d1SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data.n1SteepS - 1; ++i)
			{
				pt = ptSta - vtDir * (dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW);
				pt -= vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.d1SteepW, data.dSteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			for (i = 0; i < data.nSteep2s - 1; ++i)
			{
				pt = ptSta - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pt -= vt * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.dSteepW, data.d2SteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pPoly = makeRestPlatform2d(dc, ptEnd
				, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
				, dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW
				, -vt, vtDir, data1.d3SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data1.nSteep3s - 1; ++i)
			{
				pt = ptEnd - vtDir * (dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
				pt -= vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data1.d3SteepW, data.dSteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pt = ptEnd - vtDir * data.dStairSW;
			pPoly = makeRestPlatform2d(dc, pt
				, dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW
				, dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data1.d4SteepW
				, -vt, -vtDir, data1.d3SteepW, data1.d4SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data1.nSteep4s - 1; ++i)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pt += vt * (dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW + data.dSteepW * i);
				pPoly = DrawRect2d(pt, data.dSteepW, data1.d4SteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pt = ptSta - vtDir * data.dStairSW;
			pPoly = makeRestPlatform2d(dc, pt
				, dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data.d1SteepW
				, dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data1.d4SteepW
				, vt, -vtDir, data.d1SteepW, data1.d4SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			//内边梁
			if (data.bLBeam)
			{
				pt = ptSta - vtDir * (dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW);
				pt -= vt * data.d1SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pt -= vtDir * data.d2SteepW;
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * (dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
				pt += vt * data1.d3SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep3s - 1) * data.dSteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * (data.dStairSW - data1.d4SteepW);
				pt += vt * (dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW);
				pPoly = DrawRect2d(pt, (data1.nSteep4s - 1) * data.dSteepW, dSidet, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//外边梁
			if (data.bRBeam)
			{
				pt = ptSta - vtDir * (dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW);
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * (dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep3s - 1) * data.dSteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * data.dStairSW;
				pt += vt * (dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW);
				pPoly = DrawRect2d(pt, (data1.nSteep4s - 1) * data.dSteepW, dSidet, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			// 内侧扶手
			pt = ptSta - vtDir * (data.d2SteepW - data.dBarSide);
			pt -= vt * (data.d1SteepW - data.dBarSide);
			drawInHandRail2d(dc, pt
				, data.dStairTW - (data.d1SteepW - data.dBarSide) - (data1.d3SteepW - data.dBarSide)
				, data.dStairSW - (data.d2SteepW - data.dBarSide) - (data1.d4SteepW - data.dBarSide)
				, -data.dGarSize[0], vt, -vtDir);

			// 外侧扶手
			if (data.bOutSideHRail)
			{
				ptGe[0] = ptEnd - vtDir * (data.dStairSW - data.dBarSide);
				ptGe[0] += vt * (dL + (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW + data.dGarExt);
				ptGe[1] = ptEnd + vt * data.dBarSide;
				ptGe[1] -= vtDir * (data.dStairSW - data.dBarSide);
				ptGe[2] = ptEnd - vtDir * data.dBarSide;
				ptGe[2] += vt * data.dBarSide;
				ptGe[3] = ptSta - vtDir * data.dBarSide;
				ptGe[3] -= vt * data.dBarSide;
				ptGe[4] = ptSta - vtDir * (dW + (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW + data.dZGarExt);
				ptGe[4] -= vt * data.dBarSide;
				pPoly = drawOutHandRail2d(ptGe, 5, -data.dGarSize[0], vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}
		}
	}
	else
	{
		// AntiClockWise
		if (data.nSteepS == 2)
		{
			pPoly = makeRestPlatform2d(dc, ptSta
				, data.dStairTW - (data.n1SteepS - 1) * data.dSteepW
				, data.dStairSW - (data.nSteep2s - 1) * data.dSteepW
				, vt, vtDir, data.d2SteepW, data.d1SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i; i < data.n1SteepS - 1; ++i)
			{
				pt = ptSta - vt * data.dStairTW;
				pt += vt * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.dSteepW, data.d1SteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			for (i = 0; i < data.nSteep2s - 1; ++i)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt += vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.d2SteepW, data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//内边梁
			if (data.bLBeam)
			{
				pt = ptEnd - vtDir * data.d1SteepW;
				pPoly = DrawRect2d(pt, (data.n1SteepS - 1) * data.dSteepW, dSidet, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vtDir * data.dStairSW;
				pt -= vt * data.d2SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data.nSteep2s - 1) * data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//外边梁
			if (data.bRBeam)
			{
				pPoly = DrawRect2d(ptEnd, (data.n1SteepS - 1) * data.dSteepW, dSidet, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vtDir * data.dStairSW;
				pPoly = DrawRect2d(pt, dSidet, (data.nSteep2s - 1) * data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			// 内侧扶手
			pt = ptSta - vt * (data.d2SteepW - data.dBarSide);
			pt -= vtDir * (data.d1SteepW - data.dBarSide);
			drawInHandRail2d(dc, pt
				, data.dStairTW - data.d2SteepW + data.dBarSide + (data.dZGarExt - data.dGarSize[0])
				, data.dStairSW - data.d1SteepW + data.dBarSide + (data.dGarExt - data.dGarSize[0])
				, -data.dGarSize[0], vt, -vtDir);

			// 外侧扶手
			if (data.bOutSideHRail)
			{
				ptGe[0] = ptEnd - vt * data.dZGarExt;
				ptGe[0] -= vtDir * data.dBarSide;
				ptGe[1] = ptSta - vt * data.dBarSide;
				ptGe[1] -= vtDir * data.dBarSide;
				ptGe[2] = ptSta - vtDir * (data.dStairSW + data.dGarExt);
				ptGe[2] -= vt * data.dBarSide;
				pPoly = drawOutHandRail2d(ptGe, 3, -data.dGarSize[0], vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}
		}
		else if (data.nSteepS == 3)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;
			}

			dL = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;

			pPoly = makeRestPlatform2d(dc, ptEnd
				, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
				, data.dStairSW - (data.n1SteepS - 1) * data.dSteepW
				, -vt, vtDir, data.d1SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data.n1SteepS - 1; ++i)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pt += vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.d1SteepW, data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			for (i = 0; i < data.nSteep2s - 1; ++i)
			{
				pt = ptEnd + vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pt += vt * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.dSteepW, data.d2SteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pPoly = makeRestPlatform2d(dc, ptSta
				, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
				, data.dStairSW - (data1.nSteep3s - 1) * data.dSteepW
				, vt, vtDir, data1.d3SteepW, data.d2SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data1.nSteep3s - 1; ++i)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt += vtDir * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data1.d3SteepW, data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//内边梁
			if (data.bLBeam)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pt += vt * data.d1SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd + vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pt -= vtDir * data.d2SteepW;
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vtDir * data.dStairSW;
				pt -= vt * data1.d3SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep3s - 1) * data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//外边梁
			if (data.bRBeam)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pPoly = DrawRect2d(pt, dSidet, (data.n1SteepS - 1) * data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd + vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
				pPoly = DrawRect2d(pt, (data.nSteep2s - 1) * data.dSteepW, dSidet, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vtDir * data.dStairSW;
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep3s - 1) * data.dSteepW, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			// 内侧扶手
			pt = ptSta - vt * (data1.d3SteepW - data.dBarSide);
			pt -= vtDir * (data.d2SteepW - data.dBarSide);
			drawInHandRail2d(dc, pt
				, data.dStairTW - (data.d1SteepW - data.dBarSide) - (data1.d3SteepW - data.dBarSide)
				, data.dStairSW - (data.d2SteepW - data.dBarSide) + (data.dZGarExt - data.dGarSize[0])
				, -data.dGarSize[0], vt, -vtDir);

			// 外侧扶手
			if (data.bOutSideHRail)
			{
				ptGe[0] = ptEnd - vtDir * (data.dStairSW + data.dZGarExt);
				ptGe[0] += vt * data.dBarSide;
				ptGe[1] = ptEnd + vt * data.dBarSide;
				ptGe[1] -= vtDir * data.dBarSide;
				ptGe[2] = ptSta - vtDir * data.dBarSide;
				ptGe[2] -= vt * data.dBarSide;
				ptGe[3] = ptSta - vtDir * (data.dStairSW + data.dGarExt);
				ptGe[3] -= vt * data.dBarSide;
				pPoly = drawOutHandRail2d(ptGe, 4, -data.dGarSize[0], vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}
		}
		else if (data.nSteepS == 4)
		{
			if (data.bSymmetry)
			{
				data1.nSteep3s = data1.n1SteepS;
				data1.d3SteepW = data1.d1SteepW;

				data1.nSteep4s = data1.nSteep2s;
				data1.d4SteepW = data1.d2SteepW;
			}

			dL = (data.dStairTW - data.d2SteepW - data1.d4SteepW) * .5;
			dW = (data.dStairSW - data.d1SteepW - data1.d3SteepW) * .5;

			pt = ptEnd - vtDir * data.dStairSW;
			pPoly = makeRestPlatform2d(dc, pt
				, dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW
				, dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
				, -vt, -vtDir, data.d2SteepW, data.d1SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data.n1SteepS - 1; ++i)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pt += vt * (dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW + data.dSteepW * i);
				pPoly = DrawRect2d(pt, data.dSteepW, data.d1SteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			for (i = 0; i < data.nSteep2s - 1; ++i)
			{
				pt = ptEnd - vtDir * data.dStairSW;
				pt += vtDir * (dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW + data.dSteepW * i);
				pPoly = DrawRect2d(pt, data.d2SteepW, data.dSteepW, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pPoly = makeRestPlatform2d(dc, ptEnd
				, dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW
				, dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
				, -vt, vtDir, data.d2SteepW, data1.d3SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data1.nSteep3s - 1; ++i)
			{
				pt = ptEnd + vt * (dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
				pt += vt * data.dSteepW * i;
				pPoly = DrawRect2d(pt, data.dSteepW, data1.d3SteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pPoly = makeRestPlatform2d(dc, ptSta
				, dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data1.d4SteepW
				, dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW
				, vt, vtDir, data1.d4SteepW, data1.d3SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			for (i = 0; i < data1.nSteep4s - 1; ++i)
			{
				pt = ptSta - vtDir * (dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW + data.dSteepW * i);
				pPoly = DrawRect2d(pt, data1.d4SteepW, data.dSteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			pt = ptSta - vtDir * data.dStairSW;
			pPoly = makeRestPlatform2d(dc, pt
				, dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data1.d4SteepW
				, dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data.d1SteepW
				, vt, -vtDir, data1.d4SteepW, data.d1SteepW, data);
			if (pPoly == NULL) return Acad::eOk;
			dc.DrawEntity(pPoly);
			dc.Add2dBuffer(pPoly);

			//内边梁
			if (data.bLBeam)
			{
				pt = ptSta - vtDir * (data.dStairSW - data.d1SteepW);
				pt -= vt * (dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data1.d4SteepW);
				pPoly = DrawRect2d(pt, (data.n1SteepS - 1) * data.dSteepW, dSidet, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd + vt * data.d2SteepW;
				pt -= vtDir * (dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW);
				pPoly = DrawRect2d(pt, dSidet, (data.nSteep2s - 1) * data.dSteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * data1.d3SteepW;
				pt += vt * (dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
				pPoly = DrawRect2d(pt, (data1.nSteep3s - 1) * data.dSteepW, dSidet, -vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vtDir * (dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW);
				pt -= vt * data1.d4SteepW;
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep4s - 1) * data.dSteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			//外边梁
			if (data.bRBeam)
			{
				pt = ptSta - vtDir * data.dStairSW;
				pt -= vt * (dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data1.d4SteepW);
				pPoly = DrawRect2d(pt, (data.n1SteepS - 1) * data.dSteepW, dSidet, vt, vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd - vtDir * (dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW);
				pPoly = DrawRect2d(pt, dSidet, (data.nSteep2s - 1) * data.dSteepW, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptEnd + vt * (dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
				pPoly = DrawRect2d(pt, (data1.nSteep3s - 1) * data.dSteepW, dSidet, -vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);

				pt = ptSta - vtDir * (dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW);
				pPoly = DrawRect2d(pt, dSidet, (data1.nSteep4s - 1) * data.dSteepW, vt, -vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

			// 内侧扶手
			pt = ptSta - vtDir * (data1.d3SteepW - data.dBarSide);
			pt -= vt * (data1.d4SteepW - data.dBarSide);
			drawInHandRail2d(dc, pt
				, data.dStairTW - (data.d2SteepW - data.dBarSide) - (data1.d4SteepW - data.dBarSide)
				, data.dStairSW - (data.d1SteepW - data.dBarSide) - (data1.d3SteepW - data.dBarSide)
				, -data.dGarSize[0], vt, -vtDir);

			// 外侧扶手
			if (data.bOutSideHRail)
			{
				ptGe[0] = ptEnd - vtDir * (data.dStairSW - data.dBarSide);
				ptGe[0] += vt * (dL + (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW + data.dZGarExt);
				ptGe[1] = ptEnd + vt * data.dBarSide;
				ptGe[1] -= vtDir * (data.dStairSW - data.dBarSide);
				ptGe[2] = ptEnd - vtDir * data.dBarSide;
				ptGe[2] += vt * data.dBarSide;
				ptGe[3] = ptSta - vtDir * data.dBarSide;
				ptGe[3] -= vt * data.dBarSide;
				ptGe[4] = ptSta - vtDir * (dW + (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW + data.dGarExt);
				ptGe[4] -= vt * data.dBarSide;
				pPoly = drawOutHandRail2d(ptGe, 5, -data.dGarSize[0], vtDir);
				if (pPoly == NULL) return Acad::eOk;
				dc.DrawEntity(pPoly);
				dc.Add2dBuffer(pPoly);
			}

		}
	}

	if (data.bDimUpstair)
	{
		DrawUpStairsDir2d(dc, ptSta, ptEnd, vt, vtDir, data1);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawUpStairsClockWise3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptS, ptE, pt;
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	SFPXStair data1(data);
	AcGePoint3d ptGe[8];
	double dL(.0), dW(.0);

	if (data.nSteepS == 2)
	{
		ptS = ptFr - vt * data.d1SteepW * .5;
		ptS -= vtDir * data.dStairSW;
		ptE = ptS + vtDir * data.n1SteepS * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.n1SteepS, data.d1SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 0, data);
		}

		ptGe[0] = ptS;
		ptGe[1] = ptE;

		DrawRestPlatform3d(dc, ptFr
			, (data.dStairTW - (data.nSteep2s - 1) * data.dSteepW)
			, (data.dStairSW - (data.n1SteepS - 1) * data.dSteepW)
			, vt, vtDir
			, data.d1SteepW, data.d2SteepW
			, data.n1SteepS * data.dSteepH, data);

		ptS = ptTo - vtDir * data.d2SteepW * .5;
		ptS += Z * ((data.n1SteepS - 1) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS + vt * (data.nSteep2s - 1) * data.dSteepW;
		DrawSteep3d(dc, ptE, ptS, data.nSteep2s, data.d2SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, 0, data);
		}

		ptGe[2] = ptE;
		ptGe[3] = ptS;
	}
	else if (data.nSteepS == 3)
	{
		ptS = ptFr - vt * data.d1SteepW * .5;
		ptS -= vtDir * data.dStairSW;
		ptE = ptS + vtDir * data.n1SteepS * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.n1SteepS, data.d1SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 1, data1);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 0, data1);
		}

		ptGe[0] = ptS;
		ptGe[1] = ptE;

		if(data.bSymmetry)
		{
			data1.nSteep3s = data1.n1SteepS;
			data1.d3SteepW = data1.d1SteepW;
		}

		dL = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;

		DrawRestPlatform3d(dc, ptFr
			, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
			, (data.dStairSW - (data.n1SteepS - 1) * data.dSteepW)
			, vt, vtDir
			, data.d1SteepW, data.d2SteepW
			, data.n1SteepS * data.dSteepH, data1);

		ptS = ptFr - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
		ptS -= vtDir * data.d2SteepW * .5;
		ptS += Z * ((data.n1SteepS - 1) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS - vt * data.nSteep2s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.nSteep2s, data.d2SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 0, data);
		}

		ptGe[2] = ptS;
		ptGe[3] = ptE;

		DrawRestPlatform3d(dc, ptTo
			, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
			, (data.dStairSW - (data1.nSteep3s - 1) * data.dSteepW)
			, -vt, vtDir
			, data1.d3SteepW, data.d2SteepW
			, (data.n1SteepS - 1 + data.nSteep2s) * data.dSteepH + data.dSteepW - data.dSbThick, data1);

		ptS = ptTo + vt * data1.d3SteepW * .5;
		ptS -= vtDir * (data.dStairSW + data.dSteepW);
		ptS += Z * ((data.n1SteepS - 1 + data.nSteep2s) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS + vtDir * data1.nSteep3s * data.dSteepW;
		DrawSteep3d(dc, ptE, ptS, data1.nSteep3s, data1.d3SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, 0, data);
		}

		ptGe[4] = ptE;
		ptGe[5] = ptS;
	}
	else if (data.nSteepS == 4)
	{
		if (data.bSymmetry)
		{
			data1.nSteep3s = data1.n1SteepS;
			data1.d3SteepW = data1.d1SteepW;

			data1.nSteep4s = data1.nSteep2s;
			data1.d4SteepW = data1.d2SteepW;
		}

		dL = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;
		dW = (data.dStairSW - data.d2SteepW - data1.d4SteepW) * .5;

		ptS = ptFr - vt * data.d1SteepW * .5;
		ptS -= vtDir * (dW + (data.n1SteepS - 1) * data.dSteepW * .5 + +data.d2SteepW);
		ptE = ptS + vtDir * data.n1SteepS * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.n1SteepS, data.d1SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 1, data1);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 0, data1);
		}

		ptGe[0] = ptS;
		ptGe[1] = ptE;

		DrawRestPlatform3d(dc, ptFr
			, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
			, dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW
			, vt, vtDir
			, data.d1SteepW, data.d2SteepW
			, data.n1SteepS * data.dSteepH, data1);

		ptS = ptFr - vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
		ptS -= vtDir * data.d2SteepW * .5;
		ptS += Z * ((data.n1SteepS - 1) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS - vt * data.nSteep2s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.nSteep2s, data.d2SteepW, data.bRBeam, data.bLBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 0, data);
		}

		ptGe[2] = ptS;
		ptGe[3] = ptE;

		DrawRestPlatform3d(dc, ptTo
			, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
			, dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW
			, -vt, vtDir
			, data1.d3SteepW, data.d2SteepW
			, (data.n1SteepS - 1 + data.nSteep2s)* data.dSteepH + data.dSteepW - data.dSbThick, data1);

		ptS = ptTo + vt * data1.d3SteepW * .5;
		ptS -= vtDir * (dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
		ptS += Z * ((data.n1SteepS - 1 + data.nSteep2s - 1) * data.dSteepH + (data.dSteepW - data.dSbThick) * 2);
		ptE = ptS - vtDir * data1.nSteep3s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data1.nSteep3s, data1.d3SteepW, data.bRBeam, data.bLBeam, data1);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, 0, data);
		}

		ptGe[4] = ptS;
		ptGe[5] = ptE;

		pt = ptTo - vtDir * data.dStairSW;
		DrawRestPlatform3d(dc, pt
			, dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW
			, dW - (data1.nSteep3s - 1) * data.dSteepW * .5 + data1.d4SteepW
			, -vt, -vtDir
			, data1.d3SteepW, data1.d4SteepW
			, (data.n1SteepS - 1 + data.nSteep2s - 1 + data1.nSteep3s) * data.dSteepH + (data.dSteepW - data.dSbThick) * 2, data1);

		ptS = ptTo - vtDir * (data.dStairSW - data1.d4SteepW * .5);
		ptS += vt * (dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW);
		ptS += Z * ((data.n1SteepS - 1 + data.nSteep2s - 1 + data1.nSteep3s - 1) * data.dSteepH + (data.dSteepW - data.dSbThick) * 3);
		ptE = ptS + vt * data1.nSteep4s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data1.nSteep4s, data1.d4SteepW, data.bRBeam, data.bLBeam, data1);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, false, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, true, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, 0, data);
		}

		ptGe[6] = ptS;
		ptGe[7] = ptE;

		pt = ptFr - vtDir * data.dStairSW;
		DrawRestPlatform3d(dc, pt
			, dL - (data1.nSteep4s - 1) * data.dSteepW * .5 + data.d1SteepW
			, dW - (data.n1SteepS - 1) * data.dSteepW * .5 + data1.d4SteepW
			, vt, -vtDir
			, data.d1SteepW, data1.d4SteepW
			, (data.n1SteepS - 1 + data.nSteep2s - 1 + data1.nSteep3s - 1 + data1.nSteep4s)* data.dSteepH + (data.dSteepW - data.dSbThick) * 3, data1);
	}

	DrawHandRail3d(dc, ptGe, vt, vtDir, data1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawUpStairsAntiClockWise3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptS, ptE, pt;
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	SFPXStair data1(data);
	AcGePoint3d ptGe[8];
	double dL(.0), dW(.0);

	if (data.nSteepS == 2)
	{
		ptS = ptTo - vtDir * data.d1SteepW * .5;
		ptE = ptS + vt * data.n1SteepS * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.n1SteepS, data.d1SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 0, data);
		}

		ptGe[0] = ptS;
		ptGe[1] = ptE;

		DrawRestPlatform3d(dc, ptFr
			, (data.dStairTW - (data.n1SteepS - 1) * data.dSteepW)
			, (data.dStairSW - (data.nSteep2s - 1) * data.dSteepW)
			, vt, vtDir
			, data.d2SteepW, data.d1SteepW
			, data.n1SteepS * data.dSteepH, data);

		ptS = ptFr - vt * data.d2SteepW * .5;
		ptS -= vtDir * (data.dStairSW + data.dSteepW);
		ptS += Z * ((data.n1SteepS - 1) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS + vtDir * data.nSteep2s * data.dSteepW;
		DrawSteep3d(dc, ptE, ptS, data.nSteep2s, data.d2SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptE, ptS, data.nSteep2s - 1, data.d2SteepW, 0, data);
		}

		ptGe[2] = ptE;
		ptGe[3] = ptS;
	}
	else if (data.nSteepS == 3)
	{
		ptS = ptTo - vtDir * data.dStairSW;
		ptS += vt * data.d1SteepW * .5;
		ptE = ptS + vtDir * data.n1SteepS * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.n1SteepS, data.d1SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 1, data1);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, 0, data1);
		}

		ptGe[0] = ptS;
		ptGe[1] = ptE;

		if (data.bSymmetry)
		{
			data1.nSteep3s = data1.n1SteepS;
			data1.d3SteepW = data1.d1SteepW;
		}

		dL = (data.dStairTW - data.d1SteepW - data1.d3SteepW) * .5;

		DrawRestPlatform3d(dc, ptTo
			, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
			, (data.dStairSW - (data.n1SteepS - 1) * data.dSteepW)
			, -vt, vtDir
			, data.d1SteepW, data.d2SteepW
			, data.n1SteepS * data.dSteepH, data1);

		ptS = ptTo + vt * (dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
		ptS -= vtDir * data.d2SteepW * .5;
		ptS += Z * ((data.n1SteepS - 1) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS + vt * data.nSteep2s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.nSteep2s, data.d2SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 0, data);
		}

		ptGe[2] = ptS;
		ptGe[3] = ptE;

		DrawRestPlatform3d(dc, ptFr
			, dL - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
			, (data.dStairSW - (data1.nSteep3s - 1) * data.dSteepW)
			, vt, vtDir
			, data1.d3SteepW, data.d2SteepW
			, (data.n1SteepS - 1 + data.nSteep2s) * data.dSteepH + data.dSteepW - data.dSbThick, data1);

		ptS = ptFr - vt * data1.d3SteepW * .5;
		ptS -= vtDir * (data.dStairSW + data.dSteepW);
		ptS += Z * ((data.n1SteepS - 1 + data.nSteep2s - 1) * data.dSteepH + (data.dSteepW - data.dSbThick) * 2);
		ptE = ptS + vtDir * data1.nSteep3s * data.dSteepW;
		DrawSteep3d(dc, ptE, ptS, data1.nSteep3s, data1.d3SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptE, ptS, data1.nSteep3s - 1, data1.d3SteepW, 0, data);
		}

		ptGe[4] = ptE;
		ptGe[5] = ptS;
	}
	else if (data.nSteepS == 4)
	{
		if (data.bSymmetry)
		{
			data1.nSteep3s = data1.n1SteepS;
			data1.d3SteepW = data1.d1SteepW;

			data1.nSteep4s = data1.nSteep2s;
			data1.d4SteepW = data1.d2SteepW;
		}

		dL = (data.dStairTW - data.d2SteepW - data1.d4SteepW) * .5;
		dW = (data.dStairSW - data.d1SteepW - data1.d3SteepW) * .5;

		ptS = ptTo - vtDir * (data.dStairSW - data.d1SteepW * .5);
		ptS += vt * (dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW);
		ptE = ptS + vt * (data.n1SteepS - 1) * data.dSteepW;
		DrawSteep3d(dc, ptE, ptS, data.n1SteepS, data.d1SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptE, ptS, data.n1SteepS - 1, data.d1SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptE, ptS, data.n1SteepS - 1, data.d1SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptE, ptS, data.n1SteepS - 1, data.d1SteepW, 1, data1);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptE, ptS, data.n1SteepS - 1, data.d1SteepW, 0, data1);
		}

		ptGe[0] = ptE;
		ptGe[1] = ptS;

		pt = ptTo - vtDir * data.dStairSW;
		DrawRestPlatform3d(dc, pt
			, dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data.d2SteepW
			, dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW
			, -vt, -vtDir
			, data.d2SteepW, data.d1SteepW
			, data.n1SteepS * data.dSteepH, data1);

		ptS = ptTo - vtDir * data.dStairSW;
		ptS += vt * data.d2SteepW * .5;
		ptS += vtDir * (dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data.d1SteepW);
		ptS += Z * ((data.n1SteepS - 1) * data.dSteepH + data.dSteepW - data.dSbThick);
		ptE = ptS + vtDir * data.nSteep2s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data.nSteep2s, data.d2SteepW, data.bLBeam, data.bRBeam, data);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, 0, data);
		}

		ptGe[2] = ptS;
		ptGe[3] = ptE;

		DrawRestPlatform3d(dc, ptTo
			, dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW
			, dW - (data.nSteep2s - 1) * data.dSteepW * .5 + data1.d3SteepW
			, -vt, vtDir
			, data.d2SteepW, data1.d3SteepW
			, (data.n1SteepS - 1 + data.nSteep2s) * data.dSteepH + data.dSteepW - data.dSbThick, data1);

		ptS = ptTo - vtDir * data1.d3SteepW * .5;
		ptS += vt * (dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data.d2SteepW);
		ptS += Z * ((data.n1SteepS - 1 + data.nSteep2s - 1) * data.dSteepH + (data.dSteepW - data.dSbThick) * 2);
		ptE = ptS + vt * data1.nSteep3s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data1.nSteep3s, data1.d3SteepW, data.bLBeam, data.bRBeam, data1);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep3s - 1, data1.d3SteepW, 0, data);
		}

		ptGe[4] = ptS;
		ptGe[5] = ptE;

		DrawRestPlatform3d(dc, ptFr
			, dL - (data1.nSteep3s - 1) * data.dSteepW * .5 + data1.d4SteepW
			, dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW
			, vt, vtDir
			, data1.d4SteepW, data1.d3SteepW
			, (data.n1SteepS - 1 + data.nSteep2s - 1 + data1.nSteep3s) * data.dSteepH + (data.dSteepW - data.dSbThick) * 2, data1);

		ptS = ptFr - vt * data1.d4SteepW * .5;
		ptS -= vtDir * (dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data1.d3SteepW);
		ptS += Z * ((data.n1SteepS - 1 + data.nSteep2s - 1 + data1.nSteep3s - 1) * data.dSteepH + (data.dSteepW - data.dSbThick) * 3);
		ptE = ptS - vtDir * data1.nSteep4s * data.dSteepW;
		DrawSteep3d(dc, ptS, ptE, data1.nSteep4s, data1.d4SteepW, data.bLBeam, data.bRBeam, data1);
		if (data.bLBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, true, data);
		}
		if (data.bRBeam)
		{
			DrawSide3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, false, data);
		}

		if (data1.bInsideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, 1, data);
		}
		if (data1.bOutSideRail)
		{
			DrawRail3d(dc, ptS, ptE, data1.nSteep4s - 1, data1.d4SteepW, 0, data);
		}

		ptGe[6] = ptS;
		ptGe[7] = ptE;

		pt = ptFr - vtDir * data.dStairSW;
		DrawRestPlatform3d(dc, pt
			, dL - (data.n1SteepS - 1) * data.dSteepW * .5 + data1.d4SteepW
			, dW - (data1.nSteep4s - 1) * data.dSteepW * .5 + data.d1SteepW
			, vt, -vtDir
			, data1.d4SteepW, data.d1SteepW
			, (data.n1SteepS - 1 + data.nSteep2s - 1 + data1.nSteep3s - 1 + data1.nSteep4s) * data.dSteepH + (data.dSteepW - data.dSbThick) * 3, data1);
	}

	DrawHandRail3d(dc, ptGe, vt, vtDir, data1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawSteep3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& nStairsNum
	, const double& dStairsWidth
	, const BOOL& bLeft
	, const BOOL& bRight
	, const SFPXStair& data) const
{
	AcGePoint3d ptSta(ptFr);
	AcGeVector3d vtL(ptTo - ptFr);
	vtL.normalize();

	double dLx = nStairsNum * data.dSteepW;
	double dLh = nStairsNum * 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 = nStairsNum;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总宽
	double dSteepL = dStairsWidth;

	AcGePoint3d ptV, ptV0;
	AcGePoint3dArray arSecPts;

	ptV = ptSta;
	ptV -= vtW * 0.5 * dSteepL;

	if (bLeft)
		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);

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts.asArrayPtr(), arSecPts.length());
		if (!pReg) return Acad::eOk;

		AcDbLine lnPath;
		lnPath.setStartPoint(ptV0);

		if (bLeft)
			ptV = ptV0 + vtW * (dSteepL - 120.0);
		else
			ptV = ptV0 + vtW * dSteepL;

		if (bRight)
			ptV -= vtW * 120.0;//变梁宽,国标120

		lnPath.setEndPoint(ptV);

		AcDbX3dSolid xSolid;
		if (xSolid.CreateExtrude(pReg, lnPath))
		{
			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (!pSolid)
			{
				DELETE_PTR(pReg);
				return Acad::eOk;
			}

			dc.DrawEntity(pSolid);
			dc.Add3dBuffer(pSolid);
			add3DCache<AecDbRectCornerStair>(&xSolid);
			return Acad::eOk;
		}
	}

	return Acad::eInvalidInput;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawSide3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& nStairsNum
	, const double& dStairsWidth
	, const BOOL& bLeft
	, const SFPXStair& data) const
{
	AcGePoint3d ptSta = ptFr;
	AcGeVector3d vtL = ptTo - ptFr;
	vtL.normalize();

	double dLx = nStairsNum * data.dSteepW;
	double dLh = nStairsNum * 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 = nStairsNum;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总长
	double dSteepL = (dStairsWidth/* - 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;
		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];

		AcDbLine ln;
		ln.setStartPoint(ptGe[1]);
		ln.setEndPoint(ptGe[1] + vtW * 120);

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
		if (!pReg) return Acad::eOk;
		AcDbX3dSolid xSolid;
		if (xSolid.CreateExtrude(pReg, ln))
		{
			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (!pSolid)
			{
				DELETE_PTR(pReg);
				return Acad::eOk;
			}

			if (bLeft)
			{
				dc.DrawEntity(pSolid);
				dc.Add3dBuffer(pSolid);
				add3DCache<AecDbRectCornerStair>(&xSolid);
			}

			AcGeMatrix3d xform;
			vtW *= (dStairsWidth - 120);
			xform.setTranslation(vtW);

			if (!bLeft)
			{
				AcDb3dSolid* pOtherSide = (AcDb3dSolid*)pSolid->clone();
				if (!pOtherSide)
				{
					DELETE_PTR(pReg);
					DELETE_PTR(pSolid);
					return Acad::eOk;
				}

				pOtherSide->transformBy(xform);
				dc.DrawEntity(pOtherSide);
				dc.Add3dBuffer(pOtherSide);
				xSolid.TransformBy(xform);
				add3DCache<AecDbRectCornerStair>(&xSolid);
			}
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawRestPlatform3d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const double& dL
	, const double& dW
	, const AcGeVector3d& vecL
	, const AcGeVector3d& vecW
	, const double& dStairsWidthL// 长度方向的楼梯宽带
	, const double& dStairsWidthW// 宽度方向的楼梯宽带
	, const double& dH
	, const SFPXStair& data) const
{
	AcGePoint3d pt(AcGePoint3d::kOrigin);
	AcGePoint3dArray ptAr;
	ptAr.removeAll();
	int nOldClr = dc.GetColor();
	dc.SetColor(3);

	ptAr.append(ptSta);
	pt = ptSta - vecW * dW;
	ptAr.append(pt);
	pt -= vecL * dStairsWidthL;
	ptAr.append(pt);
	pt += vecW * (dW - dStairsWidthW);
	ptAr.append(pt);
	pt -= vecL * (dL - dStairsWidthL);
	ptAr.append(pt);
	pt += vecW * dStairsWidthW;
	ptAr.append(pt);
	ptAr.append(ptSta);

	AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptAr.asArrayPtr(), ptAr.length());
	if (!pReg) return Acad::eOk;
	drawSolid(dc, pReg, data.dSbThick, dH, AcGeVector3d::kZAxis, AcGeVector3d::kZAxis);

	dc.SetColor(nOldClr);

	return Acad::eOk;
}

// 栏杆
Acad::ErrorStatus AecDbRectCornerStairDraw::DrawRail3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& nStairsNum
	, const double& dStairsWidth
	, const int& num
	, const SFPXStair& 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 = nStairsNum;

	AcGePoint3dArray arSecPts;

	if (data.nUpSide == 0)
	{
		ptSta += vtLDir * ((dStairsWidth - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta -= vtLDir * ((dStairsWidth - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}
	else
	{
		ptSta -= vtLDir * ((dStairsWidth - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta += vtLDir * ((dStairsWidth - 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.dGarSize[0], data.dGarSize[0], vtL, vtLDir);
		}
		else
		{
			pReg = makeCircleRegion(arSecPts.at(i), AcGeVector3d::kZAxis, data.dGarSize[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<AecDbRectCornerStair>(&xSolid);
		}
	}

	return Acad::eOk;
}

// 扶手
AcDbLine* AecDbRectCornerStairDraw::DrawStairsPath3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& nStairsNum
	, const double& dStairsWidth
	, const SFPXStair& data) const
{
	AcGePoint3d ptSta(ptFr);
	AcGeVector3d vtL = (ptFr - ptTo).normalize();
	vtL.z = 0.0;

	AcGeVector3d vtLDir(vtL), Z(AcGeVector3d::kZAxis);
	vtLDir.rotateBy(-PI / 2.0, Z);
	vtLDir.normalize();

	//一共多少步
	int nCount = nStairsNum;

	//踏步左右总长
	double dSteepL = (dStairsWidth/* - 2.0 * data.dSidet*/);//无论左右有无梁

	AcGePoint3dArray arSecPts;
	arSecPts.removeAll();

	arSecPts.append(ptSta);
	for (int i = 0; i < nCount; i++)
	{
		ptSta -= vtL * data.dSteepW;
		ptSta += Z * data.dSteepH;
		arSecPts.append(ptSta);
	}

	AcDbLine* pLine = new AcDbLine(arSecPts.first(), arSecPts.last());
	if (!pLine) return NULL;
	return pLine;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawHandRailPath3d(AcGiDraw& dc
	, const AcGePoint3dArray& arPts
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& 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[0], vec, AcGeVector3d::kZAxis);
	}
	else
	{
		pReg = makeCircleRegion(arPts.at(0), vec, data.dGarSize[0] * .5);
	}
	if (!pReg) return Acad::eOk;

	AcDbX3dSolid xSolid;
	AcDb3dPolyline* p3dPoly = Format3dPolyline(arPts);
	if (!p3dPoly)
	{
		DELETE_PTR(pReg);
		return Acad::eOk;
	}
	if (xSolid.CreateSweep(pReg, (AcDbPolyline*)p3dPoly))
	{
		AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
		if (!pSolid)
		{
			DELETE_PTR(pReg);
			return Acad::eOk;
		}
		dc.DrawEntity(pSolid);
		dc.Add3dBuffer(pSolid);
		add3DCache<AecDbRectCornerStair>(&xSolid);
	}

	DELETE_PTR(pReg);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbRectCornerStairDraw::DrawHandRail3d(AcGiDraw& dc
	, const AcGePoint3d* ptAr
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptS, ptE, pt;
	AcDbLine* pLine(NULL), *pLineS(NULL), *pLineE(NULL);
	AcGeVector3d Z(AcGeVector3d::kZAxis), vec;
	AcGePoint3dArray ptGeAr, ptSEAr;
	SFPXStair data1(data);
	double dDist(.0), dLY(.0), dLX(.0);
	AcGePoint3d ptGe[15];
	AcGePoint3d ptGeSE[4];

	if (DOWN_ZERO(data.dZGarExt))
	{
		AfxMessageBox(_T("层间伸出不能小于0！"));
		return Acad::eOk;
	}
	if (DOWN_ZERO(data.dGarExt))
	{
		AfxMessageBox(_T("转角扶手伸出不能小于0！"));
		return Acad::eOk;
	}
	if (DOWN_ZERO(data.dBarSide))
	{
		AfxMessageBox(_T("扶手距边不能小于0！"));
		return Acad::eOk;
	}

	double dTanAngle = data.dSteepH / data.dSteepW;
	double dLen = sqrt(data.dSteepH * data.dSteepH + data.dSteepW * data.dSteepW);
	double dSinAngle = data.dSteepH / dLen;
	double dCosAngle = data.dSteepW / dLen;

	if (data.nUpSide == 0)
	{
		if (data.nSteepS == 2)
		{
			// 内侧扶手
			{
				ptS = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;				

				ptS = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}			
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vt * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}

			// 外侧扶手
			if (data1.bOutSideHRail)
			{
				ptS = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;				

				ptS = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				/*pt = ptGe[1] + vtDir * (data.dStairSW - data.n1SteepS * data.dSteepW - data.dBarSide - data.dGarSize[0] * .5);
				ptGeAr.append(pt);*/
				ptGeSE[0] = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vt * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}
		}
		else if (data.nSteepS == 3)
		{
			// 内侧扶手
			{
				ptS = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] += vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}				
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}

			// 外侧扶手
			if (data1.bOutSideHRail)
			{
				ptS = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				/*pt = ptGe[1] + vtDir * (data.dStairSW - data.n1SteepS * data.dSteepW - data.dBarSide - data.dGarSize[0] * .5);
				ptGeAr.append(pt);*/
				ptGeSE[0] = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				/*pt = ptGe[4] + vtDir * (data.dStairSW - (data.nSteep3s - 1) * data.dSteepW - data.dBarSide - data.dGarSize[0] * .5);
				ptGeAr.append(pt);*/
				ptGeSE[0] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] += vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}
		}
		else if (data.nSteepS == 4)
		{
			// 内侧扶手
			{
				ptS = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptS = ptAr[6] + vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[7] + vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep4s - 1, data.d4SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[6] = ptS;
				ptGe[7] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] += vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				ptGeSE[0] = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] += vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[6] + vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[7] + vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[7] - ptGe[6]).normalize();
					pt = ptGe[6] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[6]);
				ptGeAr.append(ptGe[7]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() + vt * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}

			// 外侧扶手
			if (data1.bOutSideHRail)
			{
				ptS = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptS = ptAr[6] - vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[7] - vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep4s - 1, data.d4SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[6] = ptS;
				ptGe[7] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] += vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				ptGeSE[0] = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] += vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[6] - vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[7] - vtDir * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[7] - ptGe[6]).normalize();
					pt = ptGe[6] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[6]);
				ptGeAr.append(ptGe[7]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() + vt * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}
		}
	}
	else
	{
		if (data.nSteepS == 2)
		{
			// 内侧扶手
			{
				ptS = ptAr[0] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vt * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}

			// 外侧扶手
			if (data1.bOutSideHRail)
			{
				ptS = ptAr[0] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vt * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}
		}
		else if (data.nSteepS == 3)
		{
			// 内侧扶手
			{
				ptS = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] + vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] - vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] - vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}

			// 外侧扶手
			if (data1.bOutSideHRail)
			{
				ptS = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] - vt * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] + vtDir * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] + vt * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) - vtDir * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}
		}
		else if (data.nSteepS == 4)
		{
			// 内侧扶手
			{
				ptS = ptAr[0] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] - vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] - vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptS = ptAr[6] - vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[7] - vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep4s - 1, data.d4SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[6] = ptS;
				ptGe[7] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] + vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] + vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] - vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] - vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				ptGeSE[0] = ptAr[4] - vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[5] - vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[6] - vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[7] - vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[7] - ptGe[6]).normalize();
					pt = ptGe[6] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[6]);
				ptGeAr.append(ptGe[7]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) + vt * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}

			// 外侧扶手
			if (data1.bOutSideHRail)
			{
				ptS = ptAr[0] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[1] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.n1SteepS - 1, data.d1SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[0] = ptS;
				ptGe[1] = ptE;

				ptS = ptAr[2] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[3] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep2s - 1, data.d2SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[2] = ptS;
				ptGe[3] = ptE;

				ptS = ptAr[4] + vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[5] + vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep3s - 1, data.d3SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[4] = ptS;
				ptGe[5] = ptE;

				ptS = ptAr[6] + vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptS += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				ptE = ptAr[7] + vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptE += Z * (data.dSteepH + data.dBarH - (data.dSteepW * .5) * dTanAngle);
				pLine = DrawStairsPath3d(dc, ptS, ptE, data.nSteep4s - 1, data.d4SteepW, data);
				pLine->getStartPoint(ptS);
				pLine->getEndPoint(ptE);
				DELETE_PTR(pLine);
				ptGe[6] = ptS;
				ptGe[7] = ptE;

				ptGeAr.removeAll();
				ptGeAr.append(ptGe[0]);
				ptGeAr.append(ptGe[1]);

				ptGeSE[0] = ptAr[0] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[1] - vtDir * (data.d1SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				pLineS = new AcDbLine(ptGeSE[00], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[2] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[3] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt -= vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[3] - ptGe[2]).normalize();
					pt = ptGe[2] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[2]);
				ptGeAr.append(ptGe[3]);

				ptGeSE[0] = ptAr[2] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[3] - vt * (data.d2SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vtDir * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[4] + vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[5] + vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[2] - ptGe[3]).normalize();
					pt = ptGe[3] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vtDir * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[5] - ptGe[4]).normalize();
					pt = ptGe[4] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[4]);
				ptGeAr.append(ptGe[5]);

				ptGeSE[0] = ptAr[4] + vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[0].z = 0;
				ptGeSE[1] = ptAr[5] + vtDir * (data.d3SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[1].z = 0;
				ptGeSE[1] -= vt * data.dSteepW;
				pLineS = new AcDbLine(ptGeSE[0], ptGeSE[1]);
				if (!pLineS)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineS);
				ptGeSE[2] = ptAr[6] + vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[2].z = 0;
				ptGeSE[3] = ptAr[7] + vt * (data.d4SteepW * .5 - data.dBarSide - data.dGarSize[0] * .5);
				ptGeSE[3].z = 0;
				pLineE = new AcDbLine(ptGeSE[3], ptGeSE[2]);
				if (!pLineE)
				{
					return Acad::eOk;
				}
				//CoreTools::CloneAndAddToModelSpace(pLineE);
				ptSEAr.removeAll();
				pLineS->intersectWith(pLineE, AcDb::kExtendBoth, ptSEAr);
				if (ptSEAr.length() == 1)
				{
					/*AcDbCircle* pCir1 = new AcDbCircle(ptSEAr.first(), AcGeVector3d::kZAxis, 25);
					pCir1->setColorIndex(6);
					CoreTools::AddToModelSpace(pCir1);
					AcDbCircle* pCir2 = new AcDbCircle(ptGeSE[1], AcGeVector3d::kZAxis, 25);
					pCir2->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir2);
					AcDbCircle* pCir3 = new AcDbCircle(ptGeSE[2], AcGeVector3d::kZAxis, 25);
					pCir3->setColorIndex(3);
					CoreTools::AddToModelSpace(pCir3);*/
					dLX = ptGeSE[1].distanceTo(ptSEAr.first());
					dLY = ptGeSE[2].distanceTo(ptSEAr.first());
				}
				if (dLX <= data.dSteepW * .5)
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * dLX / dCosAngle;
					ptGeAr.append(pt);
				}
				else
				{
					vec = (ptGe[4] - ptGe[5]).normalize();
					pt = ptGe[5] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);

					pt += vt * (dLX - data.dSteepW * .5);
					ptGeAr.append(pt);
				}
				if (dLY > data.dSteepW * .5)
				{
					vec = (ptGe[7] - ptGe[6]).normalize();
					pt = ptGe[6] - vec * (data.dSteepW * .5) / dCosAngle;
					ptGeAr.append(pt);
				}

				ptGeAr.append(ptGe[6]);
				ptGeAr.append(ptGe[7]);

				if (UP_ZERO(data.dZGarExt))
				{
					pt = ptGeAr.at(0) + vt * data.dZGarExt;
					ptGeAr.insertAt(0, pt);
				}
				if (UP_ZERO(data.dGarExt))
				{
					pt = ptGeAr.last() - vtDir * data.dGarExt;
					ptGeAr.append(pt);
				}

				DrawHandRailPath3d(dc, ptGeAr, vt, vtDir, data);
			}
		}
	}

	return Acad::eOk;
}