1280 lines
29 KiB
C++
1280 lines
29 KiB
C++
#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;
|
|
} |