3394 lines
75 KiB
C++
3394 lines
75 KiB
C++
#include "stdafx.h"
|
|
#include "StdArx.h"
|
|
#include "AecWall2DJoin.h"
|
|
#include "AecCoverBooleanOper.h"
|
|
#include "AcDbX3dSolid.h"
|
|
#include "AecDbX3dPart.h"
|
|
#include "KTCADUtilityEx.h"
|
|
|
|
|
|
const double g_xjoinR = 400.0;
|
|
const double g_xjoinCol = 10.0;
|
|
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
|
|
extern AcGePoint3d GetArcMidPoint(AcDbArc* pArc);
|
|
extern AcDbArc* FormatArc(const AcGePoint3d& ptGe1,const AcGePoint3d& ptGe2,const AcGePoint3d& ptGe3);
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2);
|
|
|
|
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
|
|
extern void RefreshWallOnOpeningDrawEx(const AcDbObjectId& idWall);
|
|
extern void transfromRegion(AcDbRegion *pRegion, const AcGePoint3d &ptOnRegion, const AcGeVector3d &vtNormal, const AcGePoint3d &ptOnPlan);
|
|
|
|
//weight = 20 - index
|
|
const LPCTSTR g_pszWallMaterials[] = { _T("钢筋混凝土"), _T("石材"), _T("砖墙"), _T("填充墙"), _T("玻璃幕墙"),_T("轻质隔墙"),NULL};
|
|
|
|
AecWall2DJoin::AecWall2DJoin(void)
|
|
{
|
|
}
|
|
|
|
AecWall2DJoin::~AecWall2DJoin(void)
|
|
{
|
|
ClearBuffer();
|
|
}
|
|
|
|
bool AecWall2DJoin::DoStruDraw(bool b3dUnit)
|
|
{
|
|
int nBoolUnit = b3dUnit ? TRUE : FALSE;
|
|
|
|
AcDbDatabase* pDb = acdbCurDwg();
|
|
if (pDb == NULL)
|
|
return false;
|
|
|
|
//记录有门窗的墙体
|
|
AcDbObjectIdArray arWallIds;
|
|
|
|
Acad::ErrorStatus es;
|
|
AcDbBlockTable* pTbl = NULL;
|
|
if ( Acad::eOk == (es = pDb->getBlockTable(pTbl,AcDb::kForRead)))
|
|
{
|
|
AcDbBlockTableRecord* pRec = NULL;
|
|
if ( Acad::eOk == (es = pTbl->getAt(ACDB_MODEL_SPACE,pRec,AcDb::kForRead)))
|
|
{
|
|
AcDbBlockTableRecordIterator* pIt = NULL;
|
|
pRec->newIterator(pIt);
|
|
|
|
if (pIt != NULL)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
for (pIt->start();!pIt->done();pIt->step())
|
|
{
|
|
if ( Acad::eOk == (es = pIt->getEntity(pEnt,AcDb::kForWrite) ) )
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
if (!b3dUnit)
|
|
{
|
|
pWall->RemoveAddtionShow3dPart(0);
|
|
pWall->RemoveAddtionShow3dPart(1);
|
|
}
|
|
|
|
//设置三维融合标志
|
|
pWall->GetSpecialtyData()->SetAt(KEY_3DSHOW,nBoolUnit);
|
|
pWall->ReCreateDraw3d();
|
|
|
|
if (!b3dUnit)
|
|
{
|
|
pWall->ClearForDraw2dables();
|
|
|
|
AecComplexCurve draw2d;
|
|
pWall->GetStandardDraw2d(draw2d);
|
|
pWall->SetDraw2dables(draw2d);
|
|
|
|
if (pWall->GetAssocPartCount() > 0)
|
|
{
|
|
arWallIds.append(pWall->objectId());
|
|
}
|
|
pWall->ReCreateDraw3d();
|
|
}
|
|
/*if (nRlt == 0)//不保留
|
|
{
|
|
pWall->ClearForDraw2dables();
|
|
|
|
AecComplexCurve draw2d;
|
|
pWall->GetStandardDraw2d(draw2d);
|
|
pWall->SetDraw2dables(draw2d);
|
|
|
|
if (pWall->GetAssocPartCount() > 0)
|
|
{
|
|
arWallIds.append(pWall->objectId());
|
|
}
|
|
pWall->ReCreateDraw3d();
|
|
}
|
|
else//三维融合
|
|
{
|
|
pWall->ReCreateDraw3d();
|
|
}*/
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
delete pIt;
|
|
}
|
|
pRec->close();
|
|
}
|
|
pTbl->close();
|
|
}
|
|
|
|
//墙上门窗的裁剪
|
|
AcDbObjectId idWall;
|
|
for (int i = 0;i < arWallIds.length();i++)
|
|
{
|
|
idWall = arWallIds.at(i);
|
|
RefreshWallOnOpeningDrawEx(idWall);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool AecWall2DJoin::DoStruDraw(AcDbObjectIdArray& arIds,bool b3dUnit)
|
|
{
|
|
int nBoolUnit = b3dUnit ? TRUE : FALSE;
|
|
|
|
//记录有门窗的墙体
|
|
AcDbObjectIdArray arWallIds;
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0;i < arIds.length();i++)
|
|
{
|
|
if ( Acad::eOk == (acdbOpenAcDbEntity(pEnt,arIds.at(i),AcDb::kForWrite) ) )
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
if (!b3dUnit)
|
|
{
|
|
pWall->RemoveAddtionShow3dPart(0);
|
|
pWall->RemoveAddtionShow3dPart(1);
|
|
}
|
|
|
|
//设置三维融合标志
|
|
pWall->GetSpecialtyData()->SetAt(KEY_3DSHOW,nBoolUnit);
|
|
pWall->ReCreateDraw3d();
|
|
|
|
if (!b3dUnit)
|
|
{
|
|
pWall->ClearForDraw2dables();
|
|
|
|
if (pWall->GetAssocPartCount() > 0)
|
|
{
|
|
arWallIds.append(arIds.at(i));
|
|
}
|
|
pWall->ReCreateDraw3d();
|
|
}
|
|
/*if (nRlt == 0)//不保留
|
|
{
|
|
pWall->ClearForDraw2dables();
|
|
|
|
AecComplexCurve draw2d;
|
|
pWall->GetStandardDraw2d(draw2d);
|
|
pWall->SetDraw2dables(draw2d);
|
|
|
|
if (pWall->GetAssocPartCount() > 0)
|
|
{
|
|
arWallIds.append(pWall->objectId());
|
|
}
|
|
pWall->ReCreateDraw3d();
|
|
}
|
|
else//三维融合
|
|
{
|
|
pWall->ReCreateDraw3d();
|
|
}*/
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
//墙上门窗的裁剪
|
|
AcDbObjectId idWall;
|
|
for (int i = 0;i < arWallIds.length();i++)
|
|
{
|
|
idWall = arWallIds.at(i);
|
|
RefreshWallOnOpeningDrawEx(idWall);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool AecWall2DJoin::DoWall2DDraw(AcDbObjectIdArray& arIds)
|
|
{
|
|
BuildXTJoins(arIds);
|
|
DoWall2DJoin();
|
|
return true;
|
|
}
|
|
|
|
void AecWall2DJoin::ClearBuffer()
|
|
{
|
|
m_arXJoins.removeAll();
|
|
m_arTJoins.removeAll();
|
|
m_arIntJoins.removeAll();
|
|
m_arIDsWallHasOpening.removeAll();
|
|
m_arWallExtends.removeAll();
|
|
|
|
for (int i = 0;i < m_arCmplPtrs.length();i++)
|
|
{
|
|
AecComplexCurve* pCmpl = m_arCmplPtrs.at(i);
|
|
if (pCmpl != NULL) delete pCmpl;
|
|
}
|
|
m_arCmplPtrs.removeAll();
|
|
|
|
CString sKey;
|
|
AcDbCurve* pValue = NULL;
|
|
for (POSITION ps = m_mapIdToPtr.GetStartPosition();ps != NULL;)
|
|
{
|
|
pValue = NULL;
|
|
m_mapIdToPtr.GetNextAssoc(ps,sKey,(void*&)pValue);
|
|
if (pValue != NULL)
|
|
delete pValue;
|
|
}
|
|
m_mapIdToPtr.RemoveAll();
|
|
}
|
|
|
|
bool AecWall2DJoin::ColumnAssocWall(ColEnd& ce,WallEnd& weT)
|
|
{
|
|
bool bAssoc = false;
|
|
if (ce.pColCmpl != NULL && weT.pWallCmpl != NULL)
|
|
{
|
|
AcDbCurve* pCurve1 = NULL;
|
|
AcDbCurve* pCurve2 = NULL;
|
|
AcGePoint3dArray arPts;
|
|
|
|
for (int i = 0;i < ce.pColCmpl->length();i++)
|
|
{
|
|
pCurve1 = ce.pColCmpl->segat(i);
|
|
|
|
for (int j = 0;j < weT.pWallCmpl->length();j++)
|
|
{
|
|
pCurve2 = weT.pWallCmpl->segat(j);
|
|
|
|
pCurve1->intersectWith(pCurve2,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arPts);
|
|
if ( !arPts.isEmpty() )
|
|
{
|
|
bAssoc = true;
|
|
break;
|
|
}
|
|
delete pCurve2;
|
|
}
|
|
if (bAssoc)
|
|
{
|
|
delete pCurve1;
|
|
break;
|
|
}
|
|
delete pCurve1;
|
|
}
|
|
}
|
|
return bAssoc;
|
|
}
|
|
|
|
bool AecWall2DJoin::ColumnAssocWall(ColEnd& ce,WallLn& weT)
|
|
{
|
|
bool bAssoc = false;
|
|
if (ce.pColCmpl != NULL && weT.pWallCmpl != NULL)
|
|
{
|
|
AcDbCurve* pCurve1 = NULL;
|
|
AcDbCurve* pCurve2 = NULL;
|
|
AcGePoint3dArray arPts;
|
|
|
|
for (int i = 0;i < ce.pColCmpl->length();i++)
|
|
{
|
|
pCurve1 = ce.pColCmpl->segat(i);
|
|
|
|
for (int j = 0;j < weT.pWallCmpl->length();j++)
|
|
{
|
|
pCurve2 = weT.pWallCmpl->segat(j);
|
|
|
|
pCurve1->intersectWith(pCurve2,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arPts);
|
|
if ( !arPts.isEmpty() )
|
|
{
|
|
bAssoc = true;
|
|
break;
|
|
}
|
|
delete pCurve2;
|
|
}
|
|
if (bAssoc)
|
|
{
|
|
delete pCurve1;
|
|
break;
|
|
}
|
|
delete pCurve1;
|
|
}
|
|
}
|
|
return bAssoc;
|
|
}
|
|
|
|
bool AecWall2DJoin::ColumnAssocWall(ColEnd& ce,AcGePoint3d& ptPos)
|
|
{
|
|
bool bAssoc = false;
|
|
if ( ce.pColCmpl != NULL)
|
|
{
|
|
AcDbCurve* pCurve1 = NULL;
|
|
AcDbRay ray;
|
|
ray.setBasePoint(ptPos);
|
|
ray.setUnitDir(AcGeVector3d::kXAxis);
|
|
|
|
AcGePoint3dArray arPts;
|
|
for (int i = 0;i < ce.pColCmpl->length();i++)
|
|
{
|
|
pCurve1 = ce.pColCmpl->segat(i);
|
|
|
|
ray.intersectWith(pCurve1,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arPts);
|
|
if (!arPts.isEmpty())
|
|
{
|
|
bAssoc = true;
|
|
}
|
|
delete pCurve1;
|
|
}
|
|
}
|
|
return bAssoc;
|
|
}
|
|
|
|
bool AecWall2DJoin::BuildXTJoins(AcDbObjectIdArray& arIds)
|
|
{
|
|
ClearBuffer();
|
|
|
|
WallData wdata;
|
|
AcGePoint3d ptSta,ptEnd,ptInt;
|
|
|
|
WallEnd wallEnd;
|
|
wallEnd.dParamOnM = 0.0;
|
|
wallEnd.pWallCmpl = NULL;
|
|
|
|
WallLn wallLn;
|
|
wallLn.nType = 0;
|
|
AcArray<WallLn> arWallLns;
|
|
|
|
WallIntJoin wallInt;
|
|
|
|
ColEnd colEnd;
|
|
colEnd.pColCmpl = NULL;
|
|
AcArray<ColEnd> arColEnds;
|
|
AcArray<WallEnd> arWallEnds;
|
|
|
|
//用于标识id1,id2的标识值
|
|
CPoint pt;
|
|
AcArray<CPoint> arIdIds;
|
|
Adesk::IntDbId nStartRef = 0;//参考最小的ID = BlockTable id
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for (int i = 0;i < arIds.length();i++)
|
|
{
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arIds.at(i),AcDb::kForRead))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
pWall->upgradeOpen();
|
|
pWall->GetStandardDraw2d();
|
|
pWall->downgradeOpen();
|
|
|
|
ptSta = GetWallStartPoint(pWall);
|
|
ptEnd = GetWallEndPoint(pWall);
|
|
|
|
pWall->GetWallData(wdata);
|
|
|
|
if (ptSta.distanceTo(ptEnd) < 100.0)
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
wallEnd.pWallCmpl = new AecComplexCurve;
|
|
m_arCmplPtrs.append(wallEnd.pWallCmpl);
|
|
pWall->GetDraw2dables(*wallEnd.pWallCmpl);
|
|
wallEnd.id = pEnt->objectId();
|
|
wallEnd.ptEnd = ptSta;
|
|
wallEnd.dThick = wdata.dThick;
|
|
wallEnd.vtEnd = GetWallFirstDeriv(pWall,ptSta);
|
|
wallEnd.vtEnd.negate();//向外
|
|
wallEnd.nWallWeight = MaterialWeight(wdata.szMat);
|
|
AppendWallEnd(wallEnd,0);
|
|
arWallEnds.append(wallEnd);
|
|
|
|
wallEnd.ptEnd = ptEnd;
|
|
wallEnd.vtEnd = GetWallFirstDeriv(pWall,ptEnd);
|
|
AppendWallEnd(wallEnd,1);
|
|
arWallEnds.append(wallEnd);
|
|
|
|
wallLn.nType = 0;
|
|
wallLn.ptGe[0] = ptSta;
|
|
wallLn.ptGe[1] = ptEnd;
|
|
wallLn.ptGe[2] = ptEnd;
|
|
wallLn.dThick= wdata.dThick;
|
|
wallLn.nWallWeight = wallEnd.nWallWeight;
|
|
wallLn.id = pEnt->objectId();
|
|
|
|
if (pWall->IsArcBaseCurve())
|
|
{
|
|
AcDbArc* pArc = AcDbArc::cast(pWall->GetNativeCurve());
|
|
wallLn.nType = 1;
|
|
wallLn.ptGe[1] = GetArcMidPoint(pArc);
|
|
}
|
|
|
|
wallLn.pWallCmpl = wallEnd.pWallCmpl;
|
|
arWallLns.append(wallLn);
|
|
|
|
if (pWall->GetAssocPartCount() > 0)
|
|
{
|
|
m_arIDsWallHasOpening.append(wallLn.id);
|
|
}
|
|
}
|
|
|
|
AecDbColumn* pCol = AecDbColumn::cast(pEnt);
|
|
if (pCol != NULL)
|
|
{
|
|
pCol->getStartPoint(ptSta);
|
|
ptSta.z = 0.0;//投影
|
|
|
|
colEnd.pColCmpl = new AecComplexCurve;
|
|
m_arCmplPtrs.append(colEnd.pColCmpl);
|
|
pCol->GetDraw2dables(*colEnd.pColCmpl);
|
|
colEnd.ptPos = ptSta;
|
|
colEnd.id = pEnt->objectId();
|
|
arColEnds.append(colEnd);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
//柱子关联墙体
|
|
for (int i = 0;i < arColEnds.length();i++)
|
|
{
|
|
ColEnd& colE = arColEnds.at(i);
|
|
|
|
for (int j = 0;j < arWallLns.length();j++)
|
|
{
|
|
WallLn& waL = arWallLns.at(j);
|
|
|
|
if (ColumnAssocWall(colE,waL))
|
|
{
|
|
ColOnWall colWall;
|
|
colWall.idCol = colE.id;
|
|
colWall.ptPos = colE.ptPos;
|
|
colWall.idWall = waL.id;
|
|
colWall.pColCmpl = colE.pColCmpl;
|
|
m_arColOnWall.append(colWall);
|
|
}
|
|
}
|
|
}
|
|
|
|
//然后构建T结构
|
|
for (int i = 0;i < arWallEnds.length();i++)
|
|
{
|
|
WallEnd we = arWallEnds.at(i);
|
|
|
|
//找到搭边的实体
|
|
for (int ii = 0;ii < arWallLns.length();ii++)
|
|
{
|
|
WallLn& wl = arWallLns.at(ii);
|
|
|
|
//判断是否 搭边 T 结构
|
|
if (IsTJoin(we,wl))
|
|
{
|
|
if ( we.idCol.isValid() )
|
|
{
|
|
AppendWallTJoin(wl.id,we,wl.nWallWeight);
|
|
|
|
//一端只搭一个墙体,所以去除这个
|
|
arWallEnds.removeAt(i);
|
|
i -= 1;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (we.id != wl.id)
|
|
{
|
|
AppendWallTJoin(wl.id,we,wl.nWallWeight);
|
|
|
|
//一端只搭一个墙体,所以去除这个
|
|
arWallEnds.removeAt(i);
|
|
i -= 1;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else//有可能是相交结构
|
|
{
|
|
if (wl.id != we.id)
|
|
{
|
|
if (wl.id.asOldId() < we.id.asOldId())
|
|
{
|
|
pt.x = (LONG)(wl.id.asOldId() - nStartRef);
|
|
pt.y = (LONG)(we.id.asOldId() - nStartRef);
|
|
}
|
|
else
|
|
{
|
|
pt.x = (LONG)(we.id.asOldId() - nStartRef);
|
|
pt.y = (LONG)(wl.id.asOldId() - nStartRef);
|
|
}
|
|
|
|
if (arIdIds.find(pt) == -1)
|
|
{
|
|
arIdIds.append(pt);//记下,表示处理过
|
|
|
|
for (int iii = 0;iii < arWallLns.length();iii++)
|
|
{
|
|
WallLn& wl2 = arWallLns.at(iii);
|
|
if (wl2.id == we.id)
|
|
{
|
|
if (IsIntJoin(wl,wl2,ptInt))
|
|
{
|
|
wallInt.id1 = wl.id;
|
|
wallInt.id2 = we.id;
|
|
wallInt.ptInt = ptInt;
|
|
m_arIntJoins.append(wallInt);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!m_arIntJoins.isEmpty())
|
|
{
|
|
acutPrintf(_T("\n墙体有相交,需要断开处理!"));
|
|
}
|
|
|
|
//从X结构中提取==结构
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AecWall2DJoin::IsIntJoin(WallLn& wl,WallLn& wl2,AcGePoint3d& ptInt) const
|
|
{
|
|
if (wl2.id == wl.id)//自己不交自己
|
|
return false;
|
|
|
|
AcGePoint3dArray arPts;
|
|
if (wl.nType == 0 && wl2.nType == 0)//line
|
|
{
|
|
AcDbLine ln1(wl.ptGe[0],wl.ptGe[1]);
|
|
AcDbLine ln2(wl2.ptGe[0],wl2.ptGe[1]);
|
|
|
|
ln1.intersectWith(&ln2,AcDb::kOnBothOperands,arPts);
|
|
|
|
if (!arPts.isEmpty())
|
|
{
|
|
ptInt = arPts.first();
|
|
}
|
|
return !arPts.isEmpty();
|
|
}
|
|
else
|
|
{
|
|
if (wl.nType == 0)
|
|
{
|
|
AcDbLine ln1(wl.ptGe[0],wl.ptGe[1]);
|
|
|
|
AcDbArc* pArc = FormatArc(wl2.ptGe[0],wl2.ptGe[1],wl2.ptGe[2]);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->intersectWith(&ln1,AcDb::kOnBothOperands,arPts);
|
|
delete pArc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcDbLine ln2(wl2.ptGe[0],wl2.ptGe[1]);
|
|
|
|
AcDbArc* pArc = FormatArc(wl.ptGe[0],wl.ptGe[1],wl.ptGe[2]);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->intersectWith(&ln2,AcDb::kOnBothOperands,arPts);
|
|
delete pArc;
|
|
}
|
|
}
|
|
if (!arPts.isEmpty())
|
|
{
|
|
ptInt = arPts.first();
|
|
}
|
|
}
|
|
return !arPts.isEmpty();
|
|
}
|
|
|
|
bool AecWall2DJoin::IsTJoin(WallEnd& we,WallLn& wl) const
|
|
{
|
|
if (we.id == wl.id)//自己不搭自己
|
|
return false;
|
|
|
|
if (wl.nType == 0)//line
|
|
{
|
|
AcDbLine ln(wl.ptGe[0],wl.ptGe[1]);
|
|
AcGeVector3d vtL = wl.ptGe[1] - wl.ptGe[0];
|
|
AcGePoint3d ptOn;
|
|
ln.getClosestPointTo(we.ptEnd,ptOn,Adesk::kFalse);
|
|
|
|
//如果落到端点,则不是T结构
|
|
if (ptOn.distanceTo(wl.ptGe[0]) < 1.e-1 ||
|
|
ptOn.distanceTo(wl.ptGe[1]) < 1.e-1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
double dDis = ptOn.distanceTo(we.ptEnd);
|
|
if ( (dDis - __min(wl.dThick,we.dThick)) < 1.e-6)//1个墙厚
|
|
{
|
|
if (we.vtEnd.isParallelTo(vtL))
|
|
return false;
|
|
|
|
ln.getParamAtPoint(ptOn,we.dParamOnM);
|
|
return true;
|
|
}
|
|
}
|
|
else if (wl.nType == 1)
|
|
{
|
|
AcDbArc* pArc = FormatArc(wl.ptGe[0],wl.ptGe[1],wl.ptGe[2]);
|
|
if (pArc != NULL)
|
|
{
|
|
AcGePoint3d ptOn;
|
|
pArc->getClosestPointTo(we.ptEnd,ptOn, Adesk::kFalse);
|
|
|
|
double dDis = ptOn.distanceTo(we.ptEnd);
|
|
if ( (dDis - __min(wl.dThick,we.dThick)) < 1.e-6)//1 个墙厚
|
|
{
|
|
pArc->getParamAtPoint(ptOn,we.dParamOnM);
|
|
delete pArc;
|
|
return true;
|
|
}
|
|
delete pArc;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void AecWall2DJoin::AppendWallTJoin(AcDbObjectId& idMain,const WallEnd& we,int nMainWeight)
|
|
{
|
|
//有什么快速方法?
|
|
bool bFind = false;
|
|
for (int i = 0;i < m_arTJoins.length();i++)
|
|
{
|
|
WallTJoin& wtOf = m_arTJoins.at(i);
|
|
if (wtOf.idMain == idMain)
|
|
{
|
|
if (wtOf.nValid < MAX_T_STRS)
|
|
{
|
|
wtOf.wes[wtOf.nValid] = we;
|
|
wtOf.nValid += 1;
|
|
|
|
bFind = true;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
acutPrintf(_T("\n某一面墙体超过上限T型结构!"));
|
|
}
|
|
}
|
|
if (bFind)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//没有找到
|
|
if (!bFind)
|
|
{
|
|
WallTJoin wt;
|
|
if (we.id.isValid() )
|
|
{
|
|
wt.idMain = idMain;
|
|
wt.nValid = 1;
|
|
wt.nWallWeight = nMainWeight;
|
|
wt.wes[0] = we;
|
|
m_arTJoins.append(wt);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool GetIntPoint(AcGePoint3d& ptJoin,const AcGeVector3d& vtEnd,const AcGePoint3d& ptEnd,const AcGeVector3d& vtEnd2)
|
|
{
|
|
AcGeLine3d ln1(ptJoin,vtEnd),ln2(ptEnd,vtEnd2);
|
|
|
|
AcGePoint3d ptInt;
|
|
if ( ln1.intersectWith(ln2,ptInt) )
|
|
{
|
|
ptJoin = ptInt;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool RayIntersectRay(WallXJoin& wallXj,const WallEnd& wallEnd,AcGePoint3d& ptInt)
|
|
{
|
|
//考虑和圆弧相切的情况
|
|
//避开自交
|
|
for (int ii = 0;ii < wallXj.nValid;ii++)
|
|
{
|
|
if ( wallXj.ids[ii] == wallEnd.id)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( wallXj.vtEnd[0].isParallelTo(wallEnd.vtEnd) )
|
|
{
|
|
ptInt = wallEnd.ptEnd;
|
|
return true;
|
|
}
|
|
|
|
AcDbRay ray1,ray2;
|
|
ray1.setUnitDir(-wallXj.vtEnd[0]);
|
|
ray1.setBasePoint(wallXj.ptJoin);
|
|
|
|
ray2.setUnitDir(-wallEnd.vtEnd);
|
|
ray2.setBasePoint(wallEnd.ptEnd);
|
|
|
|
AcGePoint3dArray arPts;
|
|
ray1.intersectWith(&ray2,AcDb::kOnBothOperands,arPts);
|
|
|
|
//TEST
|
|
/*if (!arPts.isEmpty())
|
|
{
|
|
AddToModelSpace((AcDbEntity*)ray1.clone());
|
|
AddToModelSpace((AcDbEntity*)ray2.clone());
|
|
}*/
|
|
|
|
if (!arPts.isEmpty())
|
|
{
|
|
ptInt = arPts.first();
|
|
}
|
|
else
|
|
{
|
|
ray1.intersectWith(&ray2,AcDb::kExtendBoth,arPts);
|
|
if (!arPts.isEmpty())
|
|
{
|
|
ptInt = arPts.first();
|
|
double dDis1 = ptInt.distanceTo(wallEnd.ptEnd);
|
|
double dDis2 = ptInt.distanceTo(wallXj.ptJoin);
|
|
|
|
if (dDis1 < __max(wallEnd.dThick,wallXj.dThick) &&
|
|
dDis2 < __max(wallEnd.dThick,wallXj.dThick) )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return !arPts.isEmpty();
|
|
}
|
|
|
|
void AecWall2DJoin::AppendWallEnd(const WallEnd& wallEnd,int nFlag)
|
|
{
|
|
//有什么快速方法?
|
|
bool bFind = false;
|
|
bool bSelX = false;
|
|
double dDis = 0.0;
|
|
|
|
if (m_arXJoins.isEmpty())
|
|
{
|
|
WallXJoin wallXj;
|
|
wallXj.nValid = 1;//只有一个
|
|
wallXj.nWallWeight[0] = wallEnd.nWallWeight;
|
|
wallXj.ids[0] = wallEnd.id;
|
|
wallXj.ptJoin = wallEnd.ptEnd;
|
|
wallXj.vtEnd[0] = wallEnd.vtEnd;
|
|
wallXj.dThick = wallEnd.dThick;
|
|
wallXj.dThicks[0] = wallEnd.dThick;
|
|
m_arXJoins.append(wallXj);
|
|
return;
|
|
}
|
|
|
|
//找到最接近的XJ
|
|
AcGePoint3d ptInt;
|
|
int nPos = -1;
|
|
for(int i = 0;i < m_arXJoins.length();i++)
|
|
{
|
|
WallXJoin& wallXj = m_arXJoins.at(i);
|
|
|
|
dDis = wallEnd.ptEnd.distanceTo(wallXj.ptJoin);
|
|
if (dDis < __max(wallEnd.dThick,wallXj.dThick) )
|
|
{
|
|
if (RayIntersectRay(wallXj,wallEnd,ptInt))
|
|
{
|
|
//避开自交
|
|
for (int ii = 0;ii < wallXj.nValid;ii++)
|
|
{
|
|
if ( wallXj.ids[ii] == wallEnd.id)
|
|
{
|
|
bSelX = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bSelX) continue;
|
|
nPos = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
bSelX = false;
|
|
if (nPos > -1 && nPos < m_arXJoins.length())
|
|
{
|
|
WallXJoin& wallXj = m_arXJoins.at(nPos);
|
|
|
|
bFind = false;
|
|
dDis = wallEnd.ptEnd.distanceTo(wallXj.ptJoin);
|
|
if (dDis - __max(wallEnd.dThick,wallXj.dThick) < 1.e-6)//-g_xjoinR
|
|
{
|
|
//且射线相交,X 结构
|
|
//if ( fabs(wallEnd.dThick - wallXj.dThick) < 1.0)//等厚
|
|
{
|
|
//避开自交
|
|
for (int ii = 0;ii < wallXj.nValid;ii++)
|
|
{
|
|
if ( wallXj.ids[ii] == wallEnd.id)
|
|
{
|
|
bSelX = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bSelX)
|
|
{
|
|
for (int ii = 0;ii < 4;ii++)
|
|
{
|
|
if (!wallXj.ids[ii].isValid() )
|
|
{
|
|
wallXj.ids[ii] = wallEnd.id;
|
|
wallXj.nValid += 1;
|
|
wallXj.nWallWeight[ii] = wallEnd.nWallWeight;
|
|
wallXj.vtEnd[ii] = wallEnd.vtEnd;
|
|
wallXj.dThicks[ii] = wallEnd.dThick;
|
|
|
|
/*if (ii > 0)
|
|
{
|
|
if ( !GetIntPoint(wallXj.ptJoin,wallXj.vtEnd[ii-1],wallEnd.ptEnd,wallEnd.vtEnd) )//取交点
|
|
{
|
|
wallXj.ptJoin = MidPoint(wallXj.ptJoin,wallEnd.ptEnd);//取中点
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wallXj.ptJoin = MidPoint(wallXj.ptJoin,wallEnd.ptEnd);//取中点
|
|
}*/
|
|
|
|
wallXj.ptJoin = ptInt;
|
|
|
|
bFind = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bFind)//没有找到,也加入
|
|
{
|
|
WallXJoin wallXj;
|
|
wallXj.nValid = 1;//只有一个
|
|
wallXj.ids[0] = wallEnd.id;
|
|
wallXj.ptJoin = wallEnd.ptEnd;
|
|
wallXj.vtEnd[0] = wallEnd.vtEnd;
|
|
wallXj.dThick = wallEnd.dThick;
|
|
wallXj.dThicks[0] = wallEnd.dThick;
|
|
wallXj.nWallWeight[0] = wallEnd.nWallWeight;
|
|
m_arXJoins.append(wallXj);
|
|
}
|
|
}
|
|
|
|
bool AecWall2DJoin::DoWall2DJoin()
|
|
{
|
|
//1.处理X结构
|
|
for (int i = 0;i < m_arXJoins.length();i++)
|
|
{
|
|
WallXJoin& wj = m_arXJoins.at(i);
|
|
if (wj.idCol.isValid())//有柱子
|
|
{
|
|
//延伸到柱子
|
|
ExtendToColumnRegion(wj);
|
|
}
|
|
else
|
|
{
|
|
//逆时针排序裁剪
|
|
if (wj.nValid > 1)//有X结构
|
|
{
|
|
XJoinSortAndTrimByUClock(wj);
|
|
}
|
|
}
|
|
}
|
|
|
|
//2.处理T结构,同时产生T结构的延伸
|
|
for (int i = 0;i < m_arTJoins.length();i++)
|
|
{
|
|
WallTJoin& wt = m_arTJoins.at(i);
|
|
TJoinSortAndTrimByMain(wt);
|
|
}
|
|
|
|
//3.处理T结构的延伸墙体
|
|
AcDbEntity* pEntE = NULL;
|
|
for (int i = 0;i < m_arWallExtends.length();i++)
|
|
{
|
|
WallExtend& exd = m_arWallExtends.at(i);
|
|
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEntE,exd.idWall,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWallE = AecDbXWall::cast(pEntE);
|
|
if (pWallE != NULL)
|
|
{
|
|
for (int j = 0;j < exd.nEnds;j++)
|
|
{
|
|
Extend(pWallE,exd.bExtendSta[j],exd.ptOn[j],exd.vtEnd[j], exd.idMain, exd.nNearSide);
|
|
}
|
|
}
|
|
pEntE->close();
|
|
}
|
|
}
|
|
|
|
//4.门窗裁剪
|
|
AcDbObjectId idWall;
|
|
for(int i = 0;i < m_arIDsWallHasOpening.length();i++)
|
|
{
|
|
idWall = m_arIDsWallHasOpening.at(i);
|
|
RefreshWallOnOpeningDrawEx(idWall);
|
|
}
|
|
|
|
//5.处理相交结构
|
|
IntJoinsBoolSubtract();
|
|
|
|
//6.墙体裁剪柱子
|
|
for (int i = 0;i < m_arColOnWall.length();i++)
|
|
{
|
|
ColOnWall& colWall = m_arColOnWall.at(i);
|
|
ColumnClipWall(colWall);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void AecWall2DJoin::ColumnClipWall(ColOnWall& colWall)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,colWall.idWall,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
//进行类似遮挡处理
|
|
AecComplexCurve draw2d;
|
|
pWall->GetDraw2dables(draw2d);
|
|
|
|
//区域裁剪
|
|
AecComplexCurve cmplOutSide,cmplInSide;
|
|
AecCoverBooleanOper::PolyClip(*colWall.pColCmpl,draw2d,cmplOutSide,cmplInSide);
|
|
|
|
pWall->SetDraw2dables(cmplOutSide);
|
|
|
|
//移除端部标记
|
|
//pWall->RemoveTailDraw2d(colWall.ptPos);
|
|
|
|
cmplOutSide.removeAll();
|
|
cmplInSide.removeAll();
|
|
draw2d.removeAll();
|
|
|
|
pWall->GetDraw2dHideTail(draw2d);
|
|
AecCoverBooleanOper::PolyClip(*colWall.pColCmpl,draw2d,cmplOutSide,cmplInSide);
|
|
|
|
pWall->SetDraw2dHideTail(cmplOutSide);
|
|
|
|
//墙体关联柱子
|
|
|
|
// 在这里没有发现关联柱子的必要啊，就是不关联功能也可以实现，
|
|
// 暂时不关联，不然deepclone和wblockclone会把柱子复制出来
|
|
|
|
//pWall->AppendAssocPart(colWall.idCol);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
AecDbX3dPart* AecWall2DJoin::Create3DSolid(AecComplexCurve& cmplCol,WallData& data1,WallData& data2)
|
|
{
|
|
AcDbX3dSolid* pXSolid = NULL;
|
|
AcDbCurve* pCurve = NULL;
|
|
AcDbVoidPtrArray arCurPtrs,arRes;
|
|
for (int i = 0;i < cmplCol.length();i++)
|
|
{
|
|
pCurve = cmplCol.segat(i);
|
|
if (pCurve != NULL)
|
|
{
|
|
arCurPtrs.append(pCurve);
|
|
}
|
|
}
|
|
|
|
pCurve = KTCADUtilityEx::ConvertBoundCurve(arCurPtrs,arRes);
|
|
if (pCurve != NULL)
|
|
{
|
|
AcDbPolyline* pPl = AcDbPolyline::cast(pCurve);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setElevation(__max(data1.dBomEl,data2.dBomEl));
|
|
pPl->setClosed(Adesk::kTrue);
|
|
|
|
AcDbExtents ext;
|
|
pPl->getGeomExtents(ext);
|
|
|
|
AcGePoint3d ptS = MidPoint(ext.minPoint(),ext.maxPoint());
|
|
AcGePoint3d ptE = ptS;
|
|
ptE.z = __min(data1.dH,data2.dH);
|
|
|
|
arCurPtrs.removeAll();
|
|
arCurPtrs.append(pPl);
|
|
|
|
arRes.removeAll();
|
|
AcDbRegion::createFromCurves(arCurPtrs,arRes);
|
|
delete pPl;
|
|
|
|
if (!arRes.isEmpty())
|
|
{
|
|
AcDbRegion* pRegion = (AcDbRegion*)arRes.first();
|
|
|
|
AcDbLine lnPath;
|
|
lnPath.setStartPoint(ptS);
|
|
lnPath.setEndPoint(ptE);
|
|
|
|
pXSolid = new AcDbX3dSolid;
|
|
pXSolid->CreateExtrude(pRegion,lnPath);
|
|
delete pRegion;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pXSolid != NULL)
|
|
{
|
|
AecDbX3dPart* pPart = new AecDbX3dPart;
|
|
pPart->SetName(_T("ExAdd"));
|
|
pPart->GetSpecialtyData()->SetAt(KEY_ADDTIONSHOW,TRUE);
|
|
pPart->GetSpecialtyData()->SetAt(KEY_POS,0);
|
|
pPart->GetSpecialtyData()->SetAt(KEY_FORSLICE,FALSE);
|
|
pPart->AddX3dSolid(pXSolid);
|
|
|
|
return pPart;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void AecWall2DJoin::IntJoinsBoolSubtract()
|
|
{
|
|
AcDbEntity* pEnt2 = NULL,*pEnt1 = NULL;
|
|
for (int i = 0;i < m_arIntJoins.length();i++)
|
|
{
|
|
WallIntJoin& wIntJ = m_arIntJoins.at(i);
|
|
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt1,wIntJ.id1,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWall1 = AecDbXWall::cast(pEnt1);
|
|
if (pWall1 != NULL)
|
|
{
|
|
AcGeVector3d vt1,vt2;
|
|
AecEqui::AecCurveElement el;
|
|
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
|
AecComplexCurve cmplSub,cmplCol;
|
|
|
|
AecEqui::AecCurveElement eL1 = pWall1->GetLeftElement(true);
|
|
AecEqui::AecCurveElement eR1 = pWall1->GetRightElement(true);
|
|
AecEqui::AecCurveElement eC1 = pWall1->GetMidElement();
|
|
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt2,wIntJ.id2,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWall2 = AecDbXWall::cast(pEnt2);
|
|
if (pWall2 != NULL)
|
|
{
|
|
AecEqui::AecCurveElement eL2 = pWall2->GetLeftElement(true);
|
|
AecEqui::AecCurveElement eR2 = pWall2->GetRightElement(true);
|
|
AecEqui::AecCurveElement eC2 = pWall2->GetMidElement();
|
|
|
|
//墙体在标高上有相交
|
|
WallData data1,data2;
|
|
pWall1->GetWallData(data1);
|
|
pWall2->GetWallData(data2);
|
|
|
|
int nWallWeight1 = MaterialWeight(data1.szMat);
|
|
int nWallWeight2 = MaterialWeight(data2.szMat);
|
|
|
|
AcGePoint3dArray arPt;
|
|
|
|
//等标高+H 相交
|
|
//不等,部分被裁
|
|
|
|
//相交结构,墙1=墙2
|
|
if ( fabs ( (data1.dBomEl + data1.dH) - ( data2.dBomEl + data2.dH ) ) < 1.e-3)
|
|
{
|
|
//L1X(L2 R2)
|
|
AecComplexCurve::IntersectWith(eL1,eL2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL1,eR2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL1,eC2,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();//sta
|
|
el.ptGe[2] = arPt.last();//mid
|
|
el.ptGe[1] = arPt.at(1);//end
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//R1X(L2 R2)
|
|
AecComplexCurve::IntersectWith(eR1,eL2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR1,eR2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR1,eC2,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();
|
|
el.ptGe[2] = arPt.last();
|
|
el.ptGe[1] = arPt.at(1);
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//裁剪 墙1材质<=墙2材质
|
|
if (nWallWeight1 <= nWallWeight2)
|
|
pWall1->SubtractDraw2d(cmplSub);
|
|
|
|
cmplCol.append(cmplSub);
|
|
cmplSub.removeAll();
|
|
|
|
//L2X(L1 R1)
|
|
AecComplexCurve::IntersectWith(eL2,eL1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL2,eR1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL2,eC1,AcDb::kOnBothOperands,arPt);
|
|
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();
|
|
el.ptGe[2] = arPt.last();
|
|
el.ptGe[1] = arPt.at(1);
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//R2X(L1 R1)
|
|
AecComplexCurve::IntersectWith(eR2,eL1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR2,eR1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR2,eC1,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();
|
|
el.ptGe[2] = arPt.last();
|
|
el.ptGe[1] = arPt.at(1);
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//裁剪
|
|
//裁剪 墙2材质<=墙1材质
|
|
if (nWallWeight2 <= nWallWeight1)
|
|
pWall2->SubtractDraw2d(cmplSub);
|
|
cmplCol.append(cmplSub);
|
|
|
|
//需要判断重墙体轻重,默认wall1去除
|
|
AecDbX3dPart* pCol1 = Create3DSolid(cmplCol,data1,data2);
|
|
if (pCol1 != NULL)
|
|
{
|
|
if (nWallWeight1 <= nWallWeight2)
|
|
{
|
|
pWall1->AddX3dPart(pCol1, AcDb::kBoolSubtract);
|
|
}
|
|
else
|
|
{
|
|
delete pCol1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//部分相交非等标高和高度的两个墙体处理
|
|
if ( (data1.dBomEl + data1.dH) - ( data2.dBomEl + data2.dH ) < 1.e-3)
|
|
{
|
|
//wall1 矮于 wall2 wall1 被穿
|
|
//L1X(L2 R2)
|
|
AcGePoint3dArray arPt;
|
|
AecComplexCurve::IntersectWith(eL1,eL2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL1,eR2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL1,eC2,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();//sta
|
|
el.ptGe[2] = arPt.last();//mid
|
|
el.ptGe[1] = arPt.at(1);//end
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//R1X(L2 R2)
|
|
AecComplexCurve::IntersectWith(eR1,eL2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR1,eR2,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR1,eC2,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();
|
|
el.ptGe[2] = arPt.last();
|
|
el.ptGe[1] = arPt.at(1);
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//裁剪
|
|
//裁剪 墙1材质<=墙2材质
|
|
if (nWallWeight1 <= nWallWeight2)
|
|
pWall1->SubtractDraw2d(cmplSub);
|
|
|
|
cmplCol.append(cmplSub);
|
|
cmplSub.removeAll();
|
|
}
|
|
else
|
|
{
|
|
//wall2 矮于 wall1 wall2 被穿
|
|
//L2X(L1 R1)
|
|
AecComplexCurve::IntersectWith(eL2,eL1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL2,eR1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eL2,eC1,AcDb::kOnBothOperands,arPt);
|
|
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();
|
|
el.ptGe[2] = arPt.last();
|
|
el.ptGe[1] = arPt.at(1);
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//R2X(L1 R1)
|
|
AecComplexCurve::IntersectWith(eR2,eL1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR2,eR1,AcDb::kOnBothOperands,arPt);
|
|
AecComplexCurve::IntersectWith(eR2,eC1,AcDb::kOnBothOperands,arPt);
|
|
if (arPt.length() == 3)
|
|
{
|
|
el.ptGe[0] = arPt.first();
|
|
el.ptGe[2] = arPt.last();
|
|
el.ptGe[1] = arPt.at(1);
|
|
|
|
vt1 = arPt.last() - arPt.first();
|
|
vt2 = arPt.at(1) - arPt.first();
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
el.ptGe[2] = el.ptGe[1];
|
|
}
|
|
|
|
cmplSub.append(el);
|
|
}
|
|
arPt.removeAll();
|
|
|
|
//裁剪
|
|
//裁剪 墙2材质<=墙1材质
|
|
if (nWallWeight2 <= nWallWeight1)
|
|
pWall2->SubtractDraw2d(cmplSub);
|
|
|
|
cmplCol.append(cmplSub);
|
|
}
|
|
}
|
|
}
|
|
pEnt2->close();
|
|
}
|
|
}
|
|
pEnt1->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SortByParam(IdParamEl& idp1,IdParamEl& idp2)
|
|
{
|
|
if (idp1.dParam - idp2.dParam < 1.e-10)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void AecWall2DJoin::GetMidPoint(AecDbXWall* pWall,AcGePoint3d& ptMid)
|
|
{
|
|
AcDbCurve* pBaseCurve = GetWallBaseCurve(pWall);
|
|
if (pBaseCurve != NULL)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
ptMid = MidPoint(pLn->startPoint(),pLn->endPoint());
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pBaseCurve);
|
|
if (pArc != NULL)
|
|
{
|
|
ptMid = GetArcMidPoint(pArc);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AecWall2DJoin::ExtendToColumnRegion(const WallXJoin& wj)
|
|
{
|
|
AecDbXWall* pWall = NULL;
|
|
AcDbEntity* pEntWall = NULL;
|
|
|
|
AcDbEntity* pEntCol = NULL;
|
|
AecDbColumn* pCol = NULL;
|
|
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEntCol,wj.idCol,AcDb::kForRead))
|
|
{
|
|
pCol = AecDbColumn::cast(pEntCol);
|
|
if (pCol != NULL)
|
|
{
|
|
//获取闭合的柱子外包线
|
|
AecComplexCurve draw2dCol;
|
|
pCol->GetDraw2dables(draw2dCol);
|
|
|
|
AcGePoint3d ptPos = pCol->GetPosition();
|
|
ptPos.z = 0.0;
|
|
|
|
//墙体裁去柱子的线
|
|
for (int i = 0;i < wj.nValid;i++)
|
|
{
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEntWall,wj.ids[i],AcDb::kForWrite))
|
|
{
|
|
pWall = AecDbXWall::cast(pEntWall);
|
|
if (pWall != NULL)
|
|
{
|
|
//进行类似遮挡处理
|
|
AecComplexCurve draw2d;
|
|
pWall->GetDraw2dables(draw2d);
|
|
|
|
//区域裁剪
|
|
AecComplexCurve cmplOutSide,cmplInSide;
|
|
AecCoverBooleanOper::PolyClip(draw2dCol,draw2d,cmplOutSide,cmplInSide);
|
|
|
|
pWall->SetDraw2dables(cmplOutSide);
|
|
|
|
//移除端部标记
|
|
pWall->RemoveTailDraw2d(ptPos);
|
|
}
|
|
pEntWall->close();
|
|
}
|
|
}
|
|
}
|
|
pEntCol->close();
|
|
}
|
|
}
|
|
|
|
bool SortIdAngleElByAngle(IdAngleEl& idael1,IdAngleEl& idael2)
|
|
{
|
|
if (idael1.dParam < idael2.dParam)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void AecWall2DJoin::UnClockWiseSortLR(std::vector<IdParamEl>& vtIdParams,const AcGePoint3d& ptOn,std::vector<IdAngleEl>& vtIdAngleEl)
|
|
{
|
|
double dA1 = 0.0,dA2 = 0.0;
|
|
AcGeVector3d vt1,vt2;
|
|
AcGePoint3d ptM1,ptM2;
|
|
|
|
AecEqui::AecCurveElement elT;
|
|
memset(&elT,0,sizeof(AecEqui::AecCurveElement));
|
|
|
|
IdAngleEl ael;
|
|
ael.bIsOverParallel = false;
|
|
for (int i = 0;i < vtIdParams.size();i++)
|
|
{
|
|
IdParamEl& idp1 = vtIdParams.at(i);
|
|
|
|
ptM1 = MidPoint(idp1.eL.ptGe[0],idp1.eL.ptGe[2]);
|
|
vt1 = ptM1 - ptOn;
|
|
vt1.z = 0.0;
|
|
|
|
ptM2 = MidPoint(idp1.eR.ptGe[0],idp1.eR.ptGe[2]);
|
|
vt2 = ptM2 - ptOn;
|
|
vt2.z = 0.0;
|
|
|
|
//vt1.normalize();
|
|
//vt2.normalize();
|
|
|
|
dA1 = AcGeVector3d::kXAxis.angleTo(vt1,AcGeVector3d::kZAxis);
|
|
dA2 = AcGeVector3d::kXAxis.angleTo(vt2,AcGeVector3d::kZAxis);
|
|
|
|
ael.el = idp1.eL;
|
|
ael.id = idp1.id;
|
|
ael.dParam = dA1;
|
|
ael.nWallWeight = idp1.nWallWeight;
|
|
vtIdAngleEl.push_back(ael);
|
|
|
|
ael.el = idp1.eR;
|
|
ael.id = idp1.id;
|
|
ael.dParam = dA2;
|
|
ael.nWallWeight = idp1.nWallWeight;
|
|
vtIdAngleEl.push_back(ael);
|
|
}
|
|
std::sort(vtIdAngleEl.begin(),vtIdAngleEl.end(),SortIdAngleElByAngle);
|
|
}
|
|
|
|
static void ElementSubtract(AecEqui::AecCurveElement& el1, AecEqui::AecCurveElement& el2, AcArray<AecEqui::AecCurveElement>& elRes1, AcArray<AecEqui::AecCurveElement>& elRes2)
|
|
{
|
|
//el1,el2均为直线
|
|
AecComplexCurve cpl1;
|
|
cpl1.append(el1);
|
|
|
|
el2.bHided = 1;
|
|
cpl1.append(el2);
|
|
el2.bHided = 0;
|
|
|
|
cpl1.boolSubtract();
|
|
for (int i = 0;i < cpl1.length();i++)
|
|
{
|
|
elRes1.append(cpl1.at(i));
|
|
}
|
|
|
|
AecComplexCurve cpl2;
|
|
cpl2.append(el2);
|
|
el1.bHided = 1;
|
|
cpl2.append(el1);
|
|
el1.bHided = 0;
|
|
cpl2.boolSubtract();
|
|
|
|
for (int i = 0;i < cpl2.length();i++)
|
|
{
|
|
elRes2.append(cpl2.at(i));
|
|
}
|
|
}
|
|
|
|
bool AecWall2DJoin::CalWeightWallEndLine(IdParamEl &idPW, IdParamEl &idPQ, AecEqui::AecCurveElement &elWEnd, AecEqui::AecCurveElement &elWExt)
|
|
{
|
|
AcGePoint3d ptGe[2],ptGeT;
|
|
AcGeVector3d vtDir[2];
|
|
|
|
AcDbCurve *pCrvL = NULL, *pCrvR = NULL;
|
|
AecComplexCurve::MakeCurve(idPW.eL, pCrvL);
|
|
|
|
AcGePoint3dArray arWPts;
|
|
arWPts.append(idPW.eL.ptGe[0]);
|
|
arWPts.append(idPW.eL.ptGe[2]);
|
|
|
|
bool bFind1 = false;
|
|
if (!bFind1 && arWPts.find(idPQ.eL.ptGe[0]) != -1)
|
|
{
|
|
ptGe[0] = idPQ.eL.ptGe[0];
|
|
bFind1 = true;
|
|
}
|
|
if (!bFind1 && arWPts.find(idPQ.eL.ptGe[2]) != -1)
|
|
{
|
|
ptGe[0] = idPQ.eL.ptGe[2];
|
|
bFind1 = true;
|
|
}
|
|
if (!bFind1 && arWPts.find(idPQ.eR.ptGe[0]) != -1)
|
|
{
|
|
ptGe[0] = idPQ.eR.ptGe[0];
|
|
bFind1 = true;
|
|
}
|
|
if (!bFind1 && arWPts.find(idPQ.eR.ptGe[2]) != -1)
|
|
{
|
|
ptGe[0] = idPQ.eR.ptGe[2];
|
|
bFind1 = true;
|
|
}
|
|
if (pCrvL != NULL)
|
|
{
|
|
pCrvL->getFirstDeriv(ptGe[0], vtDir[0]);
|
|
//delete pCrvL;->POS D
|
|
}
|
|
|
|
AecComplexCurve::MakeCurve(idPW.eR, pCrvR);
|
|
bool bFind2 = false;
|
|
arWPts.removeAll();
|
|
arWPts.append(idPW.eR.ptGe[0]);
|
|
arWPts.append(idPW.eR.ptGe[2]);
|
|
if (!bFind2 &&arWPts.find(idPQ.eL.ptGe[0]) != -1)
|
|
{
|
|
ptGe[1] = idPQ.eL.ptGe[0];
|
|
bFind2 = true;
|
|
}
|
|
if (!bFind2 && arWPts.find(idPQ.eL.ptGe[2]) != -1)
|
|
{
|
|
ptGe[1] = idPQ.eL.ptGe[2];
|
|
bFind2 = true;
|
|
}
|
|
if (!bFind2 && arWPts.find(idPQ.eR.ptGe[0]) != -1)
|
|
{
|
|
ptGe[1] = idPQ.eR.ptGe[0];
|
|
bFind2 = true;
|
|
}
|
|
if (!bFind2 && arWPts.find(idPQ.eR.ptGe[2]) != -1)
|
|
{
|
|
ptGe[1] = idPQ.eR.ptGe[2];
|
|
bFind2 = true;
|
|
}
|
|
if (pCrvR != NULL)
|
|
{
|
|
pCrvR->getFirstDeriv(ptGe[1], vtDir[1]);
|
|
//delete pCrvR;->POS D
|
|
}
|
|
|
|
vtDir[0].normalize(); vtDir[1].normalize();
|
|
|
|
AcDbCurve *pCrvW[2];
|
|
pCrvW[0] = pCrvL; pCrvW[1] = pCrvR;
|
|
|
|
//TEST
|
|
/*for (int n = 0; n < 2; n++)
|
|
{
|
|
ptGeT = ptGe[n] + vtDir[n] * 1000;
|
|
AcDbLine *pLnT = new AcDbLine(ptGe[n], ptGeT);
|
|
pLnT->setColorIndex(2);
|
|
AddToModelSpace(pLnT);
|
|
}*/
|
|
|
|
//圆弧墙体不考虑轻重搭接,因为可能圆弧和直线可能不相交
|
|
//直接轻重隔开
|
|
AcDbArc *pArcW = AcDbArc::cast(pCrvW[0]);
|
|
if (pArcW != NULL)
|
|
{
|
|
delete pCrvL;
|
|
delete pCrvR;
|
|
|
|
elWEnd.ptGe[0] = ptGe[0];
|
|
elWEnd.ptGe[1] = ptGe[1];
|
|
elWEnd.ptGe[2] = ptGe[1];
|
|
|
|
elWExt.ptGe[0] = ptGe[0];
|
|
elWExt.ptGe[1] = ptGe[0];
|
|
elWExt.ptGe[2] = ptGe[0];
|
|
|
|
return true;
|
|
}
|
|
|
|
bool bFind = false;
|
|
if (bFind1 && bFind2)
|
|
{
|
|
AcDbCurve* pCrv[2];
|
|
AecComplexCurve::MakeCurve(idPQ.eL, pCrv[0]);
|
|
AecComplexCurve::MakeCurve(idPQ.eR, pCrv[1]);
|
|
|
|
if (pCrv[0] != NULL && pCrv[1] != NULL)
|
|
{
|
|
AcGePoint3d ptOn,ptSE[2];
|
|
AcGeVector3d vt1, vt2;
|
|
|
|
for (int i = 0;i < 2;i++)
|
|
{
|
|
pCrv[i]->getStartPoint(ptSE[0]);
|
|
pCrv[i]->getEndPoint(ptSE[1]);
|
|
|
|
if (!bFind)
|
|
{
|
|
for (int j = 0;j < 2;j++)
|
|
{
|
|
pCrv[i]->getClosestPointTo(ptGe[j], vtDir[j], ptOn, Adesk::kFalse);
|
|
|
|
//判断是否落在曲线内
|
|
vt1 = ptOn - ptSE[0];
|
|
vt2 = ptOn - ptSE[1];
|
|
if (!vt1.isZeroLength() && !vt2.isZeroLength() && vt1.dotProduct(vt2) < -1.e-10)
|
|
{
|
|
elWEnd.ptGe[0] = ptGe[j];
|
|
elWEnd.ptGe[1] = ptOn;
|
|
elWEnd.ptGe[2] = ptOn;
|
|
|
|
elWExt.ptGe[0] = ptGe[1-j];//取另一个
|
|
elWExt.ptGe[1] = ptOn;
|
|
elWExt.ptGe[2] = ptOn;
|
|
|
|
bFind = true;
|
|
}
|
|
if (bFind) break;
|
|
}
|
|
|
|
}
|
|
if (bFind) break;
|
|
}
|
|
delete pCrv[0];
|
|
delete pCrv[1];
|
|
}
|
|
}
|
|
|
|
delete pCrvL;
|
|
delete pCrvR;
|
|
|
|
return bFind;
|
|
}
|
|
|
|
void AecWall2DJoin::XJoinSortAndTrimByUClock(const WallXJoin& wj)
|
|
{
|
|
IdParamEl idp;
|
|
idp.bIsOverParallel = false;
|
|
std::vector<IdParamEl> vtIdParams;
|
|
AcGePoint3d ptOn = wj.ptJoin;
|
|
|
|
AcDbObjectIdArray arIds;
|
|
int nFat = -1;
|
|
AcGeVector3d vt;
|
|
AcGePoint3d ptMid,ptOn2;
|
|
|
|
AcDbIntArray arWallWeight;
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
for(int i = 0;i < wj.nValid;i++)
|
|
{
|
|
idp.id = wj.ids[i];
|
|
if (arIds.find(idp.id,nFat) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
arIds.append(idp.id);//避开自己和自己处理
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,wj.ids[i],AcDb::kForRead))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
GetMidPoint(pWall,ptMid);
|
|
vt = ptMid - ptOn;
|
|
vt.z = 0.0;
|
|
|
|
idp.dParam = AcGeVector3d::kXAxis.angleTo(vt,AcGeVector3d::kZAxis);
|
|
|
|
idp.eL = pWall->GetLeftElement();
|
|
idp.eR = pWall->GetRightElement();
|
|
idp.nWallWeight = wj.nWallWeight[i];
|
|
|
|
if (arWallWeight.isEmpty())
|
|
arWallWeight.append(idp.nWallWeight);
|
|
else
|
|
{
|
|
if (arWallWeight.find(idp.nWallWeight) == -1)
|
|
{
|
|
arWallWeight.append(idp.nWallWeight);
|
|
}
|
|
}
|
|
|
|
vtIdParams.push_back(idp);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
if (vtIdParams.size() == 1)
|
|
return;
|
|
|
|
|
|
std::sort(vtIdParams.begin(),vtIdParams.end(),SortByParam);
|
|
|
|
//以on为圆心,墙体的左右线按圆的逆时针排序
|
|
std::vector<IdAngleEl> vtIdAngleEl;
|
|
UnClockWiseSortLR(vtIdParams,ptOn,vtIdAngleEl);
|
|
|
|
AcGePoint3d ptInt;
|
|
AcGePoint3dArray arPtInts;
|
|
|
|
AcDbObjectIdArray arIdParallel;
|
|
|
|
for (int i = 0;i < vtIdAngleEl.size() - 1;i++)
|
|
{
|
|
IdAngleEl& ael1 = vtIdAngleEl.at(i);
|
|
IdAngleEl& ael2 = vtIdAngleEl.at(i+1);
|
|
|
|
if ( TrimCurveElement(ael1,ael2,ptInt) )
|
|
{
|
|
arPtInts.append(ptInt);
|
|
}
|
|
|
|
if (i == (vtIdAngleEl.size() - 2 ))
|
|
{
|
|
IdAngleEl& aele = vtIdAngleEl.at(i+1);
|
|
IdAngleEl& ael0 = vtIdAngleEl.at(0);
|
|
|
|
if ( TrimCurveElement(aele,ael0,ptInt) )
|
|
{
|
|
arPtInts.append(ptInt);
|
|
}
|
|
}
|
|
}
|
|
|
|
//按照id 合成
|
|
vtIdParams.clear();
|
|
int nPos = 0;
|
|
for(int i = 0;i < wj.nValid;i++)
|
|
{
|
|
idp.id = wj.ids[i];
|
|
idp.bIsOverParallel = false;
|
|
idp.nWallWeight = wj.nWallWeight[i];
|
|
nPos = 0;
|
|
|
|
for (int ii = 0;ii < vtIdAngleEl.size();ii++)
|
|
{
|
|
IdAngleEl& ael1 = vtIdAngleEl.at(ii);
|
|
|
|
if (ael1.id == idp.id)
|
|
{
|
|
if (ael1.bIsOverParallel)
|
|
{
|
|
idp.bIsOverParallel = true;
|
|
}
|
|
|
|
if (nPos == 0)
|
|
{
|
|
idp.eL = ael1.el;
|
|
nPos += 1;
|
|
}
|
|
else
|
|
{
|
|
idp.eR = ael1.el;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (nPos == 1)
|
|
{
|
|
vtIdParams.push_back(idp);
|
|
}
|
|
}
|
|
|
|
//窟窿补柱子
|
|
bool bAddCol = false;
|
|
AcGeVector3d vt1,vt2;
|
|
//写回二维图元
|
|
AecComplexCurve cmpl;
|
|
for(int i = 0;i < vtIdParams.size();i++)
|
|
{
|
|
IdParamEl& idp1 = vtIdParams.at(i);
|
|
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idp1.id,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
WallData wData;
|
|
memset(&wData,0,sizeof(WallData));
|
|
pWall->GetWallData(wData);
|
|
|
|
cmpl.removeAll();
|
|
cmpl.append(idp1.eL);
|
|
cmpl.append(idp1.eR);
|
|
|
|
pWall->SetDraw2dables(cmpl);
|
|
|
|
//AcDbCircle* pCir = new AcDbCircle;
|
|
//pCir->setCenter(ptOn);
|
|
//pCir->setRadius(10.0);
|
|
//AddToModelSpace(pCir);
|
|
|
|
//移除端部标记
|
|
pWall->getClosestPointTo(ptOn,ptOn2,Adesk::kFalse);
|
|
|
|
//2022-12-21墙体断开的尾部端线去除
|
|
if (!idp1.bIsOverParallel)
|
|
{
|
|
//且等宽
|
|
pWall->RemoveTailDraw2d(ptOn2);
|
|
}
|
|
|
|
//判断是否应该补在这个墙体上
|
|
//窟窿处补上柱子,确定哪个墙体补
|
|
if (!bAddCol)
|
|
{
|
|
if (arPtInts.length() > 2)
|
|
{
|
|
arPtInts.append(arPtInts.first());
|
|
AddXPart(pWall,arPtInts,ptOn);
|
|
bAddCol = true;
|
|
}
|
|
}
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
//如果两个节点,并且材质不一致
|
|
if (vtIdParams.size() == 2 && arWallWeight.length() > 1)
|
|
{
|
|
IdParamEl &idp1 = vtIdParams.at(0);
|
|
IdParamEl &idp2 = vtIdParams.at(1);
|
|
if (idp1.bIsOverParallel && idp2.bIsOverParallel)
|
|
{
|
|
//平行不同材质不处理
|
|
}
|
|
else
|
|
{
|
|
IdParamEl idPW, idPQ;
|
|
if (idp1.nWallWeight < idp2.nWallWeight)
|
|
{
|
|
idPW = idp2;
|
|
idPQ = idp1;
|
|
}
|
|
else
|
|
{
|
|
idPW = idp1;
|
|
idPQ = idp2;
|
|
}
|
|
|
|
AecEqui::AecCurveElement elWEnd,elWExt;
|
|
memset(&elWEnd, 0, sizeof(AecEqui::AecCurveElement));
|
|
memset(&elWExt, 0, sizeof(AecEqui::AecCurveElement));
|
|
|
|
if (CalWeightWallEndLine(idPW, idPQ, elWEnd,elWExt))
|
|
{
|
|
//测试TEST
|
|
/*AcDbCurve *pCrv = NULL;
|
|
AecComplexCurve::MakeCurve(elWEnd, pCrv);
|
|
|
|
if (pCrv != NULL)
|
|
{
|
|
pCrv->setColorIndex(1);
|
|
AddToModelSpace(pCrv);
|
|
}
|
|
|
|
AecComplexCurve::MakeCurve(elWExt, pCrv);
|
|
|
|
if (pCrv != NULL)
|
|
{
|
|
pCrv->setColorIndex(3);
|
|
AddToModelSpace(pCrv);
|
|
}*/
|
|
|
|
//重
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, idPW.id, AcDb::kForWrite))
|
|
{
|
|
AecDbXWall *pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
//增加端线
|
|
cmpl.removeAll();
|
|
pWall->GetDraw2dables(cmpl);
|
|
cmpl.append(elWEnd);
|
|
if (!elWExt.ptGe[0].isEqualTo(elWExt.ptGe[2]) )
|
|
cmpl.append(elWExt);
|
|
pWall->SetDraw2dables(cmpl);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
|
|
//轻
|
|
if (!elWExt.ptGe[0].isEqualTo(elWExt.ptGe[2]))
|
|
{
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, idPQ.id, AcDb::kForWrite))
|
|
{
|
|
AecDbXWall *pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
//轻延伸到重一侧,并封闭端线
|
|
cmpl.removeAll();
|
|
pWall->GetDraw2dables(cmpl);
|
|
|
|
elWExt.bHided = 1;
|
|
cmpl.append(elWExt);
|
|
cmpl.boolSubtract();
|
|
pWall->SetDraw2dables(cmpl);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//两平行墙体的端线融合处理,多于两个的墙不处理.
|
|
if (vtIdParams.size() == 2)
|
|
{
|
|
IdParamEl &idp1 = vtIdParams.at(0);
|
|
IdParamEl &idp2 = vtIdParams.at(1);
|
|
|
|
AecEqui::AecCurveElement el1,el2;
|
|
memset(&el1, 0, sizeof(AecEqui::AecCurveElement));
|
|
memset(&el2, 0, sizeof(AecEqui::AecCurveElement));
|
|
|
|
//平行连接结构
|
|
if (idp1.bIsOverParallel && idp2.bIsOverParallel)
|
|
{
|
|
AcDbEntity *pEnt1 = NULL;
|
|
AcDbEntity *pEnt2 = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, idp1.id, AcDb::kForWrite))
|
|
{
|
|
AecDbXWall *pWall1 = AecDbXWall::cast(pEnt1);
|
|
if (pWall1 != NULL)
|
|
{
|
|
pWall1->getClosestPointTo(ptOn, ptOn2, Adesk::kFalse);
|
|
pWall1->GetTailDraw2d(ptOn2, el1);
|
|
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt2, idp2.id, AcDb::kForWrite))
|
|
{
|
|
AecDbXWall *pWall2 = AecDbXWall::cast(pEnt2);
|
|
if (pWall2 != NULL)
|
|
{
|
|
pWall2->getClosestPointTo(ptOn, ptOn2, Adesk::kFalse);
|
|
pWall2->GetTailDraw2d(ptOn2, el2);
|
|
|
|
//同等材质,才可以融合端线
|
|
if (idp1.nWallWeight == idp2.nWallWeight)
|
|
{
|
|
AcArray<AecEqui::AecCurveElement> elRes1, elRes2;
|
|
ElementSubtract(el1, el2, elRes1, elRes2);
|
|
|
|
if (elRes1.isEmpty())
|
|
{
|
|
pWall1->RemoveTailDraw2d(ptOn2);
|
|
}
|
|
else
|
|
{
|
|
AecComplexCurve cpl1,cplOn;
|
|
for (int i = 0; i < elRes1.length(); i++)
|
|
{
|
|
cpl1.append(elRes1.at(i));
|
|
}
|
|
pWall1->RemoveTailDraw2d(ptOn2);
|
|
pWall1->GetDraw2dHideTail(cplOn);
|
|
cplOn.append(cpl1);
|
|
pWall1->SetDraw2dHideTail(cplOn);
|
|
}
|
|
|
|
if (elRes2.isEmpty())
|
|
{
|
|
pWall2->RemoveTailDraw2d(ptOn2);
|
|
}
|
|
else
|
|
{
|
|
AecComplexCurve cpl2, cplOn;
|
|
for (int i = 0; i < elRes2.length(); i++)
|
|
{
|
|
cpl2.append(elRes2.at(i));
|
|
}
|
|
pWall2->RemoveTailDraw2d(ptOn2);
|
|
pWall2->GetDraw2dHideTail(cplOn);
|
|
cplOn.append(cpl2);
|
|
pWall2->SetDraw2dHideTail(cplOn);
|
|
}
|
|
}
|
|
}
|
|
pEnt2->close();
|
|
}
|
|
}
|
|
pEnt1->close();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AecWall2DJoin::AddXPart(AecDbXWall* pWall,AcGePoint3dArray& arPtInts,const AcGePoint3d& ptOn)
|
|
{
|
|
if (pWall == NULL)
|
|
return;
|
|
|
|
WallData data;
|
|
pWall->GetWallData(data);
|
|
|
|
AcGePoint3d ptSta,ptEnd;
|
|
ptSta = arPtInts.first();
|
|
ptEnd = ptSta;
|
|
ptSta.z = data.dBomEl;
|
|
ptEnd.z = ptSta.z + data.dH;
|
|
|
|
AcDbLine lnPath;
|
|
lnPath.setStartPoint(ptSta);
|
|
lnPath.setEndPoint(ptEnd);
|
|
|
|
AcDbRegion* pRegion = AecDbEarthWorm::CreatePolygonRegionOnly(arPtInts.asArrayPtr(),arPtInts.length());
|
|
if (pRegion != NULL)
|
|
{
|
|
int nPos = pWall->GetNearPosition(ptOn);
|
|
|
|
AecDbX3dPart* pPart = new AecDbX3dPart;
|
|
pPart->SetName(_T("ExAdd"));
|
|
pPart->GetSpecialtyData()->SetAt(KEY_ADDTIONSHOW,TRUE);
|
|
pPart->GetSpecialtyData()->SetAt(KEY_POS,nPos);
|
|
pPart->GetSpecialtyData()->SetAt(KEY_FORSLICE,FALSE);
|
|
|
|
AcGeVector3d vtMove;
|
|
vtMove.set(0,0,ptSta.z - arPtInts.first().z);
|
|
AcGeMatrix3d xform;
|
|
xform.setToTranslation(vtMove);
|
|
pRegion->transformBy(xform);
|
|
|
|
AcDbX3dSolid* pXSolid = new AcDbX3dSolid;
|
|
pXSolid->CreateExtrude(pRegion,lnPath);
|
|
pPart->AddX3dSolid(pXSolid);
|
|
pWall->AddX3dPart(pPart);
|
|
delete pRegion;
|
|
}
|
|
}
|
|
|
|
bool AecWall2DJoin::TrimLineArcElement(AcDbLine* pLn,AecEqui::AecCurveElement& el1,AcDbArc* pArc,AecEqui::AecCurveElement& el2,AcGePoint3d& ptInt)
|
|
{
|
|
if (pLn == NULL && pArc == NULL)
|
|
return false;
|
|
|
|
AcGePoint3dArray arPts;
|
|
pLn->intersectWith(pArc,AcDb::kOnBothOperands,arPts);
|
|
|
|
if (!arPts.isEmpty())
|
|
{
|
|
ptInt = arPts.first();
|
|
|
|
//L边
|
|
double dL1 = ptInt.distanceTo(pLn->startPoint());
|
|
double dL2 = ptInt.distanceTo(pLn->endPoint());
|
|
if ( (dL1 - dL2) > 1.e-6) // sta+int
|
|
{
|
|
el1.ptGe[0] = pLn->startPoint();
|
|
el1.ptGe[1] = ptInt;
|
|
el1.ptGe[2] = ptInt;
|
|
}
|
|
else//end + int
|
|
{
|
|
el1.ptGe[0] = ptInt;
|
|
el1.ptGe[1] = pLn->endPoint();
|
|
el1.ptGe[2] = pLn->endPoint();
|
|
}
|
|
|
|
//ARC
|
|
AcGePoint3d ptSta,ptEnd,ptMid,ptMidL;
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
dL1 = ptInt.distanceTo(ptSta);
|
|
dL2 = ptInt.distanceTo(ptEnd);
|
|
|
|
if ( (dL1 - dL2) > 1.e-6) // sta+int
|
|
{
|
|
//Sta-Int 之间Mid
|
|
ptMidL = MidPoint(ptSta,ptInt);
|
|
pArc->getClosestPointTo(ptMidL,ptMid);
|
|
|
|
el2.ptGe[0] = ptSta;
|
|
el2.ptGe[1] = ptMid;
|
|
el2.ptGe[2] = ptInt;
|
|
}
|
|
else//end + int
|
|
{
|
|
//End-Int 之间Mid
|
|
ptMidL = MidPoint(ptEnd,ptInt);
|
|
pArc->getClosestPointTo(ptMidL,ptMid);
|
|
|
|
el2.ptGe[0] = ptInt;
|
|
el2.ptGe[1] = ptMid;
|
|
el2.ptGe[2] = ptEnd;
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
pLn->intersectWith(pArc,AcDb::kExtendBoth,arPts);
|
|
|
|
if (!arPts.isEmpty())
|
|
{
|
|
AcGePoint3d ptSta,ptEnd,ptMid,ptMidL,ptT,ptInt;
|
|
double dPa = 0.0;
|
|
|
|
//取距离Arc最近的点
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
BOOL bFind = FALSE;
|
|
double dL1 = 0.0,dL2 = 0.0,dMin = 9999999.0,dTmp = 0.0;
|
|
for (int i = 0;i < arPts.length();i++)
|
|
{
|
|
ptT = arPts.at(i);
|
|
|
|
dL1 = ptT.distanceTo(ptSta);
|
|
dL2 = ptT.distanceTo(ptEnd);
|
|
dTmp = __min(dL1,dL2);
|
|
|
|
if ( (dTmp - dMin) < 1.e-6)
|
|
{
|
|
ptInt = ptT;
|
|
dMin = dTmp;
|
|
bFind = TRUE;
|
|
}
|
|
else//>
|
|
{
|
|
//...
|
|
}
|
|
}
|
|
|
|
if (bFind)
|
|
{
|
|
//TEST
|
|
//AcDbCircle* pCir = new AcDbCircle;
|
|
//pCir->setCenter(ptInt);
|
|
//pCir->setRadius(10.0);
|
|
//pCir->setColorIndex(1);
|
|
//AddToModelSpace(pCir);
|
|
|
|
//L
|
|
dL1 = ptInt.distanceTo(pLn->startPoint());
|
|
dL2 = ptInt.distanceTo(pLn->endPoint());
|
|
if ( (dL1 - dL2) > 1.e-6) // sta+int
|
|
{
|
|
el1.ptGe[0] = pLn->startPoint();
|
|
el1.ptGe[1] = ptInt;
|
|
el1.ptGe[2] = ptInt;
|
|
}
|
|
else//end + int
|
|
{
|
|
el1.ptGe[0] = ptInt;
|
|
el1.ptGe[1] = pLn->endPoint();
|
|
el1.ptGe[2] = pLn->endPoint();
|
|
}
|
|
|
|
//ARC
|
|
//如果ptInt在Arc上
|
|
if ( Acad::eOk == pArc->getParamAtPoint(ptInt,dPa) )
|
|
{
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
dL1 = ptInt.distanceTo(ptSta);
|
|
dL2 = ptInt.distanceTo(ptEnd);
|
|
|
|
if ( (dL1 - dL2) > 1.e-6) // sta+int
|
|
{
|
|
//Sta-Int 之间Mid
|
|
ptMidL = MidPoint(ptSta,ptInt);
|
|
pArc->getClosestPointTo(ptMidL,ptMid);
|
|
|
|
el2.ptGe[0] = ptSta;
|
|
el2.ptGe[1] = ptMid;
|
|
el2.ptGe[2] = ptInt;
|
|
}
|
|
else//end + int
|
|
{
|
|
//End-Int 之间Mid
|
|
ptMidL = MidPoint(ptEnd,ptInt);
|
|
pArc->getClosestPointTo(ptMidL,ptMid);
|
|
|
|
el2.ptGe[0] = ptInt;
|
|
el2.ptGe[1] = ptMid;
|
|
el2.ptGe[2] = ptEnd;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
dL1 = ptInt.distanceTo(ptSta);
|
|
dL2 = ptInt.distanceTo(ptEnd);
|
|
|
|
if ( (dL1 - dL2) > 1.e-6) // 距离end近
|
|
{
|
|
el2.ptGe[0] = ptSta;
|
|
el2.ptGe[1] = ptEnd;
|
|
el2.ptGe[2] = ptInt;
|
|
}
|
|
else//距离sta近
|
|
{
|
|
el2.ptGe[0] = ptInt;
|
|
el2.ptGe[1] = ptSta;
|
|
el2.ptGe[2] = ptEnd;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//没有交点,圆弧切线法
|
|
//...
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecWall2DJoin::TrimCurveElement(IdAngleEl& ael1,IdAngleEl& ael2,AcGePoint3d& ptInt)
|
|
{
|
|
if (ael2.id == ael1.id)
|
|
return false;
|
|
|
|
int nType1 = AecComplexCurve::GetElementType(ael1.el);
|
|
int nType2 = AecComplexCurve::GetElementType(ael2.el);
|
|
if ( nType1 == AecEqui::eLine && nType2 == AecEqui::eLine)
|
|
{
|
|
AcDbLine* pLn1 = NULL;
|
|
AcDbLine* pLn2 = NULL;
|
|
|
|
AecComplexCurve::MakeLine(ael1.el,pLn1);
|
|
AecComplexCurve::MakeLine(ael2.el,pLn2);
|
|
|
|
if (pLn1 != NULL && pLn2 != NULL)
|
|
{
|
|
pLn1->setColorIndex(1);
|
|
pLn2->setColorIndex(2);
|
|
|
|
//TEST
|
|
//AddToModelSpace(pLnL);
|
|
//AddToModelSpace(pLnR);
|
|
//return;
|
|
|
|
AcGePoint3dArray arPts;
|
|
pLn2->intersectWith(pLn1,AcDb::kExtendBoth,arPts);
|
|
|
|
if (arPts.length() == 1)
|
|
{
|
|
ptInt = arPts.first();
|
|
|
|
//原则:
|
|
//依此点，取最长长度为新元素的长度
|
|
|
|
//2边
|
|
double dL1 = ptInt.distanceTo(pLn2->startPoint());
|
|
double dL2 = ptInt.distanceTo(pLn2->endPoint());
|
|
if ( (dL1 - dL2) > 1.e-6) // sta+int
|
|
{
|
|
ael2.el.ptGe[0] = pLn2->startPoint();
|
|
ael2.el.ptGe[1] = ptInt;
|
|
ael2.el.ptGe[2] = ptInt;
|
|
}
|
|
else//end + int
|
|
{
|
|
ael2.el.ptGe[0] = ptInt;
|
|
ael2.el.ptGe[1] = pLn2->endPoint();
|
|
ael2.el.ptGe[2] = pLn2->endPoint();
|
|
}
|
|
|
|
//1边
|
|
dL1 = ptInt.distanceTo(pLn1->startPoint());
|
|
dL2 = ptInt.distanceTo(pLn1->endPoint());
|
|
if ( (dL1 - dL2) > 1.e-6) // sta+int
|
|
{
|
|
ael1.el.ptGe[0] = pLn1->startPoint();
|
|
ael1.el.ptGe[1] = ptInt;
|
|
ael1.el.ptGe[2] = ptInt;
|
|
}
|
|
else//end + int
|
|
{
|
|
ael1.el.ptGe[0] = ptInt;
|
|
ael1.el.ptGe[1] = pLn1->endPoint();
|
|
ael1.el.ptGe[2] = pLn1->endPoint();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//平行的情况
|
|
//不会有两点
|
|
AcGeVector3d vt1 = ael1.el.ptGe[1] - ael1.el.ptGe[0];
|
|
AcGeVector3d vt2 = ael2.el.ptGe[1] - ael2.el.ptGe[0];
|
|
if (vt1.isParallelTo(vt2))
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(ael1.el.ptGe[0]);
|
|
arPts.append(ael1.el.ptGe[1]);
|
|
arPts.append(ael2.el.ptGe[0]);
|
|
arPts.append(ael2.el.ptGe[1]);
|
|
AecCoverBooleanOper::SortPoints(arPts,pLn1,false);
|
|
|
|
//判断是否共线
|
|
vt1 = ael1.el.ptGe[1] - ael2.el.ptGe[0];
|
|
vt2 = ael2.el.ptGe[1] - ael1.el.ptGe[0];
|
|
if (!vt1.isParallelTo(vt2))
|
|
{
|
|
ael1.bIsOverParallel = true;
|
|
ael2.bIsOverParallel = true;
|
|
}
|
|
|
|
if (arPts.length() == 4)
|
|
{
|
|
ptInt = MidPoint(arPts.at(1),arPts.at(2));
|
|
|
|
delete pLn1;
|
|
delete pLn2;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
delete pLn1;
|
|
delete pLn2;
|
|
return false;
|
|
}
|
|
|
|
delete pLn1;
|
|
delete pLn2;
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcDbCurve* pCurve1 = NULL;
|
|
AcDbCurve* pCurve2 = NULL;
|
|
|
|
AecComplexCurve::MakeCurve(ael1.el,pCurve1);
|
|
AecComplexCurve::MakeCurve(ael2.el,pCurve2);
|
|
|
|
pCurve1->setColorIndex(1);
|
|
pCurve2->setColorIndex(2);
|
|
|
|
//TEST
|
|
//AddToModelSpace(pCurve1);
|
|
//AddToModelSpace(pCurve2);
|
|
//return;
|
|
|
|
//圆弧，取末点的切线相交
|
|
|
|
bool bSuccess = false;
|
|
if (nType1 == AecEqui::eLine && nType2 == AecEqui::eArc)
|
|
{
|
|
AcDbLine* pLn1 = AcDbLine::cast(pCurve1);
|
|
AcDbArc* pArc2 = AcDbArc::cast(pCurve2);
|
|
|
|
bSuccess = TrimLineArcElement(pLn1,ael1.el,pArc2,ael2.el,ptInt);
|
|
}
|
|
|
|
if (nType1 == AecEqui::eArc && nType2 == AecEqui::eLine)
|
|
{
|
|
AcDbArc* pArc1 = AcDbArc::cast(pCurve1);
|
|
AcDbLine* pLn2 = AcDbLine::cast(pCurve2);
|
|
|
|
bSuccess = TrimLineArcElement(pLn2,ael2.el,pArc1,ael1.el,ptInt);
|
|
}
|
|
|
|
delete pCurve1;
|
|
delete pCurve2;
|
|
return bSuccess;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SortWallEndByParam(WallEnd& we1,WallEnd& we2)
|
|
{
|
|
if ( (we1.dParamOnM - we2.dParamOnM) < 1.e-6 )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void GetNearIntPointTo(AcDbCurve* pArcR,AcDbCurve* pArcE,const AcGePoint3d& ptEnd,AcGePoint3d& ptInt)
|
|
{
|
|
if (pArcE == NULL || pArcR == NULL)
|
|
return;
|
|
|
|
AcGePoint3dArray arPts;
|
|
pArcR->intersectWith(pArcE,AcDb::kExtendBoth,arPts);
|
|
|
|
double dDis = 0.0,dMin = 9999999.0;
|
|
AcGePoint3d ptT;
|
|
for (int i = 0;i < arPts.length();i++)
|
|
{
|
|
ptT = arPts.at(i);
|
|
|
|
dDis = ptT.distanceTo(ptEnd);
|
|
|
|
if (dDis < dMin)
|
|
{
|
|
dMin = dDis;
|
|
ptInt = ptT;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AecWall2DJoin::GetBreakPoint(AcDbCurve* pCurE,AcDbCurve* pCutTo,AcGePoint3d& ptEnd,AecEqui::AecCurveElement& el,const AcGeVector3d& vtEnd,double dThick)
|
|
{
|
|
//------------------------------- --> CutTo Line or Arc
|
|
// el
|
|
//------------+----+-------------
|
|
//
|
|
// / +E /
|
|
// / /
|
|
// / /
|
|
// / / ->CurE Line or Arc
|
|
//
|
|
|
|
|
|
if (pCutTo == NULL)
|
|
return;
|
|
|
|
AcDbLine* pLineE = AcDbLine::cast(pCurE);// E 线是直线
|
|
if (pLineE != NULL)// E 线是直线
|
|
{
|
|
AcDbArc* pArc = AcDbArc::cast(pCutTo);//主线是圆弧
|
|
if (pArc != NULL)
|
|
{
|
|
//E线是直线vtEnd
|
|
AcGeVector3d vtDir = vtEnd;
|
|
vtDir.rotateBy(PI/2.0,AcGeVector3d::kZAxis);
|
|
vtDir.normalize();
|
|
|
|
AcGePoint3d pt1 = ptEnd - vtDir * 0.5 * dThick;
|
|
AcGePoint3d pt2 = ptEnd + vtDir * 0.5 * dThick;
|
|
|
|
pCutTo->getClosestPointTo(pt1,vtEnd,el.ptGe[0]);
|
|
pCutTo->getClosestPointTo(pt2,vtEnd,el.ptGe[2]);
|
|
return;
|
|
}
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(pCutTo);//主线是直线
|
|
if (pLine != NULL)//主线是直线
|
|
{
|
|
//E线是直线vtEnd
|
|
AcGeVector3d vtDir = vtEnd;
|
|
vtDir.normalize();
|
|
vtDir.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d pt1 = ptEnd - vtDir * 0.5 * dThick;
|
|
AcGePoint3d pt2 = ptEnd + vtDir * 0.5 * dThick;
|
|
|
|
pCutTo->getClosestPointTo(pt1,vtEnd,el.ptGe[0]);
|
|
pCutTo->getClosestPointTo(pt2,vtEnd,el.ptGe[1]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
AcDbArc* pArcE = AcDbArc::cast(pCurE);// E 线是圆弧
|
|
if (pArcE != NULL)
|
|
{
|
|
AcDbArc* pArc = AcDbArc::cast(pCutTo);//主线是圆弧
|
|
if (pArc != NULL)
|
|
{
|
|
//E 线是圆弧
|
|
double dRad = pArcE->radius();
|
|
double dR = dRad + 0.5 * dThick;
|
|
double dr = dRad - 0.5 * dThick;
|
|
|
|
AcDbArc* pArcR = (AcDbArc*)pArcE->clone();
|
|
pArcR->setRadius(dR);
|
|
|
|
AcDbArc* pArcr = (AcDbArc*)pArcE->clone();
|
|
pArcr->setRadius(dr);
|
|
|
|
GetNearIntPointTo(pArcR,pArc,ptEnd,el.ptGe[0]);
|
|
GetNearIntPointTo(pArcr,pArc,ptEnd,el.ptGe[2]);
|
|
|
|
delete pArcR;delete pArcr;
|
|
}
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(pCutTo);//主线是直线
|
|
if (pLine != NULL)//主线是直线
|
|
{
|
|
//E 线是圆弧
|
|
double dRad = pArcE->radius();
|
|
double dR = dRad + 0.5 * dThick;
|
|
double dr = dRad - 0.5 * dThick;
|
|
|
|
AcDbArc* pArcR = (AcDbArc*)pArcE->clone();
|
|
pArcR->setRadius(dR);
|
|
|
|
AcDbArc* pArcr = (AcDbArc*)pArcE->clone();
|
|
pArcr->setRadius(dr);
|
|
|
|
GetNearIntPointTo(pArcR,pLine,ptEnd,el.ptGe[0]);
|
|
GetNearIntPointTo(pArcr,pLine,ptEnd,el.ptGe[1]);
|
|
|
|
delete pArcR;delete pArcr;
|
|
|
|
//TEST
|
|
//pArcR->setColorIndex(1);
|
|
//pArcr->setColorIndex(2);
|
|
//AddToModelSpace(pArcR);
|
|
//AddToModelSpace(pArcr);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
int AecWall2DJoin::GetNearSideTo(AcDbCurve* pCurE,AcGePoint3d& ptEnd,const AcGeVector3d& vtEnd,AcDbCurve* pCurM,AcDbCurve* pLeft,AcDbCurve* pRight,double dThick)
|
|
{
|
|
int nNearSide = 0;
|
|
|
|
AcGePoint3d ptS,ptE,ptT;
|
|
pCurE->getStartPoint(ptS);
|
|
pCurE->getEndPoint(ptE);
|
|
|
|
//取远端
|
|
double dL1 = ptS.distanceTo(ptEnd);
|
|
double dL2 = ptE.distanceTo(ptEnd);
|
|
double dMin = 0.0;
|
|
if (dL1 < dL2)
|
|
{
|
|
ptT = ptE;
|
|
}
|
|
else
|
|
{
|
|
ptT = ptS;
|
|
}
|
|
|
|
AcGePoint3d ptOn;
|
|
pCurM->getClosestPointTo(ptEnd,vtEnd,ptOn,Adesk::kTrue);
|
|
|
|
//圆弧的getClosestPointTo(ptEnd,vtEnd,ptOn,Adesk::kTrue); 错误!!.ARX接口问题
|
|
AcDbArc *pArc = AcDbArc::cast(pCurM);
|
|
if (pArc != NULL)
|
|
{
|
|
pCurM->getClosestPointTo(ptEnd, vtEnd, ptOn, Adesk::kFalse);
|
|
}
|
|
|
|
dMin = ptOn.distanceTo(ptEnd);
|
|
if ( ( dMin - 1.5 * dThick) > 1.e-6)
|
|
{
|
|
//acutPrintf(_T("\nNear side Len = %g"),dMin);
|
|
return nNearSide;
|
|
}
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptT);
|
|
ln.setEndPoint(ptOn);
|
|
|
|
AcGePoint3dArray arPtsL;
|
|
ln.intersectWith(pLeft,AcDb::kOnBothOperands,arPtsL);
|
|
if (!arPtsL.isEmpty())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
AcGePoint3dArray arPtsR;
|
|
ln.intersectWith(pRight,AcDb::kOnBothOperands,arPtsR);
|
|
if (!arPtsR.isEmpty())
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return nNearSide;
|
|
}
|
|
|
|
void AecWall2DJoin::TJoinSortAndTrimByMain(const WallTJoin& wt)
|
|
{
|
|
//先按.wes 的param排序
|
|
if (wt.nValid > 0)
|
|
{
|
|
std::vector<WallEnd> vtWEs;
|
|
for (int i = 0;i < wt.nValid;i++)
|
|
{
|
|
vtWEs.push_back(wt.wes[i]);
|
|
}
|
|
std::sort(vtWEs.begin(),vtWEs.end(),SortWallEndByParam);
|
|
|
|
AecComplexCurve cmplL;
|
|
AecComplexCurve cmplR;
|
|
AecComplexCurve cmplT;
|
|
|
|
//主墙体不裁剪，采用隐藏的方式绘制
|
|
AcDbEntity* pEntM = NULL;
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEntM,wt.idMain,AcDb::kForRead))
|
|
{
|
|
AecDbXWall* pWallM = AecDbXWall::cast(pEntM);
|
|
if (pWallM != NULL)
|
|
{
|
|
AcDbCurve* pLeft = pWallM->GetLeftCurve();
|
|
AcDbCurve* pRight = pWallM->GetRightCurve();
|
|
AcDbCurve* pCurM = GetWallBaseCurve(pWallM);
|
|
|
|
if (pLeft == NULL || pRight == NULL || pCurM == NULL)
|
|
{
|
|
pEntM->close();
|
|
return;
|
|
}
|
|
|
|
//关闭主体墙
|
|
pEntM->close();
|
|
pEntM = NULL;
|
|
pWallM = NULL;
|
|
|
|
WallXJoin xj;
|
|
AcGeVector3d vtT,vt1,vt2;
|
|
WallData data;
|
|
AcGePoint3d ptOn1,ptOn2,ptS,ptE,ptCen,ptMid,ptTmp;
|
|
AcDbEntity* pEntE = NULL;
|
|
double dDistL = 0.0,dDistR = 0.0;
|
|
|
|
AecEqui::AecCurveElement el;
|
|
memset(&el,0,sizeof(AecEqui::AecCurveElement));
|
|
|
|
AecEqui::AecCurveElement elT;
|
|
memset(&elT,0,sizeof(AecEqui::AecCurveElement));
|
|
|
|
for (int i = 0;i < vtWEs.size();i++)
|
|
{
|
|
WallEnd we = vtWEs.at(i);
|
|
if (we.idCol.isValid())//延伸到柱子即可
|
|
{
|
|
xj.idCol = we.idCol;
|
|
xj.nValid = 1;
|
|
xj.ids[0] = we.id;
|
|
xj.ptJoin = we.ptEnd;
|
|
|
|
ExtendToColumnRegion(xj);
|
|
}
|
|
else//提取墙体的左右侧
|
|
{
|
|
Acad::ErrorStatus es;
|
|
if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEntE,we.id,AcDb::kForRead)))//forWrite
|
|
{
|
|
AecDbXWall* pWallE = AecDbXWall::cast(pEntE);
|
|
if (pWallE != NULL)
|
|
{
|
|
pWallE->GetWallData(data);
|
|
|
|
ptS = GetWallStartPoint(pWallE);
|
|
ptE = GetWallEndPoint(pWallE);
|
|
|
|
AcDbCurve* pCurE = GetWallBaseCurve(pWallE);
|
|
pLeft->getClosestPointTo(we.ptEnd,we.vtEnd,ptOn1);
|
|
pRight->getClosestPointTo(we.ptEnd,we.vtEnd,ptOn2);
|
|
|
|
vt1 = we.ptEnd - ptOn1;
|
|
vt2 = we.ptEnd - ptOn2;
|
|
|
|
dDistL = vt1.length();
|
|
dDistR = vt2.length();
|
|
|
|
int nNearSide = GetNearSideTo(pCurE,we.ptEnd,we.vtEnd,pCurM,pLeft,pRight,data.dThick);
|
|
if (nNearSide == -1)//靠近左侧
|
|
{
|
|
AcDbLine* pLnM = AcDbLine::cast(pLeft);
|
|
if (pLnM != NULL)
|
|
{
|
|
vtT = pLnM->endPoint() - pLnM->startPoint();
|
|
vtT.normalize();
|
|
|
|
GetBreakPoint(pCurE,pLeft,we.ptEnd,el,we.vtEnd,we.dThick);
|
|
//el.ptGe[0] = ptOn1 - vtT * 0.5 * data.dThick;
|
|
//el.ptGe[1] = ptOn1 + vtT * 0.5 * data.dThick;
|
|
el.ptGe[2] = el.ptGe[1];
|
|
el.gsMark = MaterialWeight(data.szMat);
|
|
//材质相同,方可裁剪主墙
|
|
if (el.gsMark == wt.nWallWeight)
|
|
cmplL.append(el);
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pLeft);
|
|
if (pArc != NULL)//待定
|
|
{
|
|
//两点定玄,
|
|
//el.ptGe[0] = ptOn1 - vtT * 0.5 * data.dThick;
|
|
//el.ptGe[2] = ptOn1 + vtT * 0.5 * data.dThick;
|
|
GetBreakPoint(pCurE,pLeft,we.ptEnd,el,we.vtEnd,we.dThick);
|
|
ptTmp = MidPoint(el.ptGe[0],el.ptGe[2]);
|
|
pArc->getClosestPointTo(ptTmp,ptMid);
|
|
el.ptGe[1] = ptMid;
|
|
el.gsMark = MaterialWeight(data.szMat);
|
|
|
|
//材质相同,方可裁剪主墙
|
|
if (el.gsMark == wt.nWallWeight)
|
|
cmplL.append(el);
|
|
}
|
|
}
|
|
else if (nNearSide == 1)//靠近右侧
|
|
{
|
|
AcDbLine* pLnM = AcDbLine::cast(pRight);
|
|
if (pLnM != NULL)
|
|
{
|
|
vtT = pLnM->endPoint() - pLnM->startPoint();
|
|
vtT.normalize();
|
|
|
|
//el.ptGe[0] = ptOn2 - vtT * 0.5 * data.dThick;
|
|
//el.ptGe[1] = ptOn2 + vtT * 0.5 * data.dThick;
|
|
GetBreakPoint(pCurE,pRight,we.ptEnd,el,we.vtEnd,we.dThick);
|
|
el.ptGe[2] = el.ptGe[1];
|
|
el.gsMark = MaterialWeight(data.szMat);
|
|
|
|
//材质相同,方可裁剪主墙
|
|
if (el.gsMark == wt.nWallWeight)
|
|
cmplR.append(el);
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pRight);
|
|
if (pArc != NULL)//待定
|
|
{
|
|
//两点定玄,
|
|
//el.ptGe[0] = ptOn1 - vtT * 0.5 * data.dThick;
|
|
//el.ptGe[2] = ptOn1 + vtT * 0.5 * data.dThick;
|
|
GetBreakPoint(pCurE,pRight,we.ptEnd,el,we.vtEnd,we.dThick);
|
|
ptTmp = MidPoint(el.ptGe[0],el.ptGe[2]);
|
|
pArc->getClosestPointTo(ptTmp,ptMid);
|
|
el.ptGe[1] = ptMid;
|
|
el.gsMark = MaterialWeight(data.szMat);
|
|
|
|
//材质相同,方可裁剪主墙
|
|
if (el.gsMark == wt.nWallWeight)
|
|
cmplR.append(el);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//...
|
|
}
|
|
|
|
|
|
Adesk::Boolean bExtendSta = true;
|
|
double dDistE = ptE.distanceTo(we.ptEnd);
|
|
double dDistS = ptS.distanceTo(we.ptEnd);
|
|
if (dDistE < dDistS)
|
|
bExtendSta = false;
|
|
|
|
if (nNearSide == -1)//靠主墙左侧
|
|
{
|
|
//Extend(pWallE,bExtendSta,ptOn1);
|
|
//pWallE->GetStandardDraw2d();
|
|
//pWallE->RemoveTailDraw2d(ptOn1);
|
|
//TrimEnd(pWallE,el,we.vtEnd);
|
|
AppendExtend(we.id,bExtendSta,ptOn1,el,we.vtEnd, nNearSide, wt.idMain);
|
|
}
|
|
else if (nNearSide == 1)//靠主墙右侧
|
|
{
|
|
//Extend(pWallE,bExtendSta,ptOn2);
|
|
//pWallE->GetStandardDraw2d();
|
|
//pWallE->RemoveTailDraw2d(ptOn2);
|
|
//TrimEnd(pWallE,el,we.vtEnd);
|
|
AppendExtend(we.id,bExtendSta,ptOn2,el,we.vtEnd, nNearSide, wt.idMain);
|
|
}
|
|
}
|
|
pEntE->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pLeft != NULL || pRight != NULL)
|
|
{
|
|
delete pLeft;pLeft = NULL;
|
|
delete pRight;pRight = NULL;
|
|
}
|
|
|
|
//再次打开主体修改
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEntM,wt.idMain,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWallM = AecDbXWall::cast(pEntM);
|
|
if (pWallM != NULL)
|
|
{
|
|
//进行类似遮挡处理
|
|
AecComplexCurve draw2d;
|
|
pWallM->GetDraw2dables(draw2d);
|
|
draw2d.setSubElementGsMark(wt.nWallWeight);
|
|
|
|
//柱子裁剪墙体的左右侧 考虑墙体的轻重
|
|
AecCoverBooleanOper::BoolSubtract(draw2d,cmplL);
|
|
AecCoverBooleanOper::BoolSubtract(draw2d,cmplR);
|
|
|
|
pWallM->SetDraw2dables(draw2d);
|
|
}
|
|
pEntM->close();
|
|
pEntM = NULL;
|
|
}
|
|
}
|
|
|
|
//确认关闭
|
|
if (pEntM != NULL) pEntM->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
void AecWall2DJoin::AppendExtend(const AcDbObjectId& id,Adesk::Boolean bExtendSta,const AcGePoint3d& ptOn,AecEqui::AecCurveElement& el,const AcGeVector3d& vtEnd,int nNearSide, const AcDbObjectId& idMain)
|
|
{
|
|
for (int i = 0;i < m_arWallExtends.length();i++)
|
|
{
|
|
WallExtend& exd = m_arWallExtends.at(i);
|
|
if (exd.idWall == id && exd.nEnds < 2)//1.找到
|
|
{
|
|
exd.bExtendSta[exd.nEnds] = bExtendSta;
|
|
memcpy(&exd.el[exd.nEnds],&el,sizeof(AecEqui::AecCurveElement));
|
|
exd.ptOn[exd.nEnds] = ptOn;
|
|
exd.vtEnd[exd.nEnds] = vtEnd;
|
|
exd.nEnds += 1;
|
|
return;
|
|
}
|
|
}
|
|
|
|
//2.未找到,添加
|
|
WallExtend ext;
|
|
ext.idWall = id;
|
|
ext.idMain = idMain;
|
|
ext.nNearSide = nNearSide;
|
|
ext.nEnds = 1;
|
|
ext.bExtendSta[0] = bExtendSta;
|
|
memcpy(&ext.el[0],&el,sizeof(AecEqui::AecCurveElement));
|
|
ext.ptOn[0] = ptOn;
|
|
ext.vtEnd[0] = vtEnd;
|
|
m_arWallExtends.append(ext);
|
|
}
|
|
|
|
AcGePoint3d AecWall2DJoin::GetWallStartPoint(AecDbXWall* pWall) const
|
|
{
|
|
AcGePoint3d ptSta = AcGePoint3d::kOrigin;
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->IsVViewWall())
|
|
{
|
|
AcDbCurve* pCurve = pWall->GetAsNativeCurveOfVView();
|
|
if (pCurve != NULL)
|
|
{
|
|
pCurve->getStartPoint(ptSta);
|
|
delete pCurve;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pWall->getStartPoint(ptSta);
|
|
}
|
|
}
|
|
return ptSta;
|
|
}
|
|
|
|
AcGePoint3d AecWall2DJoin::GetWallEndPoint(AecDbXWall* pWall) const
|
|
{
|
|
AcGePoint3d ptEnd = AcGePoint3d::kOrigin;
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->IsVViewWall())
|
|
{
|
|
AcDbCurve* pCurve = pWall->GetAsNativeCurveOfVView();
|
|
if (pCurve != NULL)
|
|
{
|
|
pCurve->getEndPoint(ptEnd);
|
|
delete pCurve;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pWall->GetNativeCurve()->getEndPoint(ptEnd);
|
|
}
|
|
}
|
|
return ptEnd;
|
|
}
|
|
|
|
AcGeVector3d AecWall2DJoin::GetWallFirstDeriv(AecDbXWall* pWall,const AcGePoint3d& ptGeOn) const
|
|
{
|
|
AcGeVector3d vtDir(0,0,0);
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->IsVViewWall())
|
|
{
|
|
AcDbCurve* pCurve = pWall->GetAsNativeCurveOfVView();
|
|
if (pCurve != NULL)
|
|
{
|
|
pCurve->getFirstDeriv(ptGeOn,vtDir);
|
|
delete pCurve;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pWall->getFirstDeriv(ptGeOn,vtDir);
|
|
|
|
//TEST
|
|
vtDir.normalize();
|
|
AcGePoint3d ptEnd = ptGeOn;
|
|
ptEnd += 10.0 * vtDir;
|
|
AcDbLine* pLnt = new AcDbLine;
|
|
pLnt->setStartPoint(ptGeOn);
|
|
pLnt->setEndPoint(ptEnd);
|
|
pLnt->setColorIndex(1);
|
|
m_arTestEntPtrs.append(pLnt);
|
|
}
|
|
}
|
|
return vtDir;
|
|
}
|
|
|
|
Acad::ErrorStatus AecWall2DJoin::Extend(AecDbXWall*pWall,Adesk::Boolean extendStart,const AcGePoint3d& toPoint,AcGeVector3d& vtEnd,AcDbObjectId& idMain, int nNearSide)
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (pWall->IsVViewWall())
|
|
{
|
|
//?
|
|
}
|
|
else
|
|
{
|
|
AcGePoint3d ptE;
|
|
if (extendStart)
|
|
pWall->getStartPoint(ptE);
|
|
else
|
|
pWall->getEndPoint(ptE);
|
|
|
|
AcGePoint3d ptOn;
|
|
es = pWall->getClosestPointTo(toPoint,ptOn,Adesk::kTrue);
|
|
|
|
pWall->RemoveTailDraw2d(ptE);
|
|
|
|
AcDbCurve* pCrv = pWall->GetNativeCurve();
|
|
|
|
//T分支延伸到主墙
|
|
es = pWall->extend(extendStart,ptOn);
|
|
|
|
//T分两侧边线延伸到主墙的边线
|
|
AecComplexCurve draw2d;
|
|
pWall->GetDraw2dables(draw2d);
|
|
|
|
AcGeVector3d vtTan;
|
|
AcDbEntity *pEntM = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEntM, idMain, AcDb::kForRead))
|
|
{
|
|
AecDbXWall *pWallM = AecDbXWall::cast(pEntM);
|
|
if (pWallM != NULL)
|
|
{
|
|
AcDbCurve *pCurve = NULL;
|
|
if ( nNearSide == -1)
|
|
pCurve = pWallM->GetLeftCurve();
|
|
else
|
|
pCurve = pWallM->GetRightCurve();
|
|
|
|
pCurve->getFirstDeriv(toPoint, vtTan);
|
|
|
|
if (vtTan.isPerpendicularTo(vtEnd))
|
|
{
|
|
//垂直不需要裁剪和延伸 T
|
|
}
|
|
else
|
|
{
|
|
//需要处理两侧 7
|
|
AecEqui::AecCurveElement el;
|
|
memset(&el, 0, sizeof(AecEqui::AecCurveElement));
|
|
pWall->GetTailDraw2d(ptOn, el);
|
|
|
|
//找到两侧最近的el
|
|
int nGsMk = 0;
|
|
AcArray<AecEqui::AecCurveElement> arExEl;
|
|
for (int i = 0;i < draw2d.length();i++)
|
|
{
|
|
AecEqui::AecCurveElement &elT = draw2d.atByRef(i);
|
|
|
|
if (el.ptGe[0].distanceTo(elT.ptGe[0]) < 1.e-2 ||
|
|
el.ptGe[0].distanceTo(elT.ptGe[2]) < 1.e-2)
|
|
{
|
|
nGsMk = elT.gsMark;
|
|
elT.gsMark = i;
|
|
arExEl.append(elT);
|
|
elT.gsMark = nGsMk;
|
|
continue;
|
|
}
|
|
if (el.ptGe[1].distanceTo(elT.ptGe[0]) < 1.e-2 ||
|
|
el.ptGe[1].distanceTo(elT.ptGe[2]) < 1.e-2)
|
|
{
|
|
nGsMk = elT.gsMark;
|
|
elT.gsMark = i;
|
|
arExEl.append(elT);
|
|
elT.gsMark = nGsMk;
|
|
}
|
|
}
|
|
|
|
//两边线
|
|
AcGePoint3dArray arPts;
|
|
for (int j = 0;j < arExEl.length();j++)
|
|
{
|
|
AecEqui::AecCurveElement &elE = arExEl.at(j);
|
|
|
|
AcDbCurve *pCrvE = NULL;
|
|
AecComplexCurve::MakeCurve(elE, pCrvE);
|
|
|
|
arPts.removeAll();
|
|
pCrvE->intersectWith(pCurve, AcDb::kOnBothOperands, arPts);
|
|
|
|
if (arPts.length() == 1)//相交裁剪
|
|
{
|
|
//
|
|
AcGeVector3d vt = elE.ptGe[0] - arPts.first();
|
|
if (vt.isCodirectionalTo(vtEnd))
|
|
{
|
|
elE.ptGe[0] = arPts.first();
|
|
}
|
|
vt = elE.ptGe[2] - arPts.first();
|
|
if (vt.isCodirectionalTo(vtEnd))
|
|
{
|
|
elE.ptGe[2] = arPts.first();
|
|
AcDbLine *pLn = AcDbLine::cast(pCrvE);
|
|
if (pLn != NULL)
|
|
{
|
|
elE.ptGe[1] = arPts.first();
|
|
}
|
|
}
|
|
|
|
AecEqui::AecCurveElement& elT = draw2d.atByRef(elE.gsMark);
|
|
memcpy(elT.ptGe, elE.ptGe, sizeof(AcGePoint3d) * 3);
|
|
draw2d.setAt(elE.gsMark, elT);
|
|
}
|
|
else//不相交，延长
|
|
{
|
|
pCrvE->intersectWith(pCurve, AcDb::kExtendThis, arPts);
|
|
if (arPts.length() == 1)
|
|
{
|
|
//取最近 arPts.first();
|
|
double dL1 = elE.ptGe[0].distanceTo(arPts.first());
|
|
double dL2 = elE.ptGe[2].distanceTo(arPts.first());
|
|
|
|
if (dL1 < dL2)
|
|
{
|
|
elE.ptGe[0] = arPts.first();
|
|
}
|
|
else
|
|
{
|
|
elE.ptGe[2] = arPts.first();
|
|
AcDbLine *pLn = AcDbLine::cast(pCrvE);
|
|
if (pLn != NULL)
|
|
{
|
|
elE.ptGe[1] = arPts.first();
|
|
}
|
|
}
|
|
AecEqui::AecCurveElement &elT = draw2d.atByRef(elE.gsMark);
|
|
memcpy(elT.ptGe, elE.ptGe, sizeof(AcGePoint3d) * 3);
|
|
draw2d.setAt(elE.gsMark, elT);
|
|
}
|
|
}
|
|
delete pCrvE;
|
|
}
|
|
pWall->SetDraw2dables(draw2d);
|
|
}
|
|
delete pCurve;
|
|
}
|
|
pEntM->close();
|
|
}
|
|
}
|
|
return es;
|
|
}
|
|
|
|
int FindNearPoint(const AcGePoint3d& pt,AecEqui::AecCurveElement& eT,AcGePoint3d& ptNear,const AcGeVector3d& vtEnd)
|
|
{
|
|
AcDbCurve* pCurve = NULL;
|
|
AecComplexCurve::MakeCurve(eT,pCurve);
|
|
|
|
if (pCurve == NULL)
|
|
return 0;
|
|
|
|
AcGePoint3d ptOn;
|
|
pCurve->getClosestPointTo(pt,ptOn,Adesk::kTrue);
|
|
|
|
if (pt.distanceTo(ptOn) - 10.0 > 1.e-3)
|
|
return 0;
|
|
|
|
double dPa = 0.0,dS = 0.0,dE = 0.0;
|
|
Acad::ErrorStatus es = pCurve->getParamAtPoint(ptOn,dPa);
|
|
if (es == Acad::eOk)
|
|
{
|
|
//落在上面
|
|
AcGePoint3d ptS,ptE;
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
|
|
dS = ptS.distanceTo(ptOn);
|
|
dE = ptE.distanceTo(ptOn);
|
|
|
|
if (dS < dE)//靠近Start端
|
|
{
|
|
ptNear = ptS;
|
|
}
|
|
else
|
|
{
|
|
ptNear = ptE;
|
|
}
|
|
|
|
AcGeVector3d vtF;
|
|
pCurve->getFirstDeriv(ptNear,vtF);
|
|
|
|
if (vtF.isParallelTo(vtEnd))
|
|
{
|
|
delete pCurve;
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//不落在上面
|
|
pCurve->getClosestPointTo(pt,ptOn,Adesk::kFalse);
|
|
|
|
AcGeVector3d vtF;
|
|
pCurve->getFirstDeriv(ptOn,vtF);
|
|
|
|
if (vtF.isParallelTo(vtEnd))
|
|
{
|
|
ptNear = ptOn;
|
|
delete pCurve;
|
|
return 2;
|
|
}
|
|
}
|
|
delete pCurve;
|
|
return 0;
|
|
}
|
|
|
|
void CopyElementSeg(AecEqui::AecCurveElement& eT,AcGePoint3d& pt,AcGePoint3d& ptNear,AecEqui::AecCurveElement& elNew)
|
|
{
|
|
//
|
|
AcDbCurve* pCurve = NULL;
|
|
AecComplexCurve::MakeCurve(eT,pCurve);
|
|
|
|
if (pCurve == NULL)
|
|
return;
|
|
|
|
AcDbLine* pLn = AcDbLine::cast(pCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
elNew.ptGe[0] = pt;
|
|
elNew.ptGe[1] = ptNear;
|
|
elNew.ptGe[2] = ptNear;
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pCurve);
|
|
if (pArc != NULL)
|
|
{
|
|
elNew.ptGe[0] = pt;
|
|
elNew.ptGe[2] = ptNear;
|
|
elNew.ptGe[1] = MidPoint(pt,ptNear);
|
|
|
|
AcDbCircle cir;
|
|
cir.setCenter(pArc->center());
|
|
cir.setRadius(pArc->radius());
|
|
cir.setNormal(AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptMid;
|
|
cir.getClosestPointTo(elNew.ptGe[1],ptMid);
|
|
elNew.ptGe[1] = ptMid;
|
|
}
|
|
delete pCurve;
|
|
}
|
|
|
|
Acad::ErrorStatus AecWall2DJoin::TrimEnd(AecDbXWall* pWallE,AecEqui::AecCurveElement& el,const AcGeVector3d& vtEnd)
|
|
{
|
|
AecComplexCurve draw2d;
|
|
pWallE->GetDraw2dables(draw2d);
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(el.ptGe[0]);
|
|
if (arPts.find(el.ptGe[1]) == -1)
|
|
arPts.append(el.ptGe[1]);
|
|
|
|
AcGePoint3d ptTo;
|
|
int nOnType = 0;
|
|
|
|
AecEqui::AecCurveElement elSub,elAdd0,elAdd2;
|
|
memset(&elSub,0,sizeof(AecEqui::AecCurveElement));
|
|
memset(&elAdd0,0,sizeof(AecEqui::AecCurveElement));
|
|
memset(&elAdd2,0,sizeof(AecEqui::AecCurveElement));
|
|
|
|
AecComplexCurve cmSub,cmAdd;
|
|
double dDisMin0 = 999999999.0,dDisMin2 = 999999999.0;
|
|
double dDis0 = 0.0,dDis2 = 0.0;
|
|
AcGePoint3d ptTo0,ptTo2;
|
|
AcGePoint3dArray arPt0,arPt2;
|
|
AecEqui::AecCurveElement eT0,eT2;
|
|
|
|
for (int i = 0;i < draw2d.length();i++)
|
|
{
|
|
AecEqui::AecCurveElement& eT = draw2d.atByRef(i);
|
|
|
|
//找距离el的两端最近的点,如果在元素eT上，则取两端最近的点,返回实减
|
|
//找距离el的两端最近的点,如果不在元素eT上，则取两端最近的点返回实加
|
|
|
|
nOnType = FindNearPoint(el.ptGe[0],eT,ptTo,vtEnd);
|
|
if (nOnType == 1)//落在上面,返回点为最近的端点
|
|
{
|
|
CopyElementSeg(eT,el.ptGe[0],ptTo,elSub);
|
|
cmSub.append(elSub);
|
|
}
|
|
|
|
if (nOnType == 2)//落在延长线上
|
|
{
|
|
dDis0 = ptTo.distanceTo(el.ptGe[0]);
|
|
if (dDis0 < dDisMin0)
|
|
{
|
|
dDisMin0 = dDis0;
|
|
ptTo0 = ptTo;
|
|
|
|
arPt0.removeAll();
|
|
arPt0.append(ptTo0);
|
|
eT0 = eT;
|
|
}
|
|
}
|
|
|
|
nOnType = FindNearPoint(el.ptGe[2],eT,ptTo,vtEnd);
|
|
if (nOnType == 1)//落在上面,返回点为最近的端点
|
|
{
|
|
CopyElementSeg(eT,el.ptGe[2],ptTo,elSub);
|
|
cmSub.append(elSub);
|
|
}
|
|
|
|
if (nOnType == 2)//落在延长线上
|
|
{
|
|
dDis2 = ptTo.distanceTo(el.ptGe[2]);
|
|
if (dDis2 < dDisMin2)
|
|
{
|
|
dDisMin2 = dDis2;
|
|
ptTo2 = ptTo;
|
|
|
|
arPt2.removeAll();
|
|
arPt2.append(ptTo2);
|
|
eT2 = eT;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!arPt0.isEmpty())
|
|
{
|
|
CopyElementSeg(eT0,el.ptGe[0],arPt0.first(),elAdd0);
|
|
cmAdd.append(elAdd0);
|
|
}
|
|
|
|
if (!arPt2.isEmpty())
|
|
{
|
|
CopyElementSeg(eT2,el.ptGe[2],arPt2.first(),elAdd2);
|
|
cmAdd.append(elAdd2);
|
|
}
|
|
|
|
AecCoverBooleanOper::BoolSubtract(draw2d,cmSub);
|
|
|
|
//没有交集加入
|
|
if (!AecCoverBooleanOper::HasIntersection(draw2d,cmAdd))
|
|
{
|
|
AecCoverBooleanOper::BoolUnite(draw2d,cmAdd);
|
|
}
|
|
|
|
if (!cmAdd.isEmpty() || !cmSub.isEmpty() )
|
|
{
|
|
pWallE->SetDraw2dables(draw2d);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecWall2DJoin::AddXPart(AecDbXWall* pWallE,const AcGePoint3d& ptEnd,const AcGeVector3d& vtEnd,Adesk::Boolean bExtendSta,const AecEqui::AecCurveElement& el)
|
|
{
|
|
if (pWallE == NULL)
|
|
return;
|
|
|
|
WallData data;
|
|
pWallE->GetWallData(data);
|
|
|
|
AcDbCurve* pCurveEl = NULL;
|
|
AecComplexCurve::MakeCurve((AecEqui::AecCurveElement&)el,pCurveEl);
|
|
|
|
if (pCurveEl != NULL)
|
|
{
|
|
AcGeVector3d vt = vtEnd;
|
|
vt.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
vt.normalize();
|
|
|
|
AcGePoint3d pt1,pt2;
|
|
pt1 = ptEnd + vt * 0.5 * data.dThick;
|
|
pt2 = ptEnd - vt * 0.5 * data.dThick;
|
|
|
|
double dDis = data.dThick;
|
|
|
|
AecDbX3dPart* pPart = NULL;
|
|
AcDbX3dSolid* pXSolid = NULL;
|
|
|
|
if (!pWallE->IsVViewWall())
|
|
{
|
|
//常规截面墙体
|
|
vt = vtEnd;
|
|
vt.normalize();
|
|
AcDbLine lnPath;
|
|
pt1 = ptEnd;
|
|
pt2 = ptEnd + vt * dDis;
|
|
|
|
pt1.z = data.dBomEl;
|
|
pt2.z = data.dBomEl;
|
|
lnPath.setStartPoint(pt1);
|
|
lnPath.setEndPoint(pt2);
|
|
|
|
AcDbRegion* pRegion = pWallE->GetSection();
|
|
if (pRegion != NULL)
|
|
{
|
|
//1.创建整体Solid
|
|
AcGePoint3d ptOnRegion;
|
|
pWallE->GetSpecialtyData()->GetAt(KEY_SECCEN,ptOnRegion);
|
|
|
|
transfromRegion(pRegion,ptOnRegion,vt,pt1);
|
|
|
|
int nPos = pWallE->GetNearPosition(ptEnd);
|
|
|
|
pPart = new AecDbX3dPart;
|
|
pPart->SetName(_T("ExAdd"));
|
|
pPart->GetSpecialtyData()->SetAt(KEY_ADDTIONSHOW,TRUE);
|
|
pPart->GetSpecialtyData()->SetAt(KEY_POS,nPos);
|
|
pPart->GetSpecialtyData()->SetAt(KEY_FORSLICE,TRUE);
|
|
pXSolid = new AcDbX3dSolid;
|
|
if ( pXSolid->CreateExtrude(pRegion,lnPath) )
|
|
{
|
|
pPart->AddX3dSolid(pXSolid);
|
|
pPart->Create();
|
|
//pWallE->AddX3dPart(pPart,AcDb::kBoolUnite);//????
|
|
|
|
//TEST
|
|
/*AcDb3dSolid* pSolid = pXSolid->GetDraw3dSolid();
|
|
pSolid->setColorIndex(3);
|
|
AddToModelSpace(pSolid);
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
delete pPart;
|
|
delete pXSolid;
|
|
}
|
|
delete pRegion;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//...是立面拉伸墙体
|
|
}
|
|
}
|
|
}
|
|
|
|
//获取统一的墙体基线,用完需要删除
|
|
AcDbCurve* AecWall2DJoin::GetWallBaseCurve(AecDbXWall* pWall)
|
|
{
|
|
AcDbObjectId id = pWall->objectId();
|
|
|
|
TCHAR tmpStr[256];
|
|
id.handle().getIntoAsciiBuffer(tmpStr);
|
|
|
|
AcDbCurve* pBaseCurve = NULL;
|
|
if (m_mapIdToPtr.Lookup(tmpStr,(void*&)pBaseCurve))
|
|
{
|
|
return pBaseCurve;
|
|
}
|
|
|
|
if (pWall->IsVViewWall())
|
|
{
|
|
pBaseCurve = pWall->GetAsNativeCurveOfVView();
|
|
}
|
|
else
|
|
{
|
|
pBaseCurve = pWall->GetBaseCurve();
|
|
}
|
|
m_mapIdToPtr.SetAt(tmpStr,(void*)pBaseCurve);
|
|
return pBaseCurve;
|
|
}
|
|
|
|
//最多20种由重到轻材质的比重
|
|
int AecWall2DJoin::MaterialWeight(LPCTSTR pszMaterial)
|
|
{
|
|
//最多20种由重到轻材质
|
|
static int nMaxWallWeight = 20;
|
|
for (int i = 0;i < 20;i++)
|
|
{
|
|
if (g_pszWallMaterials[i] == NULL)
|
|
return 0;
|
|
|
|
if (_tcscmp(g_pszWallMaterials[i], pszMaterial) == 0)
|
|
{
|
|
return (nMaxWallWeight - i);
|
|
}
|
|
}
|
|
return 0;
|
|
} |