1023 lines
24 KiB
C++
1023 lines
24 KiB
C++
#include "stdafx.h"
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// 竖板对象类
|
|
/////////////////////////////////////////////////////////////
|
|
|
|
const Adesk::UInt8 TDbVertSlab::g_nVersion = 1;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSVertSlab, ATSEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_VERTSLAB, "ATS_VERTSLAB图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbVertSlab);
|
|
|
|
TDbVertSlab::TDbVertSlab()
|
|
{
|
|
m_nThickness = 0;
|
|
m_nHeightS = m_nHeightE = 0;
|
|
}
|
|
|
|
TDbVertSlab::~TDbVertSlab()
|
|
{
|
|
}
|
|
|
|
BOOL TDbVertSlab::IsValid() const
|
|
{
|
|
BOOL bRet = TDbEntity::IsValid();
|
|
if (!bRet)
|
|
return bRet;
|
|
|
|
bRet = (m_ptStart.Distance2d(m_ptEnd)>_DIST_SNAP &&
|
|
m_nThickness>_DIST_SNAP &&
|
|
m_nHeightS*m_nHeightE>_DIST_SNAP*_DIST_SNAP); // 起点高度和终点高度, 必须全>0或<0
|
|
return bRet;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbVertSlab::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbVertSlab::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbVertSlab *pSrc = TDbVertSlab::cast(pSrcEntity);
|
|
if (pSrc)
|
|
{
|
|
m_nThickness = pSrc->m_nThickness;
|
|
m_bShow2d = pSrc->m_bShow2d;
|
|
}
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbVertSlab::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return es;
|
|
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if (nVer>g_nVersion) // Version is too new
|
|
{
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
pFiler->readItem((AcGePoint3d *)&m_ptStart);
|
|
pFiler->readItem((AcGePoint3d *)&m_ptEnd);
|
|
pFiler->readItem(&m_nThickness);
|
|
pFiler->readItem(&m_nHeightS);
|
|
pFiler->readItem(&m_nHeightE);
|
|
pFiler->readItem(&m_bShow2d);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbVertSlab::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
pFiler->writeItem((AcGePoint3d &)m_ptStart);
|
|
pFiler->writeItem((AcGePoint3d &)m_ptEnd);
|
|
pFiler->writeItem(m_nThickness);
|
|
pFiler->writeItem(m_nHeightS);
|
|
pFiler->writeItem(m_nHeightE);
|
|
pFiler->writeItem(m_bShow2d);
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbVertSlab::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dxfInFields(pFiler);
|
|
if (es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbVertSlab")))
|
|
{
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
double r1, r2, r3;
|
|
int nFlag;
|
|
XPoint pt1, pt2;
|
|
Adesk::UInt32 fieldsFlags = 0;
|
|
resbuf rb;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk))
|
|
{
|
|
switch (rb.restype)
|
|
{
|
|
case AcDb::kDxfXCoord:
|
|
pt1=rb.resval.rpoint;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfXCoord+1:
|
|
pt2=rb.resval.rpoint;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfReal:
|
|
r1=rb.resval.rreal;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfReal+1:
|
|
fieldsFlags |= 0x08;
|
|
r2 = rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfReal+2:
|
|
fieldsFlags |= 0x10;
|
|
r3 = rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfInt16:
|
|
fieldsFlags |= 0x20;
|
|
nFlag = rb.resval.rint;
|
|
break;
|
|
//fall through intentional
|
|
default:
|
|
// An unrecognized group. Push it back so that
|
|
// the subclass can read it again.
|
|
pFiler->pushBackItem();
|
|
es = Acad::eEndOfFile;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// At this point the es variable must contain eEndOfFile
|
|
// - either from readResBuf() or from pushback. If not,
|
|
// it indicates that an error happened and we should
|
|
// return immediately.
|
|
//
|
|
if (es != Acad::eEndOfFile)
|
|
return Acad::eInvalidResBuf;
|
|
if (!(fieldsFlags & 0x01)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 10"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags & 0x02)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 11"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags & 0x04)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 40"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags & 0x08)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 41"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags & 0x10)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 42"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
|
|
m_ptStart=pt1;
|
|
m_ptEnd=pt2;
|
|
m_nThickness=r1;
|
|
m_nHeightS=r2;
|
|
m_nHeightE=r3;
|
|
|
|
if (fieldsFlags&0x20)
|
|
m_bShow2d=nFlag;
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbVertSlab::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es=TDbEntity::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbVertSlab"));
|
|
assert(es == Acad::eOk);
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord, m_ptStart.AsAcGePoint2d());
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord+1, m_ptEnd.AsAcGePoint2d());
|
|
pFiler->writeDouble(AcDb::kDxfReal, m_nThickness);
|
|
pFiler->writeDouble(AcDb::kDxfReal+1, m_nHeightS);
|
|
pFiler->writeDouble(AcDb::kDxfReal+2, m_nHeightE);
|
|
pFiler->writeInt16(AcDb::kDxfInt16, m_bShow2d);
|
|
|
|
return es;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Overriden functions for edit
|
|
// to do:
|
|
// 允许通过夹点改变边界
|
|
Acad::ErrorStatus TDbVertSlab::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
gripPoints.append(m_ptStart);
|
|
gripPoints.append(m_ptEnd);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// stretch points is diffrent from grep points, with no midpoint included
|
|
Acad::ErrorStatus TDbVertSlab::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
stretchPoints.append(m_ptStart);
|
|
stretchPoints.append(m_ptEnd);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// Active when being rotated, scaled, moved, etc.
|
|
Acad::ErrorStatus TDbVertSlab::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::subTransformBy(xform);
|
|
((AcGePoint3d &)m_ptStart).transformBy(xform);
|
|
((AcGePoint3d &)m_ptEnd).transformBy(xform);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbVertSlab::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset = *(XPoint *)&offset;
|
|
vtOffset.z = 0;
|
|
|
|
for (int i = 0; i < indices.length(); i++)
|
|
{
|
|
int idx = indices[i];
|
|
if (idx==0)
|
|
{
|
|
m_ptStart += vtOffset;
|
|
m_ptEnd += vtOffset;
|
|
}
|
|
else if (idx==1)
|
|
{
|
|
m_ptEnd += vtOffset;
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
return es;
|
|
}
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus TDbVertSlab::GetGripText(int i, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
XString sInfo;
|
|
if (i == 0)
|
|
{
|
|
sInfo << _T("平移起点");
|
|
}
|
|
else
|
|
{
|
|
sInfo << _T("拉伸终点");
|
|
}
|
|
cs = sInfo;
|
|
return es;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
// 状态: 有待完成修改相关墙体门窗的操作
|
|
Acad::ErrorStatus TDbVertSlab::subMoveStretchPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
int nCount = indices.length();
|
|
return subMoveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbVertSlab::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
// sg add 100926，支持竖板开洞，首先判断是否带有洞口信息
|
|
int nLength = GetHolesNum();
|
|
if (nLength > 0)
|
|
{
|
|
return Draw3dHole(dc);
|
|
}
|
|
|
|
XLine ln(m_ptStart, m_ptEnd);
|
|
ln.SetElevation(0.0);
|
|
|
|
XLine lnLeft = ln.Offset(-m_nThickness/2);
|
|
XLine lnRight = ln.Offset(m_nThickness/2);
|
|
lnLeft.StartPoint().z = lnRight.StartPoint().z = m_ptStart.z;
|
|
lnLeft.EndPoint().z = lnRight.EndPoint().z = m_ptEnd.z;
|
|
|
|
XLine lnLeftUp = lnLeft;
|
|
XLine lnRightUp = lnRight;
|
|
lnLeftUp.StartPoint().z += m_nHeightS;
|
|
lnRightUp.StartPoint().z += m_nHeightS;
|
|
lnLeftUp.EndPoint().z += m_nHeightE;
|
|
lnRightUp.EndPoint().z += m_nHeightE;
|
|
|
|
XPoly2D polyLeft(1), polyRight(1);
|
|
polyLeft.AppendNode(lnLeft.StartPoint());
|
|
polyLeft.AppendNode(lnLeft.EndPoint());
|
|
polyLeft.AppendNode(lnLeftUp.EndPoint());
|
|
polyLeft.AppendNode(lnLeftUp.StartPoint());
|
|
polyRight.AppendNode(lnRight.StartPoint());
|
|
polyRight.AppendNode(lnRight.EndPoint());
|
|
polyRight.AppendNode(lnRightUp.EndPoint());
|
|
polyRight.AppendNode(lnRightUp.StartPoint());
|
|
|
|
dc.DrawShell(polyLeft, DList<XPoly2D>());
|
|
dc.DrawShell(polyRight, DList<XPoly2D>());
|
|
dc.DrawMesh(polyLeft, polyRight);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// sg add 100927，三维绘制，支持竖板上带洞（截面拉伸）
|
|
Acad::ErrorStatus TDbVertSlab::Draw3dHole(XExplodeDraw &dc) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
// 获取起点、终点
|
|
AcGePoint3d ptStart = m_ptStart.AsAcGePoint3d(),
|
|
ptEnd = m_ptEnd.AsAcGePoint3d(),
|
|
ptUpStart = ptStart,
|
|
ptUpEnd = ptEnd;
|
|
ptUpStart.z += m_nHeightS;
|
|
ptUpEnd.z += m_nHeightE;
|
|
|
|
// 构造起点、终点所在面
|
|
AcGePlane plane(ptEnd, ptStart, ptUpStart);
|
|
AcGeVector3d vec = plane.normal();
|
|
vec.normalize();
|
|
|
|
// 备份一分
|
|
AcGeVector3d vecSpare(vec);
|
|
double dThick = m_nThickness * (-0.5);
|
|
vec = vec * dThick;
|
|
|
|
// 中心截面PLine线
|
|
ptStart += TVector3D(vec);
|
|
ptEnd += TVector3D(vec);
|
|
ptUpEnd += TVector3D(vec);
|
|
ptUpStart += TVector3D(vec);
|
|
|
|
TGGePoly2D polyElev(1);
|
|
polyElev.AppendNode(ptStart);
|
|
polyElev.AppendNode(ptEnd);
|
|
polyElev.AppendNode(ptUpEnd);
|
|
polyElev.AppendNode(ptUpStart);
|
|
|
|
// 获得竖板上的开洞信息
|
|
TDPtrList<TGGePoly2D> lstHoles;
|
|
GetAllHoles(lstHoles);
|
|
|
|
// 将圆洞的轮廓离散
|
|
TDPtrList<TGGePoly2D> lstHolesTmp;
|
|
|
|
int nLength = lstHoles.Length();
|
|
for (int i=0; i<nLength; i++)
|
|
{
|
|
TGGePoly2D *pHoleOnSide = new TGGePoly2D(*lstHoles[i]);
|
|
for (int k = 0; k < pHoleOnSide->Length(); k++)
|
|
{
|
|
*(*pHoleOnSide)[k] += TVector3D(vec);
|
|
}
|
|
|
|
lstHolesTmp.Append(pHoleOnSide);
|
|
}
|
|
|
|
vecSpare.normalize();
|
|
vecSpare = vecSpare*m_nThickness;
|
|
dc.DrawBody(polyElev, lstHolesTmp, TVector3D(vecSpare));
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbVertSlab::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
if (m_bShow2d)
|
|
{
|
|
XLine ln(m_ptStart, m_ptEnd);
|
|
ln.SetElevation(0.0);
|
|
|
|
XLine lnLeft = ln.Offset(-m_nThickness/2);
|
|
XLine lnRight = ln.Offset(m_nThickness/2);
|
|
dc << lnLeft << lnRight << XLine(lnLeft.StartPoint(), lnRight.StartPoint())
|
|
<< XLine(lnLeft.EndPoint(), lnRight.EndPoint());
|
|
|
|
// sg add 100926，支持竖板开洞
|
|
TDPtrList<TGGePoly2D> lstHoles;
|
|
GetAllHoles(lstHoles);
|
|
|
|
TADSGePoint3d ptStart,
|
|
ptEnd;
|
|
|
|
int nLength = lstHoles.Length();
|
|
for (int i=0; i<nLength; i++)
|
|
{
|
|
const TGGePoly2D &pline = *lstHoles[i];
|
|
GetHolePtOnMidLine(pline, ptStart, ptEnd);
|
|
|
|
TGGeLine midLine(ptStart, ptEnd, LS_INFINITE);
|
|
midLine.SetElevation(0.0);
|
|
|
|
TGGeLine line1 = midLine.Offset(-m_nThickness*0.5),
|
|
line2 = midLine.Offset(m_nThickness*0.5);
|
|
|
|
// 保存旧的线型
|
|
AcDbObjectId idOldLineType = dc.GetLineTypeId();
|
|
// 设置新的线型
|
|
dc.SetLineType(InitLineType(_T("DASH"), database()));
|
|
|
|
dc << TGGeLine(line1.StartPoint(), line2.StartPoint()) <<
|
|
TGGeLine(line1.EndPoint(), line2.EndPoint());
|
|
|
|
// 还原为旧的线型
|
|
dc.SetLineType(idOldLineType);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// sg add 100927，将polyHole投影到XLine(m_ptStart, m_ptEnd)上，获取外轮廓
|
|
void TDbVertSlab::GetHolePtOnMidLine(const TGGePoly2D &polyHole,
|
|
TADSGePoint3d &ptStart, TADSGePoint3d &ptEnd) const
|
|
{
|
|
// 记录最大、最小点长度
|
|
double dMin = m_ptStart.Distance(m_ptEnd),
|
|
dMax = 0.0,
|
|
dDist = 0.0;
|
|
|
|
// 中线
|
|
TGGeCurveSegment seg(m_ptStart, m_ptEnd, LS_INFINITE);
|
|
|
|
TADSGePoint3d ptLoc;
|
|
int nLength = polyHole.Length();
|
|
for (int i=0; i<nLength; i++)
|
|
{
|
|
ptLoc = polyHole.GetAt(i); // 逐个获得顶点坐标
|
|
|
|
// 求到端点的沿曲线线位移
|
|
dDist = seg.PathDistance(ptLoc, 1);
|
|
if (dDist > dMax - _DIST_SNAP)
|
|
{
|
|
dMax = dDist;
|
|
ptEnd = ptLoc;
|
|
}
|
|
|
|
if (dDist < dMin + _DIST_SNAP)
|
|
{
|
|
dMin = dDist;
|
|
ptStart = ptLoc;
|
|
}
|
|
}
|
|
}
|
|
|
|
const TCHAR *TDbVertSlab::GetDefaultLayer() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
|
void TDbVertSlab::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("竖板")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("板厚"), Dist2Str(GetThickness())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("起点标高"), Dist2Str(m_ptStart.z)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("终点标高"), Dist2Str(m_ptEnd.z)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("起点高度"), Dist2Str(m_nHeightS)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("终点高度"), Dist2Str(m_nHeightE)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("二维显示"), m_bShow2d? _T("开启") : _T("关闭")));
|
|
|
|
//lstInfo.Append(new TObjInfoUnit(_T("周长"), Dist2Str(GetPerimeter())));
|
|
//lstInfo.Append(new TObjInfoUnit(_T("底面积"),
|
|
// XString(_T("%.2f"), _AS_SQMETER(GetBottomArea()))));
|
|
//lstInfo.Append(new TObjInfoUnit(_T("侧面积"),
|
|
// XString(_T("%.2f"), _AS_SQMETER(GetSideArea()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("体积"),
|
|
XString(_T("%.3f"), _AS_CUMETER(GetVolume()))));
|
|
|
|
}
|
|
|
|
BOOL
|
|
TDbVertSlab::Is2DVisible() const
|
|
{
|
|
return m_bShow2d;
|
|
}
|
|
|
|
double
|
|
TDbVertSlab::GetThickness() const
|
|
{
|
|
return m_nThickness;
|
|
}
|
|
|
|
double
|
|
TDbVertSlab::GetHeightS() const
|
|
{
|
|
return m_nHeightS;
|
|
}
|
|
|
|
double
|
|
TDbVertSlab::GetHeightE() const
|
|
{
|
|
return m_nHeightE;
|
|
}
|
|
|
|
XPoint
|
|
TDbVertSlab::GetStartPoint() const
|
|
{
|
|
return m_ptStart;
|
|
}
|
|
|
|
XPoint
|
|
TDbVertSlab::GetEndPoint() const
|
|
{
|
|
return m_ptEnd;
|
|
}
|
|
|
|
void
|
|
TDbVertSlab::SetThickness(double h)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nThickness = h;
|
|
}
|
|
|
|
void
|
|
TDbVertSlab::SetHeightS(double s)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nHeightS = s;
|
|
}
|
|
|
|
void
|
|
TDbVertSlab::SetHeightE(double e)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nHeightE = e;
|
|
}
|
|
|
|
void
|
|
TDbVertSlab::Set2DVisible(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
m_bShow2d=bTrue;
|
|
}
|
|
|
|
void
|
|
TDbVertSlab::SetStartPoint(const XPoint &pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptStart=pt;
|
|
}
|
|
|
|
void
|
|
TDbVertSlab::SetEndPoint(const XPoint &pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptEnd = pt;
|
|
}
|
|
|
|
|
|
// 工程量
|
|
double TDbVertSlab::GetPerimeter() const
|
|
{
|
|
XPoint ptS1=GetStartPoint()+GetHeightS();
|
|
XPoint ptE1=GetEndPoint()+GetHeightE();
|
|
double nDist1=GetStartPoint().Distance(GetEndPoint()) +
|
|
GetHeightE() +
|
|
ptS1.Distance(ptE1) +
|
|
GetHeightS();
|
|
return nDist1;
|
|
}
|
|
|
|
double TDbVertSlab::GetBottomArea() const
|
|
{
|
|
double nVal=(GetHeightS()+GetHeightE())*GetStartPoint().Distance2d(GetEndPoint())/2.0;
|
|
return nVal;
|
|
}
|
|
|
|
double TDbVertSlab::GetSideArea() const
|
|
{
|
|
return (GetPerimeter()*GetThickness());
|
|
}
|
|
|
|
double TDbVertSlab::GetVolume() const
|
|
{
|
|
return (GetBottomArea()*GetThickness());
|
|
}
|
|
|
|
|
|
// sg add 100925，支持竖板上开洞
|
|
// 如果是圆洞，dWidth为直径，dHeight为0
|
|
bool TDbVertSlab::AddHole(TADSGePoint3d ptLoc, double dWidth, double dHeight)
|
|
{
|
|
// 构造起点、终点所在面
|
|
AcGePoint3d ptStart = m_ptStart.AsAcGePoint3d(),
|
|
ptEnd = m_ptEnd.AsAcGePoint3d(),
|
|
ptUpStart = ptStart,
|
|
ptUpEnd = ptEnd;
|
|
ptUpStart.z += m_nHeightS;
|
|
ptUpEnd.z += m_nHeightE;
|
|
|
|
// 获得ptLoc投影到面上的投影点
|
|
AcGePlane plane(ptEnd, ptStart, ptUpStart);
|
|
AcGePoint3d ptSpare = ptLoc.AsAcGePoint3d(),
|
|
ptProject = ptSpare.orthoProject(plane);
|
|
|
|
// 中心截面PLine线
|
|
TGGePoly2D polyElev(1);
|
|
polyElev.AppendNode(ptStart);
|
|
polyElev.AppendNode(ptEnd);
|
|
polyElev.AppendNode(ptUpEnd);
|
|
polyElev.AppendNode(ptUpStart);
|
|
|
|
// 构造洞的PLine线
|
|
TGGePoly2D polyHole(1);
|
|
GetHolePline(ptProject, dWidth, dHeight, polyHole);
|
|
|
|
// 判断两个PLine线是否相交
|
|
int nLength1 = polyHole.TotalSegments(),
|
|
nLength2 = polyElev.TotalSegments();
|
|
TADSGePoint3d ptInt1, ptInt2;
|
|
for (int i=0; i<nLength1; i++)
|
|
{
|
|
TGGeCurveSegment seg1;
|
|
polyHole.Nth(i, seg1);
|
|
|
|
for (int j=0; j<nLength2; j++)
|
|
{
|
|
TGGeCurveSegment seg2;
|
|
polyElev.Nth(j, seg2);
|
|
|
|
// 梁上开洞，必须是完整的洞，如果相交，则不添加洞，直接返回
|
|
if (seg1.Intersection(seg2, ptInt1, ptInt2))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获得对象中保存的洞口数据
|
|
PlusHolesNum(1);
|
|
|
|
// 添加动态数据，存储新的洞口数据
|
|
SetHolePLine(polyHole);
|
|
return true;
|
|
}
|
|
|
|
// sg add 100926，根据传入的中间立面上的开洞位置点，以及洞口尺寸，返回中间立面上的洞口轮廓线
|
|
// 如果是圆洞，dWidth为直径，dHeight为0
|
|
void TDbVertSlab::GetHolePline(TADSGePoint3d ptLoc, double dWidth, double dHeight, TGGePoly2D &poly) const
|
|
{
|
|
poly.Reset(); // 清空
|
|
poly.SetFlag(1); // 设置闭合
|
|
|
|
// 构造起点、终点所在面
|
|
AcGePoint3d ptStart = m_ptStart.AsAcGePoint3d(),
|
|
ptEnd = m_ptEnd.AsAcGePoint3d(),
|
|
ptUpStart = ptStart;
|
|
ptUpStart.z += m_nHeightS;
|
|
|
|
AcGePlane plane(ptEnd, ptStart, ptUpStart);
|
|
double dW = dWidth*0.5;
|
|
|
|
// 圆洞
|
|
if (fabs(dHeight) < _DIST_SNAP)
|
|
{
|
|
AcGeVector3d vec = plane.normal();
|
|
|
|
// 构造圆，获得等分点
|
|
AcGeCircArc3d circle(ptLoc, vec, dW);
|
|
|
|
AcGePoint3dArray pointArray;
|
|
circle.getSamplePoints(40, pointArray); // 暂时分成40份
|
|
|
|
int nLength = pointArray.length();
|
|
for (int i=0; i<nLength; i++)
|
|
{
|
|
poly.AppendNode(pointArray[i]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
TVector3D vtXAxis = m_ptEnd - m_ptStart,
|
|
vtYAxis = TADSGePoint3d(ptUpStart) - m_ptStart;
|
|
vtXAxis.Normalize();
|
|
vtYAxis.Normalize();
|
|
vtXAxis.Scale(dW);
|
|
vtYAxis.Scale(dW);
|
|
|
|
TADSGePoint3d pt1 = ptLoc + vtXAxis,
|
|
pt2 = ptLoc - vtXAxis;
|
|
|
|
// 方洞
|
|
double dH = dHeight*0.5;
|
|
vtXAxis.Normalize();
|
|
vtYAxis.Normalize();
|
|
vtXAxis.Scale(dH);
|
|
vtYAxis.Scale(dH);
|
|
|
|
pt1 = pt1 + vtYAxis;
|
|
pt2 = pt2 + vtYAxis;
|
|
|
|
vtXAxis.Scale(2);
|
|
vtYAxis.Scale(2);
|
|
|
|
TADSGePoint3d pt3 = pt1 - vtYAxis,
|
|
pt4 = pt2 - vtYAxis;
|
|
poly.AppendNode(pt1);
|
|
poly.AppendNode(pt2);
|
|
poly.AppendNode(pt4);
|
|
poly.AppendNode(pt3);
|
|
}
|
|
|
|
// 开洞的数量
|
|
Adesk::UInt16 TDbVertSlab::GetHolesNum() const
|
|
{
|
|
assertReadEnabled();
|
|
const TEntityFields &fd = GetFields();
|
|
|
|
Adesk::UInt16 nLength = 0;
|
|
fd.GFD(_T("竖板开洞数量"), nLength);
|
|
return nLength;
|
|
}
|
|
|
|
void TDbVertSlab::PlusHolesNum(Adesk::UInt16 nPlusNum)
|
|
{
|
|
Adesk::UInt16 nNum = GetHolesNum();
|
|
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
|
|
nNum += nPlusNum;
|
|
fd.SFD(_T("竖板开洞数量"), nNum);
|
|
}
|
|
|
|
// sg add 100926，获取所有洞口的轮廓线
|
|
void TDbVertSlab::GetAllHoles(TDPtrList<TGGePoly2D> &lstHoles) const
|
|
{
|
|
lstHoles.Reset();
|
|
|
|
assertReadEnabled();
|
|
const TEntityFields &fd = GetFields();
|
|
|
|
AcGePoint3d point;
|
|
double dBulge = 0;
|
|
Adesk::UInt8 bIsClosed = 0;
|
|
|
|
// 逐个读取洞口轮廓线PLine线信息
|
|
long lNum = fd.GetSubFieldNum();
|
|
for (long l=0; l<lNum; l++)
|
|
{
|
|
const TEntityField &subFd = fd.GetSubField(l);
|
|
|
|
TEntityField::DataType type = subFd.GetDataType();
|
|
if (type != TEntityField::kGroup)
|
|
{
|
|
continue; // 竖板开洞数量
|
|
}
|
|
|
|
// 取一个洞口轮廓线PLine线信息
|
|
TEntityFields *holeFds = NULL;
|
|
subFd.GetData(holeFds);
|
|
|
|
long lLength = holeFds->GetSubFieldNum();
|
|
if (lLength == 0)
|
|
{
|
|
continue; // 空集合
|
|
}
|
|
|
|
// 构造一个洞口轮廓线
|
|
TGGePoly2D *pHole = new TGGePoly2D(1);
|
|
pHole->Reset();
|
|
|
|
for (int i=0; i<lLength; i++)
|
|
{
|
|
const TEntityField &pointFd = holeFds->GetSubField(i);
|
|
if (pointFd.GetDataType() != TEntityField::kGroup)
|
|
{
|
|
if (_tcscmp(pointFd.GetName(), _T("洞口线闭合")) != 0)
|
|
{
|
|
continue; // 洞口线点数
|
|
}
|
|
|
|
pointFd.GetData(bIsClosed);
|
|
pHole->SetFlag(bIsClosed); // 设置轮廓线闭合
|
|
continue;
|
|
}
|
|
|
|
// 取一个洞口轮廓线PLine线信息
|
|
TEntityFields *pointFds = NULL;
|
|
pointFd.GetData(pointFds);
|
|
|
|
if (pointFds->GetSubFieldNum() == 0)
|
|
{
|
|
continue; // 空集合
|
|
}
|
|
|
|
pointFds->GFD(_T("点"), point); // 取点坐标
|
|
pointFds->GFD(_T("凸度"), dBulge); // 取Bulge值
|
|
pHole->AppendNode(TADSGePoint3d(point[0], point[1], point[2]), dBulge);
|
|
}
|
|
|
|
lstHoles.Append(pHole);
|
|
}
|
|
}
|
|
|
|
// sg add 100926，增加洞口的动态数据
|
|
void TDbVertSlab::SetHolePLine(const TGGePoly2D &polyHole)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
|
|
// 将一个洞口的数据，保存成一个TEntityField（组），存入动态数据
|
|
TEntityField *pHole = new TEntityField(_T(""), TEntityField::kGroup);
|
|
fd.Add(pHole);
|
|
|
|
TEntityFields *pNewFds = NULL;
|
|
pHole->GetData(pNewFds);
|
|
|
|
// 保存洞口轮廓线是否闭合
|
|
Adesk::UInt8 bIsClosed = polyHole.GetFlag();
|
|
pNewFds->SFD(_T("洞口线闭合"), bIsClosed);
|
|
|
|
// 保存构成洞口轮廓线的点数
|
|
Adesk::UInt16 nVertexCount = polyHole.Length();
|
|
pNewFds->SFD(_T("洞口线点数"), nVertexCount);
|
|
|
|
AcGePoint3d point;
|
|
double dBulge = 0;
|
|
for (long l=0; l<nVertexCount; l++)
|
|
{
|
|
// 将点的坐标和Bulge值保存成一个节点的动态数据
|
|
TEntityField *pVertex = new TEntityField(_T(""), TEntityField::kGroup);
|
|
pNewFds->Add(pVertex);
|
|
|
|
TEntityFields *pTempFds = NULL;
|
|
pVertex->GetData(pTempFds);
|
|
|
|
// 保存点坐标
|
|
point = polyHole.GetAt(l).AsAcGePoint3d();
|
|
pTempFds->SFD(_T("点"), point);
|
|
|
|
// 保存Bulge值
|
|
dBulge = polyHole.GetBulge(l);
|
|
pTempFds->SFD(_T("凸度"), dBulge);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int EditVertSlab0(AcDbObjectId id);
|
|
|
|
void InitDbVertSlab(BOOL bTrue)
|
|
{
|
|
AecObjectEditMethod pOldEdit=NULL;
|
|
if (bTrue) {
|
|
TDbVertSlab::rxInit();
|
|
pOldEdit=TDbVertSlab::SetEditMethod(EditVertSlab0);
|
|
TDbVertSlab::InitMatchProtocol(TRUE);
|
|
} else {
|
|
TDbVertSlab::InitMatchProtocol(FALSE);
|
|
TDbVertSlab::SetEditMethod(pOldEdit);
|
|
deleteAcRxClass(TDbVertSlab::desc());
|
|
}
|
|
}
|
|
|
|
// Command:编辑竖板
|
|
int EditVertSlab0(AcDbObjectId id)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbVertSlab, pStep);
|
|
if (!pStep)
|
|
return RTERROR;
|
|
|
|
//判断是不是上海城建梁实体
|
|
CString strCmdName(_T(""));
|
|
TDbXDataMap map;
|
|
map.Read(pStep, _T("TGZZCL"));
|
|
map.GetAt(_T("cmdName"), strCmdName);
|
|
if (strCmdName == _T("TGZZCLKL")||
|
|
strCmdName == _T("TGZZCLLL")||
|
|
strCmdName == _T("TGZZCLTL")||
|
|
strCmdName == _T("TGZZCLXL"))
|
|
{
|
|
struct resbuf rbUr;
|
|
rbUr.restype = RTSTR;
|
|
rbUr.resval.rstring = _tcsdup(_T("EditObj"));
|
|
rbUr.rbnext = NULL;
|
|
acedSetVar(_T("USERS3"), &rbUr);
|
|
acedPostCommand(strCmdName);
|
|
acedPostCommand(_T("\n"));
|
|
return RTNORM;
|
|
}
|
|
else
|
|
{
|
|
while(1) {
|
|
const TCHAR *szPrompt1=_T("\n选择 [起点标高(A)/起边高度(S)/终点标高(D)/终边高度(F)/开关二维(G)/板厚(H)]<退出>:");
|
|
XString sKeyword;
|
|
int nRet=0;
|
|
INITGET_BEG(0, _T("A S D F G H L"));
|
|
nRet=ads_getkword(szPrompt1, sKeyword);
|
|
INITGET_END();
|
|
|
|
if (nRet!=RTNORM)
|
|
break;
|
|
if (sKeyword[0]==_T('H')) {
|
|
double nRailHeight=pStep->GetThickness();
|
|
nRet=GetReal(_T("\n板厚"), nRailHeight);
|
|
if (nRet==RTCAN)
|
|
break;
|
|
if (nRet==RTNORM) {
|
|
if (pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetThickness(nRailHeight);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if (sKeyword[0]==_T('A')) {
|
|
XPoint ptStart=pStep->GetStartPoint();
|
|
double nElev=ptStart.z;
|
|
nRet=GetReal(_T("\n起点标高"), nElev);
|
|
if (nRet==RTCAN)
|
|
break;
|
|
if (nRet==RTNORM) {
|
|
ptStart.z = nElev;
|
|
if (pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetStartPoint(ptStart);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if (sKeyword[0]==_T('S')) {
|
|
double h=pStep->GetHeightS();
|
|
nRet=GetReal(_T("\n起边高度"), h);
|
|
if (nRet==RTCAN)
|
|
break;
|
|
if (nRet==RTNORM) {
|
|
if (pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetHeightS(h);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if (sKeyword[0]==_T('D')) {
|
|
XPoint ptEnd=pStep->GetEndPoint();
|
|
double nElev=ptEnd.z;
|
|
nRet=GetReal(_T("\n终点标高"), nElev);
|
|
if (nRet==RTCAN)
|
|
break;
|
|
if (nRet==RTNORM) {
|
|
ptEnd.z = nElev;
|
|
if (pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetEndPoint(ptEnd);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if (sKeyword[0]==_T('F')) {
|
|
double h=pStep->GetHeightE();
|
|
nRet=GetReal(_T("\n终边高度"), h);
|
|
if (nRet==RTCAN)
|
|
break;
|
|
if (nRet==RTNORM) {
|
|
if (pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetHeightE(h);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if (sKeyword[0]==_T('L')) {
|
|
pStep->list();
|
|
} else if (sKeyword[0]==_T('G')) {
|
|
BOOL bShow2d=pStep->Is2DVisible();
|
|
bShow2d = !bShow2d;
|
|
if (bShow2d)
|
|
adsout << _T("\n开启二维显示!");
|
|
else
|
|
adsout << _T("\n关闭二维显示!");
|
|
|
|
if (pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->Set2DVisible(bShow2d);
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
|