#include "stdafx.h"
#include "AecDbArcStair.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.h"
#include "coretools.h"

static const Adesk::UInt16 kRed            = 1;
static const Adesk::UInt16 kYellow         = 2;
static const Adesk::UInt16 kGreen          = 3;

extern AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
extern BOOL DLLIMPEXP GetDimGripOff();
extern AcGePoint3d GetArcMidPoint(AcDbArc* pArc);
extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
static const Adesk::UInt16 kColorByLayer   = 256;
namespace
{
	AcDb3dSolid* drawSide(AcDbCurve *p, const double &t, const double &W)
	{
		AcGeVector3d vt(AcGeVector3d::kIdentity);
		AcGePoint3d pt0, pt1, pt2, pt3;
		p->getStartPoint(pt0);
		p->getFirstDeriv(pt0, vt);
		vt.z = .0;
		vt.rotateBy(PI * .5, AcGeVector3d::kZAxis);
		vt.normalize();
		pt1 = pt0 + vt * t;
		pt2 = pt1 + AcGeVector3d::kZAxis * W;
		pt3 = pt0 + AcGeVector3d::kZAxis * W;
		AcDbVoidPtrArray ar;
		ar.append(new AcDbLine(pt0, pt1));
		ar.append(new AcDbLine(pt1, pt2));
		ar.append(new AcDbLine(pt2, pt3));
		ar.append(new AcDbLine(pt3, pt0));
		AcDb3dSolid *pSolid(NULL);

		AcDbRegion *pReg = CoreTools::createRegion(ar);
		if (pReg)
		{
			pSolid = new AcDb3dSolid();
			if (pSolid)
			{
				//if (!pSolid->extrudeAlongPath(pReg, p) == Acad::eOk)
				AcDbSweepOptions op;
				op.setTwistAngle(CoreTools::A2R(12));
				if (!pSolid->createSweptSolid(pReg, p, op) == Acad::eOk)
					DELETE_PTR(pSolid);
			}
			//CoreTools::CloneAndAddToModelSpace(pReg);
			DELETE_PTR(pReg);
		}
		deleteArrayVoidPtrs< AcDbEntity>(ar);
		return pSolid;
	}
}

Adesk::UInt32 AecDbArcStair::kCurrentVersionNumber = 1;
ACRX_DXF_DEFINE_MEMBERS (AecDbArcStair, AecDbBaseStair,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_DBASTAIR,
						 "AecDbArcStair"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")


AecDbArcStair::AecDbArcStair(void)
{
	m_mapSpecXData.SetAt(KEY_NAME,_T("弧梯"));
}

AecDbArcStair::~AecDbArcStair(void)
{
}

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

	//----- Read parent class information first.
	Acad::ErrorStatus es = AecDbBaseStair::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 > AecDbArcStair::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	return pFiler->filerStatus();
}

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

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

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

	return pFiler->filerStatus();
}

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

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

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

	acutPrintf(_T("\n弧线爬梯"));
	AecDbEwPipeBase::subList();
}

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

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

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

	m_mapSpecXData.SetAt(KEY_BOMEL,pt.z);

	dBomEl = 0;
	m_mapSpecXData.GetAt(KEY_TOPEL,dBomEl);

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

	m_mapSpecXData.SetAt(KEY_TOPEL,pt.z);

	return Acad::eOk;
}

bool AecDbArcStair::GetBimInfoTip(CString& sInfoTip) const
{
	assertReadEnabled();

	CString sField,sFmt;

	sField = _T("弧线爬梯:\n");
	sInfoTip += sField;

	LineStair data;
	memset(&data,0,sizeof(LineStair));
	GetLineStairData(data);

	MAKEFIELD(_T("踏步高度"),_T("%d"),(int)(data.dSteepH + 0.5),sInfoTip);

	MAKEFIELD(_T("踏步板宽"),_T("%d"),(int)(data.dSteepW + 0.5),sInfoTip);

	MAKEFIELD(_T("踏步板厚"),_T("%d"),(int)(data.dSteept + 0.5),sInfoTip);

	MAKEFIELD(_T("楼梯总宽"),_T("%d"),(int)(data.dW + 0.5),sInfoTip);

	if (data.bBomSta)
	{
		MAKEFIELD(_T("底部标高"),_T("%.1f"),(int)(data.dBomEl + 0.5),sInfoTip);
	}
	else
	{
		MAKEFIELD(_T("顶部标高"),_T("%.1f"),(int)(data.dTopEl + 0.5),sInfoTip);
	}

	MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
	MAKEFIELD(_T("编号"),_T("%s"),data.m_sNo,sInfoTip);
	MAKEFIELD(_T("厂家"),_T("%s"),data.m_sFactory,sInfoTip);

	return true;
}

