560 lines
12 KiB
C++
560 lines
12 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbPoolCell.h"
|
|
#include "MFCDbDwgFiler.h"
|
|
#include "CoreTools.h"
|
|
|
|
namespace
|
|
{
|
|
AcDbRegion* CreateRegion(const AcGePoint3d &ptS
|
|
, const AcGePoint3d &ptE
|
|
, const double &wallHeight
|
|
, const double &halfWallThickness)
|
|
{
|
|
AcGeVector3d vt(ptE - ptS);
|
|
vt.rotateBy(PI * .5, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin)
|
|
, pt1(AcGePoint3d::kOrigin)
|
|
, pt2(AcGePoint3d::kOrigin)
|
|
, pt3(AcGePoint3d::kOrigin);
|
|
|
|
pt0 = ptS + vt * halfWallThickness;
|
|
pt1 = ptS - vt * halfWallThickness;
|
|
pt2 = pt1 + AcGeVector3d::kZAxis * wallHeight;
|
|
pt3 = pt2 + vt * 2 * halfWallThickness;
|
|
|
|
AcDbVoidPtrArray arr(0);
|
|
arr.append(new AcDbLine(pt0, pt1));
|
|
arr.append(new AcDbLine(pt1, pt2));
|
|
arr.append(new AcDbLine(pt2, pt3));
|
|
arr.append(new AcDbLine(pt3, pt0));
|
|
|
|
AcDbRegion *pReg = CoreTools::createRegion(arr);
|
|
deleteArrayVoidPtrs< AcDbEntity>(arr);
|
|
return pReg;
|
|
}
|
|
}
|
|
|
|
IMP_XDATA_KEY(AecDbPoolCell,_H_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_W_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_L_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_R_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_A_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_PT_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_TS_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_TH_);
|
|
IMP_XDATA_KEY(AecDbPoolCell,_NAME_);
|
|
|
|
Adesk::UInt32 AecDbPoolCell::kCurrentVersionNumber = 1;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbPoolCell, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBPOOLCELL,
|
|
"AecDbPoolCell"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbPoolCell::AecDbPoolCell(void)
|
|
{
|
|
SetTH(3.);
|
|
SetTStyle(_T("standard"));
|
|
SetName(_T(""));
|
|
}
|
|
|
|
AecDbPoolCell::~AecDbPoolCell(void) { }
|
|
|
|
const AecDbObjXDataMap* AecDbPoolCell::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
AecDbObjXDataMap* AecDbPoolCell::GetSpecialtyData(AcDb::OpenMode bMode)
|
|
{
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subExplode(AcDbVoidPtrArray& entitySet) const
|
|
{
|
|
if (IsCircle())
|
|
{
|
|
AcDbCircle cir;
|
|
GetCircle(cir);
|
|
entitySet.append(cir.clone());
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline poly;
|
|
GetPolyline(poly);
|
|
entitySet.append(poly.clone());
|
|
}
|
|
|
|
AcDbText txt;
|
|
GetText(txt);
|
|
entitySet.append(txt.clone());
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::copyFrom(const AcRxObject* pSrc)
|
|
{
|
|
assertReadEnabled();
|
|
AecDbPoolCell *pCell = AecDbPoolCell::cast(pSrc);
|
|
if (!pCell) return Acad::eInvalidInput;
|
|
m_mapSpecXData.CopyFrom(pCell->GetSpecialtyData());
|
|
//发送提资需要相同的ID
|
|
extern CString IDCreate();
|
|
Adesk::Int16 nVal = acdbCurDwg()->useri4();
|
|
if (nVal != KEY_NOPROTECT)
|
|
{
|
|
int nVt = 0;
|
|
CString sID = IDCreate();
|
|
if (m_mapSpecXData.HasKey(KEY_NO, nVt))
|
|
m_mapSpecXData.SetAt(KEY_NO, sID);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
AcGePoint3d pt(GetPt());
|
|
pt.transformBy(xform);
|
|
SetPt(pt);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subGetGripPoints(AcDbGripDataPtrArray & grips
|
|
, const double curViewUnitSize
|
|
, const int gripSize
|
|
, const AcGeVector3d & curViewDir
|
|
, const int bitflags) const
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subGetGripPoints(AcGePoint3dArray & gripPoints
|
|
, AcDbIntArray & osnapModes
|
|
, AcDbIntArray & geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
if (IsCircle())
|
|
{
|
|
gripPoints.append(GetPt());
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline poly;
|
|
GetPolyline(poly);
|
|
|
|
AcDbExtents ext;
|
|
poly.getGeomExtents(ext);
|
|
gripPoints.append(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
|
|
|
|
AcGePoint2d pt2d(AcGePoint2d::kOrigin);
|
|
for (int i = 0; i < poly.numVerts(); ++i)
|
|
{
|
|
poly.getPointAt(i, pt2d);
|
|
gripPoints.append(AcGePoint3d(pt2d.x, pt2d.y, .0));
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subMoveGripPointsAt(const AcDbIntArray & indices
|
|
, const AcGeVector3d & offset)
|
|
{
|
|
AssertWriteEnabled();
|
|
AcGePoint3d pt(GetPt());
|
|
|
|
AcDbPolyline poly;
|
|
GetPolyline(poly);
|
|
bool bIsCircle(IsCircle());
|
|
|
|
double a(GetA());
|
|
|
|
int idx(0);
|
|
for (int i = 0; i < indices.length(); ++i)
|
|
{
|
|
idx = indices[i];
|
|
if (bIsCircle)
|
|
{
|
|
pt += offset;
|
|
SetPt(pt);
|
|
}
|
|
else
|
|
{
|
|
if (idx == 0) // 转
|
|
{
|
|
a += AcGeVector3d::kXAxis.angleTo(offset, AcGeVector3d::kZAxis);
|
|
SetA(a);
|
|
}
|
|
else
|
|
{
|
|
pt += offset;
|
|
SetPt(pt);
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subGetOsnapPoints(AcDb::OsnapMode osnapMode
|
|
, INT_PTR gsSelectionMark
|
|
, const AcGePoint3d & pickPoint
|
|
, const AcGePoint3d & lastPoint
|
|
, const AcGeMatrix3d & viewXform
|
|
, AcGePoint3dArray & snapPoints
|
|
, AcDbIntArray & geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
if (IsCircle())
|
|
{
|
|
AcDbCircle Cir;
|
|
GetCircle(Cir);
|
|
return Cir.getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline PLine;
|
|
GetPolyline(PLine);
|
|
return PLine.getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subGetGeomExtents(AcDbExtents & extents) const
|
|
{
|
|
assertReadEnabled();
|
|
if (IsCircle())
|
|
{
|
|
AcDbCircle Cir;
|
|
GetCircle(Cir);
|
|
return Cir.getGeomExtents(extents);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline PLine;
|
|
GetPolyline(PLine);
|
|
return PLine.getGeomExtents(extents);
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subIntersectWith(const AcDbEntity * pEnt
|
|
, AcDb::Intersect intType
|
|
, AcGePoint3dArray & points
|
|
, INT_PTR thisGsMarker
|
|
, INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
if (IsCircle())
|
|
{
|
|
AcDbCircle Cir;
|
|
GetCircle(Cir);
|
|
return Cir.intersectWith(pEnt, intType, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline PLine;
|
|
GetPolyline(PLine);
|
|
return PLine.intersectWith(pEnt, intType, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::subIntersectWith(const AcDbEntity * pEnt
|
|
, AcDb::Intersect intType
|
|
, const AcGePlane & projPlane
|
|
, AcGePoint3dArray & points
|
|
, INT_PTR thisGsMarker
|
|
, INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
if (IsCircle())
|
|
{
|
|
AcDbCircle Cir;
|
|
GetCircle(Cir);
|
|
return Cir.intersectWith(pEnt, intType, projPlane, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline PLine;
|
|
GetPolyline(PLine);
|
|
return PLine.intersectWith(pEnt, intType, projPlane, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int prec(1);
|
|
AcDbExtents ext;
|
|
getGeomExtents(ext);
|
|
dc.DrawText(GetString()
|
|
, CoreTools::MidPt(ext.maxPoint() , ext.minPoint())
|
|
, AcGiDraw::kMiddleCenter
|
|
, GetTH()
|
|
, 1.
|
|
, .0
|
|
, GetTStyle());
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
Draw2DBuffers(dc);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if (IsCircle())
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle();
|
|
GetCircle(*pCir);
|
|
dc.DrawEntity(*pCir);
|
|
Add2DBuffer(pCir);
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline *pLine = new AcDbPolyline();
|
|
GetPolyline(*pLine);
|
|
dc.DrawEntity(*pLine);
|
|
Add2DBuffer(pLine);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
return Draw2d(dc);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::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 > AecDbPoolCell::kCurrentVersionNumber)
|
|
return Acad::eMakeMeProxy;
|
|
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (!pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return (es);
|
|
}
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ((es = pFiler->writeUInt32(AecDbPoolCell::kCurrentVersionNumber)) != Acad::eOk)
|
|
return (es);
|
|
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbPoolCell::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
void AecDbPoolCell::subList() const
|
|
{
|
|
acutPrintf(_T("\n水池格子对象："));
|
|
acutPrintf(_T("\n\t名称："), GetName());
|
|
if (!IsCircle())
|
|
{
|
|
acutPrintf(_T("\n\t形状：方形"));
|
|
acutPrintf(_T("\n\t长：%.2f毫米"), GetL());
|
|
acutPrintf(_T("\n\t宽：%.2f毫米"), GetW());
|
|
acutPrintf(_T("\n\t插入角度：%.2f度"), CoreTools::R2A(GetA()));
|
|
}
|
|
else
|
|
{
|
|
acutPrintf(_T("\n\t形状：圆形"));
|
|
acutPrintf(_T("\n\t半径：%.2f毫米"), GetR());
|
|
}
|
|
acutPrintf(_T("\n\t深：%.2f毫米"), GetH());
|
|
acutPrintf(_T("\n\t体积：%.2f立方米"), GetV() *10e-9);
|
|
|
|
AcGePoint3d pt(GetPt());
|
|
acutPrintf(_T("\n\t位置：(%.2f, %.2f, %.2f)"), pt.x, pt.y, pt.z);
|
|
}
|
|
|
|
CString AecDbPoolCell::ToScript() const
|
|
{
|
|
assertReadEnabled();
|
|
CString str;
|
|
m_mapSpecXData.Write(str, false);
|
|
return str;
|
|
}
|
|
|
|
void AecDbPoolCell::FromScript(LPCTSTR psz)
|
|
{
|
|
AssertWriteEnabled();
|
|
if (!psz) return;
|
|
m_mapSpecXData.Empty();
|
|
m_mapSpecXData.Read(psz, false);
|
|
}
|
|
|
|
bool AecDbPoolCell::IsCircle() const
|
|
{
|
|
if (EQUAL_ZERO(GetR())) return false;
|
|
return true;
|
|
}
|
|
|
|
void AecDbPoolCell::GetCircle(AcDbCircle & cir) const
|
|
{
|
|
double r(GetR());
|
|
AcGePoint3d pt0(GetPt());
|
|
cir.setCenter(pt0);
|
|
cir.setNormal(AcGeVector3d::kZAxis);
|
|
cir.setRadius(r);
|
|
}
|
|
|
|
void AecDbPoolCell::GetPolyline(AcDbPolyline & poly) const
|
|
{
|
|
double a(GetA()), w(GetW()), l(GetL());
|
|
AcGePoint3d pt0(GetPt());
|
|
AcGeVector3d vt(AcGeVector3d::kXAxis);
|
|
vt.rotateBy(a, AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
AcGeVector3d vtN(vt);
|
|
vtN.rotateBy(PI * .5, AcGeVector3d::kZAxis);
|
|
vtN.normalize();
|
|
|
|
pt0 -= vt * l * .5;
|
|
pt0 += vtN * w * .5;
|
|
poly.addVertexAt(0, pt0.convert2d(AcGePlane::kXYPlane));
|
|
pt0 += vt * l;
|
|
poly.addVertexAt(1, pt0.convert2d(AcGePlane::kXYPlane));
|
|
pt0 -= vtN * w;
|
|
poly.addVertexAt(2, pt0.convert2d(AcGePlane::kXYPlane));
|
|
pt0 -= vt * l;
|
|
poly.addVertexAt(3, pt0.convert2d(AcGePlane::kXYPlane));
|
|
poly.setClosed(true);
|
|
}
|
|
|
|
void AecDbPoolCell::GetText(AcDbText & txt) const
|
|
{
|
|
AcDbExtents ext;
|
|
getGeomExtents(ext);
|
|
AcGePoint3d pt(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
|
|
int prec(1);
|
|
CString sName(GetString());
|
|
txt.setTextString(sName);
|
|
txt.setTextStyle(CoreTools::findTextStyleId(GetTStyle()));
|
|
txt.setHeight(GetTH());
|
|
txt.setHorizontalMode(AcDb::kTextMid);
|
|
txt.setVerticalMode(AcDb::kTextVertMid);
|
|
txt.setPosition(pt);
|
|
txt.setAlignmentPoint(pt);
|
|
}
|
|
|
|
CString AecDbPoolCell::GetString() const
|
|
{
|
|
int prec(2);
|
|
CString str(_T(""));
|
|
if (!GetName().IsEmpty())
|
|
{
|
|
str = (GetName() + _T(" ")) + TypeConvert::d2s(GetV() * 10e-9, &prec) + _T("立方米");
|
|
}
|
|
return str;
|
|
//return CString(GetName().IsEmpty() ? _T("") : (GetName() + _T(" ")) + TypeConvert::d2s(GetV() * 10e-9, &prec) + _T("立方米"));
|
|
}
|
|
|
|
double AecDbPoolCell::GetV() const
|
|
{
|
|
double a(GetA()), w(GetW()), l(GetL()), r(GetR()), h(GetH());
|
|
|
|
if (IsCircle())
|
|
return PI * r * r * h;
|
|
else
|
|
return w * l * h;
|
|
|
|
return .0;
|
|
}
|
|
|
|
void AecDbPoolCell::GetKeyPoints(AcGePoint2dArray & ar, const double &dWallT)
|
|
{
|
|
ar.removeAll();
|
|
double dH(GetH());
|
|
if (IsCircle())
|
|
{
|
|
double dR(GetR() + dWallT * .5);
|
|
ar.append(AcGePoint2d::kOrigin);
|
|
}
|
|
else
|
|
{
|
|
double dA(GetA())
|
|
, dL(GetL() + dWallT * .5)
|
|
, dW(GetW() + dWallT * .5);
|
|
AcGeVector2d vt(AcGeVector2d::kXAxis);
|
|
vt.rotateBy(dA);
|
|
AcGeVector2d vtN(vt);
|
|
vtN.rotateBy(PI * .5);
|
|
vt.normalize();
|
|
vtN.normalize();
|
|
// 围绕原点生成四个墙
|
|
AcGePoint2d pt0(GetPt().convert2d(AcGePlane::kXYPlane))
|
|
, pt1(AcGePoint2d::kOrigin)
|
|
, pt2(AcGePoint2d::kOrigin)
|
|
, pt3(AcGePoint2d::kOrigin);
|
|
|
|
pt0 -= vt * dL * .5;
|
|
pt0 += vtN * dW * .5;
|
|
pt1 = pt0 + vt * dL;
|
|
pt2 = pt1 - vtN * dW;
|
|
pt3 = pt2 - vt * dL;
|
|
|
|
ar.append(pt0);
|
|
ar.append(pt1);
|
|
ar.append(pt2);
|
|
ar.append(pt3);
|
|
}
|
|
}
|
|
|
|
void AecDbPoolCell::GetSimplyPoolCell(AcDbPolyline *pPoly, const double & dWallT)
|
|
{
|
|
AcGePoint2dArray ar(0);
|
|
GetKeyPoints(ar, dWallT);
|
|
for (size_t i = 0; i < ar.length(); ++i)
|
|
{
|
|
pPoly->addVertexAt((int)i, ar[(int)i]);
|
|
}
|
|
pPoly->setClosed(1);
|
|
}
|
|
|