#include "stdafx.h"
#include "AecDbMRPLineStair.h"
#include "KTSetting.h"
#include "AcDbX3dSolid.h"
#include "AcGiExplodeDraw.h"
#include "AcGiViewDraw.h"
#include "ImpMD5.h"

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

extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
extern BOOL GetDocScale(double& dPScale);
extern void SortPoints(AcGePoint3dArray& points,AcDbCurve* pLine);
extern AcDbRegion* CreatePolygonRegionOnly(AcGePoint3d* pPoints,int nSize);
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
extern AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);

Adesk::UInt32 AecDbMRPLineStair::kCurrentVersionNumber = 1;

ACRX_DXF_DEFINE_MEMBERS (AecDbMRPLineStair, AecDbEwPipeBase,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_DBMRPSTAIR,
						 "AecDbMRPLineStair"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")

AecDbMRPLineStair::AecDbMRPLineStair(void)
{
}

AecDbMRPLineStair::~AecDbMRPLineStair(void)
{
	deleteContainerOfStd(m_solids);
	deleteContainerOfStd(m_pipes);
}

void AecDbMRPLineStair::SetStairData(const MRPLineStair& data)
{
	AssertWriteEnabled();

	//set section; 底层设置section,用于绘制管子
	//路径单独设置
	//bar数据key方式保存,只是占位用
	if (data.nGShape == 0)
	{
		//Circle
		SetSection(data.dGarSize[0],5.0);//5mm厚
	}
	else
	{
		//Rect
		SetSection(data.dGarSize[0],data.dGarSize[1],5.0);//5mm厚
	}

	m_mapSpecXData.SetAt(KEY_KIND,data.nKind);
	m_mapSpecXData.SetAt(KEY_STEEPH,data.dSteepH);
	m_mapSpecXData.SetAt(KEY_STEEPW,data.dSteepW);

	CString snSteeps,sTemp;
	for (int i = 0;i < data.nSteepSize;i++)
	{
		sTemp.Format(_T("%d;"),data.nSteeps[i]);
		snSteeps += sTemp;
	}
	snSteeps.TrimRight(_T(';'));
	m_mapSpecXData.SetAt(KEY_STEEPS1,snSteeps);

	m_mapSpecXData.SetAt(KEY_STAIRSW,data.dStairW);
	m_mapSpecXData.SetAt(KEY_BOMEL,data.dBomEl);

	m_mapSpecXData.SetAt(KEY_RESTPTW,data.dRestPtW);
	m_mapSpecXData.SetAt(KEY_STIFFNH,data.dStiffnH);
	m_mapSpecXData.SetAt(KEY_STIFFNW,data.dStiffnW);
	m_mapSpecXData.SetAt(KEY_SLABT,data.dSbThick);

	m_mapSpecXData.SetAt(KEY_BARH,data.dBarH);
	m_mapSpecXData.SetAt(KEY_GARSIZE0,data.dGarSize[0]);
	m_mapSpecXData.SetAt(KEY_GARSIZE1,data.dGarSize[1]);

	m_mapSpecXData.SetAt(KEY_GSHAPE,data.nGShape);
	m_mapSpecXData.SetAt(KEY_GAREXT,data.dGarExt);
	m_mapSpecXData.SetAt(KEY_GARMAT,data.szGarMat);

	m_mapSpecXData.SetAt(KEY_BARSP,data.dBarSp);
	m_mapSpecXData.SetAt(KEY_BARSIZE0,data.dBarSize[0]);
	m_mapSpecXData.SetAt(KEY_BARSIZE1,data.dBarSize[1]);
	m_mapSpecXData.SetAt(KEY_BSHAPE,data.nBShape);
	m_mapSpecXData.SetAt(KEY_BARMAT,data.szBarMat);

	m_mapSpecXData.SetAt(KEY_HASRPLT, data.bHasResetPLF);
	m_mapSpecXData.SetAt(KEY_HASGBAR, data.bHasGarBar);
	m_mapSpecXData.SetAt(KEY_GBARLR, data.nGarBarLR);
	m_mapSpecXData.SetAt(KEY_GBRSTPLF, data.bGBResetPLF);
	m_mapSpecXData.SetAt(KEY_HASSTFN, data.bHasStiffn);
}

void AecDbMRPLineStair::GetStairData(MRPLineStair& data) const
{
	assertReadEnabled();

	CString sTemp;
	m_mapSpecXData.GetAt(KEY_KIND,data.nKind);
	m_mapSpecXData.GetAt(KEY_STEEPH,data.dSteepH);
	m_mapSpecXData.GetAt(KEY_STEEPW,data.dSteepW);

	m_mapSpecXData.GetAt(KEY_STEEPS1,sTemp);
	if (!sTemp.IsEmpty())
	{
		CStringArray arVals;
		SplitStrintToArray(sTemp,arVals,_T(';'));

		data.nSteepSize = arVals.GetSize();
		for (int i = 0;i < data.nSteepSize;i++)
		{
			data.nSteeps[i] = _ttoi(arVals.GetAt(i));
		}
	}		

	m_mapSpecXData.GetAt(KEY_STAIRSW,data.dStairW);
	m_mapSpecXData.GetAt(KEY_BOMEL,data.dBomEl);

	m_mapSpecXData.GetAt(KEY_RESTPTW,data.dRestPtW);
	m_mapSpecXData.GetAt(KEY_STIFFNH,data.dStiffnH);
	m_mapSpecXData.GetAt(KEY_STIFFNW,data.dStiffnW);
	m_mapSpecXData.GetAt(KEY_SLABT,data.dSbThick);

	m_mapSpecXData.GetAt(KEY_BARH,data.dBarH);
	m_mapSpecXData.GetAt(KEY_GARSIZE0,data.dGarSize[0]);
	m_mapSpecXData.GetAt(KEY_GARSIZE1,data.dGarSize[1]);

	m_mapSpecXData.GetAt(KEY_GSHAPE,data.nGShape);
	m_mapSpecXData.GetAt(KEY_GAREXT,data.dGarExt);

	m_mapSpecXData.GetAt(KEY_GARMAT,sTemp);
	_tcscpy(data.szGarMat,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_BARSP,data.dBarSp);
	m_mapSpecXData.GetAt(KEY_BARSIZE0,data.dBarSize[0]);
	m_mapSpecXData.GetAt(KEY_BARSIZE1,data.dBarSize[1]);
	m_mapSpecXData.GetAt(KEY_BSHAPE,data.nBShape);
	m_mapSpecXData.GetAt(KEY_BARMAT,sTemp);
	_tcscpy(data.szBarMat,(LPCTSTR)sTemp);
	data.bHasResetPLF = TRUE;
	data.bHasGarBar = TRUE;
	m_mapSpecXData.GetAt(KEY_HASRPLT, data.bHasResetPLF);
	m_mapSpecXData.GetAt(KEY_HASGBAR, data.bHasGarBar);
	data.nGarBarLR = 2;//默认左右都有
	m_mapSpecXData.GetAt(KEY_GBARLR, data.nGarBarLR);
	m_mapSpecXData.GetAt(KEY_HASSTFN, data.bHasStiffn);
	m_mapSpecXData.GetAt(KEY_GBRSTPLF,data.bGBResetPLF);
}

Acad::ErrorStatus AecDbMRPLineStair::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = AecDbEwPipeBase::dwgInFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	//----- Object version number needs to be read first
	Adesk::UInt32 version =0 ;
	if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
		return (es) ;

	if ( version > AecDbMRPLineStair::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbMRPLineStair::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = AecDbEwPipeBase::dwgOutFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	//----- Object version number needs to be saved first
	if ( (es =pFiler->writeUInt32 (AecDbMRPLineStair::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbMRPLineStair::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

void AecDbMRPLineStair::subList() const
{
	assertReadEnabled();

	acutPrintf(_T("\n多段楼梯"));
	AecDbEwPipeBase::subList();
}

//AEC 派生
Acad::ErrorStatus AecDbMRPLineStair::Draw2d(AcGiDraw &dc) const
{
	AcDbObjectId idCurLay = dc.GetLayerId();
	Adesk::UInt16 nCrBk = colorIndex();

	dc.SetLayer(layerId());

	//二维缓存,未知出错!
	if (Has2DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pEnt = (AcDbEntity*)ar2D.at(i);

			dc.SetColor(colorIndex());
			dc.DrawEntity(*pEnt);
		}
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	dc.SetColor(colorIndex());

	AcDbCurve* pBaseCrv = GetBaseCurve(true);
	if (pBaseCrv != NULL)
	{
		MRPLineStair data;
		memset(&data,0,sizeof(MRPLineStair));

		GetStairData(data);

		AcDbObjectId idLayOld = dc.GetLayerId();
		AcDbObjectId idLay = layerId();
		dc.SetLayer(idLay);

		AcDbVoidPtrArray arEntDrawPtrs;

		//跑步方向
		AcDbLine* pLn = AcDbLine::cast(pBaseCrv);
		if (pLn != NULL)
		{
			AcGeVector3d vtDir = pLn->endPoint() - pLn->startPoint();
			vtDir.normalize();

			//一跑步数
			AcGePoint3d ptBase = pLn->startPoint();

			AcGePoint3d ptFr = ptBase;
			AcGePoint3d ptS[5],ptDir[2];

			AcGeVector3d vtLR;

			vtLR = vtDir;
			vtLR.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);

			//2D 侧进一个扶手宽度
			ptFr += data.dGarSize[0] * vtLR;

			//踏步线宽度
			double dLen = data.dStairW;
			dLen -= 2.0 * data.dGarSize[0];

			//绘制踏步线 踏步数
			AcGePoint3d ptTo;
			for (int i = 0;i < data.nSteepSize;i++)
			{
				for (int j = 0;j < data.nSteeps[i];j++)
				{
					ptTo = ptFr;
					ptTo += vtLR * dLen;

					AcDbLine* pLnX = new AcDbLine;
					pLnX->setStartPoint(ptFr);
					pLnX->setEndPoint(ptTo);
					pLnX->setLayer(idLay);

					//dc.DrawEntity(pLnX);
					//Add2DBuffer(pLnX);
					arEntDrawPtrs.append(pLnX);

					//步进一个台阶
					if (j == data.nSteeps[i] - 1)
						break;

					ptFr += vtDir * data.dSteepW;
				}

				if (i == data.nSteepSize - 1)
				{
					if (data.bHasResetPLF)
					{
						ptFr += data.dRestPtW * vtDir;
					}
				}
				else
				{
					ptFr += data.dRestPtW * vtDir;
				}

				if (i == (data.nSteepSize - 1) )
				{
					ptTo = ptFr;
					ptTo += vtLR * dLen;

					AcDbLine* pLnX = new AcDbLine;
					pLnX->setStartPoint(ptFr);
					pLnX->setEndPoint(ptTo);
					pLnX->setLayer(idLay);

					//dc.DrawEntity(pLnX);
					//Add2DBuffer(pLnX);
					arEntDrawPtrs.append(pLnX);
				}
			}

			//绘制扶手投影
			ptS[0] = ptBase;
			ptS[0] -= data.dGarExt * vtDir;//转角扶手伸出

			ptS[1] = ptS[0];
			ptS[1] += data.dGarSize[0] * vtLR;

			ptS[2] = ptFr;
			ptS[2] += data.dGarExt * vtDir;//转角扶手伸出

			ptS[3] = ptS[2];
			ptS[3] -= data.dGarSize[0] * vtLR;
			ptS[4] = ptS[0];

			AcDbPolyline* pL = FormatPolyline(ptS,5);
			//dc.DrawEntity(pL);
			//Add2DBuffer(pL);
			arEntDrawPtrs.append(pL);

			//右侧
			ptS[0] = ptBase;
			ptS[0] -= data.dGarExt * vtDir;//转角扶手伸出
			ptS[0] += data.dGarSize[0] * vtLR;
			ptS[0] += dLen * vtLR;

			ptS[1] = ptS[0];
			ptS[1] += data.dGarSize[0] * vtLR;

			ptS[2] = ptTo;
			ptS[2] += data.dGarSize[0] * vtLR;
			ptS[2] += data.dGarExt * vtDir;//转角扶手伸出

			ptS[3] = ptS[2];
			ptS[3] -= data.dGarSize[0] * vtLR;
			ptS[4] = ptS[0];

			pL = FormatPolyline(ptS,5);
			//dc.DrawEntity(pL);
			//Add2DBuffer(pL);
			arEntDrawPtrs.append(pL);

			//绘制向上指引线
			ptDir[0] = ptBase;
			ptDir[0] -= data.dGarExt * vtDir;//转角扶手伸出
			ptDir[0] += data.dGarSize[0] * vtLR;
			ptDir[0] += 0.5 * dLen * vtLR;

			ptDir[1] = ptFr;
			ptDir[1] += data.dGarExt * vtDir;//转角扶手伸出
			ptDir[1] += 0.5 * dLen * vtLR;

			pL = FormatPolyline(ptDir,2);
			pL->setColorIndex(kGreen);
			//dc.DrawEntity(pL);
			//Add2DBuffer(pL);
			arEntDrawPtrs.append(pL);

			DrawLeader(dc,ptDir[0],ptDir[1],kGreen);

			DrawUporDown(dc,ptDir[0],-vtDir,1);
		}

		//统一绘制
		AcDbEntity* pEnt = NULL;
		for (int j = 0;j < arEntDrawPtrs.length();j++)
		{
			pEnt = (AcDbEntity*)arEntDrawPtrs.at(j);
			dc.DrawEntity(pEnt);
			Add2DBuffer(pEnt);
		}

		delete pBaseCrv;
		dc.SetLayer(idLayOld);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::DrawUporDown(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGeVector3d& vtOff,int nUporDown) const
{
	double dDocScale = 100.0;
	GetDocScale(dDocScale);

	AcGePoint3d ptOff = ptFr + vtOff * 1.5 * dDocScale;
	ptOff += vtOff * 3.5 * dDocScale;

	LPCTSTR pszText = nUporDown < 0 ? _T("下") : _T("上");

	AcGeVector3d vtT = vtOff;
	vtT.negate();
	vtT.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
	vtT.normalize();

	double dRot = AcGeVector3d::kXAxis.angleTo(vtT);
	ptOff -= 1.75 * dDocScale * vtT;

	AcDbText* pText = new AcDbText;
	pText->setPosition(ptOff);
	pText->setHeight(3.5 * dDocScale);
	pText->setWidthFactor(0.75);
	pText->setNormal(AcGeVector3d::kZAxis);
	pText->setTextString(pszText);
	pText->setRotation(dRot);

	AcDbObjectId idSt = KTSetting::InitTextStyle(_T("Pipe_Dim"));
	pText->setTextStyle(idSt);
	pText->setLayer(layerId());
	pText->setColorIndex(kWhite);

	dc.DrawEntity(pText);
	Add2DBuffer(pText);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::DrawLeader(AcGiDraw &dc,AcGePoint3d& pt0,AcGePoint3d& pt1,int nColor) const
{
	double dAL = 3.0;
	double dAW = 0.8;
	double dDocScale = 100.0;
	GetDocScale(dDocScale);

	AcGeVector3d vt = pt1 - pt0;
	vt.normalize();

	AcGePoint3d ptA = pt1 - vt * dAL * dDocScale;

	AcDbPolyline* pPl = new AcDbPolyline;
	pPl->addVertexAt(0,pt0.convert2d(AcGePlane::kXYPlane));
	pPl->addVertexAt(1,ptA.convert2d(AcGePlane::kXYPlane),0,dAW*dDocScale);
	pPl->addVertexAt(2,pt1.convert2d(AcGePlane::kXYPlane),0,0);
	pPl->setColorIndex(nColor);

	dc.DrawEntity(pPl);
	Add2DBuffer(pPl);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::Draw3d(AcGiDraw &dc) const
{
	//样子参照 PDMS 的样子
	assertReadEnabled();

	//管线系统屏蔽掉
	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	if (m_pBaseCurve == NULL)
		return Acad::eInvalidInput;

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());

	int nCrBk = dc.GetColor();

	if (Has3DBuffer())
	{
		//Clean3DBuffer();
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			dc.SetColor(colorIndex());
			dc.DrawEntity(*pEnt);
		}

		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	dc.SetColor(colorIndex());

	MRPLineStair data;
	memset(&data,0,sizeof(MRPLineStair));
	GetStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta,ptEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			deleteContainerOfStd(m_solids);
			deleteContainerOfStd(m_pipes);
			DrawSteep3d(dc,ptSta,ptEnd,data);
		}
	}
	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::DrawSteep3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,MRPLineStair& data) const
{
	AcGePoint3d ptBase = ptFr;
	ptBase.z = data.dBomEl;

	AcGeVector3d vtDir = ptTo - ptFr;
	vtDir.z = 0.0;
	vtDir.normalize();

	AcGeVector3d vtUp;

	AcGeVector3d vtLR;
	vtLR = vtDir;
	vtLR.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
	
	AcGePoint3dArray arPts,arBarPos;
	AcGePoint3d ptPos = ptBase;
	AcGePoint3d ptBar,ptPos2,ptE;

	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());
	int nCrBk = dc.GetColor();

	for (int i = 0;i < data.nSteepSize;i++)
	{
		for (int j = 0;j < data.nSteeps[i];j++)
		{
			arPts.append(ptPos);

			ptPos.z += data.dSteepH;
			arPts.append(ptPos);

			if (arPts.length() == 4)
			{
				vtUp = arPts.last() - arPts.at(1);
			}

			ptPos += vtDir * data.dSteepW;
			ptBar = MidPoint(ptPos,arPts.last());

			ptBar += vtLR * data.dGarSize[0];
			arBarPos.append(ptBar);
		}

		if (i == data.nSteepSize - 1)
		{
			if (!data.bHasResetPLF)
			{
				ptPos2 = ptPos;
				arPts.append(ptPos2);
				ptPos = ptPos2;

				ptBar = ptPos;
				ptBar -= vtDir * 0.5 * data.dSteepW;
				ptBar += vtLR * data.dGarSize[0];
				arBarPos.append(ptBar);
			}
			else
			{
				ptPos2 = ptPos;
				ptPos2 += vtDir * (data.dRestPtW - data.dSteepW);
				arPts.append(ptPos2);
				ptPos = ptPos2;

				ptBar = ptPos;
				ptBar -= vtDir * 0.5 * data.dSteepW;
				ptBar += vtLR * data.dGarSize[0];
				arBarPos.append(ptBar);
			}
		}
		else
		{
			ptPos2 = ptPos;
			ptPos2 += vtDir * (data.dRestPtW - data.dSteepW);
			arPts.append(ptPos2);
			ptPos = ptPos2;

			ptBar = ptPos;
			ptBar -= vtDir * 0.5 * data.dSteepW;
			ptBar += vtLR * data.dGarSize[0];
			arBarPos.append(ptBar);
		}
		
		AcDbLine ln1;
		if (data.bHasStiffn)
		{
			//创建一段
			ptPos2.z -= data.dSbThick;
			ptPos2.z -= data.dStiffnH;
			arPts.append(ptPos2);

			ptPos2 -= data.dStiffnW * vtDir;
			arPts.append(ptPos2);

			if (i == data.nSteepSize - 1)
			{
				if (data.bHasResetPLF)
				{
					ptPos2.z += data.dStiffnH;
					arPts.append(ptPos2);

				}
				else
				{
					ptPos2.z += data.dStiffnH;
				}
			}
			else
			{
				ptPos2.z += data.dStiffnH;
				arPts.append(ptPos2);
			}

			if (i == data.nSteepSize - 1)
			{
				if (data.bHasResetPLF)
				{
					ptPos2 -= vtDir * (data.dRestPtW - 2.0 * data.dStiffnW);
				}
				else
				{

				}
			}
			else
			{
				ptPos2 -= vtDir * (data.dRestPtW - 2.0 * data.dStiffnW);
			}

			ln1.setStartPoint(arPts.last());
			ln1.setEndPoint(ptPos2);

			AcGeVector3d vtD = -AcGeVector3d::kZAxis;
			vtD = vtD.orthoProject(vtUp);
			vtD.normalize();

			AcDbXline xLn;
			ptE = arPts.at(2);
			ptE += vtD * data.dSbThick;
			xLn.setBasePoint(ptE);
			xLn.setUnitDir(vtUp);

			AcGePoint3dArray arPtInt;
			xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);

			if (arPtInt.isEmpty())
			{
				arPts.append(ptPos2);
			}
			else
			{
				arPts.append(arPtInt.first());
			}

			if (i == data.nSteepSize - 1 && !data.bHasResetPLF)
			{
				//...
				arPts.append(arPts.first());
			}
			else
			{
				ln1.setStartPoint(ptPos2);
				ptPos2.z -= data.dStiffnH;
				ln1.setEndPoint(ptPos2);

				arPtInt.removeAll();
				xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);

				if (arPtInt.isEmpty())
				{
					arPts.append(ln1.startPoint());
				}
				else
				{
					arPts.append(arPtInt.first());
				}

				arPts.append(ptPos2);

				ptPos2 -= vtDir * data.dStiffnW;
				arPts.append(ptPos2);

				ln1.setStartPoint(ptPos2);
				ptE = ptPos2;
				ptE.z += data.dStiffnH;
				ln1.setEndPoint(ptE);

				arPtInt.removeAll();
				xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);

				if (!arPtInt.isEmpty())
				{
					arPts.append(arPtInt.first());
				}
				else
				{
					arPts.append(ptPos2);
				}

				ptPos2 = arPts.first();
				ptPos2.z -= data.dStiffnH;

				if (i == 0)
				{
					ptPos2 += vtDir * data.dStiffnW;
				}

				ln1.setStartPoint(ptPos2);
				ptE = ptPos2;

				ptE.z += data.dStiffnH;
				ln1.setEndPoint(ptE);

				arPtInt.removeAll();
				xLn.intersectWith(&ln1, AcDb::kExtendArg, arPtInt);

				if (!arPtInt.isEmpty())
				{
					arPts.append(arPtInt.first());
				}
				else
				{
					arPts.append(ptPos2);
				}

				if (i == 0)
				{
					ptPos2 = arPts.first();
					if (data.bHasStiffn)
					{
						ptPos2.z -= data.dStiffnH;

						ptPos2 += vtDir * data.dStiffnW;
						arPts.append(ptPos2);

						ptPos2 -= vtDir * data.dStiffnW;
						arPts.append(ptPos2);

						ptPos2.z += data.dStiffnH;
						arPts.append(ptPos2);
					}
				}
				else
				{
					arPts.append(arPts.first());
				}
			}	
		}
		else
		{
			ptPos2.z -= data.dSbThick;
			arPts.append(ptPos2);

			AcGeVector3d vtD = -AcGeVector3d::kZAxis;
			vtD = vtD.orthoProject(vtUp);
			vtD.normalize();

			AcDbXline xLn;
			ptE = arPts.at(2);
			ptE += vtD * data.dSbThick;
			xLn.setBasePoint(ptE);
			xLn.setUnitDir(vtUp);

			ln1.setStartPoint(arPts.last());

			if (i == data.nSteepSize - 1)
			{
				if (data.bHasResetPLF)
				{
					ptPos2 -= vtDir * data.dRestPtW;
				}
			}
			else
			{
				ptPos2 -= vtDir * data.dRestPtW;
			}
			ln1.setEndPoint(ptPos2);

			AcGePoint3dArray arPtInt;
			xLn.intersectWith(&ln1, AcDb::kOnBothOperands, arPtInt);

			if (!arPtInt.isEmpty())
			{
				arPts.append(arPtInt.first());
			}

			AcDbXline xLn2;
			if (i > 0)
			{
				ptE = arPts.first();
				ptE.z -= data.dSbThick;
				xLn2.setBasePoint(ptE);
				xLn2.setUnitDir(vtDir);
			}
			else
			{
				xLn2.setBasePoint(arPts.first());
				xLn2.setUnitDir(vtDir);
			}

			arPtInt.removeAll();
			xLn.intersectWith(&xLn2, AcDb::kOnBothOperands, arPtInt);

			if (!arPtInt.isEmpty())
			{
				arPts.append(arPtInt.first());
			}
			if (i > 0) arPts.append(ptE);
			arPts.append(arPts.first());
		}

		AcDbRegion* pReg = CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
		if (pReg != NULL)
		{
			ln1.setStartPoint(arPts.first());
			ptE = arPts.first() + data.dStairW * vtLR;
			ln1.setEndPoint(ptE);

			AcDbX3dSolid x3dSolid;
			if ( x3dSolid.CreateExtrude(pReg,ln1) )
			{
				m_solids.push_back(x3dSolid.Clone());
				AcDb3dSolid* pSolid = (AcDb3dSolid*)x3dSolid.GetNative3dSolid()->clone();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(transparency());
					pSolid->setLayer(layerId());
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
			}
			delete pReg;
		}
		arPts.removeAll();

		//扶手护栏
		if (data.bHasGarBar)
		{
			if (data.bGBResetPLF == 0)
				arBarPos.removeLast();//休息平台不画栏杆

			DrawGuarBar3d(dc, arBarPos, vtLR, data);
			arBarPos.removeAll();
		}
		dc.SetLayer(layerId());
		dc.SetColor(nCrBk);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::DrawGuarBar3d(AcGiDraw &dc,AcGePoint3dArray& arBarPos,const AcGeVector3d& vtLR,MRPLineStair& data) const
{
	int nCrbk = dc.GetColor();

	AcGePoint3d pt,pt2;
	AcDbLine ln;
	AecDbEwPipeBase pipe;
	AcDbVoidPtrArray ar3DSoldPtrs;
	AcGiExplodeDraw dc2(ar3DSoldPtrs);

	AcGePoint3dArray arTop1,arTop2;
	for (int i = 0;i < arBarPos.length();i++)
	{
		pt = arBarPos.at(i);
		pt2 = pt;
		pt2.z += data.dBarH;
		arTop1.append(pt2);

		if (data.nBShape == 0)
			pipe.SetSection(data.dBarSize[0],data.dBarSize[1],0.0);
		else
			pipe.SetSection(data.dBarSize[0],0.0);

		ln.setStartPoint(pt);
		ln.setEndPoint(pt2);
		pipe.SetBaseCurve(&ln);

		if (data.nGarBarLR != 1)//左有
		{
			pipe.Draw3d(dc2);
			m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
			pipe.Clean3DBufferNoDel();
		}

		//对称位置
		pt += (data.dStairW - 2.0 * data.dGarSize[0]) * vtLR;
		pt2 += (data.dStairW - 2.0 * data.dGarSize[0]) * vtLR;
		arTop2.append(pt2);

		ln.setStartPoint(pt);
		ln.setEndPoint(pt2);
		pipe.SetBaseCurve(&ln);

		if (data.nGarBarLR > 0)//右有
		{
			pipe.Draw3d(dc2);
			m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
			pipe.Clean3DBufferNoDel();
		}
	}

	//两头延长,扶手伸出
	AcGeVector3d vt = arTop1.at(0) - arTop1.at(1);
	vt.z = 0.0;//水平
	vt.normalize();

	pt = arTop1.first() + vt * data.dGarExt;
	arTop1.insertAt(0,pt);

	pt = arTop2.first() + vt * data.dGarExt;
	arTop2.insertAt(0,pt);

	pt = arTop1.last() - vt * data.dGarExt;
	arTop1.append(pt);

	pt = arTop2.last() - vt * data.dGarExt;
	arTop2.append(pt);

	AcDb3dPolyline* pPl = Format3dPolyline(arTop1);
	if (pPl != NULL)
	{
		if (data.nGShape == 0)
			pipe.SetSection(data.dGarSize[0], data.dGarSize[1], 0.0);
		else
			pipe.SetSection(data.dGarSize[0], 0.0);

		pipe.SetBaseCurve(pPl);

		if (data.nGarBarLR != 1)//左有
		{
			pipe.Draw3d(dc2);
			m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
			pipe.Clean3DBufferNoDel();
		}
		delete pPl;
	}

	pPl = Format3dPolyline(arTop2);
	if (pPl != NULL)
	{
		if (data.nGShape == 0)
			pipe.SetSection(data.dGarSize[0], data.dGarSize[1], 0.0);
		else
			pipe.SetSection(data.dGarSize[0], 0.0);

		pipe.SetBaseCurve(pPl);

		if (data.nGarBarLR > 0)//右有
		{
			pipe.Draw3d(dc2);
			m_pipes.push_back((AecDbEwPipeBase*)pipe.clone());
			pipe.Clean3DBufferNoDel();
		}

		delete pPl;
	}
	
	AcDbEntity* pEnt = NULL;
	for (int i = 0;i < ar3DSoldPtrs.length();i++)
	{
		pEnt = (AcDbEntity*)ar3DSoldPtrs.at(i);
		pEnt->setColorIndex(kCyan);
		pEnt->setTransparency(transparency());
		dc.SetColor(kCyan);
		dc.DrawEntity(pEnt);
		Add3DBuffer(pEnt);
	}

	dc.SetColor(nCrbk);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbMRPLineStair::subTransformBy(const AcGeMatrix3d& xform)
{
	AecDbEwPipeBase::subTransformBy(xform);

	double dBomEl = 0.0;
	m_mapSpecXData.GetAt(KEY_BOMEL,dBomEl);

	AcGePoint3d pt(0,0,dBomEl);
	pt.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_BOMEL,pt.z);

	return Acad::eOk;
}

int AecDbMRPLineStair::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegPtrs) const
{
	assertReadEnabled();

	AcGeVector3d vtLn = ptTo - ptFr;
	AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);

	AcGePlane plan;
	plan.set(ptFr,vtNorm);

	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	if (Get3DBuffer().length() == 0)
	{
		AcGiViewDraw dc(NULL,NULL);
		Draw3d(dc);
	}

	AcDbEntity* pEnt = NULL;
	AcDb3dSolid* pSolid = NULL;

	AcDbVoidPtrArray arRegPtrsT;

	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);

		pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			//投影法
			OrthoProjected3DSolid(pSolid,plan,xform,arRegPtrsT);
		}
	}

	for (int i = 0;i < arRegPtrsT.length();i++)
	{
		pEnt = (AcDbEntity*)arRegPtrsT.at(i);
		pEnt->setLayer(layerId());
		pEnt->setColorIndex(kColorByLayer);
		arRegPtrs.append(pEnt);
	}

	return arRegPtrs.length();
}