Acad::ErrorStatus AecDbArcStair::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	Adesk::UInt16 nCrBk = colorIndex();

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

	//二维缓存,未知出错!
	if (Has2DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pEnt = (AcDbEntity*)ar2D.at(i);
			dc.DrawEntity(*pEnt);
		}
		dc.SetColor(nCrBk);
		dc.SetLayer(idCurLay);
		dc.SetLineType(idCurLty);
		return Acad::eOk;
	}

	LineStair data;
	GetLineStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
		if (pArc != NULL)
		{
			double dR = pArc->radius();

			double dLR = dR + 0.5 * data.dW;
			double dLr = dR - 0.5 * data.dW;
			AcGePoint3d ptCen = pArc->center();
			ptCen.z = 0.0;

			AcDbArc* pArc1 = (AcDbArc*)pArc->clone();
			pArc1->setRadius(dLR);
			pArc1->setCenter(ptCen);

			AcDbArc* pArc2 = (AcDbArc*)pArc->clone();
			pArc2->setRadius(dLr);
			pArc2->setCenter(ptCen);

			AcDbArc* pArc11 = (AcDbArc*)pArc->clone();
			pArc11->setRadius(dLR - data.dSidet);
			pArc11->setCenter(ptCen);

			AcDbArc* pArc22 = (AcDbArc*)pArc->clone();
			pArc22->setRadius(dLr + data.dSidet);
			pArc22->setCenter(ptCen);

			AcGePoint3d ptSta[2],ptEnd[2];
			pArc1->getStartPoint(ptSta[0]);
			pArc11->getStartPoint(ptSta[1]);

			pArc1->getEndPoint(ptEnd[0]);
			pArc11->getEndPoint(ptEnd[1]);

			AcDbLine* pLn1 = new AcDbLine(ptSta[0],ptSta[1]);
			AcDbLine* pLn2 = new AcDbLine(ptEnd[0],ptEnd[1]);

			pArc2->getStartPoint(ptSta[0]);
			pArc22->getStartPoint(ptSta[1]);

			pArc2->getEndPoint(ptEnd[0]);
			pArc22->getEndPoint(ptEnd[1]);

			AcDbLine* pLn3 = new AcDbLine(ptSta[0],ptSta[1]);
			AcDbLine* pLn4 = new AcDbLine(ptEnd[0],ptEnd[1]);

			dc.DrawEntity(pLn1);
			Add2DBuffer(pLn1);

			dc.DrawEntity(pArc1);
			Add2DBuffer(pArc1);

			dc.DrawEntity(pArc11);
			Add2DBuffer(pArc11);

			dc.DrawEntity(pLn2);
			Add2DBuffer(pLn2);

			dc.DrawEntity(pArc2);
			Add2DBuffer(pArc2);

			dc.DrawEntity(pArc22);
			Add2DBuffer(pArc22);

			dc.DrawEntity(pLn3);
			Add2DBuffer(pLn3);

			dc.DrawEntity(pLn4);
			Add2DBuffer(pLn4);

			//内部
			//2.内部踏板投影
			//水平长
			double dLen = (pArc->endAngle() - pArc->startAngle()) * dR;

			//垂直高
			double dH = data.dTopEl - data.dBomEl;

			//踏步数
			int nCount = (int)(dLen / data.dSteepW);

			AcGePoint3d ptGe[5];

			double dEnd = 0.0,dSta = 0.0;
			pArc->getEndParam(dEnd);
			pArc->getStartParam(dSta);

			double dPa = 0.0,dSteepPa = 0.0;
			
			dSteepPa = (dEnd - dSta) / nCount;
			AcGeVector3d vtV;
			AcDbLine* pLn = NULL;

			for (int i = 0;i < nCount;i++)
			{
				if (data.bBomSta)
					dPa = dSta + (i+1) * dSteepPa;////开头是低标高,End是高标高
				else
					dPa = dEnd - (i+1) * dSteepPa;

				pArc->getPointAtParam(dPa,ptGe[0]);
				ptGe[0].z = 0.0;
				ptGe[1] = ptGe[0];

				vtV = ptGe[0] - ptCen;
				vtV.normalize();

				ptGe[0] += vtV * 0.5 * (data.dW - 2 * data.dSidet);
				ptGe[1] -= vtV * 0.5 * (data.dW - 2 * data.dSidet);

				pLn = new AcDbLine;
				pLn->setStartPoint(ptGe[0]);
				pLn->setEndPoint(ptGe[1]);

				dc.DrawEntity(pLn);
				Add2DBuffer(pLn);
			}

			//绘制增高方向线 ----->
			AcDbArc* pArcCen = (AcDbArc*)pArc->clone();
			dc.DrawEntity(pArcCen);
			Add2DBuffer(pArcCen);

			AcGeVector3d vtL;
			if (data.bBomSta)//开头是低标高,End是高标高
			{
				pArc->getFirstDeriv(dEnd,vtL);//向内指向
				pArc->getEndPoint(ptGe[0]);
				vtL.negate();//向内指向
			}
			else
			{
				pArc->getFirstDeriv(dSta,vtL);
				pArc->getStartPoint(ptGe[0]);
			}

			vtL.normalize();
			vtV = vtL;
			vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			vtV.normalize();

			ptSta[0] = ptGe[0];
			vtL.normalize();

			ptSta[0] += vtL * 0.25 * data.dSteepW;

			ptSta[0] += vtV * 0.25 * data.dSteepW;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta[0]);
			pLn->setEndPoint(ptGe[0]);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			Add2DBuffer(pLn);

			ptSta[0] = ptGe[0];
			vtV.normalize();
			
			ptSta[0] += vtL * 0.25 * data.dSteepW;

			ptSta[0] -= vtV * 0.25 * data.dSteepW;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta[0]);
			pLn->setEndPoint(ptGe[0]);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			Add2DBuffer(pLn);
		}

		dc.SetColor(nCrBk);
		dc.SetLayer(idCurLay);
		dc.SetLineType(idCurLty);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbArcStair::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();

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

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

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

	LineStair data;
	GetLineStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
		if (pArc != NULL)
		{
			DrawSide3d(dc,data);
			DrawSteep3d(dc,data);
			DrawGuardBar3d(dc,data);
		}
	}
	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);
	return Acad::eOk;
}

