1637 lines
38 KiB
C++
1637 lines
38 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbColumn.h"
|
|
#include "dbgrip.h"
|
|
#include "AecGripCback.h"
|
|
#include "MFCDbDwgFiler.h"
|
|
#include "_cgal.h"
|
|
#include "simpleproperty.h"
|
|
#include "CoreTools.h"
|
|
#include "AecDbEarthWorm.h"
|
|
#include "KTCADSysVar.h"
|
|
#include "KTCadUtility.h"
|
|
#include "KTSetting.h"
|
|
#include "KTCADUtilityEx.h"
|
|
|
|
extern double PixelToWcs(int nPixel);
|
|
extern BOOL Is2DView();
|
|
extern AcGeVector3d GetUcsZvt();
|
|
extern void PushGripMessage(GripMessage&);
|
|
|
|
extern void transfromRegion(AcDbRegion *pRegion, const AcGePoint3d &ptOnRegion, const AcGeVector3d &vtNormal, const AcGePoint3d &ptOnPlan);
|
|
extern AcGePoint3d GetArcMidPoint(AcDbArc* pArc);
|
|
//extern convex_hull2d(arPt2ds,arPt2dPoly);
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2);
|
|
extern BOOL DLLIMPEXP GetDimGripOff();
|
|
static void FreeBuffer(int n,AcDbVoidPtrArray& arEntPtrs)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
while(arEntPtrs.length() > n )
|
|
{
|
|
pEnt = (AcDbEntity*)arEntPtrs.last();
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
arEntPtrs.removeLast();
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
Adesk::UInt32 AecDbColumn::kCurrentVersionNumber = 1;
|
|
const CString AecDbColumn::KEY_COL_MODEL = _T("KEY_COL_MODEL");
|
|
const CString AecDbColumn::_JZ_PT_INNER = _T("_JZ_PT_INNER");
|
|
const CString AecDbColumn::_JZ_PT_A = _T("_JZ_PT_A");
|
|
const CString AecDbColumn::_JZ_PT_B = _T("_JZ_PT_B");
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbColumn, AecDbBDPipeBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBCOLMN,
|
|
"AecDbColumn"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbColumn::AecDbColumn(void)
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_2DSTYLE,2);
|
|
m_mapSpecXData.SetAt(KEY_CENNODRAW,1);
|
|
m_mapSpecXData.SetAt(KEY_NAME,_T("柱"));
|
|
|
|
}
|
|
|
|
AecDbColumn::~AecDbColumn(void)
|
|
{
|
|
|
|
}
|
|
|
|
void AecDbColumn::SetColumnData(const AcGePoint3d& ptBom,double dL,double dW,double dH,double dRotate)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
m_pBaseCurve = new AcDbLine;
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setStartPoint(ptBom);
|
|
|
|
AcGePoint3d ptEnd = ptBom;
|
|
ptEnd.z += dH;
|
|
pLine->setEndPoint(ptEnd);
|
|
|
|
SetSection(dL,dW,0.0);
|
|
SetSectionRotation(dRotate);
|
|
}
|
|
}
|
|
|
|
void AecDbColumn::GetColumnData(ColumnParam& data) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
data.m_dBomEl = GetPosition().z;
|
|
data.m_dH = GetHeight();
|
|
m_mapSpecXData.GetAt(KEY_SHAPE,data.m_nShape);
|
|
|
|
CString sTmp;
|
|
m_mapSpecXData.GetAt(KEY_MATERIAL,sTmp);
|
|
_tcscpy(data.m_sMaterial,(LPCTSTR)sTmp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_BLOCKNAME,sTmp);
|
|
_tcscpy(data.m_sBlockName,(LPCTSTR)sTmp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_NO,data.m_szNo);
|
|
|
|
//m_mapSpecXData.GetAt(KEY_ROTATION,data.m_dRotAngle);
|
|
m_mapSpecXData.GetAt(KEY_ROTATIONBK,data.m_dRotAngle);
|
|
|
|
memset(data.m_dSizes,0,sizeof(double) * 4);
|
|
m_mapSpecXData.GetAt(KEY_SIZE1,data.m_dSizes[0]);
|
|
m_mapSpecXData.GetAt(KEY_SIZE2,data.m_dSizes[1]);
|
|
m_mapSpecXData.GetAt(KEY_SIZE3,data.m_dSizes[2]);
|
|
m_mapSpecXData.GetAt(KEY_SIZE4,data.m_dSizes[3]);
|
|
|
|
m_mapSpecXData.GetAt(KEY_XE,data.m_dXExtend);
|
|
m_mapSpecXData.GetAt(KEY_YE,data.m_dYExtend);
|
|
m_mapSpecXData.GetAt(KEY_XS,data.m_dXScale);
|
|
m_mapSpecXData.GetAt(KEY_YS,data.m_dYScale);
|
|
m_mapSpecXData.GetAt(AecDbColumn::KEY_COL_MODEL, data.m_sModel);
|
|
m_mapSpecXData.GetAt(KEY_SECTION_HATCH, data.m_sHatch);
|
|
}
|
|
|
|
void AecDbColumn::SetPosition(const AcGePoint3d& ptPos)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
bool bDefault = false;
|
|
if (m_pBaseCurve == NULL)
|
|
{
|
|
m_pBaseCurve = new AcDbLine;
|
|
bDefault = true;
|
|
}
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setStartPoint(ptPos);
|
|
|
|
//默认3米
|
|
if (bDefault)
|
|
{
|
|
AcGePoint3d ptEnd = ptPos;
|
|
ptEnd.z += 3000.0;
|
|
pLine->setEndPoint(ptEnd);
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGePoint3d AecDbColumn::GetPosition() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
{
|
|
return AcGePoint3d::kOrigin;
|
|
}
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
return pLine->startPoint();
|
|
}
|
|
return AcGePoint3d::kOrigin;
|
|
}
|
|
|
|
void AecDbColumn::SetHeight(double dH)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
bool bDefault = false;
|
|
if (m_pBaseCurve == NULL)
|
|
{
|
|
m_pBaseCurve = new AcDbLine;
|
|
bDefault = true;
|
|
}
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLine->startPoint();
|
|
AcGePoint3d ptEnd = ptSta;
|
|
ptEnd.z += dH;
|
|
|
|
pLine->setEndPoint(ptEnd);
|
|
}
|
|
}
|
|
|
|
double AecDbColumn::GetHeight() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
{
|
|
return 0.0;
|
|
}
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
return pLine->endPoint().distanceTo(pLine->startPoint());
|
|
}
|
|
return 0.0;
|
|
}
|
|
|
|
void AecDbColumn::SetRotation(double dRot)
|
|
{
|
|
AssertWriteEnabled();
|
|
SetSectionRotation(dRot);
|
|
}
|
|
|
|
double AecDbColumn::GetRotation() const
|
|
{
|
|
assertReadEnabled();
|
|
return GetSectionRotation();
|
|
}
|
|
|
|
void AecDbColumn::SetRect(double dL,double dW)
|
|
{
|
|
AssertWriteEnabled();
|
|
SetSection( dL,dW,0.0);
|
|
}
|
|
|
|
AcGePoint2d AecDbColumn::GetRect() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
double dL = 0.0,dW = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SIZE1,dL);
|
|
m_mapSpecXData.GetAt(KEY_SIZE2,dW);
|
|
|
|
return AcGePoint2d(dL,dW);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//系统屏蔽掉
|
|
if ( dc.IsDragging() )
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
DrawDTYG2D(dc);
|
|
|
|
//二维缓存
|
|
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;
|
|
}
|
|
|
|
AcDbRegion* pRegion = GetSection();
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
AcGeVector3d vtZ = ptEnd - ptSta;
|
|
transfromRegion(pRegion,AcGePoint3d::kOrigin,vtZ,ptSta);
|
|
|
|
AcDbVoidPtrArray arPtrs;
|
|
pRegion->explode(arPtrs);
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0;i < arPtrs.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arPtrs.at(i);
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->setColorIndex(nColor);
|
|
dc.DrawEntity(pEnt);
|
|
Add2DBuffer(pEnt);
|
|
}
|
|
}
|
|
}
|
|
delete pRegion;
|
|
}
|
|
dc.SetColor(nCrBk);
|
|
dc.SetLayer(idCurLay);
|
|
dc.SetLineType(idCurLty);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbColumn::GetDraw2dables(AecComplexCurve& draw2d) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecEqui::AecCurveElement el;
|
|
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
|
|
|
AcDbRegion* pRegion = GetSection();
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
AcGeVector3d vtZ = ptEnd - ptSta;
|
|
transfromRegion(pRegion,AcGePoint3d::kOrigin,vtZ,ptSta);
|
|
|
|
AcDbVoidPtrArray arPtrs,arPtrsAll;
|
|
pRegion->explode(arPtrs);
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int j = 0;j < arPtrs.length();j++)
|
|
{
|
|
pEnt = (AcDbEntity*)arPtrs.at(j);
|
|
if (pEnt != NULL)
|
|
{
|
|
AcDbRegion* pSubReg = AcDbRegion::cast(pEnt);
|
|
if (pSubReg != NULL)
|
|
{
|
|
arPtrs.removeAt(j);
|
|
j -= 1;
|
|
|
|
pSubReg->explode(arPtrsAll);
|
|
delete pSubReg;
|
|
}
|
|
else
|
|
{
|
|
arPtrs.removeAt(j);
|
|
j -= 1;
|
|
|
|
arPtrsAll.append(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
AcDbLine* pLn = NULL;
|
|
for (int i = 0;i < arPtrsAll.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arPtrsAll.at(i);
|
|
|
|
//只提取line 实体
|
|
pLn = AcDbLine::cast(pEnt);
|
|
if (pLn != NULL)
|
|
{
|
|
el.ptGe[0] = pLn->startPoint();
|
|
el.ptGe[0].z = 0.0;
|
|
el.ptGe[1] = pLn->endPoint();
|
|
el.ptGe[1].z = 0.0;
|
|
el.ptGe[2] = el.ptGe[1];
|
|
draw2d.append(el);
|
|
}
|
|
|
|
AcDbCircle* pCir = AcDbCircle::cast(pEnt);
|
|
if (pCir != NULL)
|
|
{
|
|
el.ptGe[0] = pCir->center();
|
|
el.ptGe[0].z = 0.0;
|
|
el.ptGe[0].x += pCir->radius();
|
|
|
|
el.ptGe[1] = pCir->center();
|
|
el.ptGe[1].z = 0.0;
|
|
el.ptGe[1].y += pCir->radius();
|
|
|
|
el.ptGe[2] = pCir->center();
|
|
el.ptGe[2].z = 0.0;
|
|
el.ptGe[2].x -= pCir->radius();
|
|
draw2d.append(el);
|
|
|
|
|
|
el.ptGe[0] = pCir->center();
|
|
el.ptGe[0].z = 0.0;
|
|
el.ptGe[0].x -= pCir->radius();
|
|
|
|
el.ptGe[1] = pCir->center();
|
|
el.ptGe[1].z = 0.0;
|
|
el.ptGe[1].y -= pCir->radius();
|
|
|
|
el.ptGe[2] = pCir->center();
|
|
el.ptGe[2].z = 0.0;
|
|
el.ptGe[2].x += pCir->radius();
|
|
draw2d.append(el);
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pEnt);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->getStartPoint(el.ptGe[0]);
|
|
el.ptGe[0].z = 0.0;
|
|
|
|
pArc->getEndPoint(el.ptGe[2]);
|
|
el.ptGe[2].z = 0.0;
|
|
|
|
el.ptGe[2] = GetArcMidPoint(pArc);
|
|
el.ptGe[2].z = 0.0;
|
|
|
|
draw2d.append(el);
|
|
}
|
|
}
|
|
|
|
FreeBuffer(0,arPtrsAll);
|
|
}
|
|
delete pRegion;
|
|
}
|
|
}
|
|
|
|
AcDbPolyline* AecDbColumn::GetDraw2dables() const
|
|
{
|
|
assertReadEnabled();
|
|
AcDbPolyline *pPl = NULL;
|
|
|
|
AecComplexCurve draw2d;
|
|
GetDraw2dables(draw2d);
|
|
|
|
pPl = draw2d.MakePoly();
|
|
|
|
return pPl;
|
|
}
|
|
|
|
AcDbPolyline* AecDbColumn::GetConvexhull2d() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDbPolyline* pPl = NULL;
|
|
AcDbRegion* pRegion = GetSection();
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
AcGeVector3d vtZ = ptEnd - ptSta;
|
|
transfromRegion(pRegion,AcGePoint3d::kOrigin,vtZ,ptSta);
|
|
|
|
AcDbVoidPtrArray arPtrs,arPtrsAll;
|
|
pRegion->explode(arPtrs);
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int j = 0;j < arPtrs.length();j++)
|
|
{
|
|
pEnt = (AcDbEntity*)arPtrs.at(j);
|
|
if (pEnt != NULL)
|
|
{
|
|
AcDbRegion* pSubReg = AcDbRegion::cast(pEnt);
|
|
if (pSubReg != NULL)
|
|
{
|
|
arPtrs.removeAt(j);
|
|
j -= 1;
|
|
pSubReg->explode(arPtrsAll);
|
|
delete pSubReg;
|
|
}
|
|
else
|
|
{
|
|
arPtrs.removeAt(j);
|
|
j -= 1;
|
|
arPtrsAll.append(pEnt);
|
|
}
|
|
}
|
|
}
|
|
arPtrs.removeAll();
|
|
|
|
//求二维凸包线
|
|
std::vector<AcGePoint2d> arPt2ds, arPt2dsOut;
|
|
AcGePoint2d pt2d;
|
|
|
|
AcGePoint3d ptS,ptE,ptM;
|
|
for (int i = 0;i < arPtrsAll.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arPtrsAll.at(i);
|
|
|
|
AcDbLine* pLnT = AcDbLine::cast(pEnt);
|
|
if (pLnT != NULL)
|
|
{
|
|
pt2d.set(pLnT->startPoint().x,pLnT->startPoint().y);
|
|
arPt2ds.push_back(pt2d);
|
|
|
|
pt2d.set(pLnT->endPoint().x,pLnT->endPoint().y);
|
|
arPt2ds.push_back(pt2d);
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pEnt);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->getStartPoint(ptS);
|
|
pArc->getEndPoint(ptE);
|
|
ptM = GetArcMidPoint(pArc);
|
|
|
|
arPt2ds.push_back(AcGePoint2d(ptS.x,ptS.y));
|
|
arPt2ds.push_back(AcGePoint2d(ptE.x,ptE.y));
|
|
arPt2ds.push_back(AcGePoint2d(ptM.x,ptM.y));
|
|
}
|
|
}
|
|
|
|
Geometry::calcConvexHull2D(arPt2ds,arPt2dsOut);
|
|
|
|
pPl = new AcDbPolyline;
|
|
for (int j = 0;j < arPt2dsOut.size();j++)
|
|
{
|
|
pPl->addVertexAt(j,arPt2dsOut.at(j));
|
|
}
|
|
pPl->setClosed(Adesk::kTrue);
|
|
}
|
|
delete pRegion;
|
|
}
|
|
return pPl;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
return AecDbBDPipeBase::Draw3d(dc);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
|
|
//夹点设计
|
|
//reg的夹点+中心夹点+改高度夹点(上下)+ 标高夹点(下)
|
|
|
|
AcGePoint3dArray gripPoints;
|
|
ImpGetGripPoints(gripPoints,bitflags);
|
|
|
|
int nColor = kWhite;
|
|
AcDbGripData* pGripData = NULL;
|
|
if ( bitflags >= 1394)//节点
|
|
{
|
|
memset(&m_pGripAppData[0],0,sizeof(AecGripData));
|
|
m_pGripAppData[0].nIndex = 0;
|
|
m_pGripAppData[0].ePos = eFlag;
|
|
m_pGripAppData[0].nColor = nColor;
|
|
m_pGripAppData[0].ptGrip = gripPoints.at(0);
|
|
m_pGripAppData[0].pOwner = (AcDbEntity*)this;
|
|
|
|
pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(gripPoints.at(0));
|
|
pGripData->setAppData((void*)&m_pGripAppData[0]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
_tcscpy(m_pGripAppData[0].szTip,_T("点击定位造族<柱子>记录"));
|
|
_tcscpy(m_pGripAppData[0].szID,m_sGUID);
|
|
grips.append(pGripData);
|
|
return Acad::eOk;
|
|
}
|
|
else
|
|
{
|
|
EPosition ePos;
|
|
CString sTip;
|
|
for (int i = 0;i < gripPoints.length();i++)
|
|
{
|
|
ePos = ExplainGripIndex(i,sTip);
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = ePos;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
m_pGripAppData[i].ptGrip = gripPoints.at(i);
|
|
_tcscpy(m_pGripAppData[i].szTip,sTip);
|
|
_tcscpy(m_pGripAppData[i].szID,m_sGUID);
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
|
|
pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(gripPoints.at(i));
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
}
|
|
}
|
|
|
|
//调用基类加入单击修改
|
|
SubAddHitEditGrip(grips);
|
|
|
|
//动态标注
|
|
//直线,半径 标注风格
|
|
if (!grips.isEmpty())
|
|
{
|
|
SubAddDimPoints(grips,curViewDir);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pBaseCurve != NULL)
|
|
{
|
|
extern BOOL IsFrontView();
|
|
if (IsFrontView())
|
|
{
|
|
AcGePoint3d ptS,ptE;
|
|
m_pBaseCurve->getStartPoint(ptS);
|
|
m_pBaseCurve->getEndPoint(ptE);
|
|
|
|
stretchPoints.append(ptS);
|
|
stretchPoints.append(ptE);
|
|
}
|
|
else
|
|
{
|
|
if (Is2DView())
|
|
{
|
|
AcDbRegion* pRegion = GetSection();
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
AcGeVector3d vtZ = ptEnd - ptSta;
|
|
transfromRegion(pRegion,AcGePoint3d::kOrigin,vtZ,ptSta);
|
|
|
|
pRegion->getStretchPoints(stretchPoints);
|
|
}
|
|
delete pRegion;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
|
|
{
|
|
extern BOOL IsFrontView();
|
|
if (IsFrontView())
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AcGeVector3d vtZ;
|
|
vtZ = offset.orthoProject(AcGeVector3d::kYAxis);
|
|
|
|
AcGePoint3d ptS,ptE;
|
|
m_pBaseCurve->getStartPoint(ptS);
|
|
m_pBaseCurve->getEndPoint(ptE);
|
|
|
|
if (indices.length() == 1)
|
|
{
|
|
if (indices.find(0) != -1)
|
|
{
|
|
ptS += vtZ;
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setStartPoint(ptS);
|
|
}
|
|
}
|
|
else if (indices.find(1) != -1)
|
|
{
|
|
ptE += vtZ;
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setEndPoint(ptE);
|
|
}
|
|
}
|
|
}
|
|
else if (indices.length() == 2)
|
|
{
|
|
ptS += vtZ;
|
|
ptE += vtZ;
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setStartPoint(ptS);
|
|
pLine->setEndPoint(ptE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Is2DView())
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AcGeMatrix3d xform;
|
|
xform.setToTranslation(offset);
|
|
m_pBaseCurve->transformBy(xform);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::SubAddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir) const
|
|
{
|
|
if (GetDimGripOff())
|
|
return Acad::eOk;
|
|
|
|
//柱子素线统一为直线段
|
|
AcDbRegion* pRegion = GetSection();
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
AcGePoint3d ptMid,ptPos = ptSta;
|
|
AcGeVector3d vtZ = ptEnd - ptSta;
|
|
transfromRegion(pRegion,AcGePoint3d::kOrigin,vtZ,ptSta);
|
|
|
|
ptMid = MidPoint(ptSta,ptEnd);
|
|
vtZ = ptMid - ptPos;
|
|
vtZ.normalize();
|
|
|
|
AcGeVector3d vtV = AcGeVector3d::kXAxis;
|
|
vtV *= 10.0 * 100;
|
|
ptMid += vtV;
|
|
|
|
AddDimPoints(grips,curViewDir,ptSta,ptEnd,ptMid,0);
|
|
|
|
AcDbVoidPtrArray arPtrs;
|
|
pRegion->explode(arPtrs);
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0;i < arPtrs.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)arPtrs.at(i);
|
|
if (pEnt != NULL)
|
|
{
|
|
AcDbLine* pLnT = AcDbLine::cast(pEnt);
|
|
if (pLnT != NULL)
|
|
{
|
|
ptSta = pLnT->startPoint();
|
|
ptEnd = pLnT->endPoint();
|
|
ptMid = MidPoint(ptSta,ptEnd);
|
|
vtZ = ptMid - ptPos;
|
|
vtZ.normalize();
|
|
vtZ *= 10.0 * 100;
|
|
ptMid += vtZ;
|
|
AddDimPoints(grips,curViewDir,ptSta,ptEnd,ptMid,0);
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pEnt);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->getStartPoint(ptSta);
|
|
|
|
AcGeVector3d vtL;
|
|
pArc->getFirstDeriv(ptSta,vtL);
|
|
vtL.normalize();
|
|
vtL.negate();
|
|
|
|
//半径标注
|
|
ptEnd = pArc->center();
|
|
AcGePoint3d ptAMid = GetArcMidPoint(pArc);
|
|
ptMid = MidPoint(ptAMid,ptEnd);
|
|
AddDimPoints(grips,curViewDir,ptAMid,ptEnd,ptMid,1,pArc->radius());
|
|
|
|
//角度
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
ptMid = pArc->center();
|
|
double dAngle = pArc->endAngle() - pArc->startAngle();
|
|
AddDimPoints(grips,curViewDir,ptSta,ptEnd,ptMid,3);
|
|
}
|
|
|
|
AcDbCircle* pCir = AcDbCircle::cast(pEnt);
|
|
if (pCir != NULL)
|
|
{
|
|
pCir->getStartPoint(ptSta);
|
|
|
|
AcGeVector3d vtL;
|
|
pCir->getFirstDeriv(ptSta,vtL);
|
|
vtL.normalize();
|
|
vtL.negate();
|
|
|
|
//半径标注
|
|
ptEnd = pCir->center();
|
|
ptMid = MidPoint(ptSta,ptEnd);
|
|
AddDimPoints(grips,curViewDir,ptSta,ptEnd,ptMid,1,pCir->radius());
|
|
}
|
|
|
|
delete pEnt;
|
|
}
|
|
}
|
|
}
|
|
delete pRegion;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
EPosition AecDbColumn::ExplainGripIndex(int nIndex,CString& sTip) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
EPosition ePos = eStart;
|
|
|
|
switch(nIndex)
|
|
{
|
|
case 0://上 改高度
|
|
{
|
|
ePos = eEnd;
|
|
sTip = _T("修改柱子高度夹点");
|
|
break;
|
|
}
|
|
case 1://底 改位置
|
|
{
|
|
ePos = eStart;
|
|
sTip = _T("修改柱子位置夹点");
|
|
break;
|
|
}
|
|
case 2://下 改标高
|
|
{
|
|
ePos = eAdjust0;
|
|
sTip = _T("修改柱子标高夹点");
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return ePos;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::ImpGetGripPoints(AcGePoint3dArray& gripPoints,const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//柱子素线统一为直线段
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
double dCmd = PixelToWcs(10);
|
|
|
|
//sta 底部
|
|
//end 顶部
|
|
|
|
AcGePoint3d ptGeT,ptOrg;
|
|
ptOrg = pLn->startPoint();
|
|
ptGeT = pLn->endPoint();
|
|
|
|
//上 改高度
|
|
gripPoints.append(ptGeT);
|
|
|
|
//底 改位置
|
|
gripPoints.append(ptOrg);
|
|
|
|
//下 改标高
|
|
ptGeT = ptOrg - dCmd * AcGeVector3d::kZAxis;
|
|
gripPoints.append(ptGeT);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::subMoveGripPointsAt(const AcDbVoidPtrArray& gripAppData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecGripData* pAppData = NULL;
|
|
AcDbIntArray arIndex;
|
|
|
|
if ( gripAppData.isEmpty() )
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if (HitOnGripEdit(gripAppData))
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
pAppData = (AecGripData*)gripAppData.first();
|
|
arIndex.append(pAppData->nIndex);
|
|
|
|
AcGeVector3d vtOffset = offset;
|
|
|
|
AcGeVector3d vtXYOffset;
|
|
vtXYOffset = vtOffset.orthoProject(AcGeVector3d::kZAxis);
|
|
|
|
AcGeVector3d vtZOffset;
|
|
vtZOffset = vtOffset.orthoProject(AcGeVector3d::kXAxis);
|
|
|
|
double dLen = offset.length();
|
|
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
AcGePoint3d ptGeT;
|
|
|
|
double dH = ptEnd.distanceTo(ptSta);
|
|
AcGeVector3d vtH = ptEnd - ptSta;
|
|
vtH.normalize();
|
|
|
|
switch(pAppData->nIndex)
|
|
{
|
|
case 0://改高度
|
|
{
|
|
if (vtZOffset.isCodirectionalTo(AcGeVector3d::kZAxis))//增厚
|
|
{
|
|
dH += dLen;
|
|
}
|
|
else//减去厚度
|
|
{
|
|
dH -= dLen;
|
|
}
|
|
|
|
if (dH > 1.0)
|
|
{
|
|
vtH *= dH;
|
|
ptEnd = ptSta + vtH;
|
|
pLn->setEndPoint(ptEnd);
|
|
}
|
|
break;
|
|
}
|
|
case 1://改位置
|
|
{
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
|
|
ptSta += offset;
|
|
ptEnd += offset;
|
|
|
|
pLn->setStartPoint(ptSta);
|
|
pLn->setEndPoint(ptEnd);
|
|
|
|
break;
|
|
}
|
|
case 2://改标高
|
|
{
|
|
vtZOffset.normalize();
|
|
|
|
vtZOffset *= dLen;
|
|
ptSta += vtZOffset;
|
|
|
|
pLn->setStartPoint(ptSta);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbColumn::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
acutPrintf(_T("\n柱子:"));
|
|
acutPrintf(_T("\n体积:%g 立方"),GetVolume() / 1.e9);
|
|
AecDbBDPipeBase::subList();
|
|
}
|
|
|
|
bool AecDbColumn::GetBimInfoTip(CString& sInfoTip) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
ColumnParam data;
|
|
memset(&data,0,sizeof(ColumnParam));
|
|
|
|
GetColumnData(data);
|
|
CString sField,sFmt;
|
|
|
|
//矩形;圆形;正六边形;工字钢柱;槽钢柱;
|
|
switch(data.m_nShape)
|
|
{
|
|
case 0://矩形
|
|
{
|
|
sField = _T("矩形柱子:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("高度"),_T("%.1f 毫米"),data.m_dH,sInfoTip);
|
|
|
|
MAKEFIELD(_T("横向"),_T("%.1f 毫米"),data.m_dSizes[0],sInfoTip);
|
|
MAKEFIELD(_T("纵向"),_T("%.1f 毫米"),data.m_dSizes[1],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f 毫米"),data.m_dBomEl,sInfoTip);
|
|
|
|
MAKEFIELD(_T("旋转角度"),_T("%.1f 度"),data.m_dRotAngle,sInfoTip);
|
|
|
|
MAKEFIELD(_T("体积"),_T("%.1f 立方米"),GetVolume() / 1.e9,sInfoTip);
|
|
MAKEFIELD(_T("面积"),_T("%.1f 平方米"),GetArea() / 1.e6,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.m_szNo,sInfoTip);
|
|
|
|
break;
|
|
}
|
|
case 1://圆形
|
|
{
|
|
sField = _T("圆形柱子:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("高度"),_T("%.1f 毫米"),data.m_dH,sInfoTip);
|
|
|
|
MAKEFIELD(_T("直径"),_T("%.1f 毫米"),data.m_dSizes[0],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f 毫米"),data.m_dBomEl,sInfoTip);
|
|
|
|
MAKEFIELD(_T("体积"),_T("%.1f 立方米"),GetVolume() / 1.e9,sInfoTip);
|
|
MAKEFIELD(_T("面积"),_T("%.1f 平方米"),GetArea() / 1.e6,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.m_szNo,sInfoTip);
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
sField = _T("正六边形柱子:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("高度"),_T("%.1f 毫米"),data.m_dH,sInfoTip);
|
|
|
|
MAKEFIELD(_T("边长"),_T("%.1f 毫米"),data.m_dSizes[0],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f 毫米"),data.m_dBomEl,sInfoTip);
|
|
|
|
MAKEFIELD(_T("体积"),_T("%.1f 立方米"),GetVolume() / 1.e9,sInfoTip);
|
|
MAKEFIELD(_T("面积"),_T("%.1f 平方米"),GetArea() / 1.e6,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.m_szNo,sInfoTip);
|
|
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
sField = _T("工字钢柱子:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("高度"),_T("%.1f 毫米"),data.m_dH,sInfoTip);
|
|
|
|
MAKEFIELD(_T("A"),_T("%.1f 毫米"),data.m_dSizes[0],sInfoTip);
|
|
MAKEFIELD(_T("B"),_T("%.1f 毫米"),data.m_dSizes[1],sInfoTip);
|
|
MAKEFIELD(_T("C"),_T("%.1f 毫米"),data.m_dSizes[2],sInfoTip);
|
|
MAKEFIELD(_T("D"),_T("%.1f 毫米"),data.m_dSizes[3],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f 毫米"),data.m_dBomEl,sInfoTip);
|
|
|
|
MAKEFIELD(_T("体积"),_T("%.1f 立方米"),GetVolume() / 1.e9,sInfoTip);
|
|
MAKEFIELD(_T("面积"),_T("%.1f 平方米"),GetArea() / 1.e6,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.m_szNo,sInfoTip);
|
|
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
sField = _T("槽钢柱:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("高度"),_T("%.1f 毫米"),data.m_dH,sInfoTip);
|
|
|
|
MAKEFIELD(_T("A"),_T("%.1f 毫米"),data.m_dSizes[0],sInfoTip);
|
|
MAKEFIELD(_T("B"),_T("%.1f 毫米"),data.m_dSizes[1],sInfoTip);
|
|
MAKEFIELD(_T("C"),_T("%.1f 毫米"),data.m_dSizes[2],sInfoTip);
|
|
MAKEFIELD(_T("D"),_T("%.1f 毫米"),data.m_dSizes[3],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f 毫米"),data.m_dBomEl,sInfoTip);
|
|
|
|
MAKEFIELD(_T("体积"),_T("%.1f 立方米"),GetVolume() / 1.e9,sInfoTip);
|
|
MAKEFIELD(_T("面积"),_T("%.1f 平方米"),GetArea() / 1.e6,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.m_szNo,sInfoTip);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = AecDbBDPipeBase::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 > AecDbColumn::kCurrentVersionNumber )
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = AecDbBDPipeBase::dwgOutFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ( (es =pFiler->writeUInt32 (AecDbColumn::kCurrentVersionNumber)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbColumn::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int AecDbColumn::ComparedTo(AecDbCurveBase* pCurOther) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbColumn* pColOther = AecDbColumn::cast(pCurOther);
|
|
if (pCurOther != NULL)
|
|
{
|
|
ColumnParam data;
|
|
GetColumnData(data);
|
|
|
|
ColumnParam data2;
|
|
pColOther->GetColumnData(data2);
|
|
|
|
if ( fabs(data.m_dH - data2.m_dH) > 1.e-1)
|
|
return 1;
|
|
|
|
if ( fabs(data.m_dBomEl - data2.m_dBomEl) > 1.e-1)
|
|
return 1;
|
|
|
|
if (data.m_nShape != data2.m_nShape)
|
|
return 1;
|
|
|
|
for (int i = 0;i < 4;i++)
|
|
{
|
|
if ( fabs(data.m_dSizes[i] - data2.m_dSizes[i]) > 1.e-1)
|
|
return 1;
|
|
}
|
|
|
|
if ( fabs(data.m_dXScale - data2.m_dXScale) > 1.e-1)
|
|
return 1;
|
|
|
|
if ( fabs(data.m_dYScale - data2.m_dYScale) > 1.e-1)
|
|
return 1;
|
|
|
|
AcGePoint3d ptSta,ptEnd;
|
|
getStartPoint(ptSta);
|
|
getEndPoint(ptEnd);
|
|
|
|
AcGePoint3d ptSta2,ptEnd2;
|
|
pColOther->getStartPoint(ptSta2);
|
|
pColOther->getEndPoint(ptEnd2);
|
|
|
|
if (ptSta.distanceTo(ptSta2) > 3.0)//误差3毫米
|
|
return 1;
|
|
|
|
if (ptEnd.distanceTo(ptEnd2) > 3.0)//误差3毫米
|
|
return 1;
|
|
|
|
//如果体积不同
|
|
//double dVol1 = GetVolume();
|
|
//double dVol2 = pColOther->GetVolume();
|
|
|
|
//if ( fabs(dVol1 - dVol2) > 9.0)
|
|
// return 1;
|
|
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
SHJson::WValue& AecDbColumn::ToJson(bool bExprotGeo) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbBDPipeBase::ToJson(bExprotGeo);
|
|
}
|
|
|
|
bool AecDbColumn::ByJson(const SHJson::WValue &v)
|
|
{
|
|
AssertWriteEnabled();
|
|
return AecDbBDPipeBase::ByJson(v);
|
|
}
|
|
|
|
#include "hlrcutoption.h"
|
|
void AecDbColumn::ProcessHlrResult(const AcArray<AcDbEntity *> &ar, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr, AcArray<AcDbEntity *> &output) const
|
|
{
|
|
double dW(.0);
|
|
BOOL bBold = HlrCutOption::getEnvCutLW(this, dW);
|
|
|
|
HlrCutOption::ProcessHlrResult(this
|
|
, bBold
|
|
, dW
|
|
, FALSE
|
|
, ar
|
|
, preAr
|
|
, output);
|
|
}
|
|
|
|
void AecDbColumn::PreprocessForHlr(const AcGePoint3d &ptPlnO
|
|
, const AcGeVector3d &vtPlnN
|
|
, AcArray<AcDbEntity*> &ar) const
|
|
{
|
|
// 如果实体和剖面相交，标记
|
|
HlrCutOption::setIntersectWithSection(this, AcGePlane(ptPlnO, vtPlnN));
|
|
}
|
|
|
|
bool AecDbColumn::GetProperties(SimpleProperty::PropertySetByIndex & properties) const
|
|
{
|
|
/* 形状 尺寸 偏心 底标高 柱高 材质 */
|
|
|
|
AecDbBDPipeBase::GetProperties(properties);
|
|
CoreTools::setLayerPorperty(properties);
|
|
CoreTools::setSubSystemPorperty(properties);
|
|
|
|
ColumnParam data;
|
|
::memset(&data, 0, sizeof(ColumnParam));
|
|
GetColumnData(data);
|
|
|
|
CString sShape(_T("无"));
|
|
|
|
switch (data.m_nShape)
|
|
{
|
|
case 0:
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("矩形"), false);
|
|
SimpleProperty::makeAndInsert(properties, _T("横向尺寸"), data.m_dXScale, true);
|
|
SimpleProperty::makeAndInsert(properties, _T("纵向尺寸"), data.m_dYScale, true);
|
|
break;
|
|
case 1:
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("圆形"), false);
|
|
SimpleProperty::makeAndInsert(properties, _T("直径"), data.m_dXScale, true);
|
|
break;
|
|
case 2:
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("正六边形"), false);
|
|
SimpleProperty::makeAndInsert(properties, _T("边长"), data.m_dXScale, true);
|
|
break;
|
|
case 3:
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("工字钢柱"), false);
|
|
SimpleProperty::makeAndInsert(properties, _T("型号"), data.m_sModel, false);
|
|
SimpleProperty::makeAndInsert(properties, _T("A"), data.m_dSizes[0], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("B"), data.m_dSizes[1], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("C"), data.m_dSizes[2], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("D"), data.m_dSizes[3], true);
|
|
break;
|
|
case 4:
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("槽钢柱"), false);
|
|
SimpleProperty::makeAndInsert(properties, _T("型号"), data.m_sModel, false);
|
|
SimpleProperty::makeAndInsert(properties, _T("A"), data.m_dSizes[0], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("B"), data.m_dSizes[1], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("C"), data.m_dSizes[2], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("D"), data.m_dSizes[3], true);
|
|
break;
|
|
case 6: // 角柱
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("构造柱"), false);
|
|
SimpleProperty::makeAndInsert(properties, _T("长度A"), data.m_dSizes[0], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("宽度A"), data.m_dSizes[2], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("长度B"), data.m_dSizes[1], true);
|
|
SimpleProperty::makeAndInsert(properties, _T("宽度B"), data.m_dSizes[3], true);
|
|
break;
|
|
case 7: // 构造柱
|
|
SimpleProperty::makeAndInsert(properties, _T("形状"), _T("角柱"), false);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
SimpleProperty::makeAndInsert(properties, _T("底标高"), data.m_dBomEl, true);
|
|
SimpleProperty::makeAndInsert(properties, _T("柱高"), data.m_dH, true);
|
|
SimpleProperty::makeAndInsert(properties, _T("材质"), data.m_sMaterial, true);
|
|
|
|
if (data.m_nShape != 6 && data.m_nShape != 7)
|
|
{
|
|
SimpleProperty::makeAndInsert(properties, _T("横轴偏心"), data.m_dXExtend, true);
|
|
SimpleProperty::makeAndInsert(properties, _T("纵轴偏心"), data.m_dYExtend, true);
|
|
SimpleProperty::makeAndInsert(properties, _T("转角"), data.m_dRotAngle, true);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void AecDbColumn::SetElev(const double & dElev)
|
|
{
|
|
AssertWriteEnabled();
|
|
ColumnParam data;
|
|
::memset(&data, 0, sizeof(ColumnParam));
|
|
GetColumnData(data);
|
|
|
|
AcDbCurve *pCur = GetBaseCurve();
|
|
if (!pCur) return;
|
|
|
|
AcDbLine *pLn = AcDbLine::cast(pCur);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
|
|
ptSta.z = dElev;
|
|
ptEnd.z = ptSta.z + data.m_dH;
|
|
|
|
AcGeVector3d vtOff(data.m_dXExtend, data.m_dXExtend, 0);
|
|
ptSta += vtOff;
|
|
ptEnd += vtOff;
|
|
|
|
pLn->setStartPoint(ptSta);
|
|
pLn->setEndPoint(ptEnd);
|
|
SetBaseCurve(ptSta, ptEnd);
|
|
}
|
|
delete pCur;
|
|
}
|
|
|
|
extern "C" AcDbRegion *GetColumnRegion(const ColumnParam &ColParam);
|
|
bool AecDbColumn::SetProperties(SimpleProperty::PropertySetByName & properties)
|
|
{
|
|
if (properties.m_set.empty())
|
|
return false;
|
|
|
|
AecDbBDPipeBase::SetProperties(properties);
|
|
|
|
AecDbObjXDataMap *pData = GetSpecialtyData(AcDb::kForWrite);
|
|
if (!pData) return false;
|
|
|
|
double dVal(.0);
|
|
|
|
if (properties.findAndSet(_T("底标高"), dVal))
|
|
SetElev(dVal);
|
|
if (properties.findAndSet(_T("柱高"), dVal))
|
|
SetHeight(dVal);
|
|
properties.findAndSet<CString>(_T("材质"), pData, KEY_MATERIAL);
|
|
properties.findAndSet<double>(_T("横轴偏心"), pData, KEY_XE);
|
|
properties.findAndSet<double>(_T("纵轴偏心"), pData, KEY_YE);
|
|
properties.findAndSet<double>(_T("转角"), pData, KEY_ROTATIONBK);
|
|
|
|
properties.findAndSet<double>(_T("横向尺寸"), pData, KEY_XS);
|
|
properties.findAndSet<double>(_T("纵向尺寸"), pData, KEY_YS);
|
|
|
|
|
|
if (properties.findAndSet(_T("直径"), dVal))
|
|
{
|
|
pData->SetAt(KEY_XS, dVal);
|
|
pData->SetAt(KEY_YS, dVal);
|
|
}
|
|
if (properties.findAndSet<double>(_T("边长"), dVal))
|
|
{
|
|
pData->SetAt(KEY_XS, dVal);
|
|
pData->SetAt(KEY_YS, dVal);
|
|
}
|
|
|
|
properties.findAndSet<double>(_T("A"), pData, KEY_SIZE1);
|
|
properties.findAndSet<double>(_T("B"), pData, KEY_SIZE2);
|
|
properties.findAndSet<double>(_T("C"), pData, KEY_SIZE3);
|
|
properties.findAndSet<double>(_T("D"), pData, KEY_SIZE4);
|
|
properties.findAndSet<double>(_T("长度A"), pData, KEY_SIZE1);
|
|
properties.findAndSet<double>(_T("长度B"), pData , KEY_SIZE2);
|
|
properties.findAndSet<double>(_T("宽度A"), pData , KEY_SIZE3);
|
|
properties.findAndSet<double>(_T("宽度B"), pData , KEY_SIZE4);
|
|
|
|
|
|
ColumnParam data;
|
|
::memset(&data, 0, sizeof(ColumnParam));
|
|
GetColumnData(data);
|
|
|
|
if (data.m_nShape == 6) // 角柱
|
|
{
|
|
AcGePoint3d ptGe[3];
|
|
AcGePoint3d ptA, ptB, ptInner;
|
|
double dA, dB;
|
|
GetAt(AecDbColumn::_JZ_PT_INNER, ptInner);
|
|
GetAt(AecDbColumn::_JZ_PT_A, ptA);
|
|
GetAt(AecDbColumn::_JZ_PT_B, ptB);
|
|
GetAt(KEY_SIZE1, dA);
|
|
GetAt(KEY_SIZE2, dB);
|
|
|
|
AcGeVector3d vt(ptA - ptInner);
|
|
vt.normalize();
|
|
vt *= dA;
|
|
ptA = ptInner + vt;
|
|
|
|
vt = ptB - ptInner;
|
|
vt.normalize();
|
|
vt *= dB;
|
|
ptB = ptInner + vt;
|
|
|
|
SetAt(AecDbColumn::_JZ_PT_INNER, ptInner);
|
|
SetAt(AecDbColumn::_JZ_PT_A, ptA);
|
|
SetAt(AecDbColumn::_JZ_PT_B, ptB);
|
|
|
|
AcDbRegion *pRegNew = makeJZRegion();
|
|
if (pRegNew)
|
|
SetSection(pRegNew, AcGePoint3d::kOrigin);
|
|
}
|
|
else
|
|
{
|
|
AcDbRegion *pRegAll = GetColumnRegion(data);
|
|
if (pRegAll)
|
|
SetSection(pRegAll, AcGePoint3d::kOrigin);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
extern AcDbPolyline *FormatPolyline(AcGePoint3d *ppPts, int nCount);
|
|
namespace
|
|
{
|
|
AcDbCurve* makeOffsetCurveByDir(AcDbPolyline* pCurve
|
|
, const double& dOffset
|
|
, const AcGeVector3d& vtDir)
|
|
{
|
|
if (!pCurve) return NULL;
|
|
int len(pCurve->numVerts());
|
|
if (len < 2) return NULL;
|
|
|
|
AcGeVector3d vt(vtDir);
|
|
vt.normalize();
|
|
|
|
AcGePoint3d ptS;
|
|
pCurve->getStartPoint(ptS);
|
|
|
|
AcDbRay ray;
|
|
ray.setUnitDir(vt);
|
|
ray.setBasePoint(ptS);
|
|
|
|
AcDbVoidPtrArray ar, ar2;
|
|
ar.removeAll();
|
|
pCurve->getOffsetCurves(dOffset, ar);
|
|
pCurve->getOffsetCurves(-dOffset, ar2);
|
|
|
|
// 没有都成功，那么，哪个成功用哪个。
|
|
if (!(!ar2.isEmpty() && !ar.isEmpty()))
|
|
{
|
|
AcDbVoidPtrArray &arr(ar.isEmpty() ? ar2 : ar);
|
|
if (arr.isEmpty()) return NULL;
|
|
AcDbCurve *pNew((AcDbCurve *)((AcDbCurve *)arr.first())->clone());
|
|
deleteArrayVoidPtrs< AcDbEntity>(arr);
|
|
return pNew;
|
|
}
|
|
|
|
AcDbCurve *pFir0 = (AcDbCurve *)ar.first();
|
|
AcDbCurve *pFir1 = (AcDbCurve *)ar2.first();
|
|
|
|
AcGePoint3dArray pts1, pts2;
|
|
pFir0->intersectWith(&ray, AcDb::kOnBothOperands, pts1);
|
|
pFir1->intersectWith(&ray, AcDb::kOnBothOperands, pts2);
|
|
|
|
AcDbPolyline *pNewCurve = NULL;
|
|
if (!pts1.isEmpty())
|
|
{
|
|
pNewCurve = (AcDbPolyline *)pFir0->clone();
|
|
deleteArrayVoidPtrs< AcDbEntity>(ar);
|
|
deleteArrayVoidPtrs< AcDbEntity>(ar2);
|
|
return pNewCurve;
|
|
}
|
|
|
|
if (!pts2.isEmpty())
|
|
{
|
|
pNewCurve = (AcDbPolyline *)pFir1->clone();
|
|
deleteArrayVoidPtrs< AcDbEntity>(ar);
|
|
deleteArrayVoidPtrs< AcDbEntity>(ar2);
|
|
return pNewCurve;
|
|
}
|
|
return pNewCurve;
|
|
}
|
|
|
|
AcDbCurve* makeCurve(AcDbPolyline* pPline, const std::vector<double>& arOffset, const AcGeVector3d& vtDir)
|
|
{
|
|
if (!pPline) return NULL;
|
|
|
|
if (!pPline->isOnlyLines()) return NULL;
|
|
|
|
int nSeg(pPline->numVerts() - 1);
|
|
|
|
if (nSeg > arOffset.size()) return NULL;
|
|
|
|
AcDbVoidPtrArray arCurves;
|
|
std::vector<AcGeLineSeg3d> segs;
|
|
AcGeLineSeg3d seg;
|
|
for (int i(0); i < nSeg; ++i)
|
|
{
|
|
AcDbPolyline* pCurve = (AcDbPolyline*)makeOffsetCurveByDir(pPline, arOffset[i], vtDir);
|
|
// 是第几个 polyline 就把自己的第几段seg取出来
|
|
if (pCurve)
|
|
{
|
|
pCurve->getLineSegAt(i, seg);
|
|
segs.push_back(seg);
|
|
DELETE_PTR(pCurve);
|
|
}
|
|
}
|
|
|
|
if (segs.empty()) return NULL;
|
|
|
|
AcGePoint3dArray arpts, ar;
|
|
AcGeLineSeg3d seg1, seg2;
|
|
AcDbLine line1, line2;
|
|
for (int i(0); i < segs.size() - 1; ++i)
|
|
{
|
|
ar.removeAll();
|
|
line1.setStartPoint(segs[i].startPoint());
|
|
line1.setEndPoint(segs[i].endPoint());
|
|
line2.setStartPoint(segs[i + 1].startPoint());
|
|
line2.setEndPoint(segs[i + 1].endPoint());
|
|
if (line1.intersectWith(&line2, AcDb::kExtendBoth, ar) == Acad::eOk && !ar.isEmpty())
|
|
arpts.append(ar.first());
|
|
}
|
|
|
|
arpts.insertAt(0, segs[0].startPoint());
|
|
arpts.append(segs.rbegin()->endPoint());
|
|
|
|
return FormatPolyline(arpts.asArrayPtr(), arpts.length());
|
|
}
|
|
|
|
AcDbRegion* makeRegByPoly(AcDbPolyline* pPlS , AcDbPolyline* pPlE)
|
|
{
|
|
if (!pPlS)
|
|
{
|
|
return NULL;
|
|
}
|
|
if (!pPlE)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
AcGePoint3d pt;
|
|
AcGePoint3dArray ptAr;
|
|
ptAr.removeAll();
|
|
for (int i(0); i < pPlS->numVerts(); ++i)
|
|
{
|
|
pPlS->getPointAt(i, pt);
|
|
ptAr.append(pt);
|
|
}
|
|
|
|
for (int i(pPlS->numVerts() - 1); i >= 0; --i)
|
|
{
|
|
pPlE->getPointAt(i, pt);
|
|
ptAr.append(pt);
|
|
}
|
|
|
|
ptAr.append(ptAr.first());
|
|
|
|
return AecDbEarthWorm::CreatePolygonRegionOnly(ptAr.asArrayPtr(), ptAr.length());
|
|
}
|
|
|
|
AcDbRegion *makeRegion(const AcGePoint3d &ptInner
|
|
, const AcGePoint3d &ptA
|
|
, const AcGePoint3d &ptB
|
|
, const double &dThickA
|
|
, const double &dThickB )
|
|
{
|
|
AcGePoint3d ptGe[3] = { ptA, ptInner, ptB };
|
|
|
|
AcDbPolyline *pPoly = FormatPolyline(ptGe, 3);
|
|
if (!pPoly) return NULL;
|
|
|
|
|
|
AcGeVector3d vtA, vtB, vtAB;
|
|
vtA = (ptGe[1] - ptGe[0]).normalize();
|
|
vtB = (ptGe[1] - ptGe[2]).normalize();
|
|
vtAB = vtA + vtB;
|
|
vtAB.normalize();
|
|
std::vector<double> arDoubles;
|
|
arDoubles.clear();
|
|
arDoubles.push_back(dThickA);
|
|
arDoubles.push_back(dThickB);
|
|
AcDbPolyline *pPolyOff = (AcDbPolyline *)makeCurve(pPoly, arDoubles, vtAB);
|
|
if (pPolyOff)
|
|
{
|
|
AcDbRegion *pReg = makeRegByPoly(pPoly, pPolyOff);
|
|
DELETE_PTR(pPoly);
|
|
DELETE_PTR(pPolyOff);
|
|
|
|
AcGeVector3d vtMove = ptGe[1].asVector();
|
|
vtMove.negate();
|
|
AcGeMatrix3d xform;
|
|
xform.setToTranslation(vtMove);
|
|
pReg->transformBy(xform);
|
|
|
|
return pReg;
|
|
}
|
|
|
|
DELETE_PTR(pPoly);
|
|
return NULL;
|
|
}
|
|
|
|
}
|
|
|
|
AcDbRegion* AecDbColumn::makeJZRegion()
|
|
{
|
|
AcGePoint3d ptA, ptB, ptInner;
|
|
double dAW, dBW;
|
|
GetAt(_JZ_PT_INNER, ptInner);
|
|
GetAt(_JZ_PT_A, ptA);
|
|
GetAt(_JZ_PT_B, ptB);
|
|
GetAt(KEY_SIZE3, dAW);
|
|
GetAt(KEY_SIZE4, dBW);
|
|
|
|
AcDbRegion *pRegNew = makeRegion(ptInner, ptA, ptB, dAW, dBW);
|
|
if (!pRegNew) return NULL;
|
|
return pRegNew;
|
|
}
|