3243 lines
73 KiB
C++
3243 lines
73 KiB
C++
//------------------------------------------------------------------------+
|
|
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
|
|
// = FileName : TDbBaseWall类
|
|
// = Version : ver1.0
|
|
// = Author : CET
|
|
// = CreateDate : 2011-04-25
|
|
// = Description: 抽象墙基线类实现
|
|
// = Maintainers:
|
|
//
|
|
//------------------------------------------------------------------------+
|
|
|
|
#include "stdafx.h"
|
|
#ifdef TASD
|
|
#include "TDbBaseWall.h"
|
|
#include "TAsdKeyDefine.h"
|
|
#include "TBaseWallIntegrateTool.h"
|
|
#include "TAsdGlobleDef.h"
|
|
#include "TDbStruFloorSlab.h"
|
|
#include "TDbStruBeam.h"
|
|
|
|
#define BASEWALL_AS_OBJ 0 //1作为对象，0抽象基类
|
|
extern bool g_bModifyAgain;
|
|
extern BOOL g_bSplitFloor;
|
|
extern void AddMsg(const TAssocMsg& assocMsg);
|
|
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSBaseWall, ATSStruEntityBase, AcDb::kDHL_CURRENT,
|
|
AcDb::kMReleaseCurrent, 1, ATS_BASEWALL,
|
|
"ATS_BASEWALL图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
#else
|
|
ACRX_NO_CONS_DEFINE_MEMBERS(TDbBaseWall, TDbStruEntityBase);
|
|
#endif
|
|
IMPLEMENT_TENTBASE(TDbBaseWall);
|
|
|
|
const Adesk::UInt8 TDbBaseWall::g_nVersion = 1;
|
|
|
|
TDbBaseWall::TDbBaseWall()
|
|
{
|
|
|
|
|
|
}
|
|
|
|
TDbBaseWall::~TDbBaseWall()
|
|
{
|
|
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::dwgInFields( AcDbDwgFiler* pFiler )
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbCurveEntity::dwgInFields(pFiler);
|
|
if(es != Acad::eOk)
|
|
{
|
|
return es;
|
|
}
|
|
|
|
// 版本号
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
|
|
// xy平面关联对象ID数组
|
|
Adesk::UInt8 nCount = 0;
|
|
pFiler->readItem(&nCount);
|
|
AcDbSoftPointerId id;
|
|
m_arAssocBWallIds.setLogicalLength(0);
|
|
for(Adesk::UInt8 i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->readItem(&id);
|
|
m_arAssocBWallIds.append(id);
|
|
}
|
|
|
|
// z平面关联对象ID数组
|
|
nCount = 0;
|
|
pFiler->readItem(&nCount);
|
|
m_arAssocZIds.setLogicalLength(0);
|
|
for(i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->readItem(&id);
|
|
m_arAssocZIds.append(id);
|
|
}
|
|
|
|
// 关联洞对象ID数组
|
|
nCount = 0;
|
|
pFiler->readItem(&nCount);
|
|
m_arHoleIds.setLogicalLength(0);
|
|
for(i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->readItem(&id);
|
|
m_arHoleIds.append(id);
|
|
}
|
|
|
|
// 关联板对象ID数组
|
|
nCount = 0;
|
|
pFiler->readItem(&nCount);
|
|
m_arSlabIds.setLogicalLength(0);
|
|
for(i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->readItem(&id);
|
|
m_arSlabIds.append(id);
|
|
}
|
|
|
|
// 关联柱子对象ID数组
|
|
nCount = 0;
|
|
pFiler->readItem(&nCount);
|
|
m_arColumnIds.setLogicalLength(0);
|
|
for(i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->readItem(&id);
|
|
m_arColumnIds.append(id);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::dwgOutFields( AcDbDwgFiler* pFiler ) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbCurveEntity::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk)
|
|
{
|
|
return es;
|
|
}
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
// xy平面关联对象ID数组
|
|
Adesk::UInt8 nCount=(Adesk::UInt8)m_arAssocBWallIds.length();
|
|
pFiler->writeItem(nCount);
|
|
for (Adesk::UInt8 i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->writeItem(AcDbSoftPointerId(m_arAssocBWallIds[i]));
|
|
}
|
|
|
|
// z平面关联对象ID数组
|
|
nCount=(Adesk::UInt8)m_arAssocZIds.length();
|
|
pFiler->writeItem(nCount);
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->writeItem(AcDbSoftPointerId(m_arAssocZIds[i]));
|
|
}
|
|
|
|
// 关联洞对象ID数组
|
|
nCount=(Adesk::UInt8)m_arHoleIds.length();
|
|
pFiler->writeItem(nCount);
|
|
for ( i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->writeItem(AcDbSoftPointerId(m_arHoleIds[i]));
|
|
}
|
|
|
|
// 关联板对象ID数组
|
|
nCount=(Adesk::UInt8)m_arSlabIds.length();
|
|
pFiler->writeItem(nCount);
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->writeItem(AcDbSoftPointerId(m_arSlabIds[i]));
|
|
}
|
|
|
|
// 关联柱子对象ID数组
|
|
nCount=(Adesk::UInt8)m_arColumnIds.length();
|
|
pFiler->writeItem(nCount);
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
pFiler->writeItem(AcDbSoftPointerId(m_arColumnIds[i]));
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::dxfInFields( AcDbDxfFiler* pFiler )
|
|
{
|
|
return TDbCurveEntity::dxfInFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::dxfOutFields( AcDbDxfFiler* pFiler ) const
|
|
{
|
|
return TDbCurveEntity::dxfOutFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subGetOsnapPoints( AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray& geomIds ) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbCurveEntity::subGetOsnapPoints(osnapMode,gsSelectionMark,
|
|
pickPoint,lastPoint,viewXform,snapPoints,geomIds);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subGetOsnapPoints( AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray& geomIds, const AcGeMatrix3d& insertionMat ) const
|
|
{
|
|
assertReadEnabled();
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
if(osnapMode == AcDb::kOsModeIns || osnapMode == AcDb::kOsModeMid
|
|
|| osnapMode == AcDb::kOsModeNear || osnapMode == AcDb::kOsModeEnd )
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
|
|
snapPoints.append(ptS);
|
|
snapPoints.append(ptE);
|
|
}
|
|
#endif
|
|
return TDbCurveEntity::subGetOsnapPoints(osnapMode,gsSelectionMark,
|
|
pickPoint,lastPoint,viewXform,snapPoints,geomIds,insertionMat);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subTransformBy( const AcGeMatrix3d& xform )
|
|
{
|
|
assertWriteEnabled();
|
|
TDbCurveEntity::subTransformBy(xform);
|
|
AcGePoint3d ptS, ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
if (IsMirrorMatrix(xform) && fabs(dBulge) > g_angleZero) // 镜像
|
|
{
|
|
TGGeArc arc(ptS, ptE, dBulge);
|
|
TADSGePoint3d ptMid = arc.MidPoint();
|
|
ptS.transformBy(xform);
|
|
ptE.transformBy(xform);
|
|
ptMid.TransformBy(xform);
|
|
|
|
TGGeArc arcNew(ptS, ptMid, ptE);
|
|
TADSGePoint3d pt1, pt2;
|
|
arcNew.GetStartPoint(pt1);
|
|
arcNew.GetEndPoint(pt2);
|
|
ptS = pt1;
|
|
ptE = pt2;
|
|
dBulge = arcNew.Bulge();
|
|
SetAt(KEY_START, ptS);
|
|
SetAt(KEY_END, ptE);
|
|
SetAt(KEY_BULGE, dBulge);
|
|
}
|
|
else
|
|
{
|
|
ptS.transformBy(xform);
|
|
ptE.transformBy(xform);
|
|
SetAt(KEY_START, ptS);
|
|
SetAt(KEY_END, ptE);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
|
|
{
|
|
assertReadEnabled();
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
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);
|
|
#endif
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subGetStretchPoints( AcGePoint3dArray& stretchPoints ) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subMoveGripPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
|
|
{
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
AcGePoint3d ptS;
|
|
GetAt(KEY_START, ptS);
|
|
AcGePoint3d ptE;
|
|
GetAt(KEY_END, ptE);
|
|
|
|
int nIndex = indices[0];
|
|
if (nIndex == 0) // 起点
|
|
{
|
|
ptS += offset;
|
|
SetAt(KEY_START, ptS);
|
|
}
|
|
else if (nIndex == 1) // 终点
|
|
{
|
|
ptE += offset;
|
|
SetAt(KEY_END, ptE);
|
|
}
|
|
else if (nIndex == 2) // 中点
|
|
{
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
if (fabs(dBulge) < g_angleZero) // 直线
|
|
{
|
|
ptS += offset;
|
|
SetAt(KEY_START, ptS);
|
|
ptE += offset;
|
|
SetAt(KEY_END, ptE);
|
|
}
|
|
else // 弧线
|
|
{
|
|
TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMid = arc.MidPoint();
|
|
ptMid += offset;
|
|
|
|
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);
|
|
}
|
|
}
|
|
#endif
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subMoveStretchPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subGetClassID( CLSID* pClsid ) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subDeepClone( AcDbObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbStruEntityBase::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subWblockClone( AcRxObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbStruEntityBase::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subIntersectWith( const AcDbEntity* ent, AcDb::Intersect intType, AcGePoint3dArray& points, INT_PTR thisGsMarker /*= 0*/, INT_PTR otherGsMarker /*= 0*/ ) const
|
|
{
|
|
AcDbCurve *pCurve = GetBaseCurve();
|
|
if (pCurve == NULL)
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus st = pCurve->intersectWith(ent, intType, points, thisGsMarker, otherGsMarker);
|
|
delete pCurve;
|
|
return st;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::subIntersectWith( const AcDbEntity* ent, AcDb::Intersect intType, const AcGePlane& projPlane, AcGePoint3dArray& points, INT_PTR thisGsMarker /*= 0*/, INT_PTR otherGsMarker /*= 0*/ ) const
|
|
{
|
|
AcDbCurve *pCurve = GetBaseCurve();
|
|
if (pCurve == NULL)
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus st = pCurve->intersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
|
|
delete pCurve;
|
|
return st;
|
|
}
|
|
|
|
AcDbCurve* TDbBaseWall::GetBaseCurve() const
|
|
{
|
|
assertReadEnabled();
|
|
AcGePoint3d ptS, ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
|
|
/* dBulge = atan(dBulge) * 4;*/
|
|
//AcDbPolyline *pPoly = new AcDbPolyline;
|
|
//pPoly->addVertexAt(0, ptS.convert2d(AcGePlane::kXYPlane), tan(dBulge / 4));
|
|
//pPoly->addVertexAt(1,ptE.convert2d(AcGePlane::kXYPlane));
|
|
TGGeCurveSegment cvSeg(ptS,ptE,dBulge);
|
|
return cvSeg.AsAcDbCurve();
|
|
}
|
|
|
|
//用于trim/extent时修改对象
|
|
Acad::ErrorStatus TDbBaseWall::SetBaseCurve(AcDbCurve* pCurve)
|
|
{
|
|
if (pCurve == NULL)
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
assertWriteEnabled();
|
|
|
|
AcGePoint3d ptS, ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
|
|
AcDbLine *pLine = AcDbLine::cast(pCurve);
|
|
AcDbArc *pArc = AcDbArc::cast(pCurve);
|
|
if (pLine)
|
|
{
|
|
SetAt(KEY_START, AcGePoint3d(pLine->startPoint().x, pLine->startPoint().y, ptS.z));
|
|
SetAt(KEY_END, AcGePoint3d(pLine->endPoint().x, pLine->endPoint().y, ptE.z));
|
|
SetAt(KEY_BULGE, 0.0);
|
|
}
|
|
else if (pArc)
|
|
{
|
|
TGGeArc ar(TADSGePoint3d(pArc->center()), pArc->radius(), pArc->startAngle(), pArc->endAngle());
|
|
TGGeCurveSegment cvCenter;
|
|
cvCenter = ar;
|
|
|
|
SetAt(KEY_START, AcGePoint3d(cvCenter.StartPoint().x, cvCenter.StartPoint().y, ptS.z));
|
|
SetAt(KEY_END, AcGePoint3d(cvCenter.EndPoint().x, cvCenter.EndPoint().y, ptE.z));
|
|
SetAt(KEY_BULGE, cvCenter.GetBulge());
|
|
}
|
|
else
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::GetClipBoundary( TGGePoly2D& poly ) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::GetGripText( int i, CString &cs ) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
cs=_T("改变起点");
|
|
break;
|
|
case 1:
|
|
cs=_T("改变终点");
|
|
break;
|
|
case 2:
|
|
{
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
if (fabs(dBulge) < g_angleZero) // 直线
|
|
{
|
|
cs = _T("平移");
|
|
}
|
|
else // 弧线
|
|
{
|
|
cs = _T("改变中点");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
es=Acad::eInvalidInput;
|
|
break;
|
|
}
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::ExplodeOrDraw3d( TGGiExplodeDrawBase &dc ) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::ExplodeOrDraw2d( TGGiExplodeDrawBase &dc ) const
|
|
{
|
|
assertReadEnabled();
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
|
|
// 通过融合剪切墙体
|
|
TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
|
|
GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
|
|
|
|
// 起点融合
|
|
TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
|
|
|
|
// 终点融合
|
|
TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
|
|
|
|
// 墙内融合
|
|
for (int i = 0; i < arBaseWallLinesM.Length(); i++)
|
|
{
|
|
TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
|
|
}
|
|
|
|
TGGeVisibilityPoly2D left, right;
|
|
left = bwlThis.GetLeftLine();
|
|
right = bwlThis.GetRightLine();
|
|
DrawBaseWall2d(dc, left, true);
|
|
DrawBaseWall2d(dc, right, false);
|
|
#endif
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::GetExtents2d( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
bool TDbBaseWall::UnifyElevation( double dElevation )
|
|
{
|
|
|
|
SetBottomElev(dElevation);
|
|
return true;
|
|
}
|
|
|
|
void TDbBaseWall::GetTips( TDPtrList<TObjInfoUnit> & lstInfo ) const
|
|
{
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
int nWeight = 0;
|
|
GetAt(KEY_WEIGHT, nWeight);
|
|
lstInfo.Append(new TObjInfoUnit(_T("优先级"), TCString(_T("%d"), nWeight)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("关联个数"), TCString(_T("%d"), m_arAssocBWallIds.length())));
|
|
#endif
|
|
}
|
|
|
|
const TCHAR * TDbBaseWall::GetDefaultLayer() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
BOOL TDbBaseWall::IsValid() const
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
void TDbBaseWall::CopyPropertiesFrom( AcDbEntity *pSrcEntity, unsigned gMatchFlag )
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStruEntityBase::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbBaseWall *pBaseWall = TDbBaseWall::cast(pSrcEntity);
|
|
if(pBaseWall != NULL)
|
|
{
|
|
/*double dWidth = 0.0, dHeight = 0.0;
|
|
GetAt(KEY_W, dWidth);
|
|
GetAt(KEY_H, dHeight);
|
|
int nWeight = 0;
|
|
GetAt(KEY_WEIGHT, nWeight);
|
|
|
|
GetSpecialtyData()->Empty();
|
|
*GetSpecialtyData() = *pBaseWall->GetSpecialtyData();
|
|
|
|
SetAt(KEY_W, dWidth);
|
|
SetAt(KEY_H, dHeight);
|
|
SetAt(KEY_WEIGHT, nWeight);*/
|
|
}
|
|
}
|
|
|
|
TEntityBase::DrawType TDbBaseWall::GetDrawType() const
|
|
{
|
|
assertReadEnabled();
|
|
return TEntityBase::k2Dand3D;
|
|
}
|
|
|
|
bool TDbBaseWall::GetStandardFaceBody( AcDbVoidPtrArray& arFacePtrs ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool TDbBaseWall::GetSafeProtectedSpace( AcDbVoidPtrArray& arFacePtrs ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool TDbBaseWall::GetSection( const AcDbFace &face, const AcGeVector3d& vtPlaneSecDir, std::vector<TObjSectionRecord> §ionRecords, AcDbVoidPtrArray& arFillPtrs ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CString TDbBaseWall::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
return _T("");
|
|
}
|
|
|
|
void TDbBaseWall::PostAssocMsg( TAssocMsg assocMsg ) const
|
|
{
|
|
|
|
}
|
|
|
|
void TDbBaseWall::ReceiveAssocMsg( TAssocMsg assocMsg )
|
|
{
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
AcDbObjectId id = assocMsg.GetAssocId();
|
|
if (!m_arAssocBWallIds.contains(id))
|
|
{
|
|
m_arAssocBWallIds.append(id);
|
|
}
|
|
return;
|
|
#endif
|
|
assertWriteEnabled();
|
|
|
|
//不是夹点消息直接返回
|
|
if (assocMsg.GetMethod() != TAssocMsg::kMovegrippoint)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TGGeCurveSegment cvCL = GetCenterLine();
|
|
|
|
double dElevS = cvCL.GetStartPoint().z;
|
|
double dElevE = cvCL.GetEndPoint().z;
|
|
|
|
cvCL.SetElevation(0);
|
|
|
|
AcGeVector3d vtDir = (cvCL.GetEndPoint() - cvCL.GetStartPoint()).AsAcGeVector3d();
|
|
|
|
AcGeVector3d vtOffset = assocMsg.GetOffset();
|
|
AcGePoint3d ptTarget = assocMsg.GetTarget();
|
|
|
|
double dRet = vtOffset.dotProduct(vtDir);
|
|
if (fabs(vtOffset.dotProduct(vtDir)) < _DIST_SNAP) //垂直
|
|
{
|
|
AcGePoint3d ptStart = cvCL.GetStartPoint().AsAcGePoint3d();
|
|
AcGePoint3d ptEnd = cvCL.GetEndPoint().AsAcGePoint3d();
|
|
|
|
ptStart += vtOffset;
|
|
ptStart.z = dElevS;
|
|
|
|
SetAt(KEY_START, ptStart);
|
|
|
|
ptEnd += vtOffset;
|
|
ptEnd.z = dElevE;
|
|
SetAt(KEY_END, ptEnd);
|
|
|
|
TAssocMsg msg;
|
|
msg.SetAssocId(objectId());
|
|
msg.SetMethod(TAssocMsg::kMovegrippoint);
|
|
msg.SetTarget(cvCL.MidPoint().AsAcGePoint3d());
|
|
msg.SetOffset(vtOffset);
|
|
|
|
AddMsg(msg);
|
|
}
|
|
else //不垂直时只需修改自身起始点，不发送消息
|
|
{
|
|
TADSGePoint3d pt = ptTarget;
|
|
pt.z = 0;
|
|
if (vtOffset.isParallelTo(vtDir)) //平行
|
|
{
|
|
cvCL.ProjectToMe(pt, pt);
|
|
}
|
|
else //斜交
|
|
{
|
|
AcGeVector3d vtOrth = vtOffset.perpVector();
|
|
vtOrth = vtOffset;
|
|
vtOrth.rotateBy(PI*0.5, AcGeVector3d::kZAxis);
|
|
TADSGePoint3d ptEnd = ptTarget + vtOrth;
|
|
TGGeCurveSegment cv(ptTarget, ptEnd, 0, LS_INFINITE);
|
|
|
|
cv.SetElevation(0);
|
|
cvCL.SetLineFlag(LS_INFINITE);
|
|
cv.Intersection(cvCL, pt, TADSGePoint3d());
|
|
|
|
//求投影向量
|
|
double dAng = vtOffset.angleTo(vtDir);
|
|
double dLen = vtOffset.length();
|
|
dLen /= fabs(cos(dAng)); //偏移向量在线上的投影长度
|
|
vtOffset = vtDir.normal();
|
|
vtOffset.z = 0;
|
|
vtOffset *= dLen;
|
|
if (dAng > PI*0.5)
|
|
{
|
|
vtOffset.negate();
|
|
}
|
|
}
|
|
|
|
int nPos = (pt & cvCL); //交点与线的位置关系
|
|
if (nPos == PR_ONPT1) //起点
|
|
{
|
|
AcGePoint3d ptMod = cvCL.GetStartPoint().AsAcGePoint3d();
|
|
ptMod += vtOffset;
|
|
ptMod.z = dElevS;
|
|
SetAt(KEY_START, ptMod);
|
|
}
|
|
else if (nPos == PR_ONPT2) //终点
|
|
{
|
|
AcGePoint3d ptMod = cvCL.GetEndPoint().AsAcGePoint3d();
|
|
ptMod += vtOffset;
|
|
ptMod.z = dElevE;
|
|
SetAt(KEY_END, ptMod);
|
|
}
|
|
else if (nPos == PR_INSIDE) //线内
|
|
{
|
|
AcGePoint3d ptMod = pt.AsAcGePoint3d();
|
|
ptMod += vtOffset;
|
|
|
|
nPos = (TADSGePoint3d(ptMod) & cvCL);
|
|
if (nPos == PR_EXTEND) //新位置交点在线外时需要延长
|
|
{
|
|
if (vtOffset.angleTo(vtDir) < _DIST_SNAP)//同向
|
|
{
|
|
ptMod.z = dElevE;
|
|
SetAt(KEY_END, ptMod);
|
|
}
|
|
else
|
|
{
|
|
ptMod.z = dElevS;
|
|
SetAt(KEY_START, ptMod);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDbBaseWall::MakeAssocRelation( AcDbObjectIdArray& ids )
|
|
{
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
for (int i = 0; i < ids.length(); i++)
|
|
{
|
|
if (!m_arAssocBWallIds.contains(ids[i]))
|
|
{
|
|
m_arAssocBWallIds.append(ids[i]);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// 不验证关系，直接建立关联关系
|
|
void TDbBaseWall::MakeAssocRelationDirect(const AcDbObjectId& idObj)
|
|
{
|
|
assertWriteEnabled();
|
|
TPickEntSet ss(SS_FREE);
|
|
ss += idObj;
|
|
|
|
TEntitySet ent;
|
|
for (long i = 0; i < ss.Length(); i++)
|
|
{
|
|
ent = ss[i];
|
|
if (ent.Is(_T("ATS_STRUBEAM"))
|
|
||ent.Is(_T("ATS_WALL"))) // 梁
|
|
{
|
|
if (!m_arAssocBWallIds.contains(idObj))
|
|
{
|
|
m_arAssocBWallIds.append(idObj);
|
|
}
|
|
}
|
|
else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
|
|
{
|
|
if (!m_arColumnIds.contains(idObj))
|
|
{
|
|
m_arColumnIds.append(idObj);
|
|
}
|
|
}
|
|
else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
|
|
{
|
|
if (!m_arSlabIds.contains(idObj))
|
|
{
|
|
m_arSlabIds.append(idObj);
|
|
}
|
|
}
|
|
else if (ent.Is(_T("TCH_STRU_HOLE"))) // 墙洞
|
|
{
|
|
if (!m_arHoleIds.contains(idObj))
|
|
{
|
|
m_arHoleIds.append(idObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDbBaseWall::RemoveAssocRelation( AcDbObjectId& id )
|
|
{
|
|
m_arAssocBWallIds.remove(id);
|
|
}
|
|
|
|
void TDbBaseWall::GetAssocRelation( int nType, AcDbObjectIdArray& ar ) const
|
|
{
|
|
assertReadEnabled();
|
|
switch(nType)
|
|
{
|
|
case ASSOC_XY: // XY平面关联
|
|
{
|
|
ar = m_arAssocBWallIds;
|
|
break;
|
|
}
|
|
case ASSOC_Z: // Z平面关联
|
|
{
|
|
//ar = m_arAssocZIds;
|
|
break;
|
|
}
|
|
case ASSOC_HOLE: // 关联洞
|
|
{
|
|
ar = m_arHoleIds;
|
|
break;
|
|
}
|
|
case ASSOC_SLAB:// 关联楼板
|
|
{
|
|
ar = m_arSlabIds;
|
|
break;
|
|
}
|
|
case ASSOC_COLU: // 关联柱
|
|
{
|
|
ar = m_arColumnIds;
|
|
break;
|
|
}
|
|
case ASSOC_ALL: //所有关联
|
|
{
|
|
ar.setLogicalLength(0);
|
|
if (m_arAssocBWallIds.length() > 0)
|
|
{
|
|
ar.append(m_arAssocBWallIds);
|
|
}
|
|
|
|
if (m_arColumnIds.length() > 0)
|
|
{
|
|
ar.append(m_arColumnIds);
|
|
}
|
|
|
|
if (m_arSlabIds.length() > 0)
|
|
{
|
|
ar.append(m_arSlabIds);
|
|
}
|
|
|
|
if (m_arHoleIds.length() > 0)
|
|
{
|
|
ar.append(m_arHoleIds);
|
|
}
|
|
|
|
//if (m_arAssocZIds.length() > 0)
|
|
//{
|
|
// ar.append(m_arAssocZIds);
|
|
//}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDbBaseWall::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 TDbBaseWall::GetAssocBaseWallLine( TDPtrList<TBaseWallLine>& arBaseWallLinesS, TDPtrList<TBaseWallLine>& arBaseWallLinesM, TDPtrList<TBaseWallLine>& arBaseWallLinesE ) const
|
|
{
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
|
|
TDbBaseWall *pBaseWall = NULL;
|
|
TBaseWallLine bwlThat;
|
|
for (int i = 0; i < m_arAssocBWallIds.length(); i++)
|
|
{
|
|
acdbOpenObject(pBaseWall, m_arAssocBWallIds[i], AcDb::kForRead);
|
|
if (pBaseWall != NULL)
|
|
{
|
|
pBaseWall->GetThisBaseWallLine(bwlThat);
|
|
pBaseWall->close();
|
|
|
|
// 判断墙线融合方式
|
|
TBaseWallLine *pBWLine = new TBaseWallLine;
|
|
pBWLine->SetLeftLine(bwlThat.GetLeftLine());
|
|
pBWLine->SetRightLine(bwlThat.GetRightLine());
|
|
pBWLine->SetWeight(bwlThat.GetWeight());
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDbBaseWall::GetAssocHoleline( TDPtrList<TGGePoly2D> &plHoles ) const
|
|
{
|
|
plHoles.Reset();
|
|
//TGGePoly2D poly;
|
|
//TGGeCurveSegment seg;
|
|
//TDbStruWallHole *pHole = NULL;
|
|
//for (int i = 0; i < m_arHoleIds.length(); i++)
|
|
//{
|
|
// acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
|
|
// if (pHole != NULL)
|
|
// {
|
|
// poly.Reset();
|
|
// pHole->GetOutlinePoly2D(pHole->GetBottomElev(), poly, seg);
|
|
// pHole->close();
|
|
// plHoles.Append(new TGGePoly2D(poly));
|
|
// }
|
|
//}
|
|
}
|
|
|
|
AcDbFace* TDbBaseWall::GetXYAssocFace( bool bTopOrBottom ) const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void TDbBaseWall::recordGraphicModified()const
|
|
{
|
|
|
|
}
|
|
|
|
double TDbBaseWall::GetBottomElev() const
|
|
{
|
|
assertReadEnabled();
|
|
AcGePoint3d ptE;
|
|
GetAt(KEY_END, ptE);
|
|
return ptE.z;
|
|
}
|
|
|
|
void TDbBaseWall::SetBottomElev( double dElev )
|
|
{
|
|
assertWriteEnabled();
|
|
AcGePoint3d ptS, ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
ptS.z = dElev;
|
|
ptE.z = dElev;
|
|
SetAt(KEY_START, ptS);
|
|
SetAt(KEY_END, ptE);
|
|
}
|
|
|
|
void TDbBaseWall::GetSideCurve(TGGeCurveSegment &lCurve, TGGeCurveSegment &rCurve) const
|
|
{
|
|
assertReadEnabled();
|
|
TGGeCurveSegment cvCenter = GetCenterLine();
|
|
|
|
double dWidth = 0;
|
|
GetTotalWidth(dWidth);
|
|
|
|
lCurve = cvCenter.Offset(OFFSET_LEFT, dWidth*0.5, LS_FINITE);
|
|
rCurve = cvCenter.Offset(OFFSET_RIGHT, dWidth*0.5, LS_FINITE);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbBaseWall::DrawBaseWall2d(TGGiExplodeDrawBase &dc, TGGeVisibilityPoly2D poly, bool bLeft) const
|
|
{
|
|
// 根据可见性显示各段线段
|
|
TGGeLine line;
|
|
TGGeArc arc;
|
|
AcDb::Visibility eVal;
|
|
TADSGePoint3d ptS, ptE;
|
|
for(int i = 0; i < poly.Length(); i++)
|
|
{
|
|
int nrc = poly.Nth(i, line, arc, &eVal);
|
|
if (nrc == LINE_SEGMENT && eVal == AcDb::kVisible)
|
|
{
|
|
dc << line;
|
|
}
|
|
else if (nrc == ARC_SEGMENT && eVal == AcDb::kVisible)
|
|
{
|
|
dc << arc;
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void TDbBaseWall::GetWallId(bool bStart, AcDbObjectId &idWall) const
|
|
{
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
|
|
TDbBaseWall *pBaseWall = NULL;
|
|
TBaseWallLine bwlThat;
|
|
for (int i = 0; i < m_arAssocBWallIds.length(); i++)
|
|
{
|
|
acdbOpenObject(pBaseWall, m_arAssocBWallIds[i], AcDb::kForRead);
|
|
if (pBaseWall != NULL)
|
|
{
|
|
pBaseWall->GetThisBaseWallLine(bwlThat);
|
|
pBaseWall->close();
|
|
|
|
// 判断墙线融合方式
|
|
TBaseWallLine *pBWLine = new TBaseWallLine;
|
|
pBWLine->SetLeftLine(bwlThat.GetLeftLine());
|
|
pBWLine->SetRightLine(bwlThat.GetRightLine());
|
|
pBWLine->SetWeight(bwlThat.GetWeight());
|
|
|
|
int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThis, bwlThat);
|
|
if ((nType == 1 || nType == 3) && bStart) // 起始端融合 或 两端融合
|
|
{
|
|
idWall = m_arAssocBWallIds[i];
|
|
break;
|
|
}
|
|
else if ((nType == 2 || nType == 3) && !bStart) // 终止端融合 或 两端融合
|
|
{
|
|
idWall = m_arAssocBWallIds[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDbBaseWall::GetSegmentForSlab2d(const TGGePoly2D &polySlab, const TGGeCurveSegment &seg, std::vector<TGGeCurveSegment> &vecSeg1, std::vector<TGGeCurveSegment> &vecSeg2) const
|
|
{
|
|
TGGePoly2D poly(polySlab);
|
|
poly.SetElevation(0.0);
|
|
AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
|
|
if (pLine == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool bLine = true;
|
|
AcDbLine lineTemp;
|
|
AcDbArc arcTemp;
|
|
if (seg.Is(CURVE_ARC))
|
|
{
|
|
TGGeArc arc;
|
|
arc = seg.GetArc();
|
|
bLine = false;
|
|
TADSGePoint3d ptCenter = arc.GetCenterPt();
|
|
arcTemp.setCenter(ptCenter.AsAcGePoint3d());
|
|
arcTemp.setStartAngle(arc.GetStarAngle());
|
|
arcTemp.setEndAngle(arc.GetEndAngle());
|
|
arcTemp.setRadius(arc.GetRadius());
|
|
}
|
|
else if (seg.Is(CURVE_LINE))
|
|
{
|
|
TGGeLine line;
|
|
line = seg.GetLine();
|
|
line.StartPoint().z = 0.0;
|
|
line.EndPoint().z = 0.0;
|
|
lineTemp.setStartPoint(line.StartPoint());
|
|
lineTemp.setEndPoint(line.EndPoint());
|
|
}
|
|
else
|
|
{
|
|
delete pLine;
|
|
return;
|
|
}
|
|
|
|
// 是否有交点
|
|
AcGePoint3dArray ptArr;
|
|
if (bLine)
|
|
{
|
|
pLine->intersectWith(&lineTemp, AcDb::kOnBothOperands, ptArr);
|
|
}
|
|
else
|
|
{
|
|
pLine->intersectWith(&arcTemp, AcDb::kOnBothOperands, ptArr);
|
|
}
|
|
|
|
|
|
int nNum = ptArr.length();
|
|
if (nNum > 1) // 可能存在重复点, 删除重复点
|
|
{
|
|
AcGePoint3d pt;
|
|
for (int i = 0; i < ptArr.length(); i++)
|
|
{
|
|
for (int j = i + 1; j < ptArr.length(); j++)
|
|
{
|
|
if ((ptArr[i]).distanceTo(ptArr[j]) < _DIST_SNAP)
|
|
{
|
|
ptArr.removeAt(j);
|
|
j = i;
|
|
}
|
|
}
|
|
}
|
|
nNum = ptArr.length();
|
|
}
|
|
|
|
if (nNum == 0) // 无交点
|
|
{
|
|
if (bLine)
|
|
{
|
|
if (IsLineInPoly(poly, &lineTemp)) // 直线在poly外
|
|
{
|
|
vecSeg1.push_back(seg);
|
|
}
|
|
else // 直线在poly内
|
|
{
|
|
vecSeg2.push_back(seg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TADSGePoint3d ptS, ptE;
|
|
arcTemp.getStartPoint(ptS);
|
|
arcTemp.getEndPoint(ptE);
|
|
AcDbLine line(ptS.AsAcGePoint3d(), ptE.AsAcGePoint3d());
|
|
if (IsLineInPoly(poly, &line)) // 直线在poly外
|
|
{
|
|
vecSeg1.push_back(seg);
|
|
}
|
|
else // 直线在poly内
|
|
{
|
|
vecSeg2.push_back(seg);
|
|
}
|
|
}
|
|
}
|
|
else if (nNum == 1) // 存在一个交点，有部分线段在poly2d
|
|
{
|
|
if (bLine)
|
|
{
|
|
TADSGePoint3d pt = poly.GetInsidePoint();
|
|
AcGePoint3d ptS = lineTemp.startPoint(), ptE = lineTemp.endPoint();
|
|
pt = ptArr[0];
|
|
if (!IsLineInPoly(poly, &lineTemp)) // 起点在poly内
|
|
{
|
|
TGGeLine line1(TADSGePoint3d(ptS), pt);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = line1;
|
|
vecSeg2.push_back(segTemp); // 虚线
|
|
TGGeLine line2(TADSGePoint3d(ptE), pt);
|
|
segTemp = line2;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
else
|
|
{
|
|
TGGeLine line1(TADSGePoint3d(ptE), pt);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = line1;
|
|
vecSeg2.push_back(segTemp); // 虚线
|
|
TGGeLine line2(TADSGePoint3d(ptS), pt);
|
|
segTemp = line2;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TADSGePoint3d pt = poly.GetInsidePoint();
|
|
AcGePoint3d ptS, ptE;
|
|
arcTemp.getStartPoint(ptS);
|
|
arcTemp.getEndPoint(ptE);
|
|
AcDbLine line(ptS, pt.AsAcGePoint3d());
|
|
pt = ptArr[0];
|
|
AcGePoint3d ptCenter = arcTemp.center();
|
|
AcGeVector3d vt1 = ptS - ptCenter;
|
|
AcGeVector3d vt2 = ptArr[0] - ptCenter;
|
|
AcGeVector3d vt3 = ptE - ptCenter;
|
|
double dAngle1 = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
double dAngle2 = vt2.angleTo(vt3, AcGeVector3d::kZAxis);
|
|
if (!IsLineInPoly(poly, &line)) // 起点在poly内
|
|
{
|
|
TGGeArc arc1(ptS, pt, dAngle1);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = arc1;
|
|
vecSeg2.push_back(segTemp);
|
|
TGGeArc arc2(pt, ptE, dAngle2);
|
|
segTemp = arc2;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
else
|
|
{
|
|
TGGeArc arc1(pt, ptE, dAngle2);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = arc1;
|
|
vecSeg2.push_back(segTemp);
|
|
TGGeArc arc2(ptS, pt, dAngle1);
|
|
segTemp = arc2;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
}
|
|
}
|
|
else if (nNum == 2) // 存在两个交点，线段被分成三分
|
|
{
|
|
if (bLine)
|
|
{
|
|
TADSGePoint3d pt1 = ptArr[0], pt2 = ptArr[1];
|
|
TGGeLine line1(pt1, pt2);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = line1;
|
|
vecSeg2.push_back(segTemp); // 虚线
|
|
|
|
// 根据两交点的顺序，生成相应线段
|
|
TADSGePoint3d pt3 = lineTemp.startPoint(), pt4 = lineTemp.endPoint();
|
|
if (pt1.Distance(pt3) < pt2.Distance(pt3))
|
|
{
|
|
TGGeCurveSegment segTemp;
|
|
if (pt1.Distance(pt3) > _DIST_SNAP)
|
|
{
|
|
TGGeLine line1(pt1, pt3);
|
|
segTemp = line1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
|
|
if (pt2.Distance(pt4) > 0)
|
|
{
|
|
TGGeLine line1(pt2, pt4);
|
|
segTemp = line1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TGGeCurveSegment segTemp;
|
|
if (pt1.Distance(pt4) > _DIST_SNAP)
|
|
{
|
|
TGGeLine line1(pt1, pt4);
|
|
segTemp = line1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
|
|
if (pt2.Distance(pt3) > _DIST_SNAP)
|
|
{
|
|
TGGeLine line1(pt2, pt3);
|
|
segTemp = line1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
double dDist1 = 0.0, dDist2 = 0.0;
|
|
arcTemp.getDistAtPoint(ptArr[0], dDist1);
|
|
arcTemp.getDistAtPoint(ptArr[1], dDist2);
|
|
AcGePoint3d ptS, ptE;
|
|
arcTemp.getStartPoint(ptS);
|
|
arcTemp.getEndPoint(ptE);
|
|
if (dDist1 < dDist2)
|
|
{
|
|
AcGePoint3d ptCenter = arcTemp.center();
|
|
AcGeVector3d vt1 = ptS - ptCenter;
|
|
AcGeVector3d vt2 = ptArr[0] - ptCenter;
|
|
AcGeVector3d vt3 = ptArr[1] - ptCenter;
|
|
AcGeVector3d vt4 = ptE - ptCenter;
|
|
double dAngle1 = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
double dAngle2 = vt2.angleTo(vt3, AcGeVector3d::kZAxis);
|
|
double dAngle3 = vt3.angleTo(vt4, AcGeVector3d::kZAxis);
|
|
|
|
TGGeCurveSegment segTemp;
|
|
if (ptS.distanceTo(ptArr[0]) > _DIST_SNAP)
|
|
{
|
|
TGGeArc arc1(ptS, ptArr[0], dAngle1);
|
|
segTemp = arc1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
|
|
TGGeArc arc2(ptArr[0], ptArr[1], dAngle2);
|
|
segTemp = arc2;
|
|
vecSeg2.push_back(segTemp);
|
|
|
|
if (ptE.distanceTo(ptArr[1]) > _DIST_SNAP)
|
|
{
|
|
TGGeArc arc1(ptArr[1], ptE, dAngle3);
|
|
segTemp = arc1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptCenter = arcTemp.center();
|
|
AcGeVector3d vt1 = ptS - ptCenter;
|
|
AcGeVector3d vt2 = ptArr[1] - ptCenter;
|
|
AcGeVector3d vt3 = ptArr[0] - ptCenter;
|
|
AcGeVector3d vt4 = ptE - ptCenter;
|
|
double dAngle1 = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
double dAngle2 = vt2.angleTo(vt3, AcGeVector3d::kZAxis);
|
|
double dAngle3 = vt3.angleTo(vt4, AcGeVector3d::kZAxis);
|
|
|
|
TGGeCurveSegment segTemp;
|
|
if (ptS.distanceTo(ptArr[1]) > _DIST_SNAP)
|
|
{
|
|
TGGeArc arc1(ptS, ptArr[1], dAngle1);
|
|
segTemp = arc1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
|
|
TGGeArc arc2(ptArr[1], ptArr[0], dAngle2);
|
|
segTemp = arc2;
|
|
vecSeg2.push_back(segTemp);
|
|
|
|
if (ptE.distanceTo(ptArr[0]) > _DIST_SNAP)
|
|
{
|
|
TGGeArc arc1(ptArr[0], ptE, dAngle3);
|
|
segTemp = arc1;
|
|
vecSeg1.push_back(segTemp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete pLine;
|
|
}
|
|
// 平面内的线无交点的情况下，线是否在poly内
|
|
bool TDbBaseWall::IsLineInPoly(TGGePoly2D &poly, AcDbLine *pLine) const
|
|
{
|
|
if (pLine == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool bRet = true;
|
|
XPoint pt1 = pLine->startPoint();
|
|
XPoint pt2 = pLine->endPoint();
|
|
if (((pt1 & poly) == PR_INSIDE) && ((pt2 & poly) == PR_INSIDE))
|
|
{
|
|
bRet = false;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
void TDbBaseWall::FiltrateSegment(std::vector<TGGeCurveSegment> &vecSeg1, std::vector<TGGeCurveSegment> &vecSeg2) const
|
|
{
|
|
// 删除重复线
|
|
FiltrateSegment(vecSeg1);
|
|
FiltrateSegment(vecSeg2);
|
|
|
|
// 删除与虚线重叠的实线部分
|
|
std::vector<TGGeCurveSegment>::iterator it;
|
|
for (it = vecSeg2.begin(); it != vecSeg2.end(); it++)
|
|
{
|
|
FiltrateSegment(*it, vecSeg1);
|
|
}
|
|
}
|
|
|
|
|
|
void TDbBaseWall::FiltrateSegment(const TGGeCurveSegment &seg, std::vector<TGGeCurveSegment> &vecSeg) const
|
|
{
|
|
CurveType type = seg.GetCurveType();
|
|
TGGeLine line;
|
|
TGGeArc arc;
|
|
TADSGePoint3d pt1, pt2, ptS, ptE;
|
|
ptS = seg.StartPoint();
|
|
ptE = seg.EndPoint();
|
|
bool bModify = false;
|
|
std::vector<TGGeCurveSegment> vecDel, vevNew;
|
|
std::vector<TGGeCurveSegment>::iterator it;
|
|
for(it = vecSeg.begin(); it != vecSeg.end(); it++)
|
|
{
|
|
bModify = false;
|
|
if(it->GetLength() < _DIST_SNAP)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (type == it->GetCurveType())
|
|
{
|
|
if (type == CURVE_ARC)
|
|
{
|
|
arc = it->GetArc();
|
|
}
|
|
else if (type == CURVE_LINE)
|
|
{
|
|
line = it->GetLine();
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (type == CURVE_LINE)
|
|
{
|
|
line.SetLineFlag(1);
|
|
AcGeVector3d vt1 = ptS - ptE, vt2 = line.StartPoint() - line.EndPoint();
|
|
bool bVal1 = fabs(ptS.Distance(line.StartPoint()) + ptS.Distance(line.EndPoint()) - line.GetLength())< _DIST_SNAP;
|
|
bool bVal2 = fabs(ptE.Distance(line.StartPoint()) + ptE.Distance(line.EndPoint()) - line.GetLength())< _DIST_SNAP;
|
|
if (vt1.isParallelTo(vt2) && (bVal1 || bVal2)) // 共线有交点
|
|
{
|
|
if (ptS.Distance(line.StartPoint()) < _DIST_SNAP && ptE.Distance(line.EndPoint()) < _DIST_SNAP
|
|
|| ptS.Distance(line.EndPoint()) < _DIST_SNAP && ptE.Distance(line.StartPoint()) < _DIST_SNAP) // 重合
|
|
{
|
|
bModify = true;
|
|
}
|
|
else if (bVal1 && bVal2) // 包含关系
|
|
{
|
|
double dDist1 = ptS.Distance(line.StartPoint());
|
|
double dDist2 = ptE.Distance(line.StartPoint());
|
|
if (dDist1 < dDist2)
|
|
{
|
|
if (dDist1 > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptS, line.StartPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
|
|
if (ptE.Distance(line.EndPoint()) > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptE, line.EndPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dDist2 > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptE, line.StartPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
|
|
if (ptS.Distance(line.EndPoint()) > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptS, line.EndPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
|
|
}
|
|
else if (bVal1)
|
|
{
|
|
double dDist1 = ptE.Distance(line.StartPoint());
|
|
double dDist2 = ptE.Distance(line.EndPoint());
|
|
|
|
if (dDist1 < dDist2)
|
|
{
|
|
if (ptS.Distance(line.EndPoint()) > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptS, line.EndPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ptS.Distance(line.StartPoint()) > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptS, line.StartPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
}
|
|
else if (bVal2)
|
|
{
|
|
double dDist1 = ptS.Distance(line.StartPoint());
|
|
double dDist2 = ptS.Distance(line.EndPoint());
|
|
|
|
if (dDist1 < dDist2)
|
|
{
|
|
if (ptE.Distance(line.EndPoint()) > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptE, line.EndPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ptE.Distance(line.StartPoint()) > _DIST_SNAP)
|
|
{
|
|
TGGeLine lineTemp(ptE, line.StartPoint());
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = lineTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TGGeArc arcSeg = seg.GetArc();
|
|
double dRadius = arcSeg.GetRadius();
|
|
int bVal1 = arc.PtOnArc(ptS);
|
|
int bVal2 = arc.PtOnArc(ptE);
|
|
if (fabs(dRadius - arc.GetRadius()) < _DIST_SNAP && (arc.GetCenterPt()).Distance(arcSeg.GetCenterPt()) < _DIST_SNAP
|
|
&& (bVal1 || bVal2)) // 共弧有交点
|
|
{
|
|
TADSGePoint3d pt1, pt2, ptCenter;
|
|
arc.GetStartPoint(pt1);
|
|
arc.GetEndPoint(pt2);
|
|
arc.Center(ptCenter);
|
|
if (ptS.Distance(pt1) < _DIST_SNAP && ptE.Distance(pt2) < _DIST_SNAP
|
|
|| ptS.Distance(pt2) < _DIST_SNAP && ptE.Distance(pt1) < _DIST_SNAP) // 重合
|
|
{
|
|
bModify = true;
|
|
}
|
|
else if (bVal1 && bVal1) // 虚线在实线内
|
|
{
|
|
AcGeVector3d vt1 = pt1 - ptCenter;
|
|
AcGeVector3d vt2 = ptS - ptCenter;
|
|
AcGeVector3d vt3 = ptE - ptCenter;
|
|
AcGeVector3d vt4 = pt2 - ptCenter;
|
|
double dAngle1 = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
double dAngle3 = vt3.angleTo(vt4, AcGeVector3d::kZAxis);
|
|
|
|
TGGeCurveSegment segTemp;
|
|
if (pt1.Distance(ptS) > _DIST_SNAP)
|
|
{
|
|
TGGeArc arcTemp(pt1, ptS, dAngle1);
|
|
segTemp = arcTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
|
|
if (pt2.Distance(ptE) > _DIST_SNAP)
|
|
{
|
|
TGGeArc arcTemp(ptE, pt2, dAngle3);
|
|
segTemp = arcTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
else if (bVal1) // 虚线起点在实线上
|
|
{
|
|
if (ptS.Distance(pt1) > _DIST_SNAP)
|
|
{
|
|
AcGeVector3d vt1 = pt1 - ptCenter;
|
|
AcGeVector3d vt2 = ptS - ptCenter;
|
|
double dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
TGGeArc arcTemp(pt1, ptS, dAngle);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = arcTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
else if (bVal2) // 虚线终点在实线上
|
|
{
|
|
if (ptE.Distance(pt2) > _DIST_SNAP)
|
|
{
|
|
AcGeVector3d vt1 = ptE - ptCenter;
|
|
AcGeVector3d vt2 = pt2 - ptCenter;
|
|
double dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
TGGeArc arcTemp(ptE, pt2, dAngle);
|
|
TGGeCurveSegment segTemp;
|
|
segTemp = arcTemp;
|
|
vevNew.push_back(segTemp);
|
|
bModify = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bModify)
|
|
{
|
|
vecDel.push_back(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (it = vevNew.begin(); it != vevNew.end(); it++)
|
|
{
|
|
vecSeg.push_back(*it);
|
|
}
|
|
|
|
for (it = vecDel.begin(); it != vecDel.end(); it++)
|
|
{
|
|
vecSeg.erase(std::find(vecSeg.begin(), vecSeg.end(), *it));
|
|
}
|
|
}
|
|
|
|
void TDbBaseWall::FiltrateSegment(std::vector<TGGeCurveSegment> &vecSeg) const
|
|
{
|
|
std::vector<TGGeCurveSegment>::iterator it1, it2;
|
|
TGGeArc arc1, arc2;
|
|
TGGeLine line1, line2;
|
|
TADSGePoint3d ptS1, ptE1, ptCenter1, ptS2, ptE2, ptCenter2;
|
|
int nSize = 0;
|
|
for (it1 = vecSeg.begin(); it1 != vecSeg.end(); nSize == vecSeg.size() ? it1++ : it1)
|
|
{
|
|
nSize = vecSeg.size(); // 记录修改前大小
|
|
it2 = it1;
|
|
++it2;
|
|
for (; it2 != vecSeg.end(); it2++)
|
|
{
|
|
if ((*it1).Is(CURVE_ARC) && it2->Is(CURVE_ARC))
|
|
{
|
|
arc1 = it1->GetArc();
|
|
arc2 = it2->GetArc();
|
|
double dRadius1 = arc1.GetRadius();
|
|
double dRadius2 = arc2.GetRadius();
|
|
arc1.Center(ptCenter1);
|
|
arc2.Center(ptCenter2);
|
|
arc1.GetStartPoint(ptS1);
|
|
arc1.GetEndPoint(ptE1);
|
|
arc2.GetStartPoint(ptS2);
|
|
arc2.GetEndPoint(ptE2);
|
|
if (fabs(dRadius1 - dRadius2) < _DIST_SNAP && ptCenter1.Distance(ptCenter2) < _DIST_SNAP) // 共圆
|
|
{
|
|
if ( ptS1.Distance(ptS2) < _DIST_SNAP && ptE1.Distance(ptE2) < _DIST_SNAP
|
|
|| ptS1.Distance(ptE2) < _DIST_SNAP && ptE1.Distance(ptS2) < _DIST_SNAP) // 重合
|
|
{
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
|
|
int bVal1 = false, bVal2 = false, bVal3 = false, bVal4 = false;
|
|
bVal1 = arc1.PtOnArc(ptS2);
|
|
bVal2 = arc1.PtOnArc(ptE2);
|
|
bVal3 = arc2.PtOnArc(ptS1);
|
|
bVal4 = arc2.PtOnArc(ptE1);
|
|
|
|
if (bVal1 && bVal2)
|
|
{
|
|
vecSeg.erase(it2);
|
|
break;;
|
|
}
|
|
else if (bVal3 && bVal4)
|
|
{
|
|
*it1 = *it2;
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
else if (bVal1)
|
|
{
|
|
TGGeArc arc(ptS1, ptS2, ptE2);
|
|
*it1 = arc;
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
else if (bVal2)
|
|
{
|
|
TGGeArc arc(ptS2, ptE2, ptE1);
|
|
*it1 = arc;
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
else if (bVal3)
|
|
{
|
|
TGGeArc arc(ptS2, ptS1, ptE1);
|
|
*it1 = arc;
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
else if (bVal4)
|
|
{
|
|
TGGeArc arc(ptS1, ptE1, ptE2);
|
|
*it1 = arc;
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
else if ((*it1).Is(CURVE_LINE) && it2->Is(CURVE_LINE))
|
|
{
|
|
line1 = it1->GetLine();
|
|
line2 = it2->GetLine();
|
|
ptS1 = line1.StartPoint();
|
|
ptE1 = line1.EndPoint();
|
|
ptS2 = line2.StartPoint();
|
|
ptE2 = line2.EndPoint();
|
|
if (ptS1.Distance(ptS2) < _DIST_SNAP && ptE1.Distance(ptE2) < _DIST_SNAP
|
|
|| ptS1.Distance(ptE2) < _DIST_SNAP && ptE1.Distance(ptS2) < _DIST_SNAP) // 重合
|
|
{
|
|
vecSeg.erase(it2);
|
|
break;
|
|
}
|
|
|
|
AcGeVector3d vt1 = ptE1 - ptS1, vt2 = ptE2 - ptS2;
|
|
AcDbLine lineA(ptS1, ptE1), lineB(ptS2, ptE2);
|
|
AcGePoint3d pt1;
|
|
lineB.getClosestPointTo(ptS1, pt1, Adesk::kTrue);
|
|
if (vt1.isParallelTo(vt2) && ptS1.Distance(pt1) < _DIST_SNAP) // 共线
|
|
{
|
|
AcGePoint3d pt2, pt3, pt4;
|
|
lineB.getClosestPointTo(ptS1, pt1);
|
|
lineB.getClosestPointTo(ptE1, pt2);
|
|
lineA.getClosestPointTo(ptS2, pt3);
|
|
lineA.getClosestPointTo(ptE2, pt4);
|
|
if (ptS1.Distance(pt1) < _DIST_SNAP || ptE1.Distance(pt2) < _DIST_SNAP
|
|
|| ptS2.Distance(pt3) < _DIST_SNAP || ptE2.Distance(pt4) < _DIST_SNAP) // 两直线存在交点
|
|
{
|
|
double dDist1 = ptS1.Distance(ptE1);
|
|
double dDist2 = ptS1.Distance(ptS2);
|
|
double dDist3 = ptS1.Distance(ptE2);
|
|
double dDist4 = ptE1.Distance(ptS2);
|
|
double dDist5 = ptE1.Distance(ptE2);
|
|
double dDist6 = ptS2.Distance(ptE2);
|
|
std::vector<double> vecDbl;
|
|
vecDbl.push_back(dDist1);
|
|
vecDbl.push_back(dDist2);
|
|
vecDbl.push_back(dDist3);
|
|
vecDbl.push_back(dDist4);
|
|
vecDbl.push_back(dDist5);
|
|
vecDbl.push_back(dDist6);
|
|
|
|
double dMax = *(std::max_element(vecDbl.begin(), vecDbl.end()));
|
|
if (fabs(dMax - dDist1) < _DIST_SNAP)
|
|
{
|
|
vecSeg.erase(it2);
|
|
}
|
|
else if (fabs(dMax - dDist2) < _DIST_SNAP)
|
|
{
|
|
vecSeg.erase(it2);
|
|
(*it1).SetEndPoint(ptS2);
|
|
}
|
|
else if (fabs(dMax - dDist3) < _DIST_SNAP)
|
|
{
|
|
vecSeg.erase(it2);
|
|
(*it1).SetEndPoint(ptE2);
|
|
}
|
|
else if (fabs(dMax - dDist4) < _DIST_SNAP)
|
|
{
|
|
vecSeg.erase(it2);
|
|
(*it1).SetStartPoint(ptS2);
|
|
}
|
|
else if (fabs(dMax - dDist5) < _DIST_SNAP)
|
|
{
|
|
vecSeg.erase(it2);
|
|
(*it1).SetStartPoint(ptE2);
|
|
}
|
|
else if (fabs(dMax - dDist6) < _DIST_SNAP)
|
|
{
|
|
vecSeg.erase(it2);
|
|
(*it1).SetStartPoint(ptS2);
|
|
(*it1).SetEndPoint(ptS2);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TGGeCurveSegment TDbBaseWall::GetCenterLine()const
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
|
|
return TGGeCurveSegment(ptS, ptE, dBulge);
|
|
}
|
|
|
|
// 取墙中心线的起点和终点，然后对这根线延伸1个长度
|
|
TGGeCurveSegment TDbBaseWall::GetLongBaseLine() const
|
|
{
|
|
// 转换cvBase
|
|
TGGeCurveSegment cvBase = GetCenterLine();
|
|
if (!cvBase.Is(CURVE_LINE)) // 只处理直线的情况
|
|
{
|
|
return cvBase;
|
|
}
|
|
|
|
// 将cvBase延伸一个墙体总宽度
|
|
double dWid = 0;
|
|
GetTotalWidth(dWid);
|
|
|
|
TADSGePointDir2d ptExtStart, ptExtEnd;
|
|
cvBase.Polar(-dWid, ptExtStart, TRUE);
|
|
cvBase.Polar(-dWid, ptExtEnd, FALSE);
|
|
cvBase.SetPoints(ptExtStart, ptExtEnd);
|
|
|
|
return cvBase;
|
|
}
|
|
|
|
// 获得墙体范围内的轴线或墙，梁
|
|
// 返回值: 位0x01--左轴线(墙或梁), 位0x02--右轴线(墙或梁)
|
|
int TDbBaseWall::GetAxises(int nDivType,const TADSGePoint3d &ptAt, TEntitySet &lEntAxis, TEntitySet &rEntAxis) const
|
|
{
|
|
TPickEntSet ss(SS_FREE);
|
|
|
|
//在获得墙体范围内的轴线时，采取扩大搜索范围的算法
|
|
TGGeCurveSegment segThis = GetLongBaseLine();
|
|
segThis.SetElevation(0.0);
|
|
|
|
TADSGePointDir2d ptExtStart, ptExtEnd;
|
|
segThis.Polar(-_AS_SYS_UNIT(g_nDistPrec), ptExtStart, TRUE);
|
|
segThis.Polar(-_AS_SYS_UNIT(g_nDistPrec), ptExtEnd, FALSE);
|
|
segThis.SetPoints(ptExtStart, ptExtEnd);
|
|
|
|
TGGePoly2D poly;
|
|
if (nDivType == 0 || nDivType == 3)//搜轴线直接用中心线搜
|
|
{
|
|
segThis.AsPoly2D(poly);
|
|
}
|
|
else
|
|
{
|
|
double dWidth(0);
|
|
GetTotalWidth(dWidth);
|
|
|
|
TGGeCurveSegment cv = segThis;
|
|
cv=segThis.Offset(OFFSET_RIGHT,dWidth*0.6,LS_FINITE);
|
|
cv.AsPoly2D(poly);
|
|
|
|
cv = segThis.Offset(OFFSET_LEFT,dWidth*0.6,LS_FINITE);
|
|
poly.AppendNode(cv.GetEndPoint(),-cv.GetBulge());
|
|
poly.AppendNode(cv.GetStartPoint());
|
|
}
|
|
|
|
TGGePoly poly1;
|
|
poly.MapToPolygon(poly1);
|
|
|
|
switch (nDivType)
|
|
{
|
|
case 0: //轴线等分加梁
|
|
case 3: //轴线等分插洞
|
|
if (ss.Get(_T("F"), TRBList(poly1.Fence()), NULL,
|
|
TRBList(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL)) != RTNORM)
|
|
{
|
|
return 0;
|
|
}
|
|
break;
|
|
case 1: //等分梁
|
|
if (ss.Get(_T("cp"), TRBList(poly1.Polygon()), NULL,
|
|
TRBList(RTDXF0, _T("ATS_STRUBEAM"), NULL)) != RTNORM)
|
|
{
|
|
return 0;
|
|
}
|
|
break;
|
|
case 2: //等分墙
|
|
if (ss.Get(_T("cp"), TRBList(poly1.Polygon()), NULL,
|
|
TRBList(RTDXF0, _T("ATS_WALL"), NULL)) != RTNORM)
|
|
{
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
int nRetFlag = 0;
|
|
segThis.SetLineFlag(LS_FINITE);
|
|
|
|
ads_real nDist = segThis.PathDistance(TADSGePoint3d(ptAt.x, ptAt.y));
|
|
ads_real nDistLeft = 0.0, nDistRight = segThis.GetLength();
|
|
|
|
long ssLen = ss.Length();
|
|
BOOL bIsArc = segThis.Is(CURVE_ARC); //当前是否为弧梁或墙
|
|
for (long i = 0; i < ssLen; i++)
|
|
{
|
|
TEntitySet ent = ss[i];
|
|
TGGeCurveSegment segAxis;
|
|
|
|
// 根据等分类型获得轴线或墙中心线
|
|
switch (nDivType)
|
|
{
|
|
case 0:
|
|
case 3:
|
|
{
|
|
TGGeCurveSegment cvAxis(ent, LS_FINITE);
|
|
segAxis = cvAxis;
|
|
}
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
segAxis = pEnt->GetLongBaseLine();
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
OPENOBJ_END();
|
|
break;
|
|
}
|
|
segAxis.SetElevation(0.0);
|
|
|
|
if (bIsArc)
|
|
{
|
|
if (!segAxis.Is(CURVE_LINE))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TGGeArc ar = segThis.GetArc();
|
|
double nDistTo = ar.GetCenterPt().Distance(&segAxis);
|
|
if (nDistTo > _DIST_SNAP)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// 求交
|
|
TADSGePoint3d ptInt[2];
|
|
int nInt = segThis.Intersection(segAxis, ptInt[0], ptInt[1]);
|
|
if (!nInt)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TADSGePoint3d ptInters;
|
|
if (nInt == 1)
|
|
{
|
|
ptInters = ptInt[0];
|
|
}
|
|
else
|
|
{
|
|
ptInters = TGGeLine(ptInt[0], ptInt[1]).NearPoint(TADSGePoint3d(ptAt.x, ptAt.y));
|
|
}
|
|
|
|
// 确定左右轴线
|
|
ads_real nDist0 = segThis.PathDistance(ptInters);
|
|
if (nDist0 < nDist)
|
|
{
|
|
if (nDist0 > nDistLeft)
|
|
{
|
|
nRetFlag |= 0x01;
|
|
nDistLeft = nDist0;
|
|
lEntAxis = ent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nDist0 < nDistRight)
|
|
{
|
|
nRetFlag |= 0x02;
|
|
nDistRight = nDist0;
|
|
rEntAxis = ent;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nRetFlag;
|
|
}
|
|
|
|
// 取得墙体等分的参数
|
|
// 返回值：RTNORM/RTERROR/RTCAN
|
|
// [in]nDivType:等分类型:0,轴线等分加梁，1，净跨等分加梁，2，等分加墙，3，等分插洞；
|
|
// [in]nOpWidth：插入对象的宽度；ptNew：插入点
|
|
// [out]segThis：等分线段；nOpeningCount：等分数目，仅插洞时有意义；nUnitDist：等分长度，仅插洞时有意义
|
|
// [out]pSet:插梁或墙时的边界对象，插洞时为空
|
|
int TDbBaseWall::GetIsoParameters(int nDivType, double nOpWidth, const TADSGePoint3d &ptNew, TGGeCurveSegment &segThis, int *nOpeningCount, double *nUnitDist, TEntitySet* pSet) const
|
|
{
|
|
int &nOpNum = *nOpeningCount;
|
|
ads_real &nUnitLen = *nUnitDist;
|
|
|
|
TGGeCurveSegment wall = GetCenterLine();
|
|
wall.SetLineFlag(LS_FINITE);
|
|
|
|
TEntitySet lEntAxis, rEntAxis;
|
|
AcGePoint3d ptLeft,ptRight;
|
|
GetAt(KEY_START,ptLeft);
|
|
GetAt(KEY_END,ptRight);
|
|
|
|
TADSGePoint3d ptLimLeft = ptLeft, ptLimRight = ptRight;
|
|
|
|
int nAxisNum = GetAxises(nDivType, ptNew, lEntAxis, rEntAxis);
|
|
|
|
// 求左右界限点
|
|
// 获得墙体范围内的轴线时，采取扩大搜索范围的算法
|
|
segThis = GetLongBaseLine();
|
|
segThis.SetLineFlag(LS_FINITE);
|
|
|
|
// 找到左侧轴线
|
|
if (nAxisNum & 0x01)
|
|
{
|
|
BOOL bOk = FALSE;
|
|
TGGeCurveSegment segLeft;
|
|
if (nDivType == 0 || nDivType == 3) //轴线等分加梁或插洞
|
|
{
|
|
TGGeCurveSegment cvLeft(lEntAxis, LS_FINITE);
|
|
segLeft = cvLeft;
|
|
}
|
|
else //净跨等分加梁或等分加墙
|
|
{
|
|
TGGeCurveSegment cvLeft;
|
|
OPENOBJ_BEGIN(lEntAxis, AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
cvLeft = pEnt->GetCenterLine();
|
|
if(nDivType == 1) //梁净跨等分
|
|
{
|
|
double dWidth = 0;
|
|
pEnt->GetTotalWidth(dWidth);
|
|
int nSide = cvLeft.OnWhichSide(ptNew);
|
|
cvLeft = cvLeft.Offset(nSide, dWidth*0.5, cvLeft.GetLineFlag());
|
|
}
|
|
segLeft = cvLeft;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
segLeft.SetElevation(segThis.StartPoint().z);
|
|
|
|
if (segThis.Intersection(segLeft, ptLimLeft, TADSGePoint3d()) != 1)
|
|
{
|
|
ptLimLeft = segThis.StartPoint();
|
|
}
|
|
|
|
lEntAxis.Redraw(3);
|
|
}
|
|
|
|
// 找到右侧轴线
|
|
if (nAxisNum & 0x02)
|
|
{
|
|
BOOL bOk = FALSE;
|
|
TGGeCurveSegment segRight;
|
|
if (nDivType == 0 || nDivType == 3) //轴线等分加梁或插洞
|
|
{
|
|
TGGeCurveSegment cvRight(rEntAxis, LS_FINITE);
|
|
segRight = cvRight;
|
|
}
|
|
else //净跨等分加梁或等分加墙
|
|
{
|
|
TGGeCurveSegment cvRight;
|
|
OPENOBJ_BEGIN(rEntAxis, AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
cvRight = pEnt->GetCenterLine();
|
|
if(nDivType == 1) //梁净跨等分
|
|
{
|
|
double dWidth = 0;
|
|
pEnt->GetTotalWidth(dWidth);
|
|
int nSide = cvRight.OnWhichSide(ptNew);
|
|
cvRight = cvRight.Offset(nSide, dWidth*0.5, cvRight.GetLineFlag());
|
|
}
|
|
segRight = cvRight;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
}
|
|
segRight.SetElevation(segThis.StartPoint().z);
|
|
|
|
if (segThis.Intersection(segRight, ptLimRight, TADSGePoint3d()) != 1)
|
|
{
|
|
ptLimRight = segThis.EndPoint();
|
|
}
|
|
|
|
rEntAxis.Redraw(3);
|
|
}
|
|
|
|
// 构造区间
|
|
segThis.SetPoints(ptLimLeft, ptLimRight);
|
|
|
|
{
|
|
int nMaxNum1 = TNumeric(segThis.GetLength() / nOpWidth).AsInt();
|
|
if (nOpNum > nMaxNum1 || nOpNum < 1)
|
|
{
|
|
nOpNum = 1;
|
|
}
|
|
|
|
CString strPrompt;
|
|
if (nDivType == 3)
|
|
{
|
|
strPrompt.Format(_T("\n指定参考轴线[S]/洞口个数(1~%d)<%d>:"), nMaxNum1, nOpNum);
|
|
}
|
|
else if (nDivType == 0)
|
|
{
|
|
strPrompt.Format(_T("\n指定参考轴线[S]/选择作为另一边界的梁<退出>:"));
|
|
}
|
|
else if (nDivType == 1)
|
|
{
|
|
strPrompt.Format(_T("\n指定参考梁[S]/选择作为另一边界的梁<退出>:"));
|
|
}
|
|
else if (nDivType == 2)
|
|
{
|
|
strPrompt.Format(_T("\n指定参考墙[S]/选择作为另一边界的墙<退出>:"));
|
|
}
|
|
|
|
|
|
int nCode = 0;
|
|
TEntitySet ent;
|
|
|
|
TCHAR szKeyword[80] = _T("");
|
|
if(nDivType == 3)
|
|
{
|
|
INITGET_BEG(RSG_NONEG | RSG_NOZERO, _T("S"));
|
|
nCode = ads_getint(strPrompt, &nOpNum);
|
|
INITGET_END();
|
|
|
|
if (nCode == RTKWORD)
|
|
{
|
|
ads_getinput(szKeyword);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CString strDxf(_T("ATS_STRUBEAM"));
|
|
if(nDivType == 2)
|
|
{
|
|
strDxf = _T("ATS_WALL");
|
|
}
|
|
|
|
TCHAR cKey;
|
|
nCode = SelectEntity(strPrompt, ent, TRBList(acutBuildList(RTDXF0, strDxf, NULL)), _T("S"), cKey);
|
|
szKeyword[0] = cKey;
|
|
}
|
|
|
|
|
|
// 默认轴线取消高亮
|
|
if (nAxisNum & 0x01)
|
|
{
|
|
lEntAxis.Redraw(4);
|
|
}
|
|
|
|
if (nAxisNum & 0x02)
|
|
{
|
|
rEntAxis.Redraw(4);
|
|
}
|
|
|
|
if (nCode == RTKWORD)
|
|
{
|
|
if (szKeyword[0] == _T('S'))
|
|
{
|
|
TEntitySet ent1, ent2;
|
|
ads_real nDist1 = 0.0, nDist2 = 0.0;
|
|
ads_real nDistPick = segThis.PathDistance(ptNew);
|
|
TADSGePointDir2d pt1, pt2;
|
|
int nFlag = 0;
|
|
|
|
if (nDivType == 0 || nDivType == 3)
|
|
{
|
|
TRBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
|
if (ent1.FilterSelect(_T("\n第一根轴线:"), mask) == RTCAN)
|
|
{
|
|
return RTCAN;
|
|
}
|
|
}
|
|
else if (nDivType == 1)
|
|
{
|
|
TRBList mask(RTDXF0, _T("ATS_STRUBEAM"), NULL);
|
|
if (ent1.FilterSelect(_T("\n第一个参考梁:"), mask) == RTCAN)
|
|
{
|
|
return RTCAN;
|
|
}
|
|
}
|
|
else if (nDivType == 2)
|
|
{
|
|
TRBList mask(RTDXF0, _T("ATS_WALL"), NULL);
|
|
if (ent1.FilterSelect(_T("\n第一个参考墙:"), mask) == RTCAN)
|
|
{
|
|
return RTCAN;
|
|
}
|
|
}
|
|
|
|
double dWidthL = 0,dWidthR = 0;
|
|
if (!(!ent1))
|
|
{
|
|
ent1.Redraw(3);
|
|
|
|
TGGeCurveSegment cv, cv1 = wall;
|
|
if(nDivType == 0 || nDivType == 3)
|
|
{
|
|
TGGeCurveSegment cv2(ent1, LS_FINITE);
|
|
cv = cv2;
|
|
}
|
|
else
|
|
{
|
|
OPENOBJ_BEGIN(ent1, AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
cv = pEnt->GetCenterLine();
|
|
if(nDivType == 1) //梁净跨等分
|
|
{
|
|
pEnt->GetTotalWidth(dWidthL);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
if (cv1.Is(CURVE_LINE))
|
|
{
|
|
cv1.SetLineFlag(LS_INFINITE);
|
|
}
|
|
|
|
if (cv.Is(CURVE_LINE))
|
|
{
|
|
cv.SetLineFlag(LS_INFINITE);
|
|
}
|
|
|
|
cv.SetElevation(cv1.StartPoint().z);
|
|
if (cv1.Intersection(cv, pt1, TADSGePoint3d()) == 1)
|
|
{
|
|
nDist1 = cv1.PathDistance(pt1);
|
|
nFlag |= 0x01;
|
|
}
|
|
}
|
|
|
|
if (nDivType == 0 || nDivType == 3)
|
|
{
|
|
TRBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
|
if (ent2.FilterSelect(_T("\n第二根轴线:"), mask) == RTCAN)
|
|
{
|
|
if (!!ent1)
|
|
{
|
|
ent1.Redraw(4);
|
|
}
|
|
|
|
return RTCAN;
|
|
}
|
|
}
|
|
else if (nDivType == 1)
|
|
{
|
|
TRBList mask(RTDXF0, _T("ATS_STRUBEAM"), NULL);
|
|
if (ent2.FilterSelect(_T("\n第二个参考梁:"), mask) == RTCAN)
|
|
{
|
|
if (!!ent1)
|
|
{
|
|
ent1.Redraw(4);
|
|
}
|
|
return RTCAN;
|
|
}
|
|
}
|
|
else if (nDivType == 2)
|
|
{
|
|
TRBList mask(RTDXF0, _T("ATS_WALL"), NULL);
|
|
if (ent2.FilterSelect(_T("\n第二个参考墙:"), mask) == RTCAN)
|
|
{
|
|
if (!!ent1)
|
|
{
|
|
ent1.Redraw(4);
|
|
}
|
|
return RTCAN;
|
|
}
|
|
}
|
|
|
|
if (!(!ent2))
|
|
{
|
|
ent2.Redraw(3);
|
|
|
|
TGGeCurveSegment cv, cv1 = wall;
|
|
if(nDivType == 0 || nDivType == 3)
|
|
{
|
|
TGGeCurveSegment cv2(ent2, LS_FINITE);
|
|
cv = cv2;
|
|
}
|
|
else
|
|
{
|
|
OPENOBJ_BEGIN(ent2, AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
cv = pEnt->GetCenterLine();
|
|
|
|
if(nDivType == 1) //梁净跨等分
|
|
{
|
|
pEnt->GetTotalWidth(dWidthR);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
if (cv1.Is(CURVE_LINE))
|
|
{
|
|
cv1.SetLineFlag(LS_INFINITE);
|
|
}
|
|
|
|
if (cv.Is(CURVE_LINE))
|
|
{
|
|
cv.SetLineFlag(LS_INFINITE);
|
|
}
|
|
|
|
cv.SetElevation(cv1.StartPoint().z);
|
|
if (cv1.Intersection(cv, pt2, TADSGePoint3d()) == 1)
|
|
{
|
|
nDist2 = cv1.PathDistance(pt2);
|
|
nFlag |= 0x02;
|
|
}
|
|
}
|
|
|
|
if ((nFlag & 0x01) && (nFlag & 0x02))
|
|
{
|
|
if (nDist1 < nDist2)
|
|
{
|
|
segThis.SetPoints(pt1, pt2);
|
|
|
|
if (nDivType == 1) //梁净跨等分
|
|
{
|
|
segThis.Polar(dWidthL*0.5, pt1, TRUE);
|
|
segThis.Polar(dWidthR*0.5, pt2, FALSE);
|
|
segThis.SetPoints(pt1, pt2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
segThis.SetPoints(pt2, pt1);
|
|
|
|
if (nDivType == 1) //梁净跨等分
|
|
{
|
|
segThis.Polar(dWidthR*0.5, pt2, TRUE);
|
|
segThis.Polar(dWidthL*0.5, pt1, FALSE);
|
|
segThis.SetPoints(pt2, pt1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nFlag & 0x01)
|
|
{
|
|
if (nDistPick < nDist1)
|
|
{
|
|
segThis.SetPoints(pt1, ptLimRight);
|
|
|
|
if (nDivType == 1) //梁净跨等分
|
|
{
|
|
segThis.Polar(dWidthL*0.5, pt1, TRUE);
|
|
segThis.SetPoints(pt1, ptLimRight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
segThis.SetPoints(ptLimLeft, pt1);
|
|
|
|
if (nDivType == 1) //梁净跨等分
|
|
{
|
|
segThis.Polar(dWidthL*0.5, pt1, FALSE);
|
|
segThis.SetPoints(ptLimLeft, pt1);
|
|
}
|
|
}
|
|
}
|
|
else if (nFlag & 0x02)
|
|
{
|
|
if (nDistPick < nDist2)
|
|
{
|
|
segThis.SetPoints(pt2, ptLimRight);
|
|
|
|
if (nDivType == 1) //梁净跨等分
|
|
{
|
|
segThis.Polar(dWidthR*0.5, pt2, TRUE);
|
|
segThis.SetPoints(pt2, ptLimRight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
segThis.SetPoints(ptLimLeft, pt2);
|
|
|
|
if (nDivType == 1) //梁净跨等分
|
|
{
|
|
segThis.Polar(dWidthR*0.5, pt2, FALSE);
|
|
segThis.SetPoints(ptLimLeft, pt2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nDivType == 3)
|
|
{
|
|
if (!!ent1)
|
|
{
|
|
ent1.Redraw(4);
|
|
}
|
|
|
|
if (!!ent2)
|
|
{
|
|
ent2.Redraw(4);
|
|
}
|
|
|
|
int nMaxNum = int(segThis.GetLength() / nOpWidth);
|
|
if (nMaxNum < 1)
|
|
{
|
|
adsout << _T("\n点取位置不能插洞口!");
|
|
return RTERROR;
|
|
}
|
|
|
|
adsout << _T("\n洞口个数(1~") << nMaxNum << _T(")<") << nOpNum << _T(">: ");
|
|
ads_initget(RSG_NONEG | RSG_NOZERO, NULL);
|
|
if (ads_getint(_T(""), &nOpNum) == RTCAN || nOpNum > nMaxNum)
|
|
{
|
|
return RTCAN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 取消高亮
|
|
if (!!ent1)
|
|
{
|
|
ent1.Redraw(4);
|
|
}
|
|
|
|
if (!!ent2)
|
|
{
|
|
ent2.Redraw(4);
|
|
}
|
|
|
|
CString strDxf(_T("ATS_STRUBEAM"));
|
|
if(nDivType == 2)
|
|
{
|
|
strPrompt.Format(_T("\n选择作为另一边界的墙<退出>:"));
|
|
strDxf = _T("ATS_WALL");
|
|
}
|
|
else
|
|
{
|
|
strPrompt.Format(_T("\n选择作为另一边界的梁<退出>:"));
|
|
}
|
|
|
|
nCode = SelectEntity(strPrompt, ent, TRBList(acutBuildList(RTDXF0, strDxf, NULL)));
|
|
if (nCode == RTNORM)
|
|
{
|
|
*pSet = ent;
|
|
}
|
|
else
|
|
{
|
|
return nCode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nDivType == 3) //插洞
|
|
{
|
|
if (nCode == RTCAN)
|
|
{
|
|
return nCode;
|
|
}
|
|
else if (nOpNum > nMaxNum1)
|
|
{
|
|
adsout << _T("\n不能插入指定个数的洞口!");
|
|
return RTERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nCode == RTNORM)
|
|
{
|
|
*pSet = ent;
|
|
}
|
|
else
|
|
{
|
|
return nCode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ads_real nCurveLen = segThis.GetLength();
|
|
nUnitLen = nCurveLen / nOpNum; //单元长度
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
void TDbBaseWall::GetTotalWidth(double &dWidth)const
|
|
{
|
|
|
|
}
|
|
|
|
// 获得总高度
|
|
void TDbBaseWall::GetTotalHeight(double &dHeight)const
|
|
{
|
|
|
|
}
|
|
|
|
// 夹点消息后，更新自己边界
|
|
void TDbBaseWall::UpdateMeOnGripMsg(TAssocMsg assocMsg)
|
|
{
|
|
//不是夹点消息直接返回
|
|
if (assocMsg.GetMethod() != TAssocMsg::kMovegrippoint)
|
|
{
|
|
return;
|
|
}
|
|
|
|
assertWriteEnabled();
|
|
|
|
TGGeCurveSegment cvBase = GetCenterLine(); //形心线
|
|
if (!cvBase.Is(CURVE_LINE)) //仅处理直线情况
|
|
{
|
|
return;
|
|
}
|
|
|
|
int nLength = m_arAssocBWallIds.length();
|
|
if (nLength < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double dElevS = cvBase.GetStartPoint().z;
|
|
double dElevE = cvBase.GetEndPoint().z;
|
|
|
|
AcGeVector3d vtOffset = assocMsg.GetOffset();
|
|
AcGePoint3d ptTarget = assocMsg.GetTarget();
|
|
TADSGePoint3d pt = ptTarget;
|
|
|
|
cvBase.SetElevation(0);
|
|
TADSGePoint3d ptStart = cvBase.GetStartPoint();
|
|
TADSGePoint3d ptEnd = cvBase.GetEndPoint();
|
|
|
|
ptStart -= vtOffset;
|
|
ptEnd -= vtOffset;
|
|
|
|
TGGeCurveSegment cvSrc(ptStart, ptEnd, 0);
|
|
|
|
double dDir = cvBase.TGGeLine::Direction();
|
|
double dPrec = sin(PI/36); //同向精度5°
|
|
|
|
bool bMod = false; //记录是否中心线进行了延长处理
|
|
//找出与偏移方向斜交或平行的梁（垂直时梁不需要延伸）
|
|
for (int i = 0; i < nLength; i++)
|
|
{
|
|
OPENOBJ_BEGIN(m_arAssocBWallIds[i], AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
TGGeCurveSegment cvCL = pEnt->GetCenterLine();
|
|
if (!cvCL.Is(CURVE_LINE))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TVector3D vt3d = cvCL.GetEndPoint() - cvCL.GetStartPoint();
|
|
AcGeVector3d vtCL = vt3d.AsAcGeVector3d();
|
|
|
|
double dDirCL = cvCL.TGGeLine::Direction();
|
|
bool bStart = false, bEnd = false; //当前修改的端点标志
|
|
|
|
cvCL.SetElevation(0);
|
|
if (fabs(vtCL.dotProduct(vtOffset)) < _DIST_SNAP)
|
|
{
|
|
continue; //垂直
|
|
}
|
|
|
|
if (vtOffset.isParallelTo(vtCL)) //平行
|
|
{
|
|
|
|
}
|
|
else //斜交
|
|
{
|
|
cvSrc.Intersection(cvCL, pt, TADSGePoint3d());
|
|
|
|
int nPos = (pt&cvSrc);
|
|
if (nPos == PR_ONPT1) //起点
|
|
{
|
|
bStart = true;
|
|
}
|
|
else if (nPos == PR_ONPT2) //终点
|
|
{
|
|
bEnd = true;
|
|
}
|
|
}
|
|
|
|
cvCL.SetLineFlag(LS_INFINITE);
|
|
cvBase.SetLineFlag(LS_INFINITE);
|
|
|
|
TADSGePoint3d ptInter;
|
|
cvBase.Intersection(cvCL, ptInter, TADSGePoint3d());
|
|
cvBase.SetLineFlag(LS_FINITE);
|
|
|
|
if (bStart) //修改起点
|
|
{
|
|
bMod = true;
|
|
cvBase.SetStartPoint(ptInter);
|
|
}
|
|
else if (bEnd) //修改终点
|
|
{
|
|
bMod = true;
|
|
cvBase.SetEndPoint(ptInter);
|
|
}
|
|
else if ((ptInter&cvBase) == PR_EXTEND) //延长线上点
|
|
{
|
|
bMod = true;
|
|
if (ptInter.Distance2d(cvBase.GetStartPoint())
|
|
< ptInter.Distance2d(cvBase.GetEndPoint())) //延长起始点
|
|
{
|
|
cvBase.SetStartPoint(ptInter);
|
|
}
|
|
else
|
|
{
|
|
cvBase.SetEndPoint(ptInter);
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
// 处理关联普通板
|
|
pt.z = 0;
|
|
nLength = m_arSlabIds.length();
|
|
for (i = 0; i < nLength; i++)
|
|
{
|
|
OPENOBJ_BEGIN(m_arSlabIds[i], AcDb::kForRead, TDbStruFloorSlab, pEnt);
|
|
if (pEnt)
|
|
{
|
|
int nType = 0;
|
|
GetAt(KEY_KIND, nType);
|
|
|
|
if (nType != 0) //仅处理普通板
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TGGePoly2D polySrc;
|
|
pEnt->GetOutline(polySrc);
|
|
|
|
TGGePoly2D poly = polySrc;
|
|
poly.SetElevation(0);
|
|
|
|
int nPos = poly.HitTestOnCurve(pt);
|
|
if (nPos < 0) //选中边
|
|
{
|
|
int nLen = poly.TotalSegments();
|
|
int nPre = -nPos;
|
|
int nNext = -nPos;
|
|
if (nPre == 1)
|
|
{
|
|
nPre = nLen-1;
|
|
}
|
|
else
|
|
{
|
|
nPre = nPre-2;
|
|
}
|
|
|
|
if (nNext == nLen)
|
|
{
|
|
nNext = 0;
|
|
}
|
|
|
|
TGGeCurveSegment cvPre;
|
|
TGGeCurveSegment cvNext;
|
|
poly.Nth(nPre, cvPre);
|
|
poly.Nth(nNext, cvNext);
|
|
|
|
cvPre.SetLineFlag(LS_INFINITE);
|
|
cvNext.SetLineFlag(LS_INFINITE);
|
|
cvBase.SetLineFlag(LS_INFINITE);
|
|
|
|
//求交点
|
|
TADSGePoint3d ptVert;
|
|
TADSGePoint3d ptInter1,ptInter2;
|
|
int nNum = cvBase.Intersection(cvPre, ptInter1, ptInter2);
|
|
if (nNum == 1)
|
|
{
|
|
ptVert = *polySrc[-nPos-1];
|
|
ptVert.x = ptInter1.x;
|
|
ptVert.y = ptInter1.y;
|
|
*polySrc[-nPos-1] = ptVert;
|
|
}
|
|
else if (nNum == 2)
|
|
{
|
|
ptVert = *polySrc[-nPos-1];
|
|
|
|
if (ptVert.Distance2d(ptInter1) < ptVert.Distance2d(ptInter2))
|
|
{
|
|
ptVert.x = ptInter1.x;
|
|
ptVert.y = ptInter1.y;
|
|
}
|
|
else
|
|
{
|
|
ptVert.x = ptInter2.x;
|
|
ptVert.y = ptInter2.y;
|
|
}
|
|
*polySrc[-nPos-1] = ptVert;
|
|
}
|
|
|
|
if (-nPos == nLen)
|
|
{
|
|
nPos = 0;
|
|
}
|
|
else
|
|
{
|
|
nPos = -nPos;
|
|
}
|
|
|
|
nNum = cvBase.Intersection(cvNext, ptInter1, ptInter2);
|
|
if (nNum == 1)
|
|
{
|
|
ptVert = *polySrc[nPos];
|
|
ptVert.x = ptInter1.x;
|
|
ptVert.y = ptInter1.y;
|
|
*polySrc[nPos] = ptVert;
|
|
}
|
|
else if (nNum == 2)
|
|
{
|
|
ptVert = *polySrc[nPos];
|
|
|
|
if (ptVert.Distance2d(ptInter1) < ptVert.Distance2d(ptInter2))
|
|
{
|
|
ptVert.x = ptInter1.x;
|
|
ptVert.y = ptInter1.y;
|
|
}
|
|
else
|
|
{
|
|
ptVert.x = ptInter2.x;
|
|
ptVert.y = ptInter2.y;
|
|
}
|
|
*polySrc[nPos] = ptVert;
|
|
}
|
|
|
|
//调整楼板
|
|
if(pEnt->upgradeOpen() == Acad::eOk)
|
|
{
|
|
pEnt->SetOutlinePoly(polySrc);
|
|
pEnt->downgradeOpen();
|
|
}
|
|
}
|
|
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
//中心线有修改
|
|
if (bMod)
|
|
{
|
|
//恢复标高
|
|
ptStart = cvBase.GetStartPoint();
|
|
ptEnd = cvBase.GetEndPoint();
|
|
ptStart.z = dElevS;
|
|
ptEnd.z = dElevE;
|
|
|
|
SetAt(KEY_START, ptStart.AsAcGePoint3d());
|
|
SetAt(KEY_END, ptEnd.AsAcGePoint3d());
|
|
}
|
|
}
|
|
|
|
// 抽象墙外框线
|
|
void TDbBaseWall::GetPoly2D(TGGePoly2D &poly2d) const
|
|
{
|
|
|
|
}
|
|
|
|
Adesk::Boolean TDbBaseWall::BreakAt(const TADSGePoint3d &ptLoc1, const TGGePoly2D *pPolyColu)
|
|
{
|
|
AcGePoint3d ptS,ptE;
|
|
GetAt(KEY_START, ptS);
|
|
GetAt(KEY_END, ptE);
|
|
|
|
//首先判断ptLoc是否在墙基范围内
|
|
TADSGePoint3d ptLoc = ptLoc1;
|
|
double nElev = ptS.z;
|
|
ptLoc.z = nElev;
|
|
|
|
TGGeCurveSegment cvCenter = GetCenterLine();
|
|
|
|
TADSGePoint3d ptProject;
|
|
if (cvCenter.ProjectToMe(ptLoc, ptProject) != RTNORM)
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
TADSGePoint3d ptStart = ptS;
|
|
TADSGePoint3d ptEnd = ptE;
|
|
if (pPolyColu)
|
|
{
|
|
TGGePoly2D polyColu = *pPolyColu;
|
|
polyColu.SetElevation(nElev);
|
|
|
|
if ((ptStart & polyColu) != PR_OUTSIDE || (ptEnd & polyColu) != PR_OUTSIDE)
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ptLoc.Distance2d(ptProject) > _AS_SYS_UNIT(g_nDistPrec))
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
}
|
|
|
|
{
|
|
if ((ptProject & cvCenter) != PR_INSIDE)
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
if (ptStart.Distance2d(ptProject) < _AS_SYS_UNIT(g_nDistPrec)
|
|
|| ptEnd.Distance2d(ptProject) < _AS_SYS_UNIT(g_nDistPrec))
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
}
|
|
|
|
AcDbObjectIdArray holeIds;
|
|
GetAssocRelation(ASSOC_HOLE, holeIds);
|
|
|
|
//判断位置是否在洞内
|
|
Adesk::Boolean bInHole = Adesk::kFalse;
|
|
/*int nIdCount = holeIds.length();
|
|
for (int j = 0; j < nIdCount; j++)
|
|
{
|
|
AcDbObjectId id = holeIds[j];
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbStruWallHole, pEnt);
|
|
if (pEnt)
|
|
{
|
|
TGGePoly2D poly2d(1);
|
|
pEnt->GetOutlinePoly2D(0.0, poly2d, TGGeCurveSegment());
|
|
|
|
if ((ptProject & poly2d) == PR_INSIDE)
|
|
{
|
|
bInHole = Adesk::kTrue;
|
|
break;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}*/
|
|
|
|
Adesk::Boolean bResult;
|
|
if (!bInHole) //位置不在门窗之内
|
|
{
|
|
TGGeCurveSegment segFirst = cvCenter, segSecond = cvCenter;
|
|
segFirst.SetPoints(ptStart, ptProject);
|
|
segSecond.SetPoints(ptProject, ptEnd);
|
|
|
|
// 两段的长度合理
|
|
if (segFirst.GetLength() > g_nMinLenWall && segSecond.GetLength() > g_nMinLenWall)
|
|
{
|
|
Acad::ErrorStatus es = upgradeOpen();
|
|
if (!(es == Acad::eOk || es == Acad::eWasOpenForWrite))
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
assertWriteEnabled();
|
|
|
|
g_bModifyAgain = false; //打断后需重新建立关联
|
|
bool bAdd = false;
|
|
double dWidth=0;
|
|
GetTotalWidth(dWidth);
|
|
|
|
//调整端点，有小短墙时不创建新对象
|
|
if (ptStart.Distance2d(ptProject) > dWidth)
|
|
{
|
|
SetAt(KEY_START, AcGePoint3d(ptStart));
|
|
SetAt(KEY_END, AcGePoint3d(ptProject));
|
|
SetAt(KEY_BULGE, segFirst.GetBulge());
|
|
}
|
|
else
|
|
{
|
|
if (ptEnd.Distance2d(ptProject) > dWidth)
|
|
{
|
|
SetAt(KEY_START, AcGePoint3d(ptProject));
|
|
SetAt(KEY_END, AcGePoint3d(ptEnd));
|
|
SetAt(KEY_BULGE, segSecond.GetBulge());
|
|
bAdd = true;
|
|
}
|
|
}
|
|
bResult = Adesk::kTrue;
|
|
downgradeOpen();
|
|
|
|
TAssocMsg assocMsg;
|
|
assocMsg.SetMethod(TAssocMsg::kAppend);
|
|
assocMsg.SetAssocId(objectId());
|
|
|
|
AddMsg(assocMsg);
|
|
|
|
AcDbObjectIdArray arIds;
|
|
GetAssocRelation(ASSOC_XY, arIds);
|
|
for(int i = 0; i < arIds.length(); i++)
|
|
{
|
|
TAssocMsg assocMsg;
|
|
assocMsg.SetMethod(TAssocMsg::kEdit);
|
|
assocMsg.SetAssocId(arIds[i]);
|
|
|
|
AddMsg(assocMsg);
|
|
}
|
|
|
|
if ((!bAdd) && (ptEnd.Distance2d(ptProject) > dWidth))
|
|
{
|
|
g_bModifyAgain = true; //打断后需重新建立关联
|
|
TDbBaseWall *pWall = NULL;
|
|
pWall = (TDbBaseWall *)clone();
|
|
if (pWall)
|
|
{
|
|
TPushMemVar<BOOL> pushVar(g_bMonitorDbAction, TRUE);
|
|
|
|
pWall->CopyPropertiesFrom(this, 0);
|
|
pWall->SetAt(KEY_START, AcGePoint3d(ptProject));
|
|
pWall->SetAt(KEY_END, AcGePoint3d(ptEnd));
|
|
pWall->SetAt(KEY_BULGE, segSecond.GetBulge());
|
|
pWall->AddToMSpace(Adesk::kTrue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bResult = Adesk::kFalse;
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//获得端点可以合并的连接墙
|
|
//bStart:true,起始端，false，终止端
|
|
//idAssoc:连接墙的ID
|
|
//返回值：1，成功获得连接墙， 0，不成功
|
|
BOOL TDbBaseWall::GetAssocWall(bool bStart, AcDbObjectId& idAssoc)
|
|
{
|
|
idAssoc.setNull();
|
|
if (m_arColumnIds.length() > 1)
|
|
{
|
|
//柱子个数大于1时，墙两端都有柱子，此时墙体不发生合并
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_arAssocBWallIds.length() < 1)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AcGePoint3d ptStart;
|
|
if (bStart)
|
|
{
|
|
GetAt(KEY_START, ptStart);
|
|
}
|
|
else
|
|
{
|
|
GetAt(KEY_END, ptStart);
|
|
}
|
|
|
|
if (m_arColumnIds.length() == 1)
|
|
{
|
|
OPENOBJ_BEGIN(m_arColumnIds[0], AcDb::kForRead, TDbColumn, pEnt);
|
|
if (pEnt)
|
|
{
|
|
TGGePoly2D polyout;
|
|
pEnt->GetOutline(polyout);
|
|
|
|
TADSGePoint3d pt(ptStart);
|
|
if (polyout.Length() > 0 )
|
|
{
|
|
pt.z = polyout[0]->z;
|
|
}
|
|
|
|
if ((pt & polyout) != PR_OUTSIDE)
|
|
{
|
|
//端点在柱子里，不合并
|
|
return FALSE;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
double dDistS = 0, dDistE = 0;
|
|
for (int i = 0; i < m_arAssocBWallIds.length(); i++)
|
|
{
|
|
OPENOBJ_BEGIN(m_arAssocBWallIds[i], AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
AcGePoint3d ptS,ptE;
|
|
pEnt->GetAt(KEY_START, ptS);
|
|
pEnt->GetAt(KEY_END, ptE);
|
|
|
|
dDistS = ptStart.distanceTo(ptS);
|
|
dDistE = ptStart.distanceTo(ptE);
|
|
|
|
if (dDistE < _DIST_SNAP || dDistS < _DIST_SNAP)
|
|
{
|
|
if (idAssoc.isNull())
|
|
{
|
|
idAssoc = m_arAssocBWallIds[i];
|
|
}
|
|
else
|
|
{
|
|
//端点处有多个墙时不合并
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
if (idAssoc.isNull())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TDbBaseWall::CanMerge(AcDbObjectId idWall)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbBaseWall::MergeWith(AcDbObjectId idWall)
|
|
{
|
|
TGGeCurveSegment segCenter, segCenterOther;
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
segCenterOther = pEnt->GetCenterLine();
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
segCenter = GetCenterLine();
|
|
|
|
int bLineThis = segCenter.Is(CURVE_LINE), bLineOther = segCenterOther.Is(CURVE_LINE);
|
|
if (bLineThis != bLineOther)
|
|
{
|
|
//直线和弧线不合并
|
|
return FALSE;
|
|
}
|
|
|
|
if (bLineThis)
|
|
{
|
|
if (!IsSameDrt(segCenter.TGGeLine::Direction(), segCenterOther.TGGeLine::Direction(), _angSnap))
|
|
{ //不平行的不合并
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TGGeArc arc1 = segCenter.GetArc(),
|
|
arc2 = segCenterOther.GetArc();
|
|
if (!(fabs(arc1.GetRadius() - arc2.GetRadius()) < _DIST_SNAP && arc1.GetCenterPt() == arc2.GetCenterPt()))
|
|
{ //不是同心圆的不合并
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//比较属性
|
|
if (!CanMerge(idWall))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
int nPosFlag = 0;
|
|
if (segCenter.GetStartPoint() == segCenterOther.GetStartPoint())
|
|
{
|
|
nPosFlag = 1; //合并两个起点
|
|
}
|
|
else if (segCenter.GetStartPoint() == segCenterOther.GetEndPoint())
|
|
{
|
|
nPosFlag = 2; //合并自己的起点和另外的终点
|
|
}
|
|
else if (segCenter.GetEndPoint() == segCenterOther.GetEndPoint())
|
|
{
|
|
nPosFlag = 3; //合并两个终点
|
|
}
|
|
else if (segCenter.GetEndPoint() == segCenterOther.GetStartPoint())
|
|
{
|
|
nPosFlag = 4; //合并自己的终点和另外的起点
|
|
}
|
|
|
|
if (!nPosFlag)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bCanMerge = FALSE;
|
|
|
|
TGGeCurveSegment seg;
|
|
//曲线类型相同
|
|
if (bLineThis)
|
|
{
|
|
if (nPosFlag == 4)
|
|
{
|
|
seg.SetPoints(segCenter.StartPoint(), segCenterOther.EndPoint());
|
|
bCanMerge = TRUE;
|
|
}
|
|
else if (nPosFlag == 2)
|
|
{
|
|
seg.SetPoints(segCenterOther.StartPoint(), segCenter.EndPoint());
|
|
bCanMerge = TRUE;
|
|
}
|
|
else if (nPosFlag == 1)
|
|
{
|
|
seg.SetPoints(segCenterOther.EndPoint(), segCenter.EndPoint());
|
|
bCanMerge = TRUE;
|
|
}
|
|
else if (nPosFlag == 3)
|
|
{
|
|
seg.SetPoints(segCenter.StartPoint(), segCenterOther.StartPoint());
|
|
bCanMerge = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//TGGeArc arc1 = segCenter.GetArc(),
|
|
// arc2 = segCenterOther.GetArc();
|
|
|
|
if (nPosFlag == 4)
|
|
{
|
|
if (segCenter.GetStartPoint() == segCenterOther.GetEndPoint())
|
|
{
|
|
return FALSE;
|
|
}
|
|
seg = segCenter;
|
|
seg.SetPoints(segCenter.StartPoint(), segCenterOther.EndPoint());
|
|
bCanMerge = TRUE;
|
|
}
|
|
else if (nPosFlag == 2)
|
|
{
|
|
if (segCenterOther.GetStartPoint() == segCenter.GetEndPoint())
|
|
{
|
|
return FALSE;
|
|
}
|
|
seg = segCenter;
|
|
seg.SetPoints(segCenterOther.StartPoint(), segCenter.EndPoint());
|
|
bCanMerge = TRUE;
|
|
}
|
|
}
|
|
|
|
if (bCanMerge)
|
|
{
|
|
Acad::ErrorStatus es = upgradeOpen();
|
|
if (es == Acad::eOk)
|
|
{
|
|
SetAt(KEY_START, seg.StartPoint().AsAcGePoint3d());
|
|
SetAt(KEY_END,seg.EndPoint().AsAcGePoint3d());
|
|
SetAt(KEY_BULGE, seg.GetBulge());
|
|
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForWrite, TDbBaseWall, pEnt);
|
|
if (pEnt)
|
|
{
|
|
AcDbObjectIdArray arIds;
|
|
pEnt->GetAssocRelation(ASSOC_ALL, arIds);
|
|
arIds.remove(objectId());
|
|
pEnt->RemoveAssocRelation(objectId());
|
|
|
|
for (int i=0;i<arIds.length();i++)
|
|
{
|
|
//关联移到合并后实体上
|
|
MakeAssocRelationDirect(arIds[i]);
|
|
|
|
//解除原有关联
|
|
pEnt->RemoveAssocRelation(arIds[i]);
|
|
|
|
TAssocMsg assocMsg;
|
|
assocMsg.SetMethod(TAssocMsg::kEdit);
|
|
assocMsg.SetAssocId(arIds[i]);
|
|
|
|
AddMsg(assocMsg);
|
|
}
|
|
|
|
pEnt->erase();
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// 裁剪梁的基础数组操作
|
|
void TDbBaseWall::SetBaseIds(const AcDbObjectIdArray& ids)
|
|
{
|
|
assertWriteEnabled();
|
|
m_arAssocZIds.setLogicalLength(0);
|
|
m_arAssocZIds = ids;
|
|
}
|
|
void TDbBaseWall::GetBaseIds(AcDbObjectIdArray& ids)
|
|
{
|
|
assertReadEnabled();
|
|
ids.setLogicalLength(0);
|
|
ids = m_arAssocZIds;
|
|
}
|
|
void TDbBaseWall::RemoveBaseIds(const AcDbObjectId& id)
|
|
{
|
|
assertWriteEnabled();
|
|
m_arAssocZIds.remove(id);
|
|
}
|
|
|
|
int TDbBaseWall::GetFirstVersion()const
|
|
{
|
|
return 10;
|
|
}
|
|
bool TDbBaseWall::IsModelEntity() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void InitBaseWall(bool bTrue)
|
|
{
|
|
if (bTrue)
|
|
{
|
|
TDbBaseWall::rxInit();
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
acrxBuildClassHierarchy();
|
|
TDbBaseWall::InitMatchProtocol(TRUE);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#if (BASEWALL_AS_OBJ == 1)
|
|
TDbBaseWall::InitMatchProtocol(FALSE);
|
|
#endif
|
|
deleteAcRxClass(TDbBaseWall::desc());
|
|
}
|
|
}
|
|
|
|
#endif |