bool GetSamplePoints(AcDbCurve* pSubCrv,double dFitLen,AcGePoint3dArray& arSubPts,AcGeVector3dArray& arFitDirs)
{
	if (pSubCrv != NULL && dFitLen > 1.e-6)
	{
		double dEnd = 0.0,dDis = 0.0,dSta = 0.0;
		pSubCrv->getEndParam(dEnd);
		pSubCrv->getStartParam(dSta);
		pSubCrv->getDistAtParam(dEnd,dDis);

		int nNumVerts = (int)(dDis / dFitLen) + 1;
		double dStep = (dEnd - dSta) / nNumVerts;

		AcGeVector3d vtDir;
		AcGePoint3d ptTemp;
		for (int i = 0; i <= nNumVerts; i++) //2 米 等 分
		{
			pSubCrv->getPointAtParam(dSta + dStep * i, ptTemp);
			pSubCrv->getFirstDeriv(ptTemp,vtDir);
			arSubPts.append(ptTemp);
			arFitDirs.append(vtDir);
		}
		return true;
	}
	return false;
}

AcDb3dSolid* AecDbArcStair::CreateSide3dSegSolid(const AcGePoint3dArray& arPtsR,const AcGePoint3dArray& arPtsR2,int i,double  dSideH) const
{
	AcGePoint3d ptGe[4];
	AcGePoint3d ptSta,ptEnd;
	AcDb3dSolid* pSolidSeg = NULL;
	Acad;;ErrorStatus es;

	ptGe[0] = arPtsR.at(i);
	ptGe[1] = arPtsR.at(i+1);
	ptGe[2] = arPtsR2.at(i);
	ptGe[3] = ptGe[0];

	AcDbLine ln;
	AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,4);
	if (pReg != NULL)
	{
		ptSta = ptGe[0];
		ptEnd = ptSta;
		ptEnd.z += dSideH;

		ln.setStartPoint(ptSta);
		ln.setEndPoint(ptEnd);

		AcDbX3dSolid xSolid;
		if ( xSolid.CreateExtrude(pReg,ln) )
		{
			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (pSolid != NULL)
			{
				pSolidSeg = pSolid;
			}
		}
	}

	ptGe[0] = arPtsR2.at(i);
	ptGe[1] = arPtsR2.at(i+1);
	ptGe[2] = arPtsR.at(i+1);
	ptGe[3] = ptGe[0];

	pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,4);
	if (pReg != NULL)
	{
		ptSta = ptGe[0];
		ptEnd = ptSta;
		ptEnd.z += dSideH;

		ln.setStartPoint(ptSta);
		ln.setEndPoint(ptEnd);

		AcDbX3dSolid xSolid;
		if ( xSolid.CreateExtrude(pReg,ln) )
		{
			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (pSolid != NULL)
			{
				if (pSolidSeg != NULL)
				{
					es = pSolidSeg->booleanOper(AcDb::kBoolUnite,pSolid);
				}
			}
		}
	}
	return pSolidSeg;
}

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

	/*
	GuardBar bar;//扶手

	double dSteepH;//踏步高度
	double dSteept;//踏步板厚
	double dSteepW;//踏步板宽

	double dSidet;//底侧板厚>扶手直径
	double dSideW;//底侧板宽

	double dW;	//总宽

	double dBomEl;//底部标高
	double dTopEl;//顶部标高
	BOOL   bBomSta;//对于圆弧,是否是开始位置为底标高

	TCHAR  m_sMaterial[256];
	TCHAR  m_sFactory[256];//厂家
	TCHAR  m_sNo[256];
	*/

	LineStair data;
	::memset(&data, 0, sizeof(LINESTAIR));
	GetLineStairData(data);

	WValue vBar;
	addMember(vBar, _T("__dD__"), data.bar.dD);
	addMember(vBar, _T("__dt__"), data.bar.dt);
	addMember(vBar, _T("__dBomEl__"), data.bar.dBomEl);
	addMember(vBar, _T("__dH1__"), data.bar.dH1);
	addMember(vBar, _T("__dH__"), data.bar.dH);
	addMember(vBar, _T("__dP__"), data.bar.dP);

	addMember(vBar, _T("__bNoBomLever__"), data.bar.bNoBomLever == FALSE ? false : true);
	addMember(vBar, _T("__bIsRectLever__"), data.bar.bIsRectLever == FALSE ? false : true);

	addMember(vBar, _T("__sMaterial__"), data.bar.m_sMaterial);
	addMember(vBar, _T("__sFactory__"), data.bar.m_sFactory);
	addMember(vBar, _T("__sNo__"), data.bar.m_sNo);

	addMember(v, _T("__bar__"), vBar);

	addMember(v, _T("__dSteepH__"), data.dSteepH);
	addMember(v, _T("__dSteept__"), data.dSteept);
	addMember(v, _T("__dSteepW__"), data.dSteepW);

	addMember(v, _T("__dSidet__"), data.dSidet);
	addMember(v, _T("__dSideW__"), data.dSideW);

	addMember(v, _T("__dW__"), data.dW);

	addMember(v, _T("__dBomEl__"), data.dBomEl);
	addMember(v, _T("__dTopEl__"), data.dTopEl);
	addMember(v, _T("__bBomSta__"), data.bBomSta);

	addMember(v, _T("__sMaterial__"), data.m_sMaterial);
	addMember(v, _T("__sFactory__"), data.m_sFactory);
	addMember(v, _T("__sNo__"), data.m_sNo);

	return v;
}