CString AecDbMRPLineStair::getUniqueName() const
{
	assertReadEnabled();
	CString str(_T(""));
	MRPLineStair data;
	::memset(&data, 0, sizeof(MRPLineStair));
	GetStairData(data);

	::memset(data.szGarMat, 0, 256 * sizeof(TCHAR));
	::memset(data.szBarMat, 0, 256 * sizeof(TCHAR));
	::memset(&data.dBomEl, 0, sizeof(double));

	return ImpMD5(&data, sizeof(MRPLineStair)).toString16W().c_str();
}

SHJson::WValue & AecDbMRPLineStair::ToJson(bool bExprotGeo) const
{
	assertReadEnabled();
	using namespace SHJson;
	WValue &v = AecDbEwPipeBase::ToJson(bExprotGeo);

	if (bExprotGeo)
	{
		AecDbMRPLineStair *pNew = (AecDbMRPLineStair*)clone();
		AcDbCurve *pCurve = pNew->GetNativeCurve();
		if (pCurve)
		{
			AcGePoint3d ptS(AcGePoint3d::kOrigin);
			AcGePoint3d ptE(ptS);
			pCurve->getStartPoint(ptS);
			pCurve->getEndPoint(ptE);
			AcGeMatrix3d mat;

			mat.setToTranslation(-ptS.asVector());
			pCurve->transformBy(mat);

			pCurve->getStartPoint(ptS);
			pCurve->getEndPoint(ptE);
			AcGeVector3d vt(ptE - ptS);
			if (!vt.isCodirectionalTo(AcGeVector3d::kXAxis))
			{
				double dAngle = AcGeVector3d::kXAxis.angleTo(vt, AcGeVector3d::kZAxis);
				mat.setToRotation(-dAngle, AcGeVector3d::kZAxis, ptS);
				pCurve->transformBy(mat);
			}
		}
		pNew->Clean3DBuffer();
		AcGiViewDraw dc;
		pNew->Draw3d(dc);

		WValue ar;
		ar.SetArray();

		for (size_t i(0); i < pNew->m_solids.size(); ++i)
		{
			AcDbX3dSolid *pSolid(pNew->m_solids[i]);
			if (!pSolid) continue;
			WValue &x = pSolid->ToJson();
			pushBack(ar, x);
		}
		if (!pNew->m_solids.empty())
			addMember(v, _T("__solids__"), ar);

		ar.SetArray();
		for (size_t i(0); i < pNew->m_pipes.size(); ++i)
		{
			AecDbEwPipeBase *pPipe(pNew->m_pipes[i]);
			if (!pPipe) continue;
			WValue &x = pPipe->ToJson();
			pushBack(ar, x);
		}
		if (!pNew->m_pipes.empty())
			addMember(v, _T("__pipes__"), ar);
		DELETE_PTR(pNew);
	}

	/*
	int nKind;			//0 钢筋混凝土 1 钢梯
	double dSteepH;		//踏步高度
	double dSteepW;		//踏步宽度

	int nSteepSize;		//踏步段数
	int nSteeps[20];	//最多20段

	double dStairW;		//梯段宽度 单宽

	double dBomEl;		//底部标高

	//平台参数
	double dRestPtW;	//休息平台宽
	double dStiffnW;	//加强筋宽 钢梯无效
	double dStiffnH;	//加强筋高 钢梯无效
	double dSbThick;	//平台板厚

	//边梁
	double dSideBeamW;	//边梁宽 60 预留
	double dSideBeamH;	//边梁高 60 预留

	//扶手护栏
	double dBarH;		 //扶手高度
	double dGarSize[2];  //扶手截面尺寸
	double dGarExt;		 //转角扶手伸出 60 默认

	int    nGShape;		 //截面类型0 Rect 1 C
	TCHAR  szGarMat[256];//材质

	double dBarSp;		 //护栏间距 预留
	double dBarSize[2];	 //护栏截面尺寸

	int    nBShape;		 //护栏截面类型0 Rect 1 C
	TCHAR  szBarMat[256];//材质
	*/

	MRPLineStair data;
	memset(&data, 0, sizeof(MRPLineStair));
	GetStairData(data);
	WValue vData;

	addMember(vData, _T("__nKind__"), data.nKind);
	addMember(vData, _T("__dSteepH__"), data.dSteepH);
	addMember(vData, _T("__dSteepW__"), data.dSteepW);

	addMember(vData, _T("__nSteepSize__"), data.nSteepSize);

	WValue ar;
	ar.SetArray();
	for (int i(0); i < sizeof(data.nSteeps) / sizeof(data.nSteeps[0]); ++i)
		pushBack(ar, data.nSteeps[i]);
	addMember(vData, _T("__nSteeps__"), ar);

	addMember(vData, _T("__dStairW__"), data.dStairW);

	addMember(vData, _T("__dBomEl__"), data.dBomEl);

	//平台参数
	addMember(vData, _T("__dRestPtW__"), data.dRestPtW);
	addMember(vData, _T("__dStiffnW__"), data.dStiffnW);
	addMember(vData, _T("__dStiffnH__"), data.dStiffnH);
	addMember(vData, _T("__dSbThick__"), data.dSbThick);

	//边梁
	addMember(vData, _T("__dSideBeamW__"), data.dSideBeamW);
	addMember(vData, _T("__dSideBeamH__"), data.dSideBeamH);

	//扶手护栏
	addMember(vData, _T("__dBarH__"), data.dBarH);

	ar.SetArray();
	for (int i(0); i < sizeof(data.dGarSize) / sizeof(data.dGarSize[0]); ++i)
		pushBack(ar, data.dGarSize[i]);
	addMember(vData, _T("__dGarSize__"), ar);

	addMember(vData, _T("__dGarExt__"), data.dGarExt);

	addMember(vData, _T("__nGShape__"), data.nGShape);
	addMember(vData, _T("__szGarMat__"), data.szGarMat);

	addMember(vData, _T("__dBarSp__"), data.dBarSp);

	ar.SetArray();
	for (int i(0); i < sizeof(data.dBarSize) / sizeof(data.dBarSize[0]); ++i)
		pushBack(ar, data.dBarSize[i]);
	addMember(vData, _T("__dBarSize__"), ar);

	addMember(vData, _T("__nBShape__"), data.nBShape);
	addMember(vData, _T("__szBarMat__"), data.szBarMat);

	addMember(v, _T("_MRPLineStair_data_"), vData);

	return v;
}

#include "HlrCutOption.h"
void AecDbMRPLineStair::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
	, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
	, AcArray<AcDbEntity *> &output) const
{
	HlrCutOption::ProcessHlrResult(this
		, FALSE
		, .0
		, HlrCutOption::getHlrBLK_STAIR()
		, ar
		, preAr
		, output);
}