gjm/envi-code
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
envi-code/SourceCode/Code2026/tg_shs/shs_kernal/TDbStruBeam.cpp
T
gjm 164968b62e chore 
把非utf8-bom编码的cpp/h文件改为 utf8 bom 编码, msvc识别utf8编码时,如果不是bom格式的,会使用当前cp_oem来解码.
2026-10-04 00:04:20 +08:00

6368 lines
158 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName : TDbStruBeam类
// = Version : ver1.0
// = Author : cet
// = CreateDate : 2011-05-27
// = Description: 梁对象类实现
// = Maintainers:
//
//------------------------------------------------------------------------+
#include "stdafx.h"
#ifdef TASD
#include "TDbStruBeam.h"
#include "TAsdKeyDefine.h"
#include "TBaseWallIntegrateTool.h"
#include "TDbStruFloorSlab.h"
#include "TConfigInfo.h"
#include "TAssocMsgContainer.h"
#include "TDbStruSelfBase.h"
extern void AddMsg(const TAssocMsg& assocMsg);
extern bool g_bModifyAgain;
const Adesk::UInt8 TDbStruBeam::g_nVersion = 1;
ACRX_DXF_DEFINE_MEMBERS(ATSStruBeam, ATSBaseWall, AcDb::kDHL_CURRENT,
AcDb::kMReleaseCurrent, 1, ATS_STRUBEAM,
"ATS_STRUBEAM图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbStruBeam);
#define BEAMCOLOR 5
#define AMBEAMCOLOR 4
#define CPBEAMCOLOR 2
#define TRANBEAMCOLOR 3
#define REDCOLOR 1
static bool AscCompare(TCombForceData& param1, TCombForceData& param2)
{
if (param1.m_dForce - param2.m_dForce < g_fZero)
{
return false;
}
return true;
}
TDbStruBeam::TDbStruBeam()
{
}
TDbStruBeam::~TDbStruBeam()
{
}
Acad::ErrorStatus TDbStruBeam::dwgInFields (AcDbDwgFiler* pFiler)
{
assertWriteEnabled();
Acad::ErrorStatus es = TDbBaseWall::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(&m_idLayerDim);
pFiler->readItem(&m_idLayerNum);
pFiler->readItem(&m_idLayerMark);
pFiler->readItem(&m_idLayerText);
pFiler->readItem(&m_idLayerRBar);
pFiler->readItem(&m_idLayerRBarU);
pFiler->readItem(&m_idLayerRBarO);
pFiler->readItem(&m_idLayerRealArea);
pFiler->readItem(&m_idLayerCalDefl);
pFiler->readItem(&m_idLayerCalCrk);
pFiler->readItem(&m_idLayerForce);
pFiler->readItem(&m_idLayerCalcArea);
pFiler->readItem(&m_idLayerLoad);
pFiler->readItem(&m_idLayerLoadL);
pFiler->readItem(&m_idLayerLoadC);
pFiler->readItem(&m_idTextStyle);
pFiler->readItem(&m_idTextStyleRB);
return pFiler->filerStatus();
}
Acad::ErrorStatus TDbStruBeam::dwgOutFields(AcDbDwgFiler* pFiler) const
{
assertReadEnabled();
Acad::ErrorStatus es = TDbBaseWall::dwgOutFields(pFiler);
if (es != Acad::eOk)
{
return es;
}
pFiler->writeItem(g_nVersion);
pFiler->writeItem(m_idLayerDim);
pFiler->writeItem(m_idLayerNum);
pFiler->writeItem(m_idLayerMark);
pFiler->writeItem(m_idLayerText);
pFiler->writeItem(m_idLayerRBar);
pFiler->writeItem(m_idLayerRBarU);
pFiler->writeItem(m_idLayerRBarO);
pFiler->writeItem(m_idLayerRealArea);
pFiler->writeItem(m_idLayerCalDefl);
pFiler->writeItem(m_idLayerCalCrk);
pFiler->writeItem(m_idLayerForce);
pFiler->writeItem(m_idLayerCalcArea);
pFiler->writeItem(m_idLayerLoad);
pFiler->writeItem(m_idLayerLoadL);
pFiler->writeItem(m_idLayerLoadC);
pFiler->writeItem(m_idTextStyle);
pFiler->writeItem(m_idTextStyleRB);
return pFiler->filerStatus();
}
Acad::ErrorStatus TDbStruBeam::subGetOsnapPoints( AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray& geomIds ) const
{
assertReadEnabled();
return TDbBaseWall::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
}
Acad::ErrorStatus TDbStruBeam::subTransformBy( const AcGeMatrix3d& xform )
{
assertWriteEnabled();
Acad::ErrorStatus nRet = TDbBaseWall::subTransformBy(xform);
// 拖拽结束时发送消息
if (objectId() && g_bMonitorDbAction)
{
TAssocMsg msg;
msg.SetMethod(TAssocMsg::kTransform);
msg.SetMatrix(xform);
msg.SetAssocId(objectId());
AddMsg(msg);
}
return nRet;
}
Acad::ErrorStatus TDbStruBeam::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
assertReadEnabled();
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
gripPoints.append(ptS);
gripPoints.append(ptE);
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge);
TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
if (fabs(dBulge) < g_fZero) // 直线
{
Midpoint(ptStart, ptE, ptMid);
}
else // 弧线
{
TGGeArc arc(ptStart, ptEnd, dBulge);
ptMid = arc.MidPoint();
}
gripPoints.append(ptMid);
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::subGetStretchPoints( AcGePoint3dArray& stretchPoints ) const
{
assertReadEnabled();
AcDbIntArray osnapModes;
AcDbIntArray geomIds;
return subGetGripPoints(stretchPoints, osnapModes, geomIds);
}
Acad::ErrorStatus TDbStruBeam::subMoveGripPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
if (GetCtrlToggle())
{
SingleMove(indices, offset); // 单独移动
}
else
{
AssociateMove(indices, offset); // 关联移动
}
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::subMoveStretchPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
return subMoveGripPointsAt(indices, offset);
}
Acad::ErrorStatus TDbStruBeam::subGetClassID( CLSID* pClsid ) const
{
#if (ADS >= 17)
assertReadEnabled();
#endif
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::subDeepClone( AcDbObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
{
assertReadEnabled();
return TDbBaseWall::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
}
Acad::ErrorStatus TDbStruBeam::subWblockClone( AcRxObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
{
assertReadEnabled();
return TDbBaseWall::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
}
Acad::ErrorStatus TDbStruBeam::subIntersectWith( const AcDbEntity* ent, AcDb::Intersect intType, AcGePoint3dArray& points, INT_PTR thisGsMarker /*= 0*/, INT_PTR otherGsMarker /*= 0*/ ) const
{
return TDbBaseWall::subIntersectWith(ent, intType, points, thisGsMarker, otherGsMarker);
}
Acad::ErrorStatus TDbStruBeam::subIntersectWith( const AcDbEntity* ent, AcDb::Intersect intType, const AcGePlane& projPlane, AcGePoint3dArray& points, INT_PTR thisGsMarker /*= 0*/, INT_PTR otherGsMarker /*= 0*/ ) const
{
return TDbBaseWall::subIntersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
}
Acad::ErrorStatus TDbStruBeam::GetGripText( int i, CString &cs ) const
{
Acad::ErrorStatus es=Acad::eOk;
bool bArc = true;
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge);
if (fabs(dBulge) < g_angleZero) // 直线
{
;bArc = false;
}
if (GetCtrlToggle()) // 单独移动
{
switch(i)
{
case 0:
{
cs=_T("改变位置");
break;
}
case 1:
{
cs=_T("改变位置");
break;
}
case 2:
{
if (bArc)
{
cs=_T("改变位置");
}
else
{
cs=_T("独立平行移动");
}
break;
}
default:
es=Acad::eInvalidInput;
break;
}
}
else // 关联移动
{
switch(i)
{
case 0:
{
if (bArc)
{
cs=_T("沿弧伸缩");
}
else
{
cs=_T("沿梁方向拉伸缩短");
}
break;
}
case 1:
{
if (bArc)
{
cs=_T("沿弧伸缩");
}
else
{
cs=_T("沿梁方向拉伸缩短");
}
break;
}
case 2:
{
if (bArc)
{
cs=_T("改变半径");
}
else
{
cs=_T("关联平行移动");
}
break;
}
default:
es=Acad::eInvalidInput;
break;
}
}
return es;
}
Acad::ErrorStatus TDbStruBeam::ExplodeOrDraw3d( TGGiExplodeDrawBase &dc ) const
{
assertReadEnabled();
if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
{
AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
if (!dcCommon->context()->isPlotGeneration())
{
if(DocGetShowNo()&& DocGetBeamShowNo())
{
DrawCellNo(dc); // 显示单元编号
}
if(DocGetShowRG()&& DocGetBeamShowRG())
{
DrawRG(dc); // 显示刚域
}
}
}
//modify by xlc on 120112荷载显示控制
//add by wjx on 111219 显示梁荷载
//if (DocGetShowLoadPara())
if((DocGetBeamShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == BEAMLOAD)
{
DrawBeamLoad3D(dc);
}
// 单线绘制样式
if (!g_bDetailMode)
{
TGGeCurveSegment seg;
GetBaseLine(seg);
dc << seg;
return Acad::eOk;
}
// 双线绘制样式
AcGePoint3d ptShapeBase;
if (!GetBasePoint(ptShapeBase))
{
return Acad::eInvalidInput;
}
AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
TGGePoly2D polyShape, polyBase;
GetSection2d(polyShape); // 截面外轮廓线
GetPolyBase(polyBase); // 基线
TGGePoly2D poly2d(polyBase);
TDPtrList<TGGePoly2D> lstPolys;
TDPtrList<Adesk::UInt8> lstColVis;
poly2d.SetElevation(0.0);
{
TVector3D vtOff = *polyShape[0]-ptShapeBase;
TGGePoly2D polyNew;
poly2d.Offset(vtOff.x, polyNew);
if(polyNew.Length()!=poly2d.Length())
{
return Acad::eInvalidInput;
}
polyNew.SetElevation(vtOff.y);
lstPolys.Append(new TGGePoly2D(polyNew));
lstColVis.Append(new Adesk::UInt8(TRUE));
}
for(int i=0; i<polyShape.TotalSegments(); i++)
{
TGGeDirectionCurve cv;
polyShape.Nth(i, cv);
if(cv.Is(CURVE_LINE))
{
TVector3D vtOff=cv.EndPoint()-ptShapeBase;
TGGePoly2D polyNew;
poly2d.Offset(vtOff.x, polyNew);
if(polyNew.Length()!=poly2d.Length())
{
return Acad::eInvalidInput;
}
polyNew.SetElevation(vtOff.y);
lstPolys.Append(new TGGePoly2D(polyNew));
lstColVis.Append(new Adesk::UInt8(TRUE));
}
else
{
double intAng=cv.GetBulge();
int nDiv=30;
if(cv.Is(CURVE_ARC))
{
nDiv=GetCirDivNum(cv.GetArc().GetRadius(), _AS_SYS_UNIT(g_nCirDeviation));
}
int nStep=AS_INT(fabs(intAng)/PI/2.0*nDiv); // how much section
double dDistStep=cv.GetLength()/nStep;
for(int j=0; j<nStep; j++)
{
TADSGePointDir2d ptE;
cv.Polar(dDistStep*(j+1), ptE);
TVector3D vtOff=(TADSGePoint3d &)ptE - ptShapeBase;
TGGePoly2D polyNew;
poly2d.Offset(vtOff.x, polyNew);
if(polyNew.Length()!=poly2d.Length())
{
return Acad::eInvalidInput;
}
polyNew.SetElevation(vtOff.y);
lstPolys.Append(new TGGePoly2D(polyNew));
lstColVis.Append(new Adesk::UInt8(j==nStep-1));
}
}
}
int nVertex=polyBase.Length();
for(i=0; i<lstPolys.Length(); i++)
{
TGGePoly2D &rPoly=*lstPolys[i];
for(int j=0; j<nVertex; j++)
{
rPoly[j]->z += polyBase[j]->z;
}
}
int nTotalSeg=polyBase.TotalSegments();
for(int n=0; n<nTotalSeg; n++)
{
TDPtrList<TGGeDirectionCurve> lstCurves;
for(int j=0; j<lstPolys.Length(); j++)
{
TGGeDirectionCurve *pCurve=new TGGeDirectionCurve;
lstPolys[j]->Nth(n, *pCurve);
lstCurves.Append(pCurve);
}
TGGeDirectionCurve mSeg;
poly2d.Nth(n, mSeg);
int nDiv=30;
if(mSeg.Is(CURVE_ARC))
{
nDiv=GetCirDivNum(mSeg.GetArc().GetRadius(), _AS_SYS_UNIT(g_nCirDeviation));
}
int nStep=AS_INT(fabs(mSeg.GetBulge())/PI/2.0*nDiv); // how much section
if(nStep<=0) nStep=1;
int nCol=lstCurves.Length();
int nRow=nStep+1;
TADSGePoint3d *ptArray=new TADSGePoint3d[nCol*nRow];
for(int col=0; col<nCol; col++)
{
TGGeDirectionCurve &segThis=*lstCurves[col];
TGGeDirectionCurve seg2d=segThis;
seg2d.SetElevation(segThis.StartPoint().z);
double nElevStep=(segThis.EndPoint().z - segThis.StartPoint().z)/nStep;
double nDistStep=seg2d.GetLength()/nStep;
for(int row=0; row<nRow; row++)
{
TADSGePointDir2d ptDir2d;
seg2d.Polar(nDistStep*row, ptDir2d);
ptDir2d.z += nElevStep*row;
ptArray[row*nCol+col]=ptDir2d;
}
}
// 设置边的可见性
int nEdgeNum=nRow*(nCol-1)+nCol*(nRow-1);
Adesk::UInt8 *pVisArray=new Adesk::UInt8[nEdgeNum];
for(int k=0; k<nEdgeNum; k++)
{
pVisArray[k]=kAcGiVisible;
}
for(k=1; k<nRow-1; k++) //除首末行外,其余各行的边均不可见
{
for(int j=0; j<nCol-1; j++)
{
pVisArray[k*(nCol-1)+j] = kAcGiInvisible;
}
}
int nIndexBase=nRow*(nCol-1);
for(col=0; col<nCol; col++)
{
Adesk::UInt8 bVis=*lstColVis[col];
for(int row=0; row<nRow-1; row++)
{
pVisArray[nIndexBase+col*(nRow-1)+row]=bVis;
}
}
int nVertexNum=nCol*nRow;
for(k=0; k<nVertexNum; k++)
{
ptArray[k]=Ecs2Wcs(ptArray[k], vtNormal);
}
AcGiEdgeData edgeInfo;
edgeInfo.setVisibility(pVisArray);
dc.DrawMesh(nRow, nCol, (AcGePoint3d *)ptArray, &edgeInfo);
if(n==0 && !poly2d.IsClosed() && polyShape.IsClosed())
{
TGGePoly2D polyTemp1(1);
for(col=0; col<nCol-1; col++)
{
polyTemp1.AppendNode(ptArray[col]);
}
dc.DrawShell(polyTemp1, TDPtrList<TGGePoly2D>());
}
if(n==nTotalSeg-1 && !poly2d.IsClosed() && polyShape.IsClosed())
{
TGGePoly2D polyTemp2(1);
for(col=0; col<nCol-1; col++)
{
polyTemp2.AppendNode(ptArray[(nRow-1)*nCol+col]);
}
dc.DrawShell(polyTemp2, TDPtrList<TGGePoly2D>());
}
delete []pVisArray;
delete []ptArray;
}
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::ExplodeOrDraw2d( TGGiExplodeDrawBase &dc ) const
{
assertReadEnabled();
// modify by wjx on 111230 由于绘制简图时不需要绘制双线图
if(g_bDetailMode)
{
AcDbObjectId idOwner = ownerId();
int nMatTyp = MAT_CONCRETE;
GetAt(KEY_MATTYP, nMatTyp);
BOOL bHatch = FALSE; //是否填充
BOOL bThick = FALSE; //是否加粗
CString sHatchType = _T("SOLID"); //填充样式
switch (nMatTyp)
{
case MAT_CONCRETE: //混凝土梁
bHatch = DocGetConBeamHatch();
bThick = DocGetConBeamThick();
sHatchType = DocGetConBeamHPatte();
break;
case MAT_STEEL: //钢梁
bHatch = DocGetStlBeamHatch();
bThick = DocGetStlBeamThick();
sHatchType = DocGetStlBeamHPatte();
break;
}
//梁不填充
// 填充
int nHatchType = 0;
GetAt(KEY_HATCH, nHatchType);
if(nHatchType == 0 && DocGetIsSolidFill() && bHatch
|| nHatchType == 1)
{
TGGePoly2D poly;
GetPoly2dBehindIntegrate(poly); // 端点融合后生成的闭合poly2d
if (poly.HasArcSegment())
{
TGGePoly2D poly2;
poly.Disperse(poly2);
poly.Reset();
poly = poly2;
}
poly.SetElevation(0.0);
// 添加填充裁剪线
std::vector<TGGePoly2D> vecPoly;
GetClipedPoly2d(vecPoly);
int nNum = 0;
std::vector<TGGePoly2D>::iterator it;
for (it = vecPoly.begin(); it != vecPoly.end(); it++)
{
++nNum;
it->SetElevation(0.0);
dc.PushClip(*it);
}
if (_tcsicmp(sHatchType, _T("SOLID")) == 0)
{
dc << TGGeSolid(poly);
}
else
{
dc << TGGeHatch(poly, sHatchType, GetPScale());
}
// 删除填充裁剪线
while(nNum > 0)
{
--nNum;
dc.PopClip();
}
}
int i = 0;
long iClipCount = 0; //独基裁剪边界计数
TGGePoly2D poly; //独基边界
for (i = 0; i < m_arAssocZIds.length(); i++)
{
OPENOBJ_BEGIN(m_arAssocZIds[i], AcDb::kForRead, TDbStruSelfBase, pEnt);
if (pEnt)
{
poly = pEnt->GetOutline();
poly.SetElevation(0);
dc.PushClip(poly);
iClipCount++;
}
OPENOBJ_END();
}
// 加粗
if (DocGetIsLineWeight() && bThick)
{
DrawWeightLine2d(dc);
}
// 双线绘制样式
TBaseWallLine bwlThis;
GetThisBaseWallLine(bwlThis);
// 梁与柱融合
TDbColumn *pStruColumn = NULL;
for (i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
TGGePoly2D poly2d;
pStruColumn->GetOutline(poly2d);
pStruColumn->Close();
poly2d.SetElevation(0.0);
TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
}
}
// 梁与梁融合
TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
// 起点融合
TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
// 终点融合
TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
// 梁内融合
for (i = 0; i < arBaseWallLinesM.Length(); i++)
{
TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
}
// 绘制边线
TGGeVisibilityPoly2D left, right;
left = bwlThis.GetLeftLine();
right = bwlThis.GetRightLine();
AcDbObjectIdArray idArr;
GetCoverSlab(idArr);
if (idArr.length() > 0) // 有板
{
DrawBeamLine2dForCoverSlab(dc, left);
DrawBeamLine2dForCoverSlab(dc, right);
}
else
{
DrawBaseWall2d(dc, left, true);
DrawBaseWall2d(dc, right, false);
}
// 处理端点封口
bool bLinkColumn = IsLinkColumn(true);
int nLen = arBaseWallLinesS.Length();
if (bLinkColumn && nLen == 0) // 起始端只连着柱子
{
DrawSideLine2d(true, dc);
}
else if (!bLinkColumn && nLen == 0) // 起始端未连接梁和柱子
{
if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
{
dc << TGGeLine(*left[0], *right[0]);
}
}
else if (!bLinkColumn && nLen == 1) // 起始端只连接着一根梁
{
AcDbObjectId id;
GetWallId(true, id);
DrawSideLine2d(true, id, bwlThis, dc);
}
bLinkColumn = IsLinkColumn(false);
nLen = arBaseWallLinesE.Length();
if (bLinkColumn && nLen == 0) // 终止端只连着柱子
{
DrawSideLine2d(false, dc);
}
else if (!bLinkColumn && nLen == 0) // 终止端未连接梁和柱子
{
if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
{
dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
}
}
else if (!bLinkColumn && nLen == 1) // 终止端只连接着一根梁
{
AcDbObjectId id;
GetWallId(false, id);
DrawSideLine2d(false, id, bwlThis, dc);
}
while (iClipCount > 0)
{
dc.PopClip();
iClipCount--;
}
}
else // 绘制简图
{
DrawStruBeam(dc);
}
// 显示梁尺寸
if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
{
AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
if (!dcCommon->context()->isPlotGeneration())
{
if(DocGetShowBH() && DocGetBeamShowBH())
{
DrawBH(dc);
}
}
}
// 显示构件编号
if(DocGetBeamShowCL())
{
DrawClab(dc);
}
// add by xlc on 120112荷载显示控制
// 显示梁荷载信息
//if(DocGetShowLoadPara())
if((DocGetBeamShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == BEAMLOAD)
{
DrawBeamLoad(dc);
}
if(g_nGraph == FORCE_M)
{
DrawMGraph(dc);
}
else if(g_nGraph == FORCE_S)
{
DrawSGraph(dc);
}
//显示配筋面积,配筋率
DrawReinGragh(dc);
if (g_bShowCrack)
{//显示裂缝图
DrawCrackGraph(dc);
}
if (g_bShowDef)
{//显示挠度图
DrawDeflectGraph(dc);
}
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::GetExtents2d( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
TGGePoly2D poly2d;
GetPoly2D(poly2d);
poly2d.GetExtend(ptLow, ptUp);
ptLow.z = 0.0;
ptUp.z = 0.0;
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
GetExtents2d(ptLow, ptUp);
AcGePoint3d ptS,ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
double dH = 0.0; // 总高
GetTotalHeight(dH);
ptLow.z = ptS.z > ptE.z ? ptE.z - dH : ptS.z - dH;
ptUp.z = ptS.z > ptE.z ? ptS.z : ptE.z;
return Acad::eOk;
}
void TDbStruBeam::GetTips( TDPtrList<TObjInfoUnit> &lstInfo ) const
{
}
const TCHAR * TDbStruBeam::GetDefaultLayer() const
{
return LAY_S_BEAM_PLAN_LINE;
}
BOOL TDbStruBeam::IsValid() const
{
assertReadEnabled();
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
double dWidth = 0.0;
GetAt(KEY_SUMB, dWidth);
if (fabs(ptS.z - ptE.z) < _DIST_SNAP && dWidth > 0)
{
return true;
}
return false;
}
int TDbStruBeam::GetCtrlToggleIndex() const
{
return 9;
}
void TDbStruBeam::CopyPropertiesFrom( AcDbEntity *pSrcEntity, unsigned gMatchFlag )
{
assertWriteEnabled();
TDbBaseWall::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
TDbStruBeam *pBeam = TDbStruBeam::cast(pSrcEntity);
if(pBeam != NULL)
{
CopyData(pBeam);
if(database() == NULL ||
pSrcEntity->database() == NULL ||
database() == pSrcEntity->database())
{
m_idLayerDim = pBeam->m_idLayerDim;
m_idLayerNum = pBeam->m_idLayerNum;
m_idLayerMark = pBeam->m_idLayerMark;
m_idLayerText = pBeam->m_idLayerText;
m_idLayerRBar = pBeam->m_idLayerRBar;
m_idLayerRBarU = pBeam->m_idLayerRBarU;
m_idLayerRBarO = pBeam->m_idLayerRBarO;
m_idLayerRealArea = pBeam->m_idLayerRealArea;
m_idLayerCalDefl = pBeam->m_idLayerCalDefl;
m_idLayerCalCrk = pBeam->m_idLayerCalCrk;
m_idLayerForce = pBeam->m_idLayerForce;
m_idLayerCalcArea = pBeam->m_idLayerCalcArea;
m_idLayerLoad = pBeam->m_idLayerLoad;
m_idLayerLoadL = pBeam->m_idLayerLoadL;
m_idLayerLoadC = pBeam->m_idLayerLoadC;
m_idTextStyle = pBeam->m_idTextStyle;
m_idTextStyleRB = pBeam->m_idTextStyleRB;
}
}
}
TEntityBase::DrawType TDbStruBeam::GetDrawType() const
{
assertReadEnabled();
return TEntityBase::k2Dand3D;
}
bool TDbStruBeam::GetStandardFaceBody( AcDbVoidPtrArray& arFacePtrs ) const
{
return true;
}
bool TDbStruBeam::GetSafeProtectedSpace( AcDbVoidPtrArray& arFacePtrs ) const
{
return true;
}
bool TDbStruBeam::GetSection( const AcDbFace &face, const AcGeVector3d& vtPlaneSecDir, std::vector<TObjSectionRecord> &sectionRecords, AcDbVoidPtrArray& arFillPtrs ) const
{
return true;
}
CString TDbStruBeam::GetXml(const AcGeMatrix3d& mat) const
{
TXmlTree xmlTree;
POSITION posRoot = xmlTree.Insert(_T("ATS_STRUBEAM"), NULL, NULL);
{
xmlTree.SetAttribute(posRoot, _T("name"), _T("梁"));
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
}
CString strText;
POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
{
xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
strText.Format(_T("%ld"), objectId());
xmlTree.SetItemText(posItem1, strText);
}
POSITION posItem = NULL;
POSITION posItem2 = xmlTree.Insert(_T("Link_Beam"),posRoot, posItem1);
{
xmlTree.SetAttribute(posItem2, _T("name"), _T("连接梁"));
for (int i = 0; i < m_arAssocBWallIds.length(); i++)
{
posItem = xmlTree.Insert(_T("Link_ID"), posItem2, posItem);
xmlTree.SetAttribute(posItem, _T("name"), _T("梁句柄"));
strText.Format(_T("%ld"), m_arAssocBWallIds[i]);
xmlTree.SetItemText(posItem, strText);
}
}
POSITION posItem3 = xmlTree.Insert(_T("Link_Colu"),posRoot, posItem2);
{
xmlTree.SetAttribute(posItem3, _T("name"), _T("连接柱"));
for (int i = 0; i < m_arColumnIds.length(); i++)
{
posItem = xmlTree.Insert(_T("Link_ID"), posItem3, posItem);
xmlTree.SetAttribute(posItem, _T("name"), _T("柱句柄"));
strText.Format(_T("%ld"), m_arColumnIds[i]);
xmlTree.SetItemText(posItem, strText);
}
}
AcGePoint3d pts,pte;
double dBulge;
POSITION posItem4 = xmlTree.Insert(_T("Baseline"), posRoot, posItem3);
{
xmlTree.SetAttribute(posItem4, _T("name"), _T("基线参数"));
GetAt(KEY_START, pts);
GetAt(KEY_END, pte);
GetAt(KEY_BULGE, dBulge);
posItem = NULL;
posItem = xmlTree.Insert(_T("Start_point"), posItem4, posItem);
{
TADSGePoint3d ptTransformBy = pts;
ptTransformBy.TransformBy(mat);
xmlTree.SetAttribute(posItem, _T("name"), _T("起始点"));
strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("End_point"), posItem4, posItem);
{
TADSGePoint3d ptTransformBy = pte;
ptTransformBy.TransformBy(mat);
xmlTree.SetAttribute(posItem, _T("name"), _T("结束点"));
strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("Central_ang"), posItem4, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("圆心角"));
strText.Format(_T("%f"), dBulge);
xmlTree.SetItemText(posItem, strText);
}
}
int nVal;
POSITION posItem5 = xmlTree.Insert(_T("Material"), posRoot, posItem4);
{
xmlTree.SetAttribute(posItem5, _T("name"), _T("梁材料"));
xmlTree.SetAttribute(posItem5, _T("comment"), _T("梁使用的材料"));
CString strText;
GetAt(KEY_MATTYP, nVal);
switch(nVal)
{
case MAT_CONCRETE:
strText = _T("混凝土");
break;
case MAT_STEEL:
strText = _T("钢材");
break;
default:
;
}
xmlTree.SetItemText(posItem5, strText);
}
POSITION posItem6 = xmlTree.Insert(_T("Height"), posRoot, posItem5);
{
xmlTree.SetAttribute(posItem6, _T("name"), _T("高度参数"));
posItem = NULL;
posItem = xmlTree.Insert(_T("Top_height"), posItem6, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("顶标高"));
xmlTree.SetAttribute(posItem, _T("comment"), _T("梁顶的相对标高"));
strText.Format(_T("%f"), pts.z);
xmlTree.SetItemText(posItem, strText);
}
}
POSITION posItem7 = xmlTree.Insert(_T("AxisAngle"), posRoot, posItem6);
{
xmlTree.SetAttribute(posItem7, _T("name"), _T("轴转角"));
double dAngle(0);
GetAt(KEY_AXANG,dAngle);
strText.Format(_T("%f"), dAngle);
xmlTree.SetItemText(posItem7, strText);
}
POSITION posItem8 = xmlTree.Insert(_T("Property"), posRoot, posItem7);
{
xmlTree.SetAttribute(posItem8, _T("name"), _T("截面特性"));
xmlTree.SetAttribute(posItem8, _T("comment"), _T("截面特性"));
POSITION posItem9 = NULL;
nVal = 0;
GetAt(KEY_SECTYP, nVal);
double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0, dAngle = 0.0;
switch(nVal)
{
case ST_RECT:
{
GetAt(KEY_B, dB);
GetAt(KEY_H, dH);
xmlTree.SetItemText(posItem8, _T("矩形"));
posItem9 = xmlTree.Insert(_T("Rect"), posItem8, NULL);
{
xmlTree.SetAttribute(posItem9, _T("name"), _T("矩形参数"));
xmlTree.SetAttribute(posItem9, _T("comment"), _T("用于矩形梁"));
posItem = xmlTree.Insert(_T("Width"), posItem9, NULL);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("截面宽度"));
strText.Format(_T("%f"), dB);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("Width"), posItem9, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("截面高度"));
strText.Format(_T("%f"), dH);
xmlTree.SetItemText(posItem, strText);
}
}
}
break;
case ST_IBEAM:
{
GetAt(KEY_B,dB);
GetAt(KEY_H,dH);
GetAt(KEY_U,dU);
GetAt(KEY_T,dT);
GetAt(KEY_D,dD);
GetAt(KEY_F,dF);
xmlTree.SetItemText(posItem8, _T("工字形"));
posItem9 = xmlTree.Insert(_T("IBeam"), posItem8, NULL);
{
xmlTree.SetAttribute(posItem9, _T("name"), _T("工字形参数"));
xmlTree.SetAttribute(posItem9, _T("comment"), _T("用于工字形梁"));
posItem = xmlTree.Insert(_T("B"), posItem9, NULL);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("腹板厚度"));
strText.Format(_T("%f"), dB);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("H"), posItem9, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("截面总高度"));
strText.Format(_T("%f"), dH);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("U"), posItem9, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("上翼缘宽度"));
strText.Format(_T("%f"), dU);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("T"), posItem9, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("上翼缘厚度"));
strText.Format(_T("%f"), dT);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("D"), posItem9, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("下翼缘宽度"));
strText.Format(_T("%f"), dD);
xmlTree.SetItemText(posItem, strText);
}
posItem = xmlTree.Insert(_T("F"), posItem9, posItem);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("下翼缘厚度"));
strText.Format(_T("%f"), dF);
xmlTree.SetItemText(posItem, strText);
}
}
}
break;
case ST_CIRCLE:
{
GetAt(KEY_B, dB);
xmlTree.SetItemText(posItem8, _T("圆形"));
posItem9 = xmlTree.Insert(_T("Circle"), posItem8, NULL);
{
xmlTree.SetAttribute(posItem9, _T("name"), _T("圆形参数"));
xmlTree.SetAttribute(posItem9, _T("comment"), _T("用于圆形梁"));
posItem = xmlTree.Insert(_T("Diameter"), posItem9, NULL);
{
xmlTree.SetAttribute(posItem, _T("name"), _T("截面直径"));
strText.Format(_T("%f"), dB);
xmlTree.SetItemText(posItem, strText);
}
}
}
break;
default:
break;
}
}
CString strBase = TEntityBase::GetXml(mat);
CString strXml = xmlTree.GetXml();
int nIndex = strXml.Find(_T("<Object_ID"));
strXml.Insert(nIndex, strBase);
return strXml;
}
void TDbStruBeam::PostAssocMsg( TAssocMsg assocMsg ) const
{
}
void TDbStruBeam::ReceiveAssocMsg( TAssocMsg assocMsg )
{
assertWriteEnabled();
TDbBaseWall::ReceiveAssocMsg(assocMsg);
}
void TDbStruBeam::MakeAssocRelation( AcDbObjectIdArray& ids )
{
assertWriteEnabled();
TPickEntSet ss(SS_FREE);
ads_name eName;
for (int i = 0; i < ids.length(); i++)
{
if (acdbGetAdsName(eName, ids[i]) == Acad::eOk)
{
ss += ids[i];
}
}
TEntitySet ent;
#ifdef TESTCASE
//简单方式手动建立关联
for (long j = 0; j < ss.Length(); j++)
{
ent = ss[j];
if (ent.Is(_T("ATS_STRUBEAM"))) // 梁
{
if (!m_arAssocBWallIds.contains(ids[j]))
{
m_arAssocBWallIds.append(ids[j]);
}
}
else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
{
if (!m_arColumnIds.contains(ids[j]))
{
m_arColumnIds.append(ids[j]);
}
}
else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
{
if (!m_arSlabIds.contains(ids[j]))
{
m_arSlabIds.append(ids[j]);
}
}
}
return;
#endif
TGGePoly2D poly; //梁闭合平面
GetPoly2D(poly);
double dWidth = 0; //梁平面宽
GetTotalWidth(dWidth);
TGGeCurveSegment cvCL = GetCenterLine();
cvCL.SetLineFlag(LS_INFINITE);
double dElevS = cvCL.StartPoint().z;
double dElevE = cvCL.EndPoint().z;
bool bModFlg = false; //记录梁的中心线是否调整
double dGap(0);
AcDbObjectId idObj = AcDbObjectId::kNull;
for (long j = 0; j < ss.Length(); j++)
{
ent = ss[j];
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
if (pEnt)
{
CString sss = pEnt->isA()->name();
}
OPENOBJ_END();
if (ent.Is(_T("ATS_STRUBEAM"))) // 梁
{
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruBeam, pEnt);
if (!pEnt)
{
continue;
}
TGGePoly2D polyDest;
pEnt->GetPoly2D(polyDest);
double dWidthDest(0);
pEnt->GetTotalWidth(dWidthDest);
bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
//间隙小于梁宽一半时，当作关联处理
if(bRet && (dGap < dWidth*0.5 || dGap < dWidthDest*0.5))
{
if (cvCL.Is(CURVE_LINE))
{
//建立关联时对梁的中心线进行校验，相交
TGGeCurveSegment cvCLDest = pEnt->GetCenterLine();
cvCLDest.SetLineFlag(LS_INFINITE);
TADSGePoint3d ptInter1,ptInter2;
int nNum = cvCL.Intersection(cvCLDest,ptInter1,ptInter2);
if (nNum == 0) //没有交点，直接建立关联
{
}
else
{
//两个交点时取离cvCL中点近的
if (nNum == 2)
{
TADSGePoint3d ptMid = cvCL.MidPoint();
ptInter1 = TGGeLine(ptInter1, ptInter2).NearPoint(ptMid);
}
int nHitFlag = cvCL.HitTest2d(ptInter1);
bool bModBreak = false;
if (nHitFlag == 6) //起始侧延长线
{
bModFlg = true;
bModBreak = true;
cvCL.SetStartPoint(ptInter1);
}
else if (nHitFlag == 7) //终止侧延长线
{
bModFlg = true;
bModBreak = true;
cvCL.SetEndPoint(ptInter1);
}
//add by xlc on 120417 梁柱自动打断
if (g_bAutoBreak)
{
if (bModBreak)
{
Acad::ErrorStatus es = upgradeOpen();
if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
{
AcGePoint3d pt = cvCL.StartPoint();
pt.z = dElevS;
SetAt(KEY_START, pt);
pt = cvCL.EndPoint();
pt.z = dElevE;
SetAt(KEY_END, pt);
if (es == Acad::eOk)
{
downgradeOpen();
}
}
}
bool bBreak = false;
if(nHitFlag == 5) //交点在线内时对自己进行打断
{
if(BreakAt(ptInter1,NULL))
{
bModFlg = false;
bBreak = true;
}
}
bool bModifyOld = g_bModifyAgain;
pEnt->BreakAt(ptInter1, NULL);
g_bModifyAgain = bModifyOld;
if(bBreak)
{
break;
}
}
}
}
idObj = pEnt->objectId();
}
else
{
continue;
}
OPENOBJ_END();
if (!m_arAssocBWallIds.contains(idObj))
{
m_arAssocBWallIds.append(idObj);
}
}
else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
{
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbColumn, pEnt);
if (!pEnt)
{
continue;
}
TGGePoly2D polyDest;
pEnt->GetOutline(polyDest);
polyDest.SetElevation(0);
bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
//间隙小于梁宽一半时，当作关联处理
if (bRet && dGap < dWidth*0.5)
{
if (g_bAutoBreak)
{
AcGePoint3d pt = pEnt->GetLocation();
BreakAt(TADSGePoint3d(pt), &polyDest);
}
idObj = pEnt->objectId();
}
else
{
continue;
}
OPENOBJ_END();
if (!m_arColumnIds.contains(idObj))
{
m_arColumnIds.append(idObj);
}
}
else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
{
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruFloorSlab, pEnt);
if (!pEnt)
{
continue;
}
TGGePoly2D polyDest;
pEnt->GetOutline(polyDest);
polyDest.SetElevation(0);
// 判断间隙
bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
if (bRet && dGap < _DIST_SNAP)
{
idObj = pEnt->objectId();
}
else
{
continue;
}
OPENOBJ_END();
if (!m_arSlabIds.contains(idObj))
{
m_arSlabIds.append(idObj);
}
}
}
// 修改梁的端点
if (bModFlg)
{
Acad::ErrorStatus es = upgradeOpen();
if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
{
AcGePoint3d pt = cvCL.StartPoint();
pt.z = dElevS;
SetAt(KEY_START, pt);
pt = cvCL.EndPoint();
pt.z = dElevE;
SetAt(KEY_END, pt);
if (es == Acad::eOk)
{
downgradeOpen();
}
}
}
}
void TDbStruBeam::RemoveAssocRelation( AcDbObjectId& id )
{
m_arAssocBWallIds.remove(id);
m_arColumnIds.remove(id);
m_arSlabIds.remove(id);
}
void TDbStruBeam::GetThisBaseWallLine( TBaseWallLine& baseWall ) const
{
assertReadEnabled();
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
ptS.z = 0.0;
ptE.z = 0.0;
double dBulge = 0.0, dWidth = 0.0;
GetAt(KEY_BULGE, dBulge);
GetTotalWidth(dWidth);
TGGeVisibilityPoly2D left; // 左线
TGGeVisibilityPoly2D right; // 右线
if (fabs(dBulge) < g_angleZero) // 直线
{
// 偏移向量
AcGeVector3d vt = ptE - ptS;
vt.normalize();
vt.rotateBy(PI/2, AcGeVector3d::kZAxis);
// 墙线1
ptS += vt * dWidth * 0.5;
ptE += vt * dWidth * 0.5;
left.AppendNode(ptS);
left.AppendNode(ptE);
// 墙线2
ptS -= vt * dWidth;
ptE -= vt * dWidth;
right.AppendNode(ptS);
right.AppendNode(ptE);
}
else // 弧线
{
TADSGePoint3d ptStart = ptS, ptEnd = ptE;
// 创建新弧取圆心
TGGeArc arc(ptStart, ptEnd, dBulge);
AcGePoint3d ptCenter = arc.GetCenterPt();
// 创建偏移向量
AcGeVector3d vt1 = ptStart - ptCenter, vt2 = ptEnd - ptCenter;
vt1.normalize();
vt2.normalize();
vt1 *= dWidth * 0.5;
vt2 *= dWidth * 0.5;
// 创建弧梁
ptS = ptStart + vt1;
ptE = ptEnd + vt2;
right.AppendNode(ptS,dBulge);
right.AppendNode(ptE);
ptS = ptStart - vt1;
ptE = ptEnd - vt2;
left.AppendNode(ptS,dBulge);
left.AppendNode(ptE);
}
int nWeight = 0;
GetAt(KEY_WEIGHT, nWeight);
baseWall.SetLeftLine(left);
baseWall.SetRightLine(right);
baseWall.SetWeight(nWeight);
}
void TDbStruBeam::GetAssocBaseWallLine( TDPtrList<TBaseWallLine>& arBaseWallLinesS, TDPtrList<TBaseWallLine>& arBaseWallLinesM, TDPtrList<TBaseWallLine>& arBaseWallLinesE ) const
{
TBaseWallLine bwlThis;
GetThisBaseWallLine(bwlThis);
// 获得起点终点标高
double dEleS = 0.0, dEleE = 0.0;
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
dEleS = ptS.z;
dEleE = ptE.z;
TDbStruBeam *pBaseWall = NULL;
TBaseWallLine bwlThat;
double dH = GetSection2dHeight(); // 截面高度
int nIntegrateType = DocGetBeamRelCtl();//融合方式
for (int i = 0; i < m_arAssocBWallIds.length(); i++)
{
acdbOpenObject(pBaseWall, m_arAssocBWallIds[i], AcDb::kForRead);
if (pBaseWall != NULL)
{
pBaseWall->GetThisBaseWallLine(bwlThat);
double dH2 = pBaseWall->GetSection2dHeight();
pBaseWall->GetAt(KEY_START, ptS);
pBaseWall->GetAt(KEY_END, ptE);
pBaseWall->close();
// 获得起点终点标高
double dEleS1 = 0.0, dEleE1 = 0.0;
dEleS1 = ptS.z;
dEleE1 = ptE.z;
// 判断墙线融合方式
TBaseWallLine *pBWLine = new TBaseWallLine;
pBWLine->SetLeftLine(bwlThat.GetLeftLine());
pBWLine->SetRightLine(bwlThat.GetRightLine());
// 根据梁与梁的融合方式设置优先级
if (nIntegrateType) // 全部融合
{
pBWLine->SetWeight(bwlThis.GetWeight()); // 优先级设置为相同值
}
else if (fabs(dEleS - dEleS1) < _DIST_SNAP && fabs(dEleE - dEleE1) < _DIST_SNAP) // 等标高
{
if (fabs(dH2 - dH) < _DIST_SNAP)
{
pBWLine->SetWeight(bwlThis.GetWeight());
}
else if (dH > dH2)
{
pBWLine->SetWeight(bwlThis.GetWeight() - 1);
}
else
{
pBWLine->SetWeight(bwlThis.GetWeight() + 1);
}
}
else
{
delete pBWLine;
continue;
}
int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThis, bwlThat);
if (nType == 1) // 起始端融合
{
arBaseWallLinesS.Append(pBWLine);
}
else if (nType == 2) // 终止端融合
{
arBaseWallLinesE.Append(pBWLine);
}
else if (nType == 3) // 两端融合
{
arBaseWallLinesS.Append(pBWLine);
TBaseWallLine *pbWLineNew = new TBaseWallLine;
pbWLineNew->SetLeftLine(bwlThat.GetLeftLine());
pbWLineNew->SetRightLine(bwlThat.GetRightLine());
pbWLineNew->SetWeight(bwlThat.GetWeight());
arBaseWallLinesE.Append(pbWLineNew);
}
else // 墙体内融合（非墙体起点终点）
{
arBaseWallLinesM.Append(pBWLine);
}
}
}
}
bool TDbStruBeam::GetSection2d( TGGePoly2D& polyShape ) const
{
polyShape.Reset();
int nType = 0;
GetAt(KEY_SECTYP, nType);
switch(nType)
{
case ST_RECT: // 矩形
{
ConstructRectShape(polyShape);
break;
}
case ST_IBEAM: // 工字型
{
ConstructIShape(polyShape);
break;
}
default:
{
return false;
}
}
return true;
}
double TDbStruBeam::GetSection2dWidth() const
{
TADSGePoint3d ptMin, ptMax;
TGGePoly2D poly;
GetSection2d(poly);
if (poly.Length() > 0)
{
poly.GetExtend(ptMin, ptMax);
}
return fabs(ptMax.x - ptMin.x);
}
double TDbStruBeam::GetSection2dHeight() const
{
TADSGePoint3d ptMin, ptMax;
TGGePoly2D poly;
GetSection2d(poly);
if (poly.Length() > 0)
{
poly.GetExtend(ptMin, ptMax);
}
double dHeight = fabs(ptMax.y - ptMin.y);
return dHeight;
}
void TDbStruBeam::UpdatePts(double dDist)
{
double dOldVal = 0.0;
GetAt(KEY_EDIS, dOldVal);
if (fabs(dDist - dOldVal) < _DIST_SNAP)
{
return;
}
double dDist1 = dDist - dOldVal;
// 调整型心线位置即起点终点位置
double dBugle = 0.0;
GetAt(KEY_BULGE, dBugle);
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
if (fabs(dBugle) < g_angleZero) // 直线
{
AcGeVector3d vt = ptS - ptE;
vt.normalize();
vt.rotateBy(-PI/2, AcGeVector3d::kZAxis);
ptS += vt * dDist1;
ptE += vt * dDist1;
}
else // 弧线
{
TGGeArc arc(ptS, ptE, dBugle);
AcGePoint3d ptCenter;
ptCenter = arc.GetCenterPt();
AcGeVector3d vt = ptCenter - ptS;
vt.normalize();
ptS += vt * dDist1;
vt = ptCenter - ptE;
vt.normalize();
ptE += vt * dDist1;
}
SetAt(KEY_START, ptS);
SetAt(KEY_END, ptE);
}
bool TDbStruBeam::ConstructRectShape( TGGePoly2D& polyShape ) const
{
double dWidth = 0.0, dHeight = 0.0, dAng = 0.0;
GetAt(KEY_B, dWidth);
GetAt(KEY_H, dHeight);
GetAt(KEY_AXANG, dAng);
AcGePoint3d ptOrigin = AcGePoint3d::kOrigin;
AcGeVector3d vtX = AcGeVector3d::kXAxis;
vtX = vtX.rotateBy(dAng, AcGeVector3d::kZAxis);
AcGeVector3d vtY = vtX;
vtY = vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
AcGePoint3d ptLT = ptOrigin - vtX * dWidth * 0.5 + vtY * dHeight * 0.5;
AcGePoint3d ptRT = ptLT + vtX * dWidth;
AcGePoint3d ptLB = ptLT - vtY * dHeight;
AcGePoint3d ptRB = ptRT - vtY * dHeight;
polyShape.AppendNode(ptLT);
polyShape.AppendNode(ptRT);
polyShape.AppendNode(ptRB);
polyShape.AppendNode(ptLB);
polyShape.SetFlag(1);
return true;
}
bool TDbStruBeam::ConstructIShape( TGGePoly2D& polyShape ) const
{
double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0, dAngle = 0.0;
GetAt(KEY_B,dB);
GetAt(KEY_H,dH);
GetAt(KEY_U,dU);
GetAt(KEY_T,dT);
GetAt(KEY_D,dD);
GetAt(KEY_F,dF);
GetAt(KEY_AXANG, dAngle);
AcGePoint3d ptOrigin = AcGePoint3d::kOrigin;
AcGeVector3d vtX = AcGeVector3d::kXAxis;
vtX = vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
AcGeVector3d vtY = vtX;
vtY = vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
AcGePoint3d pt1 = ptOrigin - vtX * dU * 0.5 + vtY * dH * 0.5;
AcGePoint3d pt2 = pt1 + vtX * dU;
AcGePoint3d pt3 = pt2 - vtY * dT;
AcGePoint3d pt4 = pt3 - vtX * (dU - dB) * 0.5;
AcGePoint3d pt5 = pt4 - vtY * (dH - dF - dT);
AcGePoint3d pt6 = pt5 + vtX * (dD - dB) * 0.5;
AcGePoint3d pt7 = pt6 - vtY * dF;
AcGePoint3d pt8 = pt7 - vtX * dD;
AcGePoint3d pt9 = pt8 + vtY * dF;
AcGePoint3d pt10 = pt9 + vtX * (dD - dB) * 0.5;
AcGePoint3d pt11 = pt10 + vtY * (dH - dT - dF);
AcGePoint3d pt12 = pt11 - vtX * (dU - dB) * 0.5;
polyShape.AppendNode(pt1);
polyShape.AppendNode(pt2);
polyShape.AppendNode(pt3);
polyShape.AppendNode(pt4);
polyShape.AppendNode(pt5);
polyShape.AppendNode(pt6);
polyShape.AppendNode(pt7);
polyShape.AppendNode(pt8);
polyShape.AppendNode(pt9);
polyShape.AppendNode(pt10);
polyShape.AppendNode(pt11);
polyShape.AppendNode(pt12);
polyShape.SetFlag(1);
return true;
}
void TDbStruBeam::GetPolyBase(TGGePoly2D &polyBase) const
{
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
double dBulge = 0.0;
GetAt(KEY_BULGE,dBulge);
polyBase.AppendNode(ptS, dBulge);
polyBase.AppendNode(ptE);
}
bool TDbStruBeam::IsLinkColumn(bool bStart) const
{
// 查看端点是否发生融合
TBaseWallLine bwLine;
GetThisBaseWallLine(bwLine);
TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
TGGeVisibilityPoly2D right = bwLine.GetRightLine();
TADSGePoint3d pt1, pt2; // 端点
if (bStart) // 起点
{
pt1 = *left[0];
pt2 = *right[0];
}
else // 终点
{
pt1 = *left[left.Length() - 1];
pt2 = *right[right.Length() - 1];
}
AcDbLine line(pt1, pt2);
AcGePoint3dArray ptArr;
TDbColumn *pStruColumn = NULL;
for (int i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
TGGePoly2D poly2d;
pStruColumn->GetOutline(poly2d);
pStruColumn->Close();
poly2d.SetElevation(0.0);
pt1.z = 0.0;
pt2.z = 0.0;
if (((pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE)
||((pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE))
{
return true;
}
AcDbCurve *pCurve = poly2d.AsAcDbCurve();
if (pCurve != NULL && pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr) == Acad::eOk
&& ptArr.length() > 0)
{
return true;
}
}
}
return false;
}
Acad::ErrorStatus TDbStruBeam::DrawSideLine2d(bool bStart, TGGiExplodeDrawBase &dc) const
{
// 查看端点与柱子是否发生融合
TBaseWallLine bwLine;
GetThisBaseWallLine(bwLine);
TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
TGGeVisibilityPoly2D right = bwLine.GetRightLine();
TADSGePoint3d pt1, pt2; // 端点
if (bStart) // 起点
{
pt1 = *left[0];
pt2 = *right[0];
}
else // 终点
{
pt1 = *left[left.Length() - 1];
pt2 = *right[right.Length() - 1];
}
AcDbLine line(pt1, pt2);
TDbColumn *pStruColumn = NULL;
for (int i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
TGGePoly2D poly2d;
pStruColumn->GetOutline(poly2d);
pStruColumn->Close();
bool bLink1 = (pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE;
bool bLink2 = (pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE;
if ((bLink1 && !bLink2) || (!bLink1 && bLink2)) // 端点只要一点与柱子相连时，墙体部分封口
{
TADSGePoint3d pt;
if (bLink1 && !bLink2)
{
pt = pt2;
}
else
{
pt = pt1;
}
AcDbLine line(pt1,pt2);
AcDbCurve *pCurve = poly2d.AsAcDbCurve();
AcGePoint3dArray arrPt;
line.intersectWith(pCurve, AcDb::kOnBothOperands, arrPt);
if (arrPt.length() == 1)
{
pt1 = arrPt[0]; // 将AcGePoint3d转化为TADSGePoint3d
dc << TGGeLine(pt, pt1);
}
else if (arrPt.length() > 1)
{
std::map<double, TADSGePoint3d> data;
for (int i = 0; i < arrPt.length(); i++)
{
data.insert(std::make_pair(pt.Distance(arrPt[i]), arrPt[i]));
}
//获得最近的交点
pt1 = (*data.begin()).second;
dc << TGGeLine(pt1, pt);
}
break;
}
else if (!bLink1 && !bLink2) // 两点都与poly2d不相连
{
AcGePoint3dArray ptArr;
AcDbCurve *pCurve = poly2d.AsAcDbCurve();
if (pCurve != NULL)
{
pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr);
if (ptArr.length() == 1)
{
dc << TGGeLine(pt1, pt2);
break;
}
else if (ptArr.length() == 2)
{
double dDist1 = 0.0, dDist2 = 0.0;
dDist1 = pt1.Distance(ptArr[0]);
dDist2 = pt1.Distance(ptArr[1]);
if(dDist2 > dDist1)
{
dc << TGGeLine(pt1, asDblArray(ptArr[0]));
}
else
{
dc << TGGeLine(pt1, asDblArray(ptArr[1]));
}
dDist1 = pt2.Distance(ptArr[0]);
dDist2 = pt2.Distance(ptArr[1]);
if(dDist2 > dDist1)
{
dc << TGGeLine(pt2, asDblArray(ptArr[0]));
}
else
{
dc << TGGeLine(pt2, asDblArray(ptArr[1]));
}
break;
}
}
}
}
}
return Acad::eOk;
}
Acad::ErrorStatus TDbStruBeam::DrawSideLine2d(bool bStart, const AcDbObjectId &idWall, const TBaseWallLine &wallLine, TGGiExplodeDrawBase &dc) const
{
TDbStruBeam *pBeam = NULL;
acdbOpenObject(pBeam, idWall, AcDb::kForRead);
if (pBeam != NULL)
{
TBaseWallLine bwlThat;
pBeam->GetThisBaseWallLine(bwlThat);
int nThatWeight = 0;
pBeam->GetAt(KEY_WEIGHT, nThatWeight);
pBeam->close();
// 判断墙线融合方式
TADSGePoint3d ptThat1,ptThat2;
TBaseWallLine bwlThis;
GetThisBaseWallLine(bwlThis);
int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
if (nType == 1) // 起始端相交
{
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
ptThat1 = *leftThat[0];
ptThat2 = *rightThat[0];
}
else if (nType == 2) // 终止端相交
{
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
ptThat1 = *leftThat[leftThat.Length() - 1];
ptThat2 = *rightThat[leftThat.Length() - 1];
}
else
{
return Acad::eOk;
}
if (!!ptThat1 && !!ptThat2)
{
TADSGePoint3d ptThis1,ptThis2;
TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
if (bStart)
{
ptThis1 = *leftThis[0];
ptThis2 = *rightThis[0];
}
else
{
ptThis1 = *leftThis[leftThis.Length() - 1];
ptThis2 = *rightThis[rightThis.Length() - 1];
}
AcGeVector3d vtThat = ptThat1 - ptThat2;
AcGeVector3d vtThis = ptThis1 - ptThis2;
int nThisWeight = 0;
GetAt(KEY_WEIGHT, nThisWeight);
if (vtThis.isParallelTo(vtThat)) // 端点连线平行
{
if (nThisWeight < nThatWeight) // 比较优先级
{
dc << TGGeLine(ptThis1, ptThis2);
}
else
{
bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP)
|| (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
if (!bSuperposition)
{
// 将that的融合端点投影到this融合端点连线的直线上
std::vector<TADSGePoint3d> vecPt;
vecPt.push_back(ptThis1);
vecPt.push_back(ptThis2);
TADSGePoint3d pt;
TGGeLine line(ptThis1, ptThis2);
ptThat1.Project(&line, pt);
vecPt.push_back(pt);
ptThat2.Project(&line, pt);
vecPt.push_back(pt);
// 求两点间的距离
std::map<double, std::vector<TADSGePoint3d> > mapData;
std::vector<TADSGePoint3d> vecTemp;
std::vector<TADSGePoint3d>::iterator it1, it2;
for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
{
it2 = it1;
++it2;
for (; it2 != vecPt.end(); it2++)
{
vecTemp.clear();
vecTemp.push_back(*it1);
vecTemp.push_back(*it2);
mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
}
}
// 获取距离最远的点
std::map<double, std::vector<TADSGePoint3d> >::iterator it;
it = mapData.end();
--it;
vecTemp.clear();
vecTemp.push_back((*it).second[0]);
vecTemp.push_back((*it).second[1]);
// 从vecPt中删除最远的两点
for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
{
for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
{
if ((*it1).Distance(*it2) < _DIST_SNAP)
{
vecPt.erase(it2);
break;;
}
}
}
// this的融合端点是否与最远点重合
if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
{
double dDist1 = ptThis1.Distance(vecPt[0]);
double dDist2 = ptThis1.Distance(vecPt[1]);
if (dDist1 < dDist2)
{
dc << TGGeLine(ptThis1, vecPt[0]);
}
else
{
dc << TGGeLine(ptThis1, vecPt[1]);
}
}
if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
{
double dDist1 = ptThis2.Distance(vecPt[0]);
double dDist2 = ptThis2.Distance(vecPt[1]);
if (dDist1 < dDist2)
{
dc << TGGeLine(ptThis2, vecPt[0]);
}
else
{
dc << TGGeLine(ptThis2, vecPt[1]);
}
}
}
}
}
else if (nThatWeight != nThisWeight) // 优先级不同
{
TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
TGGeVisibilityPoly2D right = wallLine.GetRightLine();
if (bStart)
{
dc << TGGeLine(*left[0], *right[0]);
}
else
{
dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
}
}
}
}
return Acad::eOk;
}
void TDbStruBeam::GetPoly2D(TGGePoly2D &poly2d) const
{
TBaseWallLine wallLine;
GetThisBaseWallLine(wallLine);
TGGeVisibilityPoly2D left, right;
left = wallLine.GetLeftLine();
right = wallLine.GetRightLine();
AcDbPolyline* pLwPoly = new AcDbPolyline();
double dBuge = 0.0;
int nIndex = 0;
for (int i = 0; i < left.Length(); i++)
{
dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
++nIndex;
}
for (i = left.Length() - 1; i >= 0; i--)
{
if (i > 0)
{
dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
}
else
{
dBuge = 0.0;
}
pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
++nIndex;
}
pLwPoly->setClosed(Adesk::kTrue);
poly2d.SetAcDbCurve(pLwPoly);
delete pLwPoly;
}
bool TDbStruBeam::GetBasePoint(AcGePoint3d &ptBase) const
{
ptBase = AcGePoint3d::kOrigin;
int nType = 0;
GetAt(KEY_SECTYP, nType);
switch(nType)
{
case ST_RECT: // 矩形
{
double dHeight = 0.0, dAng = 0.0;
GetAt(KEY_H, dHeight);
GetAt(KEY_AXANG, dAng);
AcGeVector3d vtY = AcGeVector3d::kXAxis;
vtY = vtY.rotateBy(PI / 2 + dAng, AcGeVector3d::kZAxis);
ptBase = AcGePoint3d::kOrigin + vtY * dHeight * 0.5;
break;
}
case ST_IBEAM: // 工字型
{
double dH = 0.0, dAngle = 0.0;
GetAt(KEY_H,dH);
GetAt(KEY_AXANG, dAngle);
AcGePoint3d ptOrigin = AcGePoint3d::kOrigin;
AcGeVector3d vtY = AcGeVector3d::kXAxis;
vtY = vtY.rotateBy(PI / 2 + dAngle, AcGeVector3d::kZAxis);
ptBase= ptOrigin + vtY * dH * 0.5;
break;
}
default:
{
return false;
}
}
return true;
}
void TDbStruBeam::GetBaseLine(TGGeCurveSegment &seg) const
{
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
double dBulge = 0.0;
GetAt(KEY_BULGE,dBulge);
TGGeCurveSegment segTemp(ptS, ptE, dBulge);
seg = segTemp;
}
void TDbStruBeam::CopyData(TDbStruBeam *pBeam)
{
if (pBeam == NULL)
{
return;
}
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge);
/*int nType = 0;
GetAt(KEY_SECTYP, nType);
double dAng = 0.0;
GetAt(KEY_AXANG, dAng);
double dWidth = 0.0, dHeight = 0.0;
GetAt(KEY_SUMB, dWidth);
GetAt(KEY_SUMH, dHeight);
switch(nType)
{
case ST_RECT: // 矩形
{
double dB = 0.0, dH = 0.0;
GetAt(KEY_B, dB);
GetAt(KEY_H, dH);
GetSpecialtyData()->Empty();
*GetSpecialtyData() = *pBeam->GetSpecialtyData();
SetAt(KEY_B, dB);
SetAt(KEY_H, dH);
break;
}
case ST_IBEAM: // 工字型
{
double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0;
GetAt(KEY_B,dB);
GetAt(KEY_H,dH);
GetAt(KEY_U,dU);
GetAt(KEY_T,dT);
GetAt(KEY_D,dD);
GetAt(KEY_F,dF);
GetSpecialtyData()->Empty();
*GetSpecialtyData() = *pBeam->GetSpecialtyData();
SetAt(KEY_B,dB);
SetAt(KEY_H,dH);
SetAt(KEY_U,dU);
SetAt(KEY_T,dT);
SetAt(KEY_D,dD);
SetAt(KEY_F,dF);
break;
}
}*/
GetSpecialtyData()->Empty();
*GetSpecialtyData() = *pBeam->GetSpecialtyData();
SetAt(KEY_START, ptS);
SetAt(KEY_END, ptE);
SetAt(KEY_BULGE, dBulge);
/*SetAt(KEY_SECTYP, nType);
SetAt(KEY_AXANG, dAng);
SetAt(KEY_SUMB, dWidth);
SetAt(KEY_SUMH, dHeight);*/
}
void TDbStruBeam::GetPoly2dBehindIntegrate(TGGePoly2D &poly2d) const
{
assertReadEnabled();
TBaseWallLine bwlThis;
GetThisBaseWallLine(bwlThis);
// 梁与柱融合
TDbColumn *pStruColumn = NULL;
for (int i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
TGGePoly2D poly2d;
pStruColumn->GetOutline(poly2d);
pStruColumn->Close();
poly2d.SetElevation(0.0);
TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
}
}
TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
// 起点融合
TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
// 终点融合
TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
// 端点融合后新生成的梁线
TGGeVisibilityPoly2D left, right;
left = bwlThis.GetLeftLine();
right = bwlThis.GetRightLine();
// 删除端点出不可见的梁线
DeleteInVisiblePt(true, left);
DeleteInVisiblePt(false,left);
DeleteInVisiblePt(true, right);
DeleteInVisiblePt(false, right);
// 有left,right生成闭合poly2d
AcDbPolyline* pLwPoly = new AcDbPolyline();
double dBuge = 0.0;
int nIndex = 0;
for (i = 0; i < left.Length(); i++)
{
dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
++nIndex;
}
for (i = right.Length() - 1; i >= 0; i--)
{
if (i > 0)
{
dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
}
else
{
dBuge = 0.0;
}
pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
++nIndex;
}
pLwPoly->setClosed(Adesk::kTrue);
poly2d.SetAcDbCurve(pLwPoly);
delete pLwPoly;
}
void TDbStruBeam::DeleteInVisiblePt(bool bStart, TGGeVisibilityPoly2D &poly) const
{
if (bStart) // 删除起点处不可见的点
{
for (int i = 0; i < poly.Length(); i++)
{
if (poly.GetVisibleAt(i) == AcDb::kInvisible)
{
poly.RemoveNode(i);
continue;
}
break;
}
}
else // 删除终点处不可见的点
{
for (int i = poly.Length() - 1; i >= 0 ; i--)
{
if (poly.GetVisibleAt(i) == AcDb::kInvisible && i > 0 && poly.GetVisibleAt(i - 1) == AcDb::kInvisible)
{
poly.RemoveNode(i);
continue;
}
break;
}
}
}
Acad::ErrorStatus TDbStruBeam::DrawWeightLine2d(TGGiExplodeDrawBase &dc) const
{
// 获取融合后的poly2d
TGGeVisibilityPoly2D poly;
GetIntegratedPoly2d(poly);
poly.Compress();
// dc.SetColor(1);
// TGGeCurveSegment seg;
// for (int j = 0; j < poly.Length(); j++)
// {
// if (poly.GetVisibleAt(j) == AcDb::kInvisible)
// {
// continue;
// }
//
// poly.Nth(j, seg);
// dc << seg;
// }
// return Acad::eOk;
int nMatTyp = MAT_CONCRETE;
GetAt(KEY_MATTYP, nMatTyp);
double dLineWidth = 0; //加粗线宽
switch (nMatTyp)
{
case MAT_CONCRETE: //混凝土梁
dLineWidth = DocGetConBeamLWeight();
break;
case MAT_STEEL: //钢梁
dLineWidth = DocGetStlBeamLWeight();
break;
}
dLineWidth *= GetPScale();
TGGePoly2D polyDest;
if (poly.PathArea() > 0) // 顺时针
{
poly.Offset(dLineWidth, polyDest);
}
else
{
poly.Offset(dLineWidth * (-1), polyDest);
}
if (poly.Length() != polyDest.Length())
{
return Acad::eInvalidInput;
}
TGGePoly2D poly2dNew;
for (int i = 0; i < poly.Length() - 1; i++)
{
if (poly.GetVisibleAt(i) == AcDb::kInvisible)
{
continue;
}
poly2dNew.Reset();
poly2dNew.AppendNode(*poly[i], *(poly.m_ardbulges[i]));
poly2dNew.AppendNode(*poly[i+1]);
poly2dNew.AppendNode(*polyDest[i+1], *(polyDest.m_ardbulges[i]) * (-1));
poly2dNew.AppendNode(*polyDest[i]);
poly2dNew.SetClosed();
dc << TGGeSolid(poly2dNew);
}
if (poly.GetVisibleAt(poly.Length() - 1) == AcDb::kVisible)
{
poly2dNew.Reset();
poly2dNew.AppendNode(*poly[poly.Length() - 1], *(poly.m_ardbulges[poly.Length() - 1]));
poly2dNew.AppendNode(*poly[0]);
poly2dNew.AppendNode(*polyDest[0], *(polyDest.m_ardbulges[polyDest.Length() - 1]) * (-1));
poly2dNew.AppendNode(*polyDest[polyDest.Length() - 1]);
poly2dNew.SetClosed();
dc << TGGeSolid(poly2dNew);
}
return Acad::eOk;
}
void TDbStruBeam::GetIntegratedPoly2d(TGGeVisibilityPoly2D &poly) const
{
// 双线绘制样式
TBaseWallLine bwlThis;
GetThisBaseWallLine(bwlThis);
// 梁与柱融合
TDbColumn *pStruColumn = NULL;
for (int i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
TGGePoly2D poly2d;
pStruColumn->GetOutline(poly2d);
pStruColumn->Close();
poly2d.SetElevation(0.0);
TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
}
}
// 梁与梁融合
TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
// 起点融合
TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
// 终点融合
TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
// 梁内融合
for (i = 0; i < arBaseWallLinesM.Length(); i++)
{
TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
}
// 生成poly2d
// 添加左线
TGGeVisibilityPoly2D left, right;
left = bwlThis.GetLeftLine();
right = bwlThis.GetRightLine();
for (i = 0; i < left.Length(); i++)
{
poly.AppendNode(*left[i], *(left.m_ardbulges[i]), left.GetVisibleAt(i));
}
// 添加终点封口线
int nLen = arBaseWallLinesE.Length();
bool bHasColumn = IsLinkColumn(false);
if (arBaseWallLinesE.Length() == 0 && !bHasColumn) // 终点封口
{
if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
{
poly.AppendNode(*left[left.Length() - 1]);
poly.AppendNode(*right[right.Length() - 1]);
}
}
else if (nLen == 1 && !bHasColumn) // 处理终点处有一个融合墙体时，墙体端点两点连线平行的情况
{
AcDbObjectId id;
GetWallId(false, id);
TGGeVisibilityPoly2D polyNew;
GetSideLine2d(false, id, bwlThis, polyNew);
polyNew.Compress();
for (int i = 0; i < polyNew.Length(); i++)
{
poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
}
// 未封口时，设置为不可见
if (polyNew.Length() == 0)
{
poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible); // 改变点的可见性
}
}
else if (nLen == 0 && bHasColumn) // 终点关联柱子
{
TGGeVisibilityPoly2D polyNew;
GetIntegratedPoly2dForColumn(false, polyNew);
polyNew.Compress();
for (int i = 0; i < polyNew.Length(); i++)
{
poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
}
}
else
{
poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible); // 改变点的可见性
}
// 添加右线
right.Reverse();
for (i = 0; i < right.Length(); i++)
{
poly.AppendNode(*right[i], *(right.m_ardbulges[i]), right.GetVisibleAt(i));
}
// 添加起点封口线
nLen = arBaseWallLinesS.Length();
bHasColumn = IsLinkColumn(true);
if (nLen == 0 && !bHasColumn) // 起点封口
{
if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
{
poly.AppendNode(*right[right.Length() - 1]); // right 已逆转方向
poly.AppendNode(*left[0]);
}
}
else if (nLen == 1 && !bHasColumn) // 处理起点处有一个融合墙体时，墙体端点两点连线平行的情况
{
AcDbObjectId id;
GetWallId(true, id);
TGGeVisibilityPoly2D polyNew;
GetSideLine2d(true, id, bwlThis, polyNew);
polyNew.Compress();
polyNew.Reverse();
for (int i = 0; i < polyNew.Length(); i++)
{
poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
}
// 未封口时，设置为不可见
if (polyNew.Length() == 0)
{
poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible); // 改变点的可见性
}
}
else if (nLen == 0 && bHasColumn) // 起点关联柱子
{
TGGeVisibilityPoly2D polyNew;
GetIntegratedPoly2dForColumn(true, polyNew);
polyNew.Compress();
polyNew.Reverse();
for (int i = 0; i < polyNew.Length(); i++)
{
poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
}
}
else
{
poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible); // 改变点的可见性
}
poly.SetClosed();
}
void TDbStruBeam::GetSideLine2d(bool bStart, const AcDbObjectId &idBeam, const TBaseWallLine &wallLine, TGGeVisibilityPoly2D &poly) const
{
poly.Reset();
TDbStruBeam *pBeam = NULL;
acdbOpenObject(pBeam, idBeam, AcDb::kForRead);
if (pBeam != NULL)
{
TBaseWallLine bwlThat;
pBeam->GetThisBaseWallLine(bwlThat);
int nThatWeight = 0;
pBeam->GetAt(KEY_WEIGHT, nThatWeight);
pBeam->close();
// 判断墙线融合方式
TADSGePoint3d ptThat1,ptThat2;
TBaseWallLine bwlThis;
GetThisBaseWallLine(bwlThis);
int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
if (nType == 1) // 起始端相交
{
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
ptThat1 = *leftThat[0];
ptThat2 = *rightThat[0];
}
else if (nType == 2) // 终止端相交
{
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
ptThat1 = *leftThat[leftThat.Length() - 1];
ptThat2 = *rightThat[leftThat.Length() - 1];
}
else
{
return;
}
if (!!ptThat1 && !!ptThat2)
{
TADSGePoint3d ptThis1,ptThis2;
TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
if (bStart)
{
ptThis1 = *leftThis[0];
ptThis2 = *rightThis[0];
}
else
{
ptThis1 = *leftThis[leftThis.Length() - 1];
ptThis2 = *rightThis[rightThis.Length() - 1];
}
AcGeVector3d vtThat = ptThat1 - ptThat2;
AcGeVector3d vtThis = ptThis1 - ptThis2;
int nThisWeight = 0;
GetAt(KEY_WEIGHT, nThisWeight);
if (vtThis.isParallelTo(vtThat)) // 端点连线平行
{
if (nThisWeight < nThatWeight) // 比较优先级
{
poly.AppendNode(ptThis1);
poly.AppendNode(ptThis2);
}
else
{
bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP)
|| (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
if (!bSuperposition)
{
// 将that的融合端点投影到this融合端点连线的直线上
std::vector<TADSGePoint3d> vecPt;
vecPt.push_back(ptThis1);
vecPt.push_back(ptThis2);
TADSGePoint3d pt;
TGGeLine line(ptThis1, ptThis2);
ptThat1.Project(&line, pt);
vecPt.push_back(pt);
ptThat2.Project(&line, pt);
vecPt.push_back(pt);
// 求两点间的距离
std::map<double, std::vector<TADSGePoint3d> > mapData;
std::vector<TADSGePoint3d> vecTemp;
std::vector<TADSGePoint3d>::iterator it1, it2;
for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
{
it2 = it1;
++it2;
for (; it2 != vecPt.end(); it2++)
{
vecTemp.clear();
vecTemp.push_back(*it1);
vecTemp.push_back(*it2);
mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
}
}
// 获取距离最远的点
std::map<double, std::vector<TADSGePoint3d> >::iterator it;
it = mapData.end();
--it;
vecTemp.clear();
vecTemp.push_back((*it).second[0]);
vecTemp.push_back((*it).second[1]);
// 从vecPt中删除最远的两点
for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
{
for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
{
if ((*it1).Distance(*it2) < _DIST_SNAP)
{
vecPt.erase(it2);
break;;
}
}
}
// this的融合端点是否与最远点重合
if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
{
double dDist1 = ptThis1.Distance(vecPt[0]);
double dDist2 = ptThis1.Distance(vecPt[1]);
if (dDist1 < dDist2)
{
poly.AppendNode(ptThis1);
poly.AppendNode(vecPt[0], 0.0, AcDb::kInvisible);
}
else
{
poly.AppendNode(ptThis1);
poly.AppendNode(vecPt[1], 0.0, AcDb::kInvisible);
}
}
if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
{
double dDist1 = ptThis2.Distance(vecPt[0]);
double dDist2 = ptThis2.Distance(vecPt[1]);
if (dDist1 < dDist2)
{
poly.AppendNode(vecPt[0]);
poly.AppendNode(ptThis2);
}
else
{
poly.AppendNode(vecPt[1]);
poly.AppendNode(ptThis2);
}
}
if (poly.Length() == 0)
{
poly.AppendNode(ptThis1, 0.0, AcDb::kInvisible);
poly.AppendNode(ptThis2, 0.0, AcDb::kInvisible);
}
}
}
}
else if (nThatWeight != nThisWeight) // 优先级不同
{
TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
TGGeVisibilityPoly2D right = wallLine.GetRightLine();
if (bStart)
{
poly.AppendNode(*left[0]);
poly.AppendNode(*right[0]);
}
else
{
poly.AppendNode(*left[left.Length() - 1]);
poly.AppendNode(*right[right.Length() - 1]);
}
}
}
}
}
void TDbStruBeam::GetIntegratedPoly2dForColumn(bool bStart, TGGeVisibilityPoly2D &poly) const
{
poly.Reset();
// 查看端点与柱子是否发生融合
TBaseWallLine bwLine;
GetThisBaseWallLine(bwLine);
TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
TGGeVisibilityPoly2D right = bwLine.GetRightLine();
TADSGePoint3d pt1, pt2; // 端点
if (bStart) // 起点
{
pt1 = *left[0];
pt2 = *right[0];
}
else // 终点
{
pt1 = *left[left.Length() - 1];
pt2 = *right[right.Length() - 1];
}
pt1.z = 0.0;
pt2.z = 0.0;
AcDbLine line(pt1, pt2);
TDbColumn *pStruColumn = NULL;
for (int i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
TGGePoly2D poly2d;
pStruColumn->GetOutline(poly2d);
pStruColumn->Close();
poly2d.SetElevation(0.0);
bool bLink1 = (pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE;
bool bLink2 = (pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE;
// 端点只要一点与柱子相连时，墙体部分封口
if ((bLink1 && !bLink2) || (!bLink1 && bLink2))
{
TADSGePoint3d pt;
if (bLink1 && !bLink2)
{
pt = pt2;
}
else
{
pt = pt1;
}
AcDbLine line(pt1,pt2);
AcDbCurve *pCurve = poly2d.AsAcDbCurve();
AcGePoint3dArray arrPt;
line.intersectWith(pCurve, AcDb::kOnBothOperands, arrPt);
if (arrPt.length() == 1)
{
if (bLink1 && !bLink2)
{
poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
poly.AppendNode(arrPt[0]);
poly.AppendNode(pt2);
}
else
{
poly.AppendNode(pt1);
poly.AppendNode(arrPt[0], 0.0, AcDb::kInvisible);
poly.AppendNode(pt2);
}
}
else if (arrPt.length() > 1)
{
std::map<double, TADSGePoint3d> data;
for (int i = 0; i < arrPt.length(); i++)
{
data.insert(std::make_pair(pt.Distance(arrPt[i]), arrPt[i]));
}
if (bLink1 && !bLink2)
{
poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
poly.AppendNode((*data.begin()).second);
poly.AppendNode(pt2);
}
else
{
poly.AppendNode(pt1);
poly.AppendNode((*data.begin()).second, 0.0, AcDb::kInvisible);
poly.AppendNode(pt2);
}
}
break;
}
else if (!bLink1 && !bLink2) // 两点都与poly2d不相连
{
AcGePoint3dArray ptArr;
AcDbCurve *pCurve = poly2d.AsAcDbCurve();
if (pCurve != NULL)
{
pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr);
if (ptArr.length() == 1)
{
poly.AppendNode(pt1);
poly.AppendNode(pt2);
break;
}
else if (ptArr.length() == 2)
{
double dDist1 = 0.0, dDist2 = 0.0;
dDist1 = pt1.Distance(ptArr[0]);
dDist2 = pt1.Distance(ptArr[1]);
if(dDist2 > dDist1)
{
poly.AppendNode(pt1);
poly.AppendNode(asDblArray(ptArr[0]), 0.0, AcDb::kInvisible);
poly.AppendNode(pt2);
}
else
{
poly.AppendNode(pt1);
poly.AppendNode(asDblArray(ptArr[1]), 0.0, AcDb::kInvisible);
poly.AppendNode(pt2);
}
dDist1 = pt2.Distance(ptArr[0]);
dDist2 = pt2.Distance(ptArr[1]);
if(dDist2 > dDist1)
{
poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
poly.AppendNode(asDblArray(ptArr[0]));
poly.AppendNode(pt2);
}
else
{
poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
poly.AppendNode(asDblArray(ptArr[1]));
poly.AppendNode(pt2);
}
break;
}
}
}
if (poly.Length() == 0)
{
poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
poly.AppendNode(pt2);
}
}
}
}
void TDbStruBeam::GetCoverSlab(AcDbObjectIdArray& idArr) const
{
//modify by cet 111206 多边形时部分遮挡有问题
//TBaseWallLine baseWallLine;
//GetThisBaseWallLine(baseWallLine);
//TGGeVisibilityPoly2D left = baseWallLine.GetLeftLine();
//TGGeVisibilityPoly2D right = baseWallLine.GetRightLine();
//left.SetElevation(0.0);
//right.SetElevation(0.0);
//AcDbPolyline *pLeft = static_cast<AcDbPolyline*>(left.AsAcDbCurve());
//if (pLeft == NULL)
//{
// return;
//}
//
//AcDbPolyline *pRight = static_cast<AcDbPolyline*>(right.AsAcDbCurve());
//if (pRight == NULL)
//{
// return;
//}
//
//AcGePoint3dArray ptArrLeft, ptArrRight;
//AcGePoint3d pt;
//GetAt(KEY_START, pt);
//double dBeamEle = pt.z;
//for (int i = 0; i < m_arSlabIds.length(); i++)
//{
// TDbStruFloorSlab *pSlab = NULL;
// acdbOpenObject(pSlab, m_arSlabIds[i], AcDb::kForRead);
// if (pSlab != NULL)
// {
// double dSlabElev = pSlab->GetTopElev();
// if (dSlabElev > dBeamEle || fabs(dSlabElev - dBeamEle) < _DIST_SNAP)
// {
// TGGePoly2D poly;
// pSlab->GetOutline(poly);
// poly.SetElevation(0.0);
// AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
// if (pLine != NULL)
// {
// ptArrLeft.setLogicalLength(0);
// ptArrRight.setLogicalLength(0);
// pLine->intersectWith(pLeft, AcDb::kOnBothOperands, ptArrLeft);
// pLine->intersectWith(pRight,AcDb::kOnBothOperands, ptArrRight);
//
// if (ptArrLeft.length() > 0 || ptArrRight.length() > 0)
// {
// idArr.append(m_arSlabIds[i]);
// }
// delete pLine;
// }
// }
// pSlab->close();
// }
//}
//
//delete pLeft;
//delete pRight;
TGGePoly2D poly;
GetPoly2D(poly);
poly.SetElevation(0.0);
AcDbPolyline *pWallLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
if (pWallLine == NULL)
{
return;
}
AcGePoint3dArray ptArr;
AcGePoint3d pt;
GetAt(KEY_START, pt);
double dBeamEle = pt.z;
for (int i = 0; i < m_arSlabIds.length(); i++)
{
TDbStruFloorSlab *pSlab = NULL;
acdbOpenObject(pSlab, m_arSlabIds[i], AcDb::kForRead);
if (pSlab != NULL)
{
double dSlabElev = pSlab->GetTopElev();
if (dSlabElev > dBeamEle || fabs(dSlabElev - dBeamEle) < _DIST_SNAP)
{
TGGePoly2D poly;
pSlab->GetOutline(poly);
poly.SetElevation(0.0);
AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
if (pLine != NULL)
{
ptArr.setLogicalLength(0);
pLine->intersectWith(pWallLine, AcDb::kOnBothOperands, ptArr);
if (ptArr.length() > 0)
{
idArr.append(m_arSlabIds[i]);
}
delete pLine;
}
}
pSlab->close();
}
}
delete pWallLine;
}
Acad::ErrorStatus TDbStruBeam::DrawBeamLine2dForCoverSlab(TGGiExplodeDrawBase &dc, const TGGeVisibilityPoly2D &poly) const
{
AcDbObjectIdArray idArr;
GetCoverSlab(idArr);
TGGeCurveSegment seg;
AcDb::Visibility eVal;
TDbStruFloorSlab *pSlab = NULL;
TGGePoly2D polySlab;
std::vector<TGGeCurveSegment> vecSeg1, vecSeg2; // 保存生成的实线虚线
for (int i = 0; i < poly.TotalSegments(); i++)
{
poly.Nth(i, seg, &eVal);
if (eVal == AcDb::kVisible)
{
for (int j = 0; j < idArr.length(); j++)
{
acdbOpenObject(pSlab, idArr[j], AcDb::kForRead);
if (pSlab != NULL)
{
polySlab.Reset();
pSlab->GetOutline(polySlab);
pSlab->close();
polySlab.SetElevation(0.0);
GetSegmentForSlab2d(polySlab, seg, vecSeg1, vecSeg2);
}
}
}
}
// 过滤，剪切实线虚线
FiltrateSegment(vecSeg1, vecSeg2);
std::vector<TGGeCurveSegment>::iterator it;
for (it = vecSeg1.begin(); it < vecSeg1.end(); it++)
{
dc << *it;
}
//Adesk::UInt16 nColor = dc.GetColor();
//dc.SetColor(1);
AcDbObjectId idOldLine = dc.GetLineTypeId();
dc.SetLineType(InitLineType(_T("DASHED"),database()));
for (it = vecSeg2.begin(); it < vecSeg2.end(); it++)
{
dc << *it;
}
//dc.SetColor(nColor);
dc.SetLineType(idOldLine);
return Acad::eOk;
}
void TDbStruBeam::GetClipedPoly2d(std::vector<TGGePoly2D> &vecPoly) const
{
TGGePoly2D poly2d;
TDbColumn *pStruColumn = NULL;
for (int i = 0; i < m_arColumnIds.length(); i++)
{
acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
if (pStruColumn != NULL)
{
poly2d.Reset();
pStruColumn->GetOutline(poly2d);
vecPoly.push_back(poly2d);
pStruColumn->Close();
}
}
// 获得起点终点标高
double dEleS = 0.0, dEleE = 0.0;
AcGePoint3d ptS, ptE;
GetAt(KEY_START, ptS);
GetAt(KEY_END, ptE);
dEleS = ptS.z;
dEleE = ptE.z;
double dH = GetSection2dHeight(); // 截面高度
int nIntegrateType = DocGetBeamRelCtl();//融合方式
TDbStruBeam *pBeam = NULL;
for(i = 0; i < m_arAssocBWallIds.length(); i++)
{
acdbOpenObject(pBeam, m_arAssocBWallIds[i], AcDb::kForRead);
if (pBeam != NULL)
{
// 获得起点终点标高
pBeam->GetAt(KEY_START, ptS);
pBeam->GetAt(KEY_END, ptE);
double dEleS1 = 0.0, dEleE1 = 0.0;
dEleS1 = ptS.z;
dEleE1 = ptE.z;
double dH2 = pBeam->GetSection2dHeight();
pBeam->close();
if (!nIntegrateType &&fabs(dEleS - dEleS1) < _DIST_SNAP && fabs(dEleE - dEleE1) < _DIST_SNAP) // 等标高
{
if (dH < dH2)
{
poly2d.Reset();
pBeam->GetPoly2dBehindIntegrate(poly2d);
vecPoly.push_back(poly2d);
}
}
}
}
}
void TDbStruBeam::AssociateMove( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
AcGePoint3d ptS;
GetAt(KEY_START, ptS);
AcGePoint3d ptE;
GetAt(KEY_END, ptE);
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge);
// 限制在平面移动
AcGeVector3d vtOffset = offset;
vtOffset.z = 0.0;
int nIndex = indices[0];
if (nIndex == 0) // 起点
{
// 将拖动方向限制在剪力墙方向
if (fabs(dBulge) < g_angleZero) // 直线 沿线方向拉伸缩短
{
TGGeLine line(asDblArray(ptS), asDblArray(ptE));
TADSGePoint3d ptTemp;
ptTemp = ptS + vtOffset;
ptTemp.Project(&line, ptTemp);
vtOffset = ptTemp - ptS;
ptS += vtOffset;
SetAt(KEY_START, ptS);
}
else // 弧线 沿弧拉伸缩短
{
TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
TGGeArc arc(ptStart, ptEnd, dBulge);
ptMid = arc.MidPoint();
TADSGePoint3d ptCenter;
arc.Center(ptCenter);
TGGeCircle cir(ptCenter, arc.GetRadius());
ptStart += vtOffset;
ptStart.Project(&cir,ptStart);
arc.Set(ptStart, ptMid, ptEnd);
SetAt(KEY_START, ptStart.AsAcGePoint3d());
SetAt(KEY_BULGE, arc.Bulge());
}
}
else if (nIndex == 1) // 终点
{
// 将拖动方向限制在剪力墙方向
if (fabs(dBulge) < g_angleZero) // 直线 沿线方向拉伸缩短
{
TGGeLine line(asDblArray(ptS), asDblArray(ptE));
TADSGePoint3d ptTemp;
ptTemp = ptE + vtOffset;
ptTemp.Project(&line, ptTemp);
vtOffset = ptTemp - ptE;
ptE += vtOffset;
SetAt(KEY_END, ptE);
}
else // 弧线 沿弧拉伸缩短
{
TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
TGGeArc arc(ptStart, ptEnd, dBulge);
ptMid = arc.MidPoint();
TADSGePoint3d ptCenter;
arc.Center(ptCenter);
TGGeCircle cir(ptCenter, arc.GetRadius());
ptEnd += vtOffset;
ptEnd.Project(&cir,ptEnd);
arc.Set(ptStart, ptMid, ptEnd);
SetAt(KEY_END, ptEnd.AsAcGePoint3d());
SetAt(KEY_BULGE, arc.Bulge());
}
}
else if (nIndex == 2) // 中点
{
if (fabs(dBulge) < g_angleZero) // 直线 关联平行移动
{
// 限制移动方向
TADSGePoint3d pt = ptS + vtOffset, pt2;
TGGeLine line(asDblArray(ptS), asDblArray(ptE));
pt.Project(&line, pt2);
vtOffset = pt - pt2;
vtOffset.z = 0;
ptS += vtOffset;
SetAt(KEY_START, ptS);
ptE += vtOffset;
SetAt(KEY_END, ptE);
// 拖拽结束时发送消息
if (objectId())
{
TAssocMsg msg;
msg.SetMethod(TAssocMsg::kMovegrippoint);
msg.SetTarget(line.MidPoint());
msg.SetOffset(vtOffset);
msg.SetAssocId(objectId());
AddMsg(msg);
}
}
else // 弧线 改变半径
{
TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
TGGeArc arc(ptStart, ptEnd, dBulge);
ptMid = arc.MidPoint();
TADSGePoint3d ptCenter;
arc.Center(ptCenter);
TGGeLine line(ptCenter, ptMid);
ptMid += vtOffset;
ptMid.Project(&line, ptMid);
if (ptMid.Distance(ptCenter) > _DIST_SNAP)
{
AcGeVector3d vt1 = ptS - ptCenter.AsAcGePoint3d(), vt2 = ptE - ptCenter.AsAcGePoint3d();
double dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
vt1 = ptMid - ptCenter;
ptStart = ptCenter + vt1.rotateBy(-dAngle * 0.5, AcGeVector3d::kZAxis);
ptEnd = ptCenter + vt1.rotateBy(dAngle, AcGeVector3d::kZAxis);
arc.Set(ptStart, ptMid, ptEnd);
SetAt(KEY_START, ptStart.AsAcGePoint3d());
SetAt(KEY_END, ptEnd.AsAcGePoint3d());
SetAt(KEY_BULGE, arc.Bulge());
}
}
}
}
void TDbStruBeam::SingleMove( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
if (m_arHoleIds.length() > 0) // 有洞时不移动
{
return;
}
AcGePoint3d ptS;
GetAt(KEY_START, ptS);
AcGePoint3d ptE;
GetAt(KEY_END, ptE);
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge);
// 限制在平面移动
AcGeVector3d vtOffset = offset;
vtOffset.z = 0.0;
int nIndex = indices[0];
if (nIndex == 0) // 起点 改变端点位置
{
ptS += vtOffset;
SetAt(KEY_START, ptS);
}
else if (nIndex == 1) // 终点 改变端点位置
{
ptE += vtOffset;
SetAt(KEY_END, ptE);
}
else if (nIndex == 2) // 中点
{
if (fabs(dBulge) < g_angleZero) // 直线 独立平行移动
{
ptS += vtOffset;
SetAt(KEY_START, ptS);
ptE += vtOffset;
SetAt(KEY_END, ptE);
}
else // 弧线 改变位置
{
TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
TGGeArc arc(ptStart, ptEnd, dBulge);
ptMid = arc.MidPoint();
ptMid += vtOffset;
TGGeArc arcNew(ptStart, ptMid, ptEnd); // 移动后的新弧
arcNew.GetStartPoint(ptStart);
arcNew.GetEndPoint(ptEnd);
dBulge = arcNew.Bulge();
ptS = ptStart;
ptE = ptEnd;
SetAt(KEY_START, ptS);
SetAt(KEY_END, ptE);
SetAt(KEY_BULGE, dBulge);
}
}
}
void TDbStruBeam::GetTotalWidth(double &dWidth)const
{
int nSecTyp = 0;
GetAt(KEY_SECTYP, nSecTyp);
dWidth = 0;
switch (nSecTyp)
{
case ST_RECT:
GetAt(KEY_B, dWidth);
break;
case ST_IBEAM:
{
double dU(0),dD(0); //工形截面上下翼缘宽度
GetAt(KEY_U, dU);
GetAt(KEY_D, dD);
dWidth = dU > dD ? dU : dD;
}
break;
default:
break;
}
}
// 获得总高度
void TDbStruBeam::GetTotalHeight(double &dHeight)const
{
int nSecTyp = 0;
GetAt(KEY_SECTYP, nSecTyp);
dHeight = 0;
switch (nSecTyp)
{
case ST_RECT:
case ST_IBEAM:
GetAt(KEY_H, dHeight);
break;
default:
break;
}
}
// 梁标注
void TDbStruBeam::DrawBH(TGGiExplodeDrawBase &dc) const
{
TDbText text;
if (m_idLayerDim.isValid())
{
text.setLayer(m_idLayerDim);
}
AcDbObjectId idBHStyl = DocGetBeamBHStyle();
if(idBHStyl.isNull())
{
idBHStyl = InitTextStyle(TS_STANDARD);
}
text.SetStyleId(idBHStyl); // 设置文字样式
text.SetHeight(DocGetBeamBHHigh()); // 设置尺寸文字高度
text.setColorIndex(DocGetBeamBHColor()); // 设置尺寸文字颜色
text.SetAlignment(XExplodeDraw::kCenter); // 设置文字的对齐方式
double dWidth = GetSection2dWidth(); // 得到梁截面的宽度
double dHeight = GetSection2dHeight(); // 得到梁截面的高度
//add by xlc on 140421 截面尺寸考虑轴转角的影响
double dAxis(0.0);
GetAt(KEY_AXANG,dAxis);
double dVal = fabs(cos(dAxis));
if(dVal < g_fZero)
{
double dTmp = dWidth;
dWidth = dHeight;
dHeight = dTmp;
}
else
{
dWidth = dWidth/dVal;
dHeight = dHeight/dVal;
}
CString strHeight, strWidth;
strHeight = Dist2Str(dHeight);
strWidth = Dist2Str(dWidth);
CString strText;
strText.Format(_T("%s×%s"), strWidth, strHeight);
text.SetText(strText); // 设置显示内容
TADSGePoint3d ptMid;
AcGePoint3d ptStart, ptEnd;
GetAt(KEY_START, ptStart); // 得到梁的起始位置
GetAt(KEY_END, ptEnd); // 得到梁的终止位置
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge);
double dDis = (DocGetBeamBHDist() * GetPScale());// 得到文字到梁的距离考虑图纸比例
double dBeamWidth;
GetTotalWidth(dBeamWidth); // 得到梁的宽度
double dTextDis = dBeamWidth/2+dDis; // 考虑到文字显示位置(梁形心为文字的对齐点)所以距离为梁的一半宽度加上距离
ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd)); // 与x轴的夹角
if (angle - PI < g_angleZero) // 0-180度之间
{
if(angle - PI/2 > g_angleZero) // 90-180度时文字的显示角度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
if(fabs(dBulge) > g_angleZero) // 弧梁
{
dTextDis = -dTextDis;
}
}
}
else // 180-360度之间
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度时文字的显示角度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
if(fabs(dBulge) > g_angleZero) // 弧梁
{
dTextDis = -dTextDis;
}
}
}
text.SetRotation(angle); // 设置文字旋转角度
TADSGePoint3d ptTextAlign;
if(fabs(dBulge) > g_angleZero)
{
TGGeCurveSegment cvsegCenter = GetCenterLine(); // 得到梁的中心线
TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧墙的圆心
TADSGePoint3d ptMid = cvsegCenter.MidPoint(); // 得到中心线的中心点
double dBeamAngle = ads_angle(ptMid, ptCenter); // 得到中心线的中点和圆心与x轴的角度
ptTextAlign = TADSGePoint3d(ptMid, dBeamAngle, dTextDis); // 得到文字的显示位置
}
else
{
Midpoint(ptStart, ptEnd, ptTextAlign); // 得到梁的中点
ptTextAlign = TADSGePoint3d(ptTextAlign, angle+PI/2, dTextDis);//与梁垂直方向
}
text.SetLocation(ptTextAlign); // 设置文字的插入位置
TPushProperty vProp(&text, dc);
if (dc.IsFullExplode())
{
text.ExplodeOrDraw2d(dc);
}
else
{
dc.DrawEntity(text);
}
}
// 构件编号
void TDbStruBeam::DrawClab(TGGiExplodeDrawBase &dc) const
{
TDbText text;
text.setPropertiesFrom(this);
AcDbObjectId idCLStyl = DocGetBeamCLStyle();
if(idCLStyl.isNull())
{
idCLStyl = InitTextStyle(TS_STANDARD);
}
text.SetStyleId(idCLStyl); // 设置文字样式
text.SetHeight(DocGetBeamCLHigh()); // 设置文字高度
text.setColorIndex(DocGetBeamCLColor()); // 设置文字颜色
text.SetAlignment(XExplodeDraw::kTopCenter);// 设置文字对齐方式
CString strText;
GetAt(KEY_CLAB, strText); // 得到梁的构件编号
text.SetText(strText); // 设置文字显示内容
AcGePoint3d ptStart, ptEnd;
GetAt(KEY_START, ptStart);
GetAt(KEY_END, ptEnd);
double dBeamWidth;
GetTotalWidth(dBeamWidth); // 得到梁宽
double dDis = dBeamWidth/2;
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge); // 得到梁的凸度,根据凸度判断是否是弧梁
// 计算文字的旋转角度
ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));// 与x轴的夹角
if (angle - PI < g_angleZero)
{
if(angle - PI/2 > g_angleZero) // 90-180度时文字的显示角度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
if(fabs(dBulge) > g_angleZero) // 弧梁
{
dDis = -dDis;
}
}
}
else
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度时文字的显示角度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
if(fabs(dBulge) > _DIST_SNAP) // 弧梁
{
dDis = -dDis;
}
}
}
TADSGePoint3d ptTextAlign; // 墙体构件文字位置点
if(fabs(dBulge) > _DIST_SNAP) // 弧梁
{
TGGeCurveSegment cvsegCenter = GetCenterLine(); // 得到梁的中心线
TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
TADSGePoint3d ptMid = cvsegCenter.MidPoint(); // 得到弧梁中心线的中心点
double dBeamAngle = ads_angle(ptMid, ptCenter); // 得到中心线的中心点和圆心得连线的角度
ptTextAlign = TADSGePoint3d(ptMid, dBeamAngle, -dDis); // 得到文字的插入位置
}
else
{
Midpoint(ptStart, ptEnd, ptTextAlign); // 得到梁的中点
ptTextAlign = TADSGePoint3d(ptTextAlign, angle+PI/2, -dDis);//与梁垂直方向
}
text.SetRotation(angle);
text.SetLocation(ptTextAlign);
//text.setLayer(DocGetBeamCLLayer()); // 设置文字图层
if (m_idLayerNum.isValid())
{
text.setLayer(m_idLayerNum);
}
TPushProperty vProp(&text, dc);
if (dc.IsFullExplode())
{
text.ExplodeOrDraw2d(dc);
}
else
{
dc.DrawEntity(text);
}
}
// 单元编号
void TDbStruBeam::DrawCellNo(TGGiExplodeDrawBase &dc) const
{
CString strCellNo;
GetAt(KEY_CELLNO, strCellNo);
if (strCellNo.IsEmpty())
{
return;
}
AcDbText text;
text.setTextString(strCellNo); // 设置文字显示内容
if (m_idLayerNum.isValid())
{
text.setLayer(m_idLayerNum);
}
// 设置文字样式
AcDbObjectId idNoStyl = DocGetBeamNoStyle();
if(!idNoStyl.isNull())
{
text.setTextStyle(idNoStyl); // 设置文字样式
}
else
{
text.setTextStyle(InitTextStyle(TS_STANDARD));
}
text.setHeight(DocGetBeamNoHigh() * GetPScale()); // 设置文字高
text.setColorIndex(DocGetBeamNoColor()); // 设置文字颜色
// 设置文字法向
if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
{
AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();
AcGePoint3d ptCamera, ptTarget;
vp.getCameraTarget(ptTarget); // 得到目标位置点
vp.getCameraLocation(ptCamera); // 得到照相机位置点
AcGeVector3d vtViewDrt = ptCamera-ptTarget;
AcGeVector3d vtViewDir1= vp.viewDir();
AcGeVector3d vtCamera;
vp.getCameraUpVector(vtCamera);
vtViewDrt.normalize(); // 单位化向量
text.setNormal(vtViewDrt); // 设置文字法向
}
TGGeCurveSegment cvCenter = GetCenterLine(); // 得到梁的中心线
TADSGePoint3d ptNoDist = cvCenter.MidPoint(); // 得到梁中心线的中心点
double dBeamWidth;
GetTotalWidth(dBeamWidth); // 得到梁的宽
dBeamWidth /= 2;
ptNoDist.y += dBeamWidth;
ptNoDist.y += DocGetBeamNoDist() * GetPScale(); // 设置文字到梁的距离
text.setPosition(ptNoDist); // 设置文字显示位置
text.setHorizontalMode(AcDb::kTextCenter); // 设置文字的对齐方式
dc.DrawEntity(text); // 画文字对象
}
// 刚域
void TDbStruBeam::DrawRG(TGGiExplodeDrawBase &dc) const
{
double dRGI, dRGJ;
bool bI = GetAt(KEY_RIGIDI, dRGI);
bool bJ = GetAt(KEY_RIGIDJ, dRGJ);
if(!bI && !bJ)
{
return;
}
CString strRGI, strRGJ;
AcDbText text;
if (m_idLayerText.isValid())
{
text.setLayer(m_idLayerText);
}
// 设置文字样式
AcDbObjectId idRGStyl = DocGetBeamRGStyle();
if(!idRGStyl.isNull())
{
text.setTextStyle(idRGStyl);
}
else
{
text.setTextStyle(InitTextStyle(TS_STANDARD));
}
text.setHeight(DocGetBeamRGHigh() * GetPScale());// 设置文字高度
text.setColorIndex(DocGetBeamRGColor()); // 设置文字颜色
// 设置文字法向
if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
{
AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();
AcGePoint3d ptCamera, ptTarget;
vp.getCameraTarget(ptTarget);
vp.getCameraLocation(ptCamera);
AcGeVector3d vtViewDrt = ptCamera-ptTarget;
AcGeVector3d vtViewDir1= vp.viewDir();
AcGeVector3d vtCamera;
vp.getCameraUpVector(vtCamera);
vtViewDrt.normalize();
text.setNormal(vtViewDrt);
}
TADSGePoint3d ptNoDist;
AcGePoint3d ptStart, ptEnd;
if(bI)
{
GetAt(KEY_START, ptStart);
ptStart.x -= DocGetBeamRGDist() * GetPScale(); // 设置文字到梁的距离
text.setPosition(ptStart); // 设置文字位置
text.setHorizontalMode(AcDb::kTextLeft); // 设置文字的对齐方式
strRGI = TrimDoubleZero(dRGI);
text.setTextString(strRGI); // 设置文字显示内容
dc.DrawEntity(text); // 画该对象
}
if(bJ)
{
GetAt(KEY_END, ptEnd);
strRGJ = TrimDoubleZero(dRGJ);
text.setTextString(strRGJ); // 设置文字显示内容
ptEnd.x += DocGetBeamRGDist() * GetPScale(); // 设置文字到梁的距离
text.setPosition(ptEnd); // 设置文字显示位置
text.setHorizontalMode(AcDb::kTextRight); // 设置文字对齐方式
dc.DrawEntity(text); // 画该对象
}
}
//铰接属性
//返回值 0：普通梁，1:一端铰梁,2:两端铰梁
int TDbStruBeam::GetHinge()const
{
assertReadEnabled();
int nHingeNum(0);
int nHinge(0);
if(GetAt(KEY_HINGE, nHinge))
{
nHingeNum += ((nHinge & HINGE_START) != 0);
nHingeNum += ((nHinge & HINGE_END) != 0);
}
return nHingeNum;
}
//梁两端的铰接属性
BOOL TDbStruBeam::GetHinge(BOOL bStart)
{
assertReadEnabled();
BOOL bTrue = FALSE;
int nHinge(0);
if(GetAt(KEY_HINGE, nHinge))
{
if(bStart)
{
bTrue = ((nHinge & HINGE_START) != 0);
}
else
{
bTrue = ((nHinge & HINGE_END) != 0);
}
}
return bTrue;
}
void TDbStruBeam::SetHinge(BOOL bStart, BOOL bTrue)
{
assertReadEnabled();
int nHingeNum(0);
int nHinge(0);
GetAt(KEY_HINGE, nHinge);
if(bStart)
{
if(bTrue)
{
nHinge |= HINGE_START;
}
else
{
nHinge &= ~HINGE_START;
}
}
else
{
if(bTrue)
{
nHinge |= HINGE_END;
}
else
{
nHinge &= ~HINGE_END;
}
}
SetAt(KEY_HINGE, nHinge);
}
// add by wjx on 111220
// 功能:得到中心线的中心点和圆心得连线的角度和距离
// [in]:dDis: 到梁边的距离
// return: 中心线的中点和圆心连线的角度
double TDbStruBeam::GetCenetrAngle(double &dDis) const
{
double dBulge = 0.0;
GetAt(KEY_BULGE, dBulge); // 得到梁的凸度,根据凸度判断是否是弧梁
AcGePoint3d ptStart, ptEnd;
GetAt(KEY_START, ptStart);
GetAt(KEY_END, ptEnd);
// double dBeamWidth;
// GetTotalWidth(dBeamWidth); // 得到梁宽
// dDis += dBeamWidth/2;
// 计算文字的旋转角度
ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));// 与x轴的夹角
if (angle - PI < g_angleZero)
{
if(angle - PI/2 > g_angleZero) // 90-180度时文字的显示角度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
if(fabs(dBulge) > g_angleZero) // 弧梁
{
dDis = -dDis;
}
}
}
else
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度时文字的显示角度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
if(fabs(dBulge) > _DIST_SNAP) // 弧梁
{
dDis = -dDis;
}
}
}
double dBeamAngle = 0;
if(fabs(dBulge) > _DIST_SNAP) // 弧梁
{
TGGeCurveSegment cvsegCenter = GetCenterLine(); // 得到梁的中心线
TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
TADSGePoint3d ptMid = cvsegCenter.MidPoint(); // 得到弧梁中心线的中心点
dBeamAngle = ads_angle(ptMid, ptCenter); // 得到中心线的中心点和圆心得连线的角度
}
else
{
dBeamAngle = angle+PI/2;
}
return dBeamAngle;
}
// add by wjx on 111220
// 确定左右端点,以x方向和y方向确定
// [in]: ptStart:梁的起始点
// [in]: ptEnd:梁的终止点
// return: 是否交换梁的起始点和终止点
BOOL TDbStruBeam::GetLRPoint(XPoint &ptStart, XPoint &ptEnd)const
{
bool bSEFlag = true; // 取起始点的标志
if (fabs(ptStart.x - ptEnd.x) < _DIST_SNAP) // 竖向
{
if(ptStart.y - ptEnd.y > _DIST_SNAP)
{
XPoint ptTemp = ptStart;
ptStart = ptEnd;
ptEnd = ptTemp;
bSEFlag = false;
}
}
else if(ptStart.x - ptEnd.x > _DIST_SNAP) // 横向
{
XPoint ptTemp = ptStart;
ptStart = ptEnd;
ptEnd = ptTemp;
bSEFlag = false;
}
return bSEFlag;
}
// add by wjx on 111219
// 功能: 显示梁的荷载信息
void TDbStruBeam::DrawBeamLoad(TGGiExplodeDrawBase &dc) const
{
//if(NULL == g_pStruSubProject)
//{
// return;
//}
//add by xlc on 120112荷载显示控制
BOOL bShowGraphic = false; //显示图形
BOOL bShowLive = false; //显示活荷
BOOL bShowUnLive = false; //显示恒荷
if(g_nLoadDrawMode == BYOBJLOAD)
{
bShowGraphic = true;
bShowLive = bShowUnLive = DocGetShowLoadPara();
}
else
{
bShowGraphic = GetViewStyle(BYGRAPHIC);
bShowLive = GetViewStyle(BYVARYING);
bShowUnLive = GetViewStyle(BYUNVARYING);
}
//都不显示时直接返回
if (!(bShowGraphic||bShowLive||bShowUnLive))
{
return;
}
// AcDbHandle hBeam;
// getAcDbHandle(hBeam);
// int nHandle = hBeam.low();
//
// // 在自然层中找到该句柄对应的荷载信息
// int nSize = g_pStruSubProject->m_vecFloorData.size();// 自然层数
// int nLoadSize = 0; // 自然层中荷载数量
// TStruEntLoads entLoad;
// bool bFind = false; // 是否找到梁的荷载信息
// for(int i = 0; i < nSize; i++)
// {
// nLoadSize = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads.size();
// for (int j = 0; j < nLoadSize; j++)
// {
// entLoad = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j];
//
// if (entLoad.GetEntHandle().low() == nHandle)
// {
// bFind = true; // 找到自然层中梁的荷载
// 得到荷载数据
// int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
std::vector<TStruLoad> vecLoad;
bool bl = GetLoadsArray(vecLoad);
// int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
int nLoadInfoCount = vecLoad.size();
if(nLoadInfoCount < 1)
{
return;
}
TStruLoad loadData;
// 画荷载图形
TGGeCurveSegment segCenter = GetCenterLine();
segCenter.SetElevation(0.0);
XPoint ptStart = segCenter.StartPoint();
XPoint ptEnd = segCenter.EndPoint();
BOOL bSwtchSEFlag = GetLRPoint(ptStart, ptEnd);
//int nColorOld = dc.GetColor();
//dc.SetColor(1);
TPushProperty vProp(this, dc);
if (m_idLayerLoad.isValid())
{
dc.SetLayer(m_idLayerLoad);
}
// 计算移动方向
double dLoadDis = 0.0; // 荷载到梁的距离
double dAugle = 0.0;
TADSGePoint3d ptMid = segCenter.MidPoint(); // 得到梁中心线的中心点
XPoint ptInsert;
ads_matrix mat;
double dLoadLen = segCenter.GetLength();
double dTextDis = 300.0; // 文字到线的距离
// 画图形和荷载信息
for(int k = 0; k < nLoadInfoCount; k++)
{
// loadData = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads[k];
loadData = vecLoad[k];
// modify by wjx on 120313 修改原因:根据荷载的实际数据显示荷载图
if(bShowGraphic)
{
TGGeCurveSegment segSub, segTemp;
XPoint ptSToCenter, ptEtoCenter; // 映射到中心线上的点
switch (loadData.GetLoadType())
{
case TStruLoad::LT_ALL_H:
dLoadDis = 100.0; // 荷载到梁的距离
dAugle = GetCenetrAngle(dLoadDis);
ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
ptMid.GetMoveMatrix(ptInsert, mat);
segTemp = segCenter;
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
break;
case TStruLoad::LT_LEFT:
dLoadDis = 150.0; // 荷载到梁的距离
dAugle = GetCenetrAngle(dLoadDis);
ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
ptMid.GetMoveMatrix(ptInsert, mat);
// segCenter.GetSubSegment(ptStart, dLoadLen/4, segTemp);
// segCenter.GetSubSegment((bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(),
// dLoadLen/4, segSub);
segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000, segTemp);
segCenter.GetSubSegment((bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(),
loadData.GetPara1() * 1000, segSub);
segSub.TransformBy(mat);
dc.DrawCurve(segSub);
segTemp = segSub;
ptSToCenter = segTemp.GetStartPoint();
segCenter.ProjectToMe(ptSToCenter, ptSToCenter);
segSub = TGGeCurveSegment(ptSToCenter, segTemp.GetStartPoint(), 0);
dc.DrawCurve(segSub);
ptEtoCenter = segTemp.GetEndPoint();
segCenter.ProjectToMe(ptEtoCenter, ptEtoCenter);
segSub = TGGeCurveSegment(ptEtoCenter, segTemp.GetEndPoint(), 0);
dc.DrawCurve(segSub);
break;
case TStruLoad::LT_RIGHT:
dLoadDis = 150.0; // 荷载到梁的距离
dAugle = GetCenetrAngle(dLoadDis);
ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
ptMid.GetMoveMatrix(ptInsert, mat);
// segCenter.GetSubSegment(ptEnd, dLoadLen/4, segTemp);
// segCenter.GetSubSegment((!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(),
// dLoadLen/4, segSub);
segCenter.GetSubSegment(ptEnd, loadData.GetPara1() * 1000, segTemp);
segCenter.GetSubSegment((!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(),
loadData.GetPara1() * 1000, segSub);
segSub.TransformBy(mat);
dc.DrawCurve(segSub);
segTemp = segSub;
ptSToCenter = segTemp.GetStartPoint();
segCenter.ProjectToMe(ptSToCenter, ptSToCenter);
segSub = TGGeCurveSegment(ptSToCenter, segTemp.GetStartPoint(), 0);
dc.DrawCurve(segSub);
ptEtoCenter = segTemp.GetEndPoint();
segCenter.ProjectToMe(ptEtoCenter, ptEtoCenter);
segSub = TGGeCurveSegment(ptEtoCenter, segTemp.GetEndPoint(), 0);
dc.DrawCurve(segSub);
break;
case TStruLoad::LT_FOCUS:
dAugle = ads_angle(ptStart, ptEnd);
ptStart.GetRotationMatrix(dAugle, mat);
dLoadDis = 200.0;
// ptEtoCenter = XPoint(ptMid.x, ptMid.y,0);
// ptSToCenter = XPoint(ptMid.x, ptMid.y+dLoadDis,0);
ptEtoCenter = XPoint(ptStart.x + loadData.GetPara1()*1000, ptStart.y,0);
ptSToCenter = XPoint(ptEtoCenter.x, ptEtoCenter.y+dLoadDis,0);
segTemp = TGGeCurveSegment(ptSToCenter, ptEtoCenter, 0);
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x-100, ptEtoCenter.y+100, 0.0), 0);
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y+100, 0.0), 0);
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
break;
case TStruLoad::LT_TRAPE:
dLoadDis = 200.0; // 荷载到梁的距离
dAugle = GetCenetrAngle(dLoadDis);
ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
ptMid.GetMoveMatrix(ptInsert, mat);
segCenter.GetSubSegment(ptMid, dLoadLen - loadData.GetPara1()*1000*2, segSub);
segSub.TransformBy(mat);
dc.DrawCurve(segSub);
segTemp = segSub;
ptSToCenter = (!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
segSub = TGGeCurveSegment(ptStart, ptSToCenter, 0);
dc.DrawCurve(segSub);
ptEtoCenter = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
segSub = TGGeCurveSegment(ptEnd, ptEtoCenter, 0);
dc.DrawCurve(segSub);
break;
case TStruLoad::LT_TRIGON:
dLoadDis = 200.0; // 荷载到梁的距离
dAugle = GetCenetrAngle(dLoadDis);
// ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
segCenter.GetSubSegment(ptStart, 2*(loadData.GetPara1()+loadData.GetPara2())*1000, segSub);
ptInsert = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
ptInsert = TADSGePoint3d(ptInsert, dAugle, dLoadDis);
// segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
segCenter.GetSubSegment(ptStart, 2*loadData.GetPara1()*1000, segSub);
ptSToCenter = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
segSub = TGGeCurveSegment(ptInsert, ptSToCenter, 0);
dc.DrawCurve(segSub);
segCenter.GetSubSegment(ptStart, 2*(loadData.GetPara1()+loadData.GetPara2()*2)*1000, segSub);
ptEtoCenter = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
segSub = TGGeCurveSegment(ptInsert, ptEtoCenter, 0);
dc.DrawCurve(segSub);
break;
case TStruLoad::LT_FOLD:
dLoadDis = 250.0; // 荷载到梁的距离
dAugle = GetCenetrAngle(dLoadDis);
// segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
segCenter.GetSubSegment(ptStart, loadData.GetPara2()*2*1000, segSub);
// segTemp = segSub;
ptInsert = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
ptSToCenter = TADSGePoint3d(ptInsert, dAugle, dLoadDis-200);
segSub = TGGeCurveSegment(ptInsert, ptSToCenter, 0);
dc.DrawCurve(segSub);
segCenter.GetSubSegment(ptStart, (loadData.GetPara2()+loadData.GetPara3())*2*1000, segSub);
ptInsert = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
ptEtoCenter = TADSGePoint3d(ptInsert, dAugle, dLoadDis);
segSub = TGGeCurveSegment(ptInsert, ptEtoCenter, 0);
dc.DrawCurve(segSub);
segSub = TGGeCurveSegment(ptSToCenter, ptEtoCenter, 0);
dc.DrawCurve(segSub);
break;
case TStruLoad::LT_MOMENT:
dAugle = ads_angle(ptStart, ptEnd);
// ptMid.GetRotationMatrix(dAugle, mat);
ptStart.GetRotationMatrix(dAugle, mat);
dLoadDis = 200;
// ptEtoCenter = XPoint(ptMid.x, ptMid.y-dLoadDis/2,0);
// ptSToCenter = XPoint(ptMid.x, ptMid.y+dLoadDis/2,0);
ptEtoCenter = XPoint(ptStart.x+loadData.GetPara1()*1000, ptStart.y-dLoadDis/2,0);
ptSToCenter = XPoint(ptStart.x+loadData.GetPara1()*1000, ptStart.y+dLoadDis/2,0);
segTemp = TGGeCurveSegment(ptSToCenter, ptEtoCenter, -PI*5/4);
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y+100, 0.0), 0);
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y-100, 0.0), 0);
segTemp.TransformBy(mat);
dc.DrawCurve(segTemp);
break;
}
}
// 显示文字
if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive) //活荷
||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive) //恒荷
)
{
dAugle = ads_angle(ptStart, ptEnd);
DrawBeamLoadText2d(loadData, dAugle, dTextDis, dc);
}
}
//dc.SetColor(nColorOld);
// break;
// }
// }
//
// if(bFind)
// {
// break;
// }
// }
}
// add by wjx on 111220
// 功能: 设置显示梁荷载的文字
// [in]: loadData: 荷载信息
// [in]: dAugle: 梁线与x轴的夹角
// [in]: dDis: 荷载信息显示位置到线的距离
void TDbStruBeam::DrawBeamLoadText2d(TStruLoad loadData, double dAugle,
double &dDis, TGGiExplodeDrawBase &dc) const
{
int nKind = loadData.GetLoadKind(); // 荷载种类
//del by xlc on 120112显示控制移到外边了
//if(!GetViewStyle(nKind))
//{
// return;
//}
// 设置文字
AcDbText text;
text.setTextStyle(InitTextStyle(TS_STANDARD));
text.setHeight(DocGetLoadTextHeight());// 设置文字高度
// 得到梁的中心线
TGGeCurveSegment segCenter = GetCenterLine();
segCenter.SetElevation(0.0);
XPoint ptMid = segCenter.MidPoint();
// 生成要显示的荷载文字
int nType = loadData.GetLoadType(); // 荷载类型
CString strLoadInfo;
if(nType == TStruLoad::LT_FOLD)
{
strLoadInfo.Format(_T("7*%s*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()),
TrimDoubleZero(loadData.GetPara3()));
}
else if(nType == TStruLoad::LT_TRIGON)
{
strLoadInfo.Format(_T("6*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()));
}
else if(nType == TStruLoad::LT_ALL_H)
{
strLoadInfo.Format(_T("1*%s"), TrimDoubleZero(loadData.GetValue()));
}
else
{
strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
TrimDoubleZero(loadData.GetPara1()));
}
text.setTextString(strLoadInfo);
//if(nKind == TStruLoad::LK_UNVARYING)
//{
// text.setColorIndex(7);
//}
//else if(nKind == TStruLoad::LK_VARYING)
//{
// text.setColorIndex(2);
//}
if (nKind == TStruLoad::LK_UNVARYING)
{
if (m_idLayerLoadC.isValid())
{
text.setLayer(m_idLayerLoadC);
}
}
else
{
if (m_idLayerLoadL.isValid())
{
text.setLayer(m_idLayerLoadL);
}
}
double dBugle = GetCenetrAngle(dDis); // 与梁线垂直方向与x轴夹角
text.setRotation(dAugle);
TADSGePoint3d ptInsert = TADSGePoint3d(ptMid, dBugle, dDis); // 得到梁中心线的中心点
text.setPosition(ptInsert);
dc.DrawEntity(text);
dDis += DocGetLoadTextHeight();
}
// 在线的中点位置画箭头
// [in]: seg:梁线
// [in]: nEdgeFlag: 0:起始点 1:中点 2:终止点
void TDbStruBeam::DrawArrow3D(TGGeCurveSegment seg, TGGiExplodeDrawBase &dc, int nEdgeFalg)const
{
XPoint ptS;
if(nEdgeFalg == 1)
{
ptS= seg.MidPoint();
}
else if(nEdgeFalg == 0)
{
ptS = seg.StartPoint();
}
else
{
ptS = seg.EndPoint();
}
XPoint ptPro, ptTemp;
TGGeCurveSegment segCenter = GetCenterLine();
segCenter.ProjectToMe(ptS, ptPro);
TGGeCurveSegment segTemp(ptS, ptPro, 0);
dc.DrawCurve(segTemp);
ptTemp = ptPro;
TGGeCurveSegment segSub;
seg.GetSubSegment(ptS, 200, segSub);
segCenter.ProjectToMe(segSub.StartPoint(), ptPro);
segTemp = TGGeCurveSegment(XPoint(ptPro.x, ptPro.y, ptPro.z+100), ptTemp, 0);
dc.DrawCurve(segTemp);
segCenter.ProjectToMe(segSub.EndPoint(), ptPro);
segTemp = TGGeCurveSegment(XPoint(ptPro.x, ptPro.y, ptPro.z+100), ptTemp, 0);
dc.DrawCurve(segTemp);
}
// add by wjx 0n 111221
// 绘制3d荷载信息
void TDbStruBeam::DrawBeamLoad3D(TGGiExplodeDrawBase &dc)const
{
//if(NULL == g_pStruSubProject)
//{
// return;
//}
//add by xlc on 120112荷载显示控制
BOOL bShowGraphic = false; //显示图形
BOOL bShowLive = false; //显示活荷
BOOL bShowUnLive = false; //显示恒荷
if(g_nLoadDrawMode == BYOBJLOAD)
{
bShowGraphic = true;
bShowLive = bShowUnLive = DocGetShowLoadPara();
}
else
{
bShowGraphic = GetViewStyle(BYGRAPHIC);
bShowLive = GetViewStyle(BYVARYING);
bShowUnLive = GetViewStyle(BYUNVARYING);
}
//都不显示时直接返回
if (!(bShowGraphic||bShowLive||bShowUnLive))
{
return;
}
// modify by wjx on 120119 修改荷载的读取方式
// AcDbHandle hBeam;
// getAcDbHandle(hBeam);
// int nHandle = hBeam.low();
//
// // 在自然层中找到该句柄对应的荷载信息
// int nSize = g_pStruSubProject->m_vecFloorData.size();// 自然层数
// int nLoadSize = 0; // 自然层中荷载数量
// TStruEntLoads entLoad;
// bool bFind = false; // 是否找到梁的荷载信息
// for(int i = 0; i < nSize; i++)
// {
// nLoadSize = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads.size();
// for (int j = 0; j < nLoadSize; j++)
// {
// entLoad = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j];
// if (entLoad.GetEntHandle().low() == nHandle)
// {
// bFind = true; // 找到自然层中梁的荷载
//
// int nColorOld = dc.GetColor();
// dc.SetColor(1);
//
// TGGeCurveSegment segCenter = GetCenterLine();// 梁的中心线
// TGGeCurveSegment segSub, segCenterBak;
// XPoint ptMid = segCenter.MidPoint();
// XPoint ptStart = segCenter.GetStartPoint();
// XPoint ptEnd = segCenter.GetEndPoint();
// BOOL bSwitchSE = GetLRPoint(ptStart, ptEnd);// 确定起始点和终止点那个点在左侧或右侧
// XPoint ptS, ptE, ptM; // 荷载图像上的起始,结束,中点
// ads_matrix mat;
// double dLoadLen = segCenter.GetLength();
// double dZ = 500;
// double dAugle = ads_angle(ptStart, ptEnd);
// AcDbArc arcLine;
// AcGeVector3d vecNormal = AcGeVector3d(0, 0, 1);
// // 得到荷载数据
// int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
// TStruLoad loadData;
//
// for(int k = 0; k < nLoadInfoCount; k++)
// {
// loadData = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads[k];
// if(bShowGraphic)
// {
//
// switch (loadData.GetLoadType())
// {
// case TStruLoad::LT_ALL_H:
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+300);
// ptMid.GetMoveMatrix(ptM, mat);
// segCenterBak = segCenter;
// segCenterBak.TransformBy(mat);
// dc.DrawCurve(segCenterBak);
//
// DrawArrow3D(segCenterBak, dc);
// segCenterBak.GetSubSegment(ptM, dLoadLen/2, segSub);
// DrawArrow3D(segSub, dc, 0);
// DrawArrow3D(segSub, dc, 2);
// DrawArrow3D(segCenterBak, dc, 0);
// DrawArrow3D(segCenterBak, dc, 2);
// break;
// case TStruLoad::LT_LEFT:
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
// ptMid.GetMoveMatrix(ptM, mat);
// segCenter.GetSubSegment(ptStart, dLoadLen/4, segCenterBak);
// segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(),
// dLoadLen/4, segSub);
// segSub.TransformBy(mat);
// dc.DrawCurve(segSub);
//
// segCenterBak = segSub;
//
// ptM = segCenterBak.MidPoint();
//
// DrawArrow3D(segCenterBak, dc);
// segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
// DrawArrow3D(segSub, dc, 0);
// DrawArrow3D(segSub, dc, 2);
// DrawArrow3D(segCenterBak, dc, 0);
// DrawArrow3D(segCenterBak, dc, 2);
// break;
// case TStruLoad::LT_RIGHT:
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
// ptMid.GetMoveMatrix(ptM, mat);
// segCenter.GetSubSegment(ptEnd, dLoadLen/4, segCenterBak);
// segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(),
// dLoadLen/4, segSub);
// segSub.TransformBy(mat);
// dc.DrawCurve(segSub);
//
// segCenterBak = segSub;
//
// ptM = segCenterBak.MidPoint();
//
// DrawArrow3D(segCenterBak, dc);
// segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
// DrawArrow3D(segSub, dc, 0);
// DrawArrow3D(segSub, dc, 2);
// DrawArrow3D(segCenterBak, dc, 0);
// DrawArrow3D(segCenterBak, dc, 2);
// break;
// case TStruLoad::LT_FOCUS:
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
// ptMid.GetMoveMatrix(ptM, mat);
// segCenterBak = segCenter;
// segCenterBak.TransformBy(mat);
//
// DrawArrow3D(segCenterBak, dc);
// break;
// case TStruLoad::LT_TRAPE:
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
// ptMid.GetMoveMatrix(ptM, mat);
// segCenter.GetSubSegment(ptMid, dLoadLen/3, segCenterBak);
// segCenterBak.TransformBy(mat);
// dc.DrawCurve(segCenterBak);
//
// DrawArrow3D(segCenterBak, dc, 0);
// DrawArrow3D(segCenterBak, dc, 1);
// DrawArrow3D(segCenterBak, dc, 2);
//
// ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
// segSub = TGGeCurveSegment(ptStart, ptS, 0);
// dc.DrawCurve(segSub);
// DrawArrow3D(segSub, dc);
//
// ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
// segSub = TGGeCurveSegment(ptEnd, ptE, 0);
// dc.DrawCurve(segSub);
// DrawArrow3D(segSub, dc);
// break;
// case TStruLoad::LT_TRIGON:
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
// ptMid.GetMoveMatrix(ptM, mat);
//
// segCenterBak = segCenter;
// segCenterBak.TransformBy(mat);
// DrawArrow3D(segCenterBak, dc);
//
// segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
// segCenterBak = segSub;
//
// ptS = segCenterBak.StartPoint();
// segSub = TGGeCurveSegment(ptM, ptS, 0);
// dc.DrawCurve(segSub);
//
// DrawArrow3D(segSub, dc);
//
// ptE = segCenterBak.EndPoint();
// segSub = TGGeCurveSegment(ptM, ptE, 0);
// dc.DrawCurve(segSub);
//
// DrawArrow3D(segSub, dc);
// break;
// case TStruLoad::LT_FOLD:
// segCenter.GetSubSegment(ptMid, dLoadLen/4, segSub);
// segCenterBak = segSub;
//
// ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
// ptS = XPoint(ptS.x, ptS.y, ptS.z+100);
//
// ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
// ptE = XPoint(ptE.x, ptE.y, ptE.z+400);
//
// segSub = TGGeCurveSegment(ptS, ptE, 0);
// dc.DrawCurve(segSub);
//
// DrawArrow3D(segSub, dc, 0);
// DrawArrow3D(segSub, dc, 1);
// DrawArrow3D(segSub, dc, 2);
// break;
// case TStruLoad::LT_MOMENT:
// arcLine.setCenter(ptMid);
// arcLine.setStartAngle(0);
// arcLine.setEndAngle(PI*3/2);
// arcLine.setRadius(200);
// arcLine.setNormal(AcGeVector3d::kZAxis);
// arcLine.setColorIndex(1);
// dc.DrawEntity(arcLine);
//
// arcLine.getEndPoint(ptE);
// segSub = TGGeCurveSegment(ptE, ptMid, 0);
// dc.DrawCurve(segSub);
// segSub = TGGeCurveSegment(ptE, XPoint(ptMid.x, ptMid.y, ptMid.z-200), 0);
// dc.DrawCurve(segSub);
//
// break;
// }
// }
//
// if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive) //活荷
// ||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive) //恒荷
// )
// {
// DrawLoadText3D(loadData, dAugle, dZ, dc);
// }
// }
//
// dc.SetColor(nColorOld);
// break;
// }
// }
//
// if(bFind)
// {
// break;
// }
// }
std::vector<TStruLoad> vecLoad;
GetLoadsArray(vecLoad);
int nSize = vecLoad.size();
if(nSize < 1)
{
return;
}
//int nColorOld = dc.GetColor();
//dc.SetColor(1);
TPushProperty vProp(this, dc);
if (m_idLayerLoad.isValid())
{
dc.SetLayer(m_idLayerLoad);
}
TGGeCurveSegment segCenter = GetCenterLine();// 梁的中心线
TGGeCurveSegment segSub, segCenterBak;
XPoint ptMid = segCenter.MidPoint();
XPoint ptStart = segCenter.GetStartPoint();
XPoint ptEnd = segCenter.GetEndPoint();
BOOL bSwitchSE = GetLRPoint(ptStart, ptEnd);// 确定起始点和终止点那个点在左侧或右侧
XPoint ptS, ptE, ptM; // 荷载图像上的起始,结束,中点
ads_matrix mat;
double dLoadLen = segCenter.GetLength();
double dZ = 500;
double dAugle = ads_angle(ptStart, ptEnd);
AcDbArc arcLine;
AcGeVector3d vecNormal = AcGeVector3d(0, 0, 1);
TStruLoad loadData;
for(int i = 0; i < nSize; i++)
{
loadData = vecLoad[i];
if(bShowGraphic)
{
// modify by wjx on 120314 修改原因:要根据荷载参数绘制荷载
switch (loadData.GetLoadType())
{
case TStruLoad::LT_ALL_H:
ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+300);
ptMid.GetMoveMatrix(ptM, mat);
segCenterBak = segCenter;
segCenterBak.TransformBy(mat);
dc.DrawCurve(segCenterBak);
DrawArrow3D(segCenterBak, dc);
segCenterBak.GetSubSegment(ptM, dLoadLen/2, segSub);
DrawArrow3D(segSub, dc, 0);
DrawArrow3D(segSub, dc, 2);
DrawArrow3D(segCenterBak, dc, 0);
DrawArrow3D(segCenterBak, dc, 2);
break;
case TStruLoad::LT_LEFT:
ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
ptMid.GetMoveMatrix(ptM, mat);
// segCenter.GetSubSegment(ptStart, dLoadLen/4, segCenterBak);
// segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(),
// dLoadLen/4, segSub);
segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000, segCenterBak);
segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(),
loadData.GetPara1() * 1000, segSub);
segSub.TransformBy(mat);
dc.DrawCurve(segSub);
segCenterBak = segSub;
ptM = segCenterBak.MidPoint();
DrawArrow3D(segCenterBak, dc);
segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
DrawArrow3D(segSub, dc, 0);
DrawArrow3D(segSub, dc, 2);
DrawArrow3D(segCenterBak, dc, 0);
DrawArrow3D(segCenterBak, dc, 2);
break;
case TStruLoad::LT_RIGHT:
ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
ptMid.GetMoveMatrix(ptM, mat);
// segCenter.GetSubSegment(ptEnd, dLoadLen/4, segCenterBak);
// segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(),
// dLoadLen/4, segSub);
segCenter.GetSubSegment(ptEnd, loadData.GetPara1() * 1000, segCenterBak);
segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(),
loadData.GetPara1() * 1000, segSub);
segSub.TransformBy(mat);
dc.DrawCurve(segSub);
segCenterBak = segSub;
ptM = segCenterBak.MidPoint();
DrawArrow3D(segCenterBak, dc);
segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
DrawArrow3D(segSub, dc, 0);
DrawArrow3D(segSub, dc, 2);
DrawArrow3D(segCenterBak, dc, 0);
DrawArrow3D(segCenterBak, dc, 2);
break;
case TStruLoad::LT_FOCUS:
ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
ptMid.GetMoveMatrix(ptM, mat);
// segCenterBak = segCenter;
segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000 * 2, segCenterBak);
segCenterBak.TransformBy(mat);
DrawArrow3D(segCenterBak, dc, 2);
break;
case TStruLoad::LT_TRAPE:
ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
ptMid.GetMoveMatrix(ptM, mat);
// segCenter.GetSubSegment(ptMid, dLoadLen/3, segCenterBak);
segCenter.GetSubSegment(ptMid, dLoadLen - 2 * loadData.GetPara1()*1000, segCenterBak);
segCenterBak.TransformBy(mat);
dc.DrawCurve(segCenterBak);
DrawArrow3D(segCenterBak, dc, 0);
DrawArrow3D(segCenterBak, dc, 1);
DrawArrow3D(segCenterBak, dc, 2);
ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
segSub = TGGeCurveSegment(ptStart, ptS, 0);
dc.DrawCurve(segSub);
DrawArrow3D(segSub, dc);
ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
segSub = TGGeCurveSegment(ptEnd, ptE, 0);
dc.DrawCurve(segSub);
DrawArrow3D(segSub, dc);
break;
case TStruLoad::LT_TRIGON:
segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2())*2*1000, segSub);
// ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
// ptMid.GetMoveMatrix(ptM, mat);
ptS = (bSwitchSE)? segSub.GetEndPoint(): segSub.GetStartPoint();
ptM = XPoint(ptS.x, ptS.y, ptS.z+400);
ptS.GetMoveMatrix(ptM, mat);
// segCenterBak = segCenter;
segCenter.GetSubSegment(ptS, loadData.GetPara2()*2*1000, segCenterBak);
segCenterBak.TransformBy(mat);
DrawArrow3D(segCenterBak, dc);
// segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segCenterBak);
// segCenterBak = segSub;
ptS = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
segSub = TGGeCurveSegment(ptM, ptS, 0);
dc.DrawCurve(segSub);
DrawArrow3D(segSub, dc);
segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2()*2)*2*1000, segCenterBak);
ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
segSub = TGGeCurveSegment(ptM, ptE, 0);
dc.DrawCurve(segSub);
DrawArrow3D(segSub, dc);
break;
case TStruLoad::LT_FOLD:
// segCenter.GetSubSegment(ptMid, dLoadLen/4, segSub);
segCenter.GetSubSegment(ptStart, loadData.GetPara2()*2*1000, segCenterBak);
ptS = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
ptS = XPoint(ptS.x, ptS.y, ptS.z+100);
segCenter.GetSubSegment(ptStart, (loadData.GetPara2()+loadData.GetPara3())*2*1000, segCenterBak);
ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
ptE = XPoint(ptE.x, ptE.y, ptE.z+400);
segSub = TGGeCurveSegment(ptS, ptE, 0);
dc.DrawCurve(segSub);
DrawArrow3D(segSub, dc, 0);
DrawArrow3D(segSub, dc, 1);
DrawArrow3D(segSub, dc, 2);
break;
case TStruLoad::LT_MOMENT:
segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segCenterBak);
// arcLine.setCenter(ptMid);
ptM = (bSwitchSE)? segCenterBak.GetEndPoint(): segCenterBak.GetStartPoint();
arcLine.setCenter(ptM);
arcLine.setStartAngle(0);
arcLine.setEndAngle(PI*3/2);
arcLine.setRadius(200);
arcLine.setNormal(AcGeVector3d::kZAxis);
arcLine.setColorIndex(1);
dc.DrawEntity(arcLine);
arcLine.getEndPoint(ptE);
segSub = TGGeCurveSegment(ptE, ptM, 0);
dc.DrawCurve(segSub);
segSub = TGGeCurveSegment(ptE, XPoint(ptM.x, ptM.y, ptM.z-200), 0);
dc.DrawCurve(segSub);
break;
}
}
if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive) //活荷
||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive) //恒荷
)
{
DrawLoadText3D(loadData, dAugle, dZ, dc);
}
}
//dc.SetColor(nColorOld);
}
void TDbStruBeam::DrawLoadText3D(TStruLoad loadData, double dAugle, double &dZ, TGGiExplodeDrawBase &dc)const
{
int nKind = loadData.GetLoadKind(); // 荷载种类
//del by xlc on 120112显示控制移到外边了
//if(!GetViewStyle(nKind))
//{
// return;
//}
// 设置文字
AcDbText text;
text.setHeight(DocGetLoadTextHeight());// 设置文字高度
// 得到梁的中心线
TGGeCurveSegment segCenter = GetCenterLine();
XPoint ptMid = segCenter.MidPoint();
// 生成要显示的荷载文字
int nType = loadData.GetLoadType(); // 荷载类型
CString strLoadInfo;
if(nType == TStruLoad::LT_FOLD)
{
strLoadInfo.Format(_T("7*%s*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()),
TrimDoubleZero(loadData.GetPara3()));
}
else if(nType == TStruLoad::LT_TRIGON)
{
strLoadInfo.Format(_T("6*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()));
}
else if(nType == TStruLoad::LT_ALL_H)
{
strLoadInfo.Format(_T("1*%s"), TrimDoubleZero(loadData.GetValue()));
}
else
{
strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
TrimDoubleZero(loadData.GetPara1()));
}
text.setTextString(strLoadInfo);
//if(nKind == TStruLoad::LK_UNVARYING)
//{
// text.setColorIndex(7);
//}
//else if(nKind == TStruLoad::LK_VARYING)
//{
// text.setColorIndex(2);
//}
if (nKind == TStruLoad::LK_UNVARYING)
{
if (m_idLayerLoadC.isValid())
{
text.setLayer(m_idLayerLoadC);
}
}
else
{
if (m_idLayerLoadL.isValid())
{
text.setLayer(m_idLayerLoadL);
}
}
text.setRotation(dAugle);
// 设置文字法向
if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
{
AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();
AcGePoint3d ptCamera, ptTarget;
vp.getCameraTarget(ptTarget);
vp.getCameraLocation(ptCamera);
AcGeVector3d vtViewDrt = ptCamera-ptTarget;
AcGeVector3d vtViewDir1= vp.viewDir();
AcGeVector3d vtCamera;
vp.getCameraUpVector(vtCamera);
vtViewDrt.normalize();
text.setNormal(vtViewDrt);
}
text.setPosition(XPoint(ptMid.x, ptMid.y, ptMid.z+dZ));
dc.DrawEntity(text);
dZ += DocGetLoadTextHeight();
}
// add by wjx on 111230
// 绘制特殊梁
void TDbStruBeam::DrawStruBeam(TGGiExplodeDrawBase &dc)const
{
int nColor = dc.GetColor();
double dLineWidth = 100;
int nType = kBeam;
XPoint ptCenter;
TGGeCurveSegment segBase;
GetBaseLine(segBase); // 得到基线
GetAt(KEY_USETYP, nType);
if(nType == kBeam) // 普通梁
{
dc.SetColor(BEAMCOLOR);
}
else if(nType == kAMBeam) // 不调幅梁
{
dc.SetColor(AMBEAMCOLOR);
}
else if(nType == kCPBeam) // 连梁
{
dc.SetColor(CPBEAMCOLOR);
}
else if(nType == kTransBeam) // 转换梁
{
dc.SetColor(TRANBEAMCOLOR);
}
else if(nType == kSlideBeam) // 滑动支梁
{
// 绘制梁中圆点
ptCenter = segBase.MidPoint();
AcDbPolyline polyLine;
double dDis = 10;
polyLine.setColorIndex(BEAMCOLOR);
polyLine.addVertexAt(0, XPoint(ptCenter.x, ptCenter.y+dDis, 0), PI, dLineWidth, dLineWidth);
polyLine.addVertexAt(1, XPoint(ptCenter.x, ptCenter.y-dDis, 0), 0.3, dLineWidth, dLineWidth);
polyLine.setClosed(Adesk::kTrue);
dc.DrawEntity(polyLine);
dc.SetColor(BEAMCOLOR);
}
dc.DrawCurve(segBase);
dc.SetColor(1);
int nHinge = GetHinge();
double dRadius = 100;
TGGeCurveSegment seg;
if(nHinge == 1) // 一端铰梁
{
int nHinge(0);
if(GetAt(KEY_HINGE, nHinge))
{
if((nHinge & HINGE_START) != 0) // 起始端
{
getStartPoint(ptCenter);
}
else
{
getEndPoint(ptCenter); // 终端
}
}
seg.SetCircle(ptCenter, dRadius);
dc.DrawCurve(seg);
}
else if(nHinge == 2) // 两端铰梁
{
getStartPoint(ptCenter);
seg.SetCircle(ptCenter, dRadius);
dc.DrawCurve(seg);
TGGeCurveSegment cvseg;
getEndPoint(ptCenter);
cvseg.SetCircle(ptCenter, dRadius);
dc.DrawCurve(cvseg);
}
dc.SetColor(nColor);
}
//add by xlc on 120118
//设置荷载数组
bool TDbStruBeam::SetLoadsArray(const std::vector<TStruLoad>& vectLoads)
{
assertWriteEnabled();
ClearLoadsArray();
return SetAt(KEY_BEAM, vectLoads);
}
//获得荷载数组
bool TDbStruBeam::GetLoadsArray(std::vector<TStruLoad>& vectLoads)const
{
assertReadEnabled();
return GetAt(KEY_BEAM, vectLoads);
}
//清除荷载数组
void TDbStruBeam::ClearLoadsArray()
{
assertWriteEnabled();
RemoveLoadsKey(KEY_BEAM);
}
// add by wjx on 120223 弯矩包络图
bool TDbStruBeam::SetMGraArray(const std::vector<TCombForceData>& vectMin, const std::vector<TCombForceData>& vectMax)
{
assertWriteEnabled();
ClearMGraArray();
return SetAt(KEY_MGRA, vectMin, vectMax);
}
//获得弯矩包络图数组
bool TDbStruBeam::GetMGraArray(std::vector<TCombForceData>& vectMin, std::vector<TCombForceData>& vectMax)const
{
assertReadEnabled();
return GetAt(KEY_MGRA, vectMin, vectMax);
}
//清除弯矩包络图数组
void TDbStruBeam::ClearMGraArray()
{
assertWriteEnabled();
RemoveMGraKey(KEY_MGRA);
}
// add by wjx on 120224 弯矩包络图
void TDbStruBeam::DrawMGraph(TGGiExplodeDrawBase &dc)const
{
std::vector<TCombForceData> vecMin, vecMax;
TPushProperty vProp(this, dc);
if(m_idLayerForce.isValid())
{
dc.SetLayer(m_idLayerForce);
}
if(GetMGraArray(vecMin, vecMax))
{
//int nColorOld = dc.GetColor();
//int nColor = 7;
//dc.SetColor(nColor);
// 得到梁的中心线
TGGeCurveSegment segCenter = GetCenterLine();
AcGePoint3d ptNode, ptStart, ptEnd;
GetAt(KEY_START, ptStart); // 得到梁的起始位置
GetAt(KEY_END, ptEnd); // 得到梁的终止位置
if(ptStart.x - ptEnd.x > _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
}
else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
{
if(ptEnd.y - ptStart.y < _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
}
}
int nCount = vecMin.size();
if (nCount < 2 || vecMax.size() < 2)
{
return;
}
double dLen = segCenter.GetLength();// 梁的长度
double dSepDis = dLen / (nCount-1); // 最小点之间的间距
double dDis= 0; // 最小点与梁起始位置的距离
TADSGePointDir2d ptTemp;
ads_real angle = 0; // 旋转方向
int nBeamType = segCenter.GetCurveType();
TADSGePoint3d ptCenter = segCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
double dRia = 0;
if(nBeamType == CURVE_ARC)
{
dRia = segCenter.GetArc().GetRadius();
}
else
{
// 计算旋转方向
angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd)); // 与x轴的夹角
if (angle - PI < g_angleZero) // 0-180度之间
{
if(angle - PI/2 > g_angleZero) // 90-180度时
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
else // 180-360度之间
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
}
bool bVisible = false;
TGGeVisibilityPoly2D polyMin;
for(int i = 0; i < nCount; i++)
{
// 求对应的最小点位置
dDis = i * dSepDis;
segCenter.Polar(dDis, ptTemp);
if(nBeamType == CURVE_ARC)
{
TGGeCurveSegment segTemp(ptCenter, ptTemp, 0, LS_INFINITE);
segTemp.Polar((vecMin[i].m_dForce*g_dMGrapScal)+dRia, ptTemp);
ptNode = ptTemp;
}
else
{
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[i].m_dForce*g_dMGrapScal);//与梁垂直方向
}
//确定边的可见性
if (vecMin[i].m_dForce < -_DIST_SNAP)
{
bVisible = true;
}
else
{
bVisible = false;
}
if (i!=0)
{
TGGeCurveSegment cvSeg(*polyMin[polyMin.Length()-1], ptNode, 0);
TADSGePoint3d ptInter1,ptInter2;
int nNum = cvSeg.Intersection(segCenter, ptInter1, ptInter2);
if (nNum == 1)
{
polyMin.AppendNode(ptInter1, 0, bVisible ? AcDb::kVisible : AcDb::kInvisible);
}
}
polyMin.AppendNode(ptNode, 0, bVisible ? AcDb::kVisible : AcDb::kInvisible);
if(i == 0)
{
ptStart = ptNode;
}
else if(i == (nCount-1))
{
ptEnd = ptNode;
}
}
DrawBaseWall2d(dc, polyMin, false);
TGGePoly2D polyMax;
polyMax.AppendNode(ptStart);
nCount = vecMax.size();
dSepDis = dLen / (nCount-1);
for(int i = 0; i < nCount; i++)
{
// 求对应的最小点位置
dDis = i * dSepDis;
segCenter.Polar(dDis, ptTemp);
if(nBeamType == CURVE_ARC) //得到梁是直梁还是弧梁
{
TGGeCurveSegment segTemp(ptCenter, ptTemp, 0, LS_INFINITE);
segTemp.Polar(dRia + (vecMax[i].m_dForce*g_dMGrapScal), ptTemp);
ptNode = ptTemp;
}
else
{
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMax[i].m_dForce*g_dMGrapScal);//与梁垂直方向
}
polyMax.AppendNode(ptNode);
}
polyMax.AppendNode(ptEnd);
dc.DrawXPoly(polyMax);
//dc.SetColor(nColorOld);
}
DrawMGraphText(dc);
}
void TDbStruBeam::DrawMGraphText(TGGiExplodeDrawBase &dc)const
{
std::vector<TCombForceData> vecMin, vecMax;
TPushProperty vProp(this, dc);
if (m_idLayerText.isValid())
{
dc.SetLayer(m_idLayerText);
}
if(GetMGraArray(vecMin, vecMax))
{
std::sort(vecMin.begin(), vecMin.end(), AscCompare);
std::sort(vecMax.begin(), vecMax.end(), AscCompare);
double dPaperScale = GetPScale();
AcDbText text;
text.setTextStyle(InitTextStyle(TS_STANDARD));
text.setHeight(g_dMGrapTextH*dPaperScale);// 设置文字高度
// 得到梁的中心线
TGGeCurveSegment segCenter = GetCenterLine();
int nBeamType = segCenter.GetCurveType();
AcGePoint3d ptNode, ptStart, ptEnd;
GetAt(KEY_START, ptStart); // 得到梁的起始位置
GetAt(KEY_END, ptEnd); // 得到梁的终止位置
BOOL bSwitch = false;
if(ptStart.x - ptEnd.x > _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
bSwitch = true;
}
else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
{
if(ptStart.y - ptEnd.y > _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
bSwitch = true;
}
}
// 计算旋转方向
ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd)); // 与x轴的夹角
if (angle - PI < g_angleZero) // 0-180度之间
{
if(angle - PI/2 > g_angleZero) // 90-180度时
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
else // 180-360度之间
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
int nCount = vecMin.size();
double dPos = segCenter.GetLength() / 10;
TADSGePointDir2d ptTemp;
CString strText;
text.setHeight(g_dMGrapTextH*dPaperScale);
// int nColor = 7;
// text.setColorIndex(nColor);
if(nCount > 0)
{
text.setRotation(angle);
strText.Format(_T("%.3f"),vecMin[nCount-1].m_dForce);
text.setTextString(strText);
segCenter.Polar((bSwitch)? 9*dPos: dPos, ptTemp);
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[nCount-1].m_dForce*g_dMGrapScal);//与梁垂直方向
text.setPosition(ptNode);
dc.DrawEntity(text);
if(nCount > 1)
{
strText.Format(_T("%.3f"),vecMin[nCount-2].m_dForce);
text.setTextString(strText);
segCenter.Polar((bSwitch)? dPos: 9*dPos, ptTemp);
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[nCount-1].m_dForce*g_dMGrapScal);
text.setPosition(ptNode);
dc.DrawEntity(text);
}
}
nCount = vecMax.size();
if(nCount > 0)
{
strText.Format(_T("%.3f"),vecMax[0].m_dForce);
text.setTextString(strText);
ptNode = TADSGePoint3d(segCenter.MidPoint(), angle+PI/2, (-1) * (vecMax[0].m_dForce*g_dMGrapScal+g_dMGrapTextH*dPaperScale));
text.setPosition(ptNode);
dc.DrawEntity(text);
}
}
}
void InitStruBeam(bool bTrue)
{
if (bTrue)
{
TDbStruBeam::rxInit();
acrxBuildClassHierarchy();
TDbStruBeam::InitMatchProtocol(TRUE);
}
else
{
TDbStruBeam::InitMatchProtocol(FALSE);
deleteAcRxClass(TDbStruBeam::desc());
}
}
// add by wjx on 120330 剪力包络图
bool TDbStruBeam::SetSGraArray(const std::vector<TCombForceData>& vectMin)
{
assertWriteEnabled();
ClearSGraArray();
return SetAt(KEY_SGRA, vectMin);
}
//获得剪力包络图数组
bool TDbStruBeam::GetSGraArray(std::vector<TCombForceData>& vectMin)const
{
assertReadEnabled();
return GetAt(KEY_SGRA, vectMin);
}
//清除剪力包络图数组
void TDbStruBeam::ClearSGraArray()
{
assertWriteEnabled();
RemoveNGraKey(KEY_SGRA);
}
// 绘制剪力包络图
void TDbStruBeam::DrawSGraph(TGGiExplodeDrawBase &dc)const
{
std::vector<TCombForceData> vecMin, vecMax;
TPushProperty vProp(this, dc);
if(m_idLayerForce.isValid())
{
dc.SetLayer(m_idLayerForce);
}
if(GetSGraArray(vecMin))
{
//int nColorOld = dc.GetColor();
//int nColor = 7;
//dc.SetColor(nColor);
// 得到梁的中心线
TGGeCurveSegment segCenter = GetCenterLine();
XPoint ptMid = segCenter.MidPoint();
AcGePoint3d ptNode, ptStart, ptEnd;
GetAt(KEY_START, ptStart); // 得到梁的起始位置
GetAt(KEY_END, ptEnd); // 得到梁的终止位置
BOOL blSwitch = FALSE;
if(ptStart.x - ptEnd.x > _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
blSwitch = TRUE;
}
else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
{
if(ptEnd.y - ptStart.y < _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
blSwitch = TRUE;
}
}
TGGePoly2D poly;
int nCount = vecMin.size();
if (nCount < 2)
{
return;
}
nCount -= 1;
double dLen = segCenter.GetLength(); // 梁的一半长度
double dSepDis = dLen/nCount; // 最小点之间的间距
double dDis= 0; // 最小点与梁起始位置的距离
TADSGePointDir2d ptTemp;
ads_real angle = 0; // 旋转方向
int nBeamType = segCenter.GetCurveType();
TADSGePoint3d ptCenter = segCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
double dRia = 0;
if(nBeamType == CURVE_ARC)
{
dRia = segCenter.GetArc().GetRadius();
}
else
{
// 计算旋转方向
angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd)); // 与x轴的夹角
if (angle - PI < g_angleZero) // 0-180度之间
{
if(angle - PI/2 > g_angleZero) // 90-180度时
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
else // 180-360度之间
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
}
int i = 0;
poly.AppendNode(ptStart);
for(; i < (int)vecMin.size(); i++)
{
// 求对应的点位置
dDis = (blSwitch) ? ((nCount - i) * dSepDis): (i * dSepDis);
segCenter.Polar(dDis, ptTemp);
if(nBeamType == CURVE_ARC)
{
TGGeCurveSegment segTemp(ptCenter, ptTemp, 0, LS_INFINITE);
segTemp.Polar((vecMin[i].m_dForce*g_dSGrapScal)+dRia, ptTemp);
ptNode = ptTemp;
}
else
{
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[i].m_dForce*g_dSGrapScal);//与梁垂直方向
}
poly.AppendNode(ptNode);
}
poly.AppendNode(ptEnd);
dc.DrawXPoly(poly);
//dc.SetColor(nColorOld);
}
DrawSGraphText(dc);
}
// 从大到小
BOOL ComparaDouble(double d1, double d2)
{
if(d1 < d2)
{
return TRUE;
}
return FALSE;
}
void TDbStruBeam::DrawSGraphText(TGGiExplodeDrawBase &dc)const
{
std::vector<TCombForceData> vecMin, vecMax;
TPushProperty vProp(this, dc);
if(m_idLayerText.isValid())
{
dc.SetLayer(m_idLayerText);
}
if(GetSGraArray(vecMin))
{
std::sort(vecMin.begin(), vecMin.end(), AscCompare);
std::sort(vecMax.begin(), vecMax.end(), AscCompare);
double dPaperScale = GetPScale();
AcDbText text;
text.setTextStyle(InitTextStyle(TS_STANDARD));
text.setHeight(g_dSGrapTextH*dPaperScale);// 设置文字高度
// 得到梁的中心线
TGGeCurveSegment segCenter = GetCenterLine();
int nBeamType = segCenter.GetCurveType();
AcGePoint3d ptNode, ptStart, ptEnd;
GetAt(KEY_START, ptStart); // 得到梁的起始位置
GetAt(KEY_END, ptEnd); // 得到梁的终止位置
BOOL bSwitch = false;
if(ptStart.x - ptEnd.x > _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
bSwitch = true;
}
else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
{
if(ptEnd.y - ptStart.y < _DIST_SNAP)
{
ptNode = ptEnd;
ptEnd = ptStart;
ptStart = ptNode;
bSwitch = true;
}
}
// 计算旋转方向
ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd)); // 与x轴的夹角
if (angle - PI < g_angleZero) // 0-180度之间
{
if(angle - PI/2 > g_angleZero) // 90-180度时
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
else // 180-360度之间
{
if(angle - 3*PI/2 < g_angleZero) // 180-270度
{
angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
}
}
double dPos = segCenter.GetLength() / 10;
TADSGePointDir2d ptTemp;
text.setRotation(angle);
//int nColor = 7;
//text.setColorIndex(nColor);
int nSize = vecMax.size();
CString strText;
if(nSize > 0)
{
strText.Format(_T("%.3f"), vecMax[0].m_dForce);
text.setTextString(strText);
segCenter.Polar((bSwitch)? 9*dPos: dPos, ptTemp);
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMax[0].m_dForce*g_dSGrapScal);//与梁垂直方向
text.setPosition(ptNode);
dc.DrawEntity(text);
}
int nCount = vecMin.size();
if(nCount > 0)
{
strText.Format(_T("%.3f"),vecMin[nCount-1].m_dForce);
text.setTextString(strText);
segCenter.Polar((bSwitch)? dPos: 9*dPos, ptTemp);
ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[nCount-1].m_dForce*g_dSGrapScal);
text.setPosition(ptNode);
dc.DrawEntity(text);
}
}
}
//梁可以合并的属性条件判断
BOOL TDbStruBeam::CanMerge(AcDbObjectId idWall)
{
int nMatTyp, nMatTypOther;
GetAt(KEY_MATTYP, nMatTyp);
double dAxAng,dAxAngOther;
GetAt(KEY_AXANG, dAxAng);
int nSecTypThis,nSecTypOther;
GetAt(KEY_SECTYP,nSecTypThis);
double dB,dH,dU,dT,dD,dF;
switch (nSecTypThis)
{
case ST_RECT:
GetAt(KEY_B,dB);
GetAt(KEY_H,dH);
break;
case ST_IBEAM:
GetAt(KEY_B,dB);
GetAt(KEY_H,dH);
GetAt(KEY_U,dU);
GetAt(KEY_T,dT);
GetAt(KEY_D,dD);
GetAt(KEY_F,dF);
break;
default:
break;
}
double dBOther,dHOther,dUOther,dTOther,dDOther,dFOther;
OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbStruBeam, pEnt);
if (pEnt)
{
pEnt->GetAt(KEY_MATTYP, nMatTypOther);
if (nMatTyp - nMatTypOther != 0)
{
//材料不同
return FALSE;
}
pEnt->GetAt(KEY_AXANG, dAxAngOther);
if (fabs(dAxAng - dAxAngOther) > g_angleZero)
{
return FALSE;
}
pEnt->GetAt(KEY_SECTYP,nSecTypOther);
if(nSecTypThis != nSecTypOther)
{
//截面类型不同
return FALSE;
}
switch (nSecTypOther)
{
case ST_RECT:
GetAt(KEY_B,dBOther);
GetAt(KEY_H,dHOther);
if(fabs(dB - dBOther) > _DIST_SNAP || fabs(dHOther - dH) > _DIST_SNAP )
{
return FALSE;
}
break;
case ST_IBEAM:
GetAt(KEY_B,dBOther);
GetAt(KEY_H,dHOther);
GetAt(KEY_U,dUOther);
GetAt(KEY_T,dTOther);
GetAt(KEY_D,dDOther);
GetAt(KEY_F,dFOther);
if(fabs(dB - dBOther) > _DIST_SNAP || fabs(dHOther - dH) > _DIST_SNAP
||fabs(dU - dUOther) > _DIST_SNAP || fabs(dTOther - dT) > _DIST_SNAP
||fabs(dD - dDOther) > _DIST_SNAP || fabs(dFOther - dF) > _DIST_SNAP)
{
return FALSE;
}
break;
default:
break;
}
}
else
{
return FALSE;
}
OPENOBJ_END();
return TRUE;
}
//梁正截面配筋面积数据
bool TDbStruBeam::SetRSArray(const std::vector<TReinSectData>& vecRSData)
{
assertWriteEnabled();
ClearRSArray();
return SetAt(KEY_RSA, vecRSData);
}
bool TDbStruBeam::GetRSArray(std::vector<TReinSectData>& vecRSData)const
{
assertReadEnabled();
return GetAt(KEY_RSA, vecRSData);
}
void TDbStruBeam::ClearRSArray()
{
assertWriteEnabled();
RemoveRSDataKey(KEY_RSA);
}
//梁正截面计算配筋面积数据
bool TDbStruBeam::SetCRSArray(const std::vector<TReinSectData>& vecRSData)
{
assertWriteEnabled();
ClearRSArray();
return SetAt(KEY_CRSA, vecRSData);
}
bool TDbStruBeam::GetCRSArray(std::vector<TReinSectData>& vecRSData)const
{
assertReadEnabled();
return GetAt(KEY_CRSA, vecRSData);
}
void TDbStruBeam::ClearCRSArray()
{
assertWriteEnabled();
RemoveRSDataKey(KEY_CRSA);
}
//梁斜截面配筋面积数据
bool TDbStruBeam::SetRSSArray(const std::vector<TReinSectData>& vecRSData)
{
assertWriteEnabled();
ClearRSSArray();
return SetAt(KEY_RSSA, vecRSData);
}
bool TDbStruBeam::GetRSSArray(std::vector<TReinSectData>& vecRSData)const
{
assertReadEnabled();
return GetAt(KEY_RSSA, vecRSData);
}
void TDbStruBeam::ClearRSSArray()
{
assertWriteEnabled();
RemoveRSDataKey(KEY_RSSA);
}
//梁尺寸图层
AcDbObjectId TDbStruBeam::GetLayerDim() const
{
return m_idLayerDim;
}
void TDbStruBeam::SetLayerDim(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerDim = idLayer;
}
//梁编号图层
AcDbObjectId TDbStruBeam::GetLayerNum() const
{
return m_idLayerNum;
}
void TDbStruBeam::SetLayerNum(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerNum = idLayer;
}
//梁标注图层
AcDbObjectId TDbStruBeam::GetLayerMark() const
{
return m_idLayerMark;
}
void TDbStruBeam::SetLayerMark(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerMark = idLayer;
}
//梁其他文字图层
AcDbObjectId TDbStruBeam::GetLayerText() const
{
return m_idLayerText;
}
void TDbStruBeam::SetLayerText(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerText = idLayer;
}
//梁钢筋图层
AcDbObjectId TDbStruBeam::GetLayerRBar() const
{
return m_idLayerRBar;
}
void TDbStruBeam::SetLayerRBar(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerRBar = idLayer;
}
//梁附加吊筋图层
AcDbObjectId TDbStruBeam::GetLayerRBarU() const
{
return m_idLayerRBarU;
}
void TDbStruBeam::SetLayerRBarU(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerRBarU = idLayer;
}
//梁附加箍筋图层
AcDbObjectId TDbStruBeam::GetLayerRBarO() const
{
return m_idLayerRBarO;
}
void TDbStruBeam::SetLayerRBarO(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerRBarO = idLayer;
}
//梁实配面积图层
AcDbObjectId TDbStruBeam::GetLayerRealArea() const
{
return m_idLayerRealArea;
}
void TDbStruBeam::SetLayerRealArea(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerRealArea = idLayer;
}
//梁计算挠度图层
AcDbObjectId TDbStruBeam::GetLayerCalDefl() const
{
return m_idLayerCalDefl;
}
void TDbStruBeam::SetLayerCalDefl(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerCalDefl = idLayer;
}
//梁计算裂缝图层
AcDbObjectId TDbStruBeam::GetLayerCalCrk() const
{
return m_idLayerCalCrk;
}
void TDbStruBeam::SetLayerCalCrk(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerCalCrk = idLayer;
}
//梁内力结果图层
AcDbObjectId TDbStruBeam::GetLayerForce() const
{
return m_idLayerForce;
}
void TDbStruBeam::SetLayerForce(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerForce = idLayer;
}
//梁计算配筋图层
AcDbObjectId TDbStruBeam::GetLayerCalcArea() const
{
return m_idLayerCalcArea;
}
void TDbStruBeam::SetLayerCalcArea(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerCalcArea = idLayer;
}
//梁荷载
AcDbObjectId TDbStruBeam::GetLayerLoad() const
{
return m_idLayerLoad;
}
void TDbStruBeam::SetLayerLoad(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerLoad = idLayer;
}
//梁活荷值
AcDbObjectId TDbStruBeam::GetLayerLoadL() const
{
return m_idLayerLoadL;
}
void TDbStruBeam::SetLayerLoadL(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerLoadL = idLayer;
}
//梁恒荷值
AcDbObjectId TDbStruBeam::GetLayerLoadC() const
{
return m_idLayerLoadC;
}
void TDbStruBeam::SetLayerLoadC(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerLoadC = idLayer;
}
//文字样式
AcDbObjectId TDbStruBeam::GetTextStyle() const
{
return m_idTextStyle;
}
void TDbStruBeam::SetTextStyle(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idTextStyle = idLayer;
}
//文字样式
AcDbObjectId TDbStruBeam::GetTextStyleRB() const
{
return m_idTextStyleRB;
}
void TDbStruBeam::SetTextStyleRB(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idTextStyleRB = idLayer;
}
//得到显示配筋面积的梁线
TGGeCurveSegment TDbStruBeam::GetBeamLine()const
{
TGGeCurveSegment segCenter = GetCenterLine();
AcDbObjectIdArray idColus;
GetAssocRelation(ASSOC_COLU, idColus); //得到关联柱子
TADSGePoint3d pt1, pt2;
for (int i = 0; i < idColus.length(); i++)
{
OPENOBJ_BEGIN(idColus[i], AcDb::kForRead, TDbColumn, pColumn);
if (pColumn == NULL)
{
continue;
}
TGGePoly2D poly;
pColumn->GetOutline(poly);
for (int j = 0; j < poly.TotalSegments(); j++)
{
TGGeCurveSegment segTemp;
poly.Nth(j, segTemp);
if (segTemp.Intersection(segCenter, pt1, pt2) == 1) //梁线跟柱子的多段线只有一个交点
{
//判断交点应该设置为梁线的哪一个点
if (segCenter.StartPoint().Distance2d(pt1) < segCenter.EndPoint().Distance2d(pt1))
{
double dDist = segCenter.PathDistance(pt1);
double dBugle = (segCenter.GetLength() - dDist)*segCenter.GetBulge()/segCenter.GetLength();
segCenter.SetStartPoint(pt1);
segCenter.SetBulge(dBugle);
}
else
{
double dDist = segCenter.PathDistance(pt1, 0);
double dBugle = (segCenter.GetLength() - dDist)*segCenter.GetBulge()/segCenter.GetLength();
segCenter.SetEndPoint(pt1);
segCenter.SetBulge(dBugle);
}
}
}
OPENOBJ_END();
}
return segCenter;
}
CString TDbStruBeam::FormatText(double dValue, int nPrec) const
{
TCString sFormat;
sFormat << _T("%.") << nPrec << _T("f");
CString strValue;
strValue = TCString(sFormat, dValue);
return strValue;
}
//绘制配筋面积数据
void TDbStruBeam::DrawReinText(TGGiExplodeDrawBase &dc, double dLeft, double dRight, double dMidUp, double dMidDown, int nPrec) const
{
TGGeCurveSegment cvSeg = GetBeamLine();
bool bIsTurn = false; //判断线段是否是逆时针
double dAngle = ads_angle(cvSeg.StartPoint(), cvSeg.EndPoint());
if (dAngle > PI/2 && dAngle <= 3*PI/2)
{
bIsTurn = true;
}
TDbText text;
AcDbObjectId id = GetTextStyleId(_T("STANDARD"));
text.setPropertiesFrom(this);
double dTextHeight = 3.5; //文字字高
text.SetHeight(dTextHeight);
text.SetStyleId(id);
text.SetText(FormatText(dLeft, nPrec));
TADSGePoint3d ptTemp = bIsTurn ? cvSeg.EndPoint() : cvSeg.StartPoint();
text.SetLocation(ptTemp);
dAngle = bIsTurn ? cvSeg.Direction(ptTemp) - PI : cvSeg.Direction(ptTemp);
text.SetRotation(dAngle); //设置文字角度，跟梁线有关系
text.SetAlignment(XExplodeDraw::kBottomLeft); //文字左侧底部对齐
dc.DrawEntity(text);
text.SetLocation(cvSeg.MidPoint()); //中间文字位置点
text.SetText(FormatText(dMidUp, nPrec));
text.SetAlignment(XExplodeDraw::kBottomCenter);
dAngle = bIsTurn ? cvSeg.Direction(cvSeg.MidPoint()) - PI : cvSeg.Direction(cvSeg.MidPoint());
text.SetRotation(dAngle); //设置文字角度
dc.DrawEntity(text);
text.SetText(FormatText(dMidDown, nPrec));
text.SetAlignment(XExplodeDraw::kTopCenter);
dc.DrawEntity(text);
text.SetText(FormatText(dRight, nPrec)); //设置右侧文字
ptTemp = bIsTurn ? cvSeg.StartPoint() : cvSeg.EndPoint();
text.SetLocation(ptTemp);
dAngle = bIsTurn ? cvSeg.Direction(ptTemp) - PI : cvSeg.Direction(ptTemp);
text.SetRotation(dAngle);
text.SetAlignment(XExplodeDraw::kBottomRight); //设置对齐方式为底部右侧对齐
dc.DrawEntity(text);
}
//绘制配筋图
void TDbStruBeam::DrawReinGragh(TGGiExplodeDrawBase &dc) const
{
double dLeft = 0, dRight = 0, dMidUp = 0, dMidDown = 0;
int nPrec = 0;
bool bShow = false;
TPushProperty vPorp(this, dc);
switch (g_nReinAreaMode)
{
case eCalArea: //计算配筋面积
{
std::vector<TReinSectData> vecData;
if( GetRSArray(vecData))
{
int nSize = vecData.size();
if(nSize > 1)
{
TReinSectData reinData = vecData[0];
dLeft = reinData.m_dArea;
reinData = vecData[nSize - 1];
dRight = reinData.m_dArea;
reinData = vecData[(int)(nSize / 2)];
dMidDown = reinData.m_dArea;
dMidUp = reinData.m_dAreaS;
dc.SetLayer(m_idLayerCalcArea);
bShow = true;
}
}
}
break;
case eRealArea: //实配面积
{
std::vector<TReinSectData> vecData;
if( GetCRSArray(vecData))
{
int nSize = vecData.size();
if(nSize > 1)
{
TReinSectData reinData = vecData[0];
dLeft = reinData.m_dArea;
reinData = vecData[nSize - 1];
dRight = reinData.m_dArea;
reinData = vecData[(int)(nSize / 2)];
dMidDown = reinData.m_dArea;
dMidUp = reinData.m_dAreaS;
dc.SetLayer(m_idLayerRealArea);
bShow = true;
}
}
}
break;
case eReinRate: //配筋率
{
std::vector<TReinSectData> vecData;
if( GetCRSArray(vecData))
{
int nSize = vecData.size();
if(nSize > 1)
{
double dArea = CalSectionArea();
if (dArea > _DIST_SNAP)
{
TReinSectData reinData = vecData[0];
dLeft = reinData.m_dArea / dArea * 100;
reinData = vecData[nSize - 1];
dRight = reinData.m_dArea / dArea * 100;
reinData = vecData[(int)(nSize / 2)];
dMidDown = reinData.m_dArea/ dArea * 100;
dMidUp = reinData.m_dAreaS / dArea * 100;
dc.SetLayer(m_idLayerRealArea);
bShow = true;
nPrec = 2; //两位精度
}
}
}
}
break;
default:
break;
}
if (bShow)
{
DrawReinText(dc, dLeft, dRight, dMidUp, dMidDown, nPrec);
}
}
//计算截面有效面积
double TDbStruBeam::CalSectionArea()const
{
int nSectType(0);
GetAt(KEY_SECTYP, nSectType);
double dB(0),dH(0),dU(0),dT(0),dD(0),dF(0),dHw(0), dArea(0);
switch (nSectType)
{
case ST_RECT: // 矩形
{
GetAt(KEY_B, dB);
GetAt(KEY_H, dH);
break;
}
case ST_IBEAM: // 工字型
{
GetAt(KEY_B, dB);
GetAt(KEY_H, dH);
break;
}
}
dArea = dB * dH;
return dArea;
}
void TDbStruBeam::RemoveCrackArray(LPCTSTR pszKey)
{
CString sKey;
sKey.Format(_T("%sLeft"), pszKey);
GetSpecialtyData()->RemoveAt(sKey);
sKey.Format(_T("%sMid"), pszKey);
GetSpecialtyData()->RemoveAt(sKey);
sKey.Format(_T("%sRight"), pszKey);
GetSpecialtyData()->RemoveAt(sKey);
}
bool TDbStruBeam::SetCrackArray(const TCrackData& crackData)
{
bool bRet = SetAt(KEY_CRACKDATA, crackData);
return bRet;
}
bool TDbStruBeam::GetCrackArray(TCrackData& crackData) const
{
bool bRet = GetAt(KEY_CRACKDATA, crackData);
return bRet;
}
void TDbStruBeam::ClearCrackArray()
{
RemoveCrackArray(KEY_CRACKDATA);
}
void TDbStruBeam::DrawCrackGraph(TGGiExplodeDrawBase& dc) const
{
// 裂缝数据
TCrackData crackData;
if (!GetCrackArray(crackData))
{
return;
}
// 获取梁的中线
TGGeCurveSegment segCenterLine = GetCenterLine();
// 梁的起点、终点和中点
TADSGePoint3d ptStart = segCenterLine.GetStartPoint();
TADSGePoint3d ptEnd = segCenterLine.GetEndPoint();
ptStart[Z] = 0;
ptEnd[Z] = 0;
TADSGePoint3d ptMid;
Midpoint(ptStart, ptEnd, ptMid);
// 梁的方向向量
TADSGePoint3d vtBeamDir = ptEnd - ptStart;
// 使梁的方向向量角度<=90度，>270度
double dAngle = vtBeamDir.AsAcGeVector2d().angle();
if (dAngle > PI / 2.0f + g_angleZero && // > 90度
dAngle < PI / 2.0f * 3.0f + g_angleZero) // <= 270度
{
// 反转方向向量
vtBeamDir = TADSGePoint3d(0, 0, 0) - vtBeamDir;
TADSGePoint3d ptTemp = ptEnd;
ptEnd = ptStart;
ptStart = ptTemp;
}
// 构造文本对象
TDbText text;
text.SetStyleId(GetTextStyleId(_T("STANDARD")));
text.SetRotation(vtBeamDir.AsAcGeVector2d().angle());
text.SetHeight(g_dCrackGraphTextH);
CString sText;
// 起点文本
sText.Format(_T("%lf"), crackData.m_dLeft);
sText.TrimRight('0');
sText.TrimRight('.');
text.SetText(sText);
text.SetLocation(ptStart);
text.SetAlignment(TGGiExplodeDrawBase::kBottomLeft);
if (crackData.m_dLeft > g_dCrackLimit + g_fZero) // > g_dCrackLimit
{
text.setColorIndex(1);
}
else
{
text.setColorIndex(7);
}
dc.DrawEntity(text);
// 中点文本
sText.Format(_T("%lf"), crackData.m_dMid);
sText.TrimRight('0');
sText.TrimRight('.');
text.SetText(sText);
text.SetLocation(ptMid);
text.SetAlignment(TGGiExplodeDrawBase::kTopCenter);
if (crackData.m_dMid > g_dCrackLimit + g_fZero) // > g_dCrackLimit
{
text.setColorIndex(1);
}
else
{
text.setColorIndex(7);
}
dc.DrawEntity(text);
// 终点文本
sText.Format(_T("%lf"), crackData.m_dRight);
sText.TrimRight('0');
sText.TrimRight('.');
text.SetText(sText);
text.SetLocation(ptEnd);
text.SetAlignment(TGGiExplodeDrawBase::kBottomRight);
if (crackData.m_dRight > g_dCrackLimit + g_fZero) // > g_dCrackLimit
{
text.setColorIndex(1);
}
else
{
text.setColorIndex(7);
}
dc.DrawEntity(text);
}
// 挠度图
bool TDbStruBeam::SetDeflectArray(const std::vector<double>& deflectData)
{
AcGeDoubleArray arData;
for (UINT i=0; i<deflectData.size(); i++)
{
arData.append(deflectData[i]);
}
bool bRet = (bool)GetSpecialtyData()->SetAt(KEY_DEFLECTDATA, arData);
return bRet;
}
bool TDbStruBeam::GetDeflectArray(std::vector<double>& deflectData) const
{
AcGeDoubleArray arData;
if (!GetSpecialtyDataReadOnly()->GetAt(KEY_DEFLECTDATA, arData))
{
return false;
}
for (int i=0; i<arData.length(); i++)
{
deflectData.push_back(arData[i]);
}
return true;
}
void TDbStruBeam::ClearDeflectArray()
{
GetSpecialtyData()->RemoveAt(KEY_DEFLECTDATA);
}
void TDbStruBeam::DrawDeflectGraph(TGGiExplodeDrawBase& dc) const
{
// 获取挠度数据
std::vector<double> vecData;
if (!GetDeflectArray(vecData) || vecData.size() < 1)
{
return;
}
// 获取数组的中间值
double dValue;
UINT uCount = vecData.size();
if (uCount % 2 != 0) // 奇数个
{
dValue = vecData[(uCount + 1) / 2 - 1];
}
else
{
dValue = max(vecData[uCount / 2 - 1], vecData[uCount / 2]);
}
// 获取梁的中线
TGGeCurveSegment segCenterLine = GetCenterLine();
// 梁的起点、终点和中点
TADSGePoint3d ptStart = segCenterLine.GetStartPoint();
TADSGePoint3d ptEnd = segCenterLine.GetEndPoint();
ptStart[Z] = 0;
ptEnd[Z] = 0;
TADSGePoint3d ptMid;
Midpoint(ptStart, ptEnd, ptMid);
// 梁的方向向量
TADSGePoint3d vtBeamDir = ptEnd - ptStart;
// 使梁的方向向量角度<=90度，>270度
double dAngle = vtBeamDir.AsAcGeVector2d().angle();
if (dAngle > PI / 2.0f + g_angleZero && // > 90度
dAngle < PI / 2.0f * 3.0f + g_angleZero) // <= 270度
{
// 反转方向向量
vtBeamDir = TADSGePoint3d(0, 0, 0) - vtBeamDir;
TADSGePoint3d ptTemp = ptEnd;
ptEnd = ptStart;
ptStart = ptTemp;
}
// 文本的偏移方向向量
TADSGePoint3d vtOffsetDir = vtBeamDir;
vtOffsetDir.Rotate(-PI / 2.0f);
// 偏移后的中点
vtOffsetDir.Normalize();
ptMid = ptMid + vtOffsetDir.AsAcGePoint3d() * dValue * g_dDeflectGraphScale;
// 绘制线
AcDbPolyline plLine;
plLine.setNormal(AcGeVector3d(0, 0, 1));
plLine.addVertexAt(0, ptStart.AsAcGePoint2d());
plLine.addVertexAt(1, ptMid.AsAcGePoint2d());
plLine.addVertexAt(2, ptEnd.AsAcGePoint2d());
plLine.setColorIndex(6);
dc.DrawEntity(plLine);
// 文本
CString sText;
sText.Format(_T("%lf"), dValue);
sText.TrimRight('0');
sText.TrimRight('.');
TDbText text;
text.SetStyleId(GetTextStyleId(_T("STANDARD")));
text.SetRotation(vtBeamDir.AsAcGeVector2d().angle());
text.SetHeight(g_dDeflectGraphTextH);
text.SetText(sText);
text.SetLocation(ptMid);
text.SetAlignment(TGGiExplodeDrawBase::kTopCenter);
text.setColorIndex(7);
dc.DrawEntity(text);
}
//恒荷弯矩值
BOOL TDbStruBeam::SetMArray(const AcGeDoubleArray& arM)
{
assertWriteEnabled();
return GetSpecialtyData()->SetAt(KEY_M, arM);
}
BOOL TDbStruBeam::GetMArray(AcGeDoubleArray& arM)const
{
assertReadEnabled();
return GetSpecialtyDataReadOnly()->GetAt(KEY_M, arM);
}
void TDbStruBeam::ClearMArray()
{
assertWriteEnabled();
GetSpecialtyData()->RemoveAt(KEY_M);
}
//活荷弯矩值
BOOL TDbStruBeam::SetMVArray(const AcGeDoubleArray& arM)
{
assertWriteEnabled();
return GetSpecialtyData()->SetAt(KEY_MV, arM);
}
BOOL TDbStruBeam::GetMVArray(AcGeDoubleArray& arM)const
{
assertReadEnabled();
return GetSpecialtyDataReadOnly()->GetAt(KEY_MV, arM);
}
void TDbStruBeam::ClearMVArray()
{
assertWriteEnabled();
GetSpecialtyData()->RemoveAt(KEY_MV);
}
//恒荷剪力值
BOOL TDbStruBeam::SetSArray(const AcGeDoubleArray& arM)
{
assertWriteEnabled();
return GetSpecialtyData()->SetAt(KEY_S, arM);
}
BOOL TDbStruBeam::GetSArray(AcGeDoubleArray& arM)const
{
assertReadEnabled();
return GetSpecialtyDataReadOnly()->GetAt(KEY_S, arM);
}
void TDbStruBeam::ClearSArray()
{
assertWriteEnabled();
GetSpecialtyData()->RemoveAt(KEY_S);
}
//活荷剪力值
BOOL TDbStruBeam::SetSVArray(const AcGeDoubleArray& arM)
{
assertWriteEnabled();
return GetSpecialtyData()->SetAt(KEY_SV, arM);
}
BOOL TDbStruBeam::GetSVArray(AcGeDoubleArray& arM)const
{
assertReadEnabled();
return GetSpecialtyDataReadOnly()->GetAt(KEY_SV, arM);
}
void TDbStruBeam::ClearSVArray()
{
assertWriteEnabled();
GetSpecialtyData()->RemoveAt(KEY_SV);
}
int TDbStruBeam::GetFirstVersion()const
{
return 10;
}
bool TDbStruBeam::IsModelEntity() const
{
return true;
}
#endif
Reference in new issue View Git Blame Copy Permalink