bool AecDbArcStair::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbEwPipeBase::ByJson(v);
}

extern void transfromRegion(AcDbRegion *pRegion, const AcGePoint3d &ptOnRegion, const AcGeVector3d &vtNormal, const AcGePoint3d &ptOnPlan);
static void FreeBuffer(AcDbVoidPtrArray& arCurves)
{
	for (int i = 0;i < arCurves.length();i++)
	{
		AcDbEntity* pEnt = (AcDbEntity*)arCurves.at(i);
		if (pEnt != NULL)
		{
			DELETE_PTR(pEnt);
		}
	}
	arCurves.setLogicalLength(0);	
}

//长x宽x厚 水平面为长,Z向为宽
AcDbRegion* CreateRegion(AcGePoint3d& ptFrBom,double dSideH,double dSidet,AcGeVector3d& vtNorm)
{
	AcGePoint3d ptGe[5];
	AcDbVoidPtrArray arCurPtrs;

	ptGe[0] = AcGePoint3d::kOrigin;
	ptGe[0].x -= 0.5 * dSidet;
	ptGe[0].y += 0.5 * dSideH;

	ptGe[1] = ptGe[0];
	ptGe[1].x += dSidet;

	ptGe[2] = ptGe[1];
	ptGe[2].y -= dSideH;

	ptGe[3] = ptGe[0];
	ptGe[3].y -= dSideH;
	ptGe[4] = ptGe[0];

	AcDbVoidPtrArray arRegnPtrs;
	AcDbLine* pLn = NULL;
	for (int i = 0;i < 4;i++)
	{
		pLn = new AcDbLine;
		pLn->setStartPoint(ptGe[i]);
		pLn->setEndPoint(ptGe[i+1]);
		arCurPtrs.append(pLn);
	}

	AcDbRegion* pRegion = NULL;
	if ( Acad::eOk == AcDbRegion::createFromCurves(arCurPtrs,arRegnPtrs) )
	{
		if (!arRegnPtrs.isEmpty() )
		{
			pRegion = (AcDbRegion*)arRegnPtrs.first();
		}
	}
	FreeBuffer(arCurPtrs);

	transfromRegion(pRegion,ptGe[3],vtNorm,ptFrBom);

	return pRegion;
}

Acad::ErrorStatus AecDbArcStair::DrawSide3d(AcGiDraw &dc,const LineStair& data) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();

	AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
	if (pArc != NULL)
	{
		AcGePoint3d ptSta,ptEnd;
		pArc->getStartPoint(ptSta);
		pArc->getEndPoint(ptEnd);

		if (data.bBomSta)
		{
			ptSta.z = data.dBomEl;
			ptEnd.z = data.dTopEl;
		}
		else
		{
			ptSta.z = data.dTopEl;
			ptEnd.z = data.dBomEl;
		}

		double dAngle = asin( (data.dTopEl - data.dBomEl) / ptSta.distanceTo(ptEnd) );

		double dR = pArc->radius() + 0.5 * data.dW;

		//以直代曲
		double dLen = (pArc->endAngle() - pArc->startAngle()) * pArc->radius();
		//100毫米一个节点
		double dFitLen = 100.0;//

		AcGePoint3dArray arPoints;
		AcGeVector3dArray arFitDirs;

		GetSamplePoints(pArc,dFitLen,arPoints,arFitDirs);
	
		AcDbLine ln;
		ln.setStartPoint(ptSta);
		ln.setEndPoint(ptEnd);

		AcGePoint3d ptGeOn,ptGeR,ptGer;
		AcGeVector3d vtFit;

		AcGePoint3dArray arPtsR,arPtsr;
		for (int i = 0;i < arPoints.length();i++)
		{
			AcGePoint3d& ptGe = arPoints.at(i);
			ln.getClosestPointTo(ptGe,AcGeVector3d::kZAxis,ptGeOn/*,Adesk::kTrue*/);
			ptGe.z = ptGeOn.z;

			vtFit = arFitDirs.at(i);
			vtFit.z = 0.0;
			vtFit.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			vtFit.normalize();

			ptGeR = ptGe + vtFit * 0.5 * data.dW;
			ptGeR -= vtFit * data.dSidet;
			arPtsR.append(ptGeR);

			ptGer = ptGe - vtFit * 0.5 * data.dW;
			arPtsr.append(ptGer);
		}
		
		AcGePoint3dArray arPtsR2,arPtsr2;
		arPtsR2.append(arPtsR);
		arPtsr2.append(arPtsr);

		// 得出两条路径
		AcDbArc *pDbArc1(NULL), *pDbArc2(NULL);
		if (arPtsR2.length() > 3)
		{
			AcGePoint3d pt1(arPtsR2[0]), pt2(arPtsR2[int(arPoints.length() * .5)]), pt3(arPtsR2.last());
			pDbArc1 = CoreTools::geArc2DbArc(AcGeCircArc3d(pt1, pt2, pt3));
		}
		else
			return Acad::eInvalidInput;

		if (arPtsr2.length() > 3)
		{
			AcGePoint3d pt1(arPtsr2[0]), pt2(arPtsr2[int(arPoints.length() * .5)]), pt3(arPtsr2.last());
			pDbArc2 = CoreTools::geArc2DbArc(AcGeCircArc3d(pt1, pt2, pt3));
		}
		else
			return Acad::eInvalidInput;

		//CoreTools::CloneAndAddToModelSpace(pDbArc1);

		AcDb3dSolid *pSolid = drawSide(pDbArc1, data.dSidet, data.dSideW);
		if (pSolid)
		{
			pSolid->setTransparency(tr);
			dc.DrawEntity(*pSolid);
			Add3DBuffer(pSolid);
			DELETE_PTR(pDbArc1);
		}

		pSolid = drawSide(pDbArc2, data.dSidet, data.dSideW);
		if (pSolid)
		{
			pSolid->setTransparency(tr);
			dc.DrawEntity(*pSolid);
			Add3DBuffer(pSolid);
			DELETE_PTR(pDbArc1);
		}

		return Acad::eOk;

		Acad::ErrorStatus es = Acad::eOk;

		//dSideH,dSidet
		double dSideH = data.dSideW / cos(dAngle);
		double dSidet = data.dSidet;

		//路径拉伸的方法，速度较快,但放置有点斜
		/*
		AcGeVector3d vtNorm = arPtsR.at(1) - arPtsR.at(0);
		AcGePoint3d ptFrBom = MidPoint(arPtsR.first(),arPtsR2.first());
		AcDbRegion* pRegR = CreateRegion(ptFrBom,dSideH,dSidet,vtNorm);
		AcDb3dPolyline* pPlPath = Format3dPolyline(arPtsR);
		if (pRegR != NULL && pPlPath != NULL)
		{
			AcDb3dSolid* pSolidR = new AcDb3dSolid;
			es = pSolidR->extrudeAlongPath(pRegR,pPlPath);
			if (es == Acad::eOk)
			{
				dc.DrawEntity(pSolidR);
				Add3DBuffer(pSolidR);
			}
			delete pRegR;
			delete pPlPath;
		}

		vtNorm = arPtsr.at(1) - arPtsr.at(0);
		ptFrBom = MidPoint(arPtsr.first(),arPtsr2.first());
		pRegR = CreateRegion(ptFrBom,dSideH,dSidet,vtNorm);
		pPlPath = Format3dPolyline(arPtsr);
		if (pRegR != NULL && pPlPath != NULL)
		{
			AcDb3dSolid* pSolidR = new AcDb3dSolid;
			es = pSolidR->extrudeAlongPath(pRegR,pPlPath);
			if (es == Acad::eOk)
			{
				dc.DrawEntity(pSolidR);
				Add3DBuffer(pSolidR);
			}
			delete pRegR;
			delete pPlPath;
		}
		return Acad::eOk;*/

		//以下速度较慢*+++++++++++++++
		AcDb3dSolid* pSolidAllR = NULL;
		AcDb3dSolid* pSolidAllr = NULL;
		AcDbVoidPtrArray arSoldPtrs;

		AcGePoint3d ptGe[5];
		for (int i = 0;i < arPtsR.length() - 1;i++)
		{
			AcDb3dSolid* pSolidR = CreateSide3dSegSolid(arPtsR,arPtsR2,i,dSideH);
			if (pSolidAllR == NULL)
			{
				pSolidAllR = pSolidR;
			}
			else
			{
				arSoldPtrs.append(pSolidR);
				//es = pSolidAllR->booleanOper(AcDb::kBoolUnite,pSolidR);
			}
			
			AcDb3dSolid* pSolidr = CreateSide3dSegSolid(arPtsr,arPtsr2,i,dSideH);
			if (pSolidAllr == NULL)
			{
				pSolidAllr = pSolidr;
			}
			else
			{
				arSoldPtrs.append(pSolidr);
				//es = pSolidAllr->booleanOper(AcDb::kBoolUnite,pSolidr);
			}
		}

		/*
		if (pSolidAllR != NULL)
		{
			dc.DrawEntity(pSolidAllR);
			Add3DBuffer(pSolidAllR);
		}
		if (pSolidAllr != NULL)
		{
			dc.DrawEntity(pSolidAllr);
			Add3DBuffer(pSolidAllr);
		}*/

		for (int k = 0;k < arSoldPtrs.length();k++)
		{
			pSolidAllr->setTransparency(tr);
			pSolidAllr = (AcDb3dSolid*)arSoldPtrs.at(k);
			dc.DrawEntity(pSolidAllr);
			Add3DBuffer(pSolidAllr);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbArcStair::DrawSteep3d(AcGiDraw &dc,const LineStair& data) const
{
	assertReadEnabled();
	AcCmTransparency tr = transparency();
	AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
	if (pArc != NULL)
	{
		AcGePoint3d ptSta,ptEnd;
		pArc->getStartPoint(ptSta);
		pArc->getEndPoint(ptEnd);

		if (data.bBomSta)
		{
			ptSta.z = data.dBomEl;
			ptEnd.z = data.dTopEl;
		}
		else
		{
			ptSta.z = data.dTopEl;
			ptEnd.z = data.dBomEl;
		}

		//一共多少步
		int nCount = (int)( (data.dTopEl - data.dBomEl) / data.dSteepH);

		double dAngle = asin( (data.dTopEl - data.dBomEl) / ptSta.distanceTo(ptEnd) );

		double dR = pArc->radius() + 0.5 * data.dW;

		//踏步斜边步长 
		double dLSteep = data.dSteepH / sin(dAngle);

		//踏步左右总长
		double dSteepL = (data.dW - 2.0 * data.dSidet);

		//以直代曲
		double dLen = (pArc->endAngle() - pArc->startAngle()) * pArc->radius();

		//
		double dFitLen = dLen / nCount;//

		AcGePoint3dArray arPoints;
		AcGeVector3dArray arFitDirs;

		GetSamplePoints(pArc,dFitLen,arPoints,arFitDirs);

		AcDbLine ln;
		ln.setStartPoint(ptSta);
		ln.setEndPoint(ptEnd);

		AcGePoint3d ptGeOn,ptGeR,ptGer;
		AcGeVector3d vtFit;
		AcGePoint3d ptGeT[5];

		AcDbLine lnPath;
		AcGePoint3dArray arPtsR,arPtsr;
		for (int i = 1;i < arPoints.length() - 1;i++)
		{
			AcGePoint3d& ptGe = arPoints.at(i);
			ln.getClosestPointTo(ptGe,AcGeVector3d::kZAxis,ptGeOn/*,Adesk::kTrue*/);
			ptGe.z = ptGeOn.z;
			//arx<=16
			//arPoints.setAt(i,ptGe);

			vtFit = arFitDirs.at(i);
			vtFit.z = 0.0;
			vtFit.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			vtFit.normalize();

			ptGeR = ptGe + vtFit * 0.5 * (data.dW - 2.0 * data.dSidet);
			//arPtsR.append(ptGeR);

			ptGer = ptGe - vtFit * 0.5 * (data.dW - 2.0 * data.dSidet);
			//arPtsr.append(ptGer);

			vtFit = arFitDirs.at(i);
			vtFit.normalize();

			ptGeT[0] = ptGeR;
			ptGeT[0] -= vtFit * 0.5 * data.dSideW;
			ptGeT[1] = ptGeT[0] + vtFit * data.dSideW;

			ptGeT[2] = ptGer;
			ptGeT[2] += vtFit * 0.5 * data.dSideW;

			ptGeT[3] = ptGeT[2] - vtFit * data.dSideW;
			ptGeT[4] = ptGeT[0];

			lnPath.setStartPoint(ptGeT[0]);
			lnPath.setEndPoint(ptGeT[0] + AcGeVector3d::kZAxis * data.dSteept);

			AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGeT,5);
			if (pReg != NULL)
			{
				AcDbX3dSolid xSolid;
				if ( xSolid.CreateExtrude(pReg,lnPath) )
				{
					AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
					if (pSolid != NULL)
					{
						pSolid->setTransparency(tr);
						dc.DrawEntity(pSolid);
						Add3DBuffer(pSolid);
					}
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbArcStair::DrawGuardBar3d(AcGiDraw &dc,const LineStair& data) const
{
	assertReadEnabled();

	AcCmTransparency tr = transparency();
	AcCmTransparency oldTr = dc.SetTransparency(tr);

	int nCrBk = dc.GetColor();
	int nColor = nCrBk;
	if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
	{
	}

	AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
	if (pArc != NULL)
	{
		AcGePoint3d ptSta,ptEnd;
		pArc->getStartPoint(ptSta);
		pArc->getEndPoint(ptEnd);

		if (data.bBomSta)
		{
			ptSta.z = data.dBomEl;
			ptEnd.z = data.dTopEl;
		}
		else
		{
			ptSta.z = data.dTopEl;
			ptEnd.z = data.dBomEl;
		}

		//一共多少步
		int nCount = (int)( (data.dTopEl - data.dBomEl) / data.dSteepH);

		double dAngle = asin( (data.dTopEl - data.dBomEl) / ptSta.distanceTo(ptEnd) );

		double dH = data.bar.dH;
		double dH1 = data.bar.dH1;
		double dL = (pArc->endAngle() - pArc->startAngle()) * pArc->radius();

		int nCols = (int)( dL / data.bar.dP + 0.5);
		
		//
		double dFitLen = dL / nCols;//

		AcGePoint3dArray arPoints;
		AcGeVector3dArray arFitDirs;

		GetSamplePoints(pArc,dFitLen,arPoints,arFitDirs);

		AcDbLine ln;
		ln.setStartPoint(ptSta);
		ln.setEndPoint(ptEnd);

		AcGePoint3d ptGeOn,ptGeR,ptGer;
		AcGeVector3d vtFit;
		AcGePoint3d ptGeT[5];

		AcDbRegion* pRegCln = NULL;
		AcDbEntity* pEnt3d = NULL;
		AcDbLine lnPath;
		AcGePoint3dArray arPtsR,arPtsr,arPtsRH1,arPtsrH1,arPtsRH2,arPtsrH2;
		for (int i = 0;i < arPoints.length();i++)
		{
			AcGePoint3d& ptGe = arPoints.at(i);
			ln.getClosestPointTo(ptGe,AcGeVector3d::kZAxis,ptGeOn/*,Adesk::kTrue*/);
			ptGe.z = ptGeOn.z;
			//arx<=16
			//arPoints.setAt(i,ptGe);

			vtFit = arFitDirs.at(i);
			vtFit.z = 0.0;
			vtFit.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			vtFit.normalize();

			ptGeR = ptGe + vtFit * 0.5 * (data.dW - data.dSidet);
			arPtsR.append(ptGeR);

			ptGer = ptGe - vtFit * 0.5 * (data.dW - data.dSidet);
			arPtsr.append(ptGer);

			vtFit = arFitDirs.at(i);
			vtFit.normalize();

			pRegCln = GetSection();
			if (pRegCln != NULL)
			{
				ptGeT[0] = ptGeR;
				ptGeT[1] = ptGeR + AcGeVector3d::kZAxis * dH1;
				ptGeT[2] = ptGeR + AcGeVector3d::kZAxis * dH;
				arPtsRH1.append(ptGeT[1]);
				arPtsRH2.append(ptGeT[2]);

				lnPath.setStartPoint(ptGeT[0]);
				lnPath.setEndPoint(ptGeT[2]);

				pEnt3d = dc.DrawPipe(&lnPath,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(nColor);
					Add3DBuffer(pEnt3d);
				}
				delete pRegCln;
				pRegCln = NULL;
			}

			pRegCln = GetSection();
			if (pRegCln != NULL)
			{
				ptGeT[0] = ptGer;
				ptGeT[1] = ptGer + AcGeVector3d::kZAxis * dH1;
				ptGeT[2] = ptGer + AcGeVector3d::kZAxis * dH;
				arPtsrH1.append(ptGeT[1]);
				arPtsrH2.append(ptGeT[2]);

				lnPath.setStartPoint(ptGeT[0]);
				lnPath.setEndPoint(ptGeT[2]);

				pEnt3d = dc.DrawPipe(&lnPath,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(nColor);
					Add3DBuffer(pEnt3d);
				}
				delete pRegCln;
				pRegCln = NULL;
			}
		}

		for (int i = 0;i < arPtsRH1.length() - 1;i++)
		{
			//中间分格
			pRegCln = GetSection();
			if (pRegCln != NULL)
			{
				lnPath.setStartPoint(arPtsRH1.at(i));
				lnPath.setEndPoint(arPtsRH1.at(i+1));

				pEnt3d = dc.DrawPipe(&lnPath,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(nColor);
					Add3DBuffer(pEnt3d);
				}
				delete pRegCln;
				pRegCln = NULL;
			}

			pRegCln = GetSection();
			if (pRegCln != NULL)
			{
				lnPath.setStartPoint(arPtsrH1.at(i));
				lnPath.setEndPoint(arPtsrH1.at(i+1));

				pEnt3d = dc.DrawPipe(&lnPath,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(nColor);
					Add3DBuffer(pEnt3d);
				}
				delete pRegCln;
				pRegCln = NULL;
			}

			//顶部
			pRegCln = GetSection();
			if (pRegCln != NULL)
			{
				lnPath.setStartPoint(arPtsRH2.at(i));
				lnPath.setEndPoint(arPtsRH2.at(i+1));

				pEnt3d = dc.DrawPipe(&lnPath,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(nColor);
					Add3DBuffer(pEnt3d);
				}
				delete pRegCln;
				pRegCln = NULL;
			}

			pRegCln = GetSection();
			if (pRegCln != NULL)
			{
				lnPath.setStartPoint(arPtsrH2.at(i));
				lnPath.setEndPoint(arPtsrH2.at(i+1));

				pEnt3d = dc.DrawPipe(&lnPath,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(nColor);
					Add3DBuffer(pEnt3d);
				}
				delete pRegCln;
				pRegCln = NULL;
			}
		}
	}
	dc.SetTransparency(oldTr);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbArcStair::subGetGripPoints(AcDbGripDataPtrArray& grips,
												   const double curViewUnitSize,
												   const int gripSize,
												   const AcGeVector3d& curViewDir,
												   const int bitflags) const
{
	AecDbEwPipeBase::subGetGripPoints(grips,curViewUnitSize,gripSize,curViewDir,bitflags);

	//动态标注
	//直线,半径 标注风格
	if (!grips.isEmpty())
	{
		SubAddDimPoints(grips,curViewDir);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbArcStair::SubAddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir) const
{
	if (GetDimGripOff())
		return Acad::eOk;

	LineStair data;
	GetLineStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcGePoint3d ptGe[2],ptMid;

		AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
		if (pArc != NULL)
		{
			//标注半径
			AcGePoint3d ptSta;
			pArc->getStartPoint(ptSta);

			AcGeVector3d vtL;
			pArc->getFirstDeriv(ptSta,vtL);
			vtL.normalize();
			vtL.negate();

			//半径标注
			ptSta.z = data.dBomEl;
			AcGePoint3d ptEnd = pArc->center();
			ptEnd.z = data.dBomEl;
			AcGePoint3d ptAMid = GetArcMidPoint(pArc);
			ptAMid.z = data.dBomEl;
			AcGePoint3d ptMid = MidPoint(ptAMid,ptEnd);
			AddDimPoints(grips,curViewDir,ptAMid,ptEnd,ptMid,1,pArc->radius());

			//标注高度
			ptGe[0] = ptSta;
			ptGe[1] = ptSta;
			ptGe[0].z = data.dBomEl;
			ptGe[1].z = data.dTopEl;

			ptGe[0] += vtL * 10.0;
			ptGe[1] += vtL * 10.0;
			ptMid = MidPoint(ptGe[0],ptGe[1]);
			ptMid += vtL * 10.0 * 100.0;//标注文字位置
			AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);

			//宽度
			AcGeVector3d vtV = vtL;
			vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			ptGe[0] = ptSta;
			ptGe[0] += 0.5 * data.dW * vtV;
			ptGe[1] = ptGe[0] - data.dW * vtV;

			ptMid = MidPoint(ptGe[0],ptGe[1]);
			ptMid -= vtL * 10.0 * 100.0;//标注文字位置
			AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
		}
	}
	return Acad::eOk;
}