2028 lines
50 KiB
C++
2028 lines
50 KiB
C++
#include "stdafx.h"
|
|
#include "BaseHoleOperation.h"
|
|
#include "BaseHoleDlg.h"
|
|
#include "SelectBlkDlg.h"
|
|
#include "dbxutil.h"
|
|
#include "DbEquipment.h"
|
|
#include <utility>
|
|
#include "TBaseHoleLableEdJig.h"
|
|
#include "HydrantSetting.h"
|
|
#include <utility>
|
|
|
|
CBaseHoleOperation::CBaseHoleOperation()
|
|
{
|
|
m_bLabel = FALSE;
|
|
m_bDimLabel = FALSE;
|
|
m_nDist = 0;
|
|
m_pArc = NULL;
|
|
m_bArcWall = FALSE;
|
|
}
|
|
|
|
CBaseHoleOperation::~CBaseHoleOperation()
|
|
{
|
|
if (m_pArc != NULL)
|
|
{
|
|
delete m_pArc;
|
|
}
|
|
}
|
|
|
|
XPoint CBaseHoleOperation::Mid(XPoint ptStart, XPoint ptEnd)
|
|
{
|
|
XPoint ptCenter ;
|
|
ptCenter.x = (ptStart.x + ptEnd.x)/2;
|
|
ptCenter.y = (ptStart.y + ptEnd.y)/2;
|
|
ptCenter.z = (ptStart.z + ptEnd.z)/2;
|
|
|
|
return ptCenter;
|
|
}
|
|
|
|
void CBaseHoleOperation::RunBaseHole(CBaseHoleDlg &baseHoleDlg)
|
|
{
|
|
//是否添加标注
|
|
m_bLabel = FALSE;
|
|
|
|
//是否添加尺寸标注
|
|
m_bDimLabel = FALSE;
|
|
|
|
while(TRUE)
|
|
{
|
|
m_bLabel =TRUE;
|
|
|
|
RBList rbMask = ads_buildlist(RTDXF0, _T("LINE"), NULL);
|
|
Entity entBaseLine , entWall;
|
|
|
|
int nRet;
|
|
TCHAR chKey = _T('\0');
|
|
const TCHAR* pKey = _T("F");
|
|
INITGET_BEG(0,pKey);
|
|
nRet = SelectEntity(_T("\n请选择基准线[选择消火栓(F)]<自由布置>:"), entBaseLine, m_ptBaseLine, rbMask, pKey, chKey);
|
|
INITGET_END();
|
|
#if (ADS == 19)
|
|
if (chKey == _T('\0'))
|
|
{
|
|
TCHAR szCh[20];
|
|
acedGetInput(szCh);
|
|
chKey = szCh[0];
|
|
}
|
|
#endif
|
|
|
|
acdbUcs2Wcs(m_ptBaseLine,m_ptBaseLine,false);
|
|
m_ptBaseLine = asPnt3d(m_ptBaseLine);
|
|
|
|
if (nRet == RTNORM)
|
|
{
|
|
// cet 2010.5.19 add 因m_ptBaseLine可能不在基准线上导致基础洞位置有误,故将m_ptBaseLine投影到基准线上
|
|
AcDbObjectId idBaseLine;
|
|
acdbGetObjectId(idBaseLine, entBaseLine);
|
|
AcDbLine *pLine = NULL;
|
|
acdbOpenObject(pLine, idBaseLine, AcDb::kForRead);
|
|
if (pLine == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
pLine->getClosestPointTo(m_ptBaseLine, m_ptBaseLine, Adesk::kTrue);
|
|
pLine->close();
|
|
|
|
if (acedGetInt(_T("\n请输入基础洞距基准线距离<退出>:"), &m_nDist) != RTNORM)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
m_bDimLabel = TRUE;
|
|
|
|
RBList rbMask2 = ads_buildlist(RTDXF0, _T("ATS_WALL"), NULL);
|
|
if(SelectEntity(_T("\n请选择墙体<退出>"), entWall, rbMask2) != RTNORM)
|
|
break;
|
|
|
|
//基准线是否与墙体相邻
|
|
if (!IsInWall(entBaseLine, entWall))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//创建基础洞
|
|
CreateBaseHole(baseHoleDlg, entWall, entBaseLine);
|
|
|
|
}
|
|
else if (nRet == RTERROR)
|
|
{
|
|
m_bDimLabel = FALSE;
|
|
RBList rbMask2 = ads_buildlist(RTDXF0, _T("ATS_WALL"), NULL);
|
|
if(SelectEntity1(_T("\n请选择墙线<退出>"), entWall, m_ptWallLine, rbMask2) != RTNORM)
|
|
break;
|
|
|
|
acdbUcs2Wcs(m_ptWallLine,m_ptWallLine,false);
|
|
// m_ptWallLine = asPnt3d(m_ptWallLine); cet 2009.12.21 del
|
|
|
|
//创建基础洞
|
|
CreateBaseHole(baseHoleDlg,entWall, entBaseLine);
|
|
}
|
|
else if (nRet == RTKWORD)
|
|
{
|
|
baseHoleDlg.ShowWindow(SW_HIDE);
|
|
//为消火栓添加基础洞
|
|
if (chKey == _T('F') || chKey == _T('f'))
|
|
{
|
|
std::map<AcDbObjectId, AcDbObjectId> mapEnt;
|
|
SelectHydrant(mapEnt);
|
|
|
|
if (mapEnt.size() == 1) //选择单个消火栓
|
|
{
|
|
AcDbObjectId idWall, idHydrant;
|
|
idHydrant = mapEnt.begin()->first;
|
|
idWall = mapEnt.begin()->second;
|
|
AddHoleToHydrant(idWall, idHydrant);
|
|
}
|
|
else if (!mapEnt.empty()) //当选择多个消火栓时
|
|
{
|
|
TCHAR szSelChar[10];
|
|
int nStatus = acedGetString(0, _T("\n是否按消火栓箱高度精确开洞[Y/N]<Y>:"), szSelChar);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
continue;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (szSelChar[0] == 'Y' || szSelChar[0] == 'y')
|
|
{
|
|
AddBaseHoleByBatch(mapEnt);
|
|
}
|
|
else if (szSelChar[0] == 'N' || szSelChar[0] == 'n')
|
|
{
|
|
AddHoleToHydrant(mapEnt); //统一开大小相同的基础洞
|
|
}
|
|
else if (szSelChar[0] == '\0') //默认操作
|
|
{
|
|
AddBaseHoleByBatch(mapEnt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_bDimLabel = FALSE;
|
|
m_bLabel = FALSE;
|
|
baseHoleDlg.ShowWindow(SW_SHOW);
|
|
}
|
|
else
|
|
{
|
|
m_bDimLabel = FALSE;
|
|
m_bLabel = FALSE;
|
|
break;
|
|
}
|
|
|
|
//添加标注
|
|
if (m_bLabel)
|
|
{
|
|
AddLabel(baseHoleDlg, m_ptWallLine);
|
|
}
|
|
|
|
//添加尺寸标注
|
|
if (m_bDimLabel)
|
|
{
|
|
if (m_bArcWall)
|
|
{
|
|
addArcLabel();
|
|
}
|
|
else
|
|
{
|
|
AddDimLabel(m_ptBaseLine, m_ptWallLine, m_nDist);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::SelectHydrant(std::map<AcDbObjectId,AcDbObjectId> &mapEnt)
|
|
{
|
|
RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
|
|
|
|
PickSet ss(SS_FREE);
|
|
if(SelectEntities(_T("\n请选择消火栓<退出>"), ss, rbMask) != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
PickSet ssInWall(SS_FREE);
|
|
|
|
for(long i = 0; i < ss.Length(); i++)
|
|
{
|
|
Entity ent = ss[i];
|
|
IsInWall(ent, mapEnt);
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::AddLabel(XPoint ptIns, double dAngle, LPCTSTR pszText)
|
|
{
|
|
if (pszText == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TDbSymbMultiLeader *pLeader = new TDbSymbMultiLeader;
|
|
if (pLeader != NULL)
|
|
{
|
|
XPointList lstVertexes;
|
|
lstVertexes.Append(new XPoint(ptIns));
|
|
pLeader->SetLeaderVertexes(lstVertexes);
|
|
pLeader->SetLeaderPoint(ptIns);
|
|
pLeader->SetLayoutRotation(Ucs2Wcs(0.0));
|
|
pLeader->SetArrow(TDbSymbMultiLeader::kNone);
|
|
pLeader->SetTextAlign(TDbSymbMultiLeader::kAtStart);
|
|
|
|
AcDbObjectId idTextStyle = InitTwtTextStyle(g_csTwtDimStyle);
|
|
pLeader->SetTextStyleId(idTextStyle);
|
|
pLeader->SetTextLayerId(InitLayer(LAY_TEXT));
|
|
pLeader->SetTextHeight(g_nVPipeHeight);
|
|
pLeader->SetTextBaseLen(pLeader->GetDefaultTextBaseLen() + 2);
|
|
pLeader->SetText1(pszText);
|
|
|
|
TLeaderEdJig jig(pLeader);
|
|
jig.SetOperCode(TLeaderEdJig::kLeader);
|
|
jig.SetPrompt(_T("\n输入引线位置<退出>: "));
|
|
if(jig.DoIt()==RTNORM)
|
|
{
|
|
lstVertexes.Reset();
|
|
lstVertexes.Append(new XPoint(ptIns));
|
|
pLeader->SetLeaderVertexes(lstVertexes);
|
|
pLeader->AddToCSpace(Adesk::kFalse);
|
|
pLeader->setLayer(LAY_VPIPE_DIM);
|
|
pLeader->close();
|
|
}
|
|
else
|
|
{
|
|
delete pLeader;
|
|
pLeader = NULL;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
Adesk::Boolean CBaseHoleOperation::AddLabel(CBaseHoleDlg &baseHoleDlg, XPoint ptStart)
|
|
{
|
|
TDbSymbMultiLeader *pLeader = new TDbSymbMultiLeader;
|
|
if (pLeader != NULL)
|
|
{
|
|
XPointList lstVertexes;
|
|
lstVertexes.Append(new XPoint(ptStart));
|
|
pLeader->SetLeaderVertexes(lstVertexes);
|
|
pLeader->SetLeaderPoint(ptStart);
|
|
pLeader->SetLayoutRotation(Ucs2Wcs(0.0));
|
|
pLeader->SetArrow(TDbSymbMultiLeader::kNone);
|
|
pLeader->SetTextAlign(TDbSymbMultiLeader::kAtStart);
|
|
|
|
AcDbObjectId idTextStyle = InitTwtTextStyle(g_csTwtDimStyle);
|
|
pLeader->SetTextStyleId(idTextStyle);
|
|
pLeader->SetTextLayerId(InitLayer(LAY_TEXT));
|
|
pLeader->SetTextHeight(g_nVPipeHeight);
|
|
pLeader->SetTextBaseLen(pLeader->GetDefaultTextBaseLen());
|
|
pLeader->SetText1(baseHoleDlg.getSuperscript());
|
|
pLeader->SetText2(baseHoleDlg.getSubscript());
|
|
|
|
TBaseHoleLabelEdJig jig(pLeader);
|
|
jig.SetDlgPtr(&baseHoleDlg);
|
|
jig.SetOperCode(TLeaderEdJig::kLeader);
|
|
jig.SetPrompt(_T("\n输入引线位置<退出>: "));
|
|
if(jig.DoIt()==RTNORM)
|
|
{
|
|
lstVertexes.Reset();
|
|
lstVertexes.Append(new XPoint(ptStart));
|
|
pLeader->SetLeaderVertexes(lstVertexes);
|
|
pLeader->AddToCSpace(Adesk::kFalse);
|
|
pLeader->setLayer(LAY_VPIPE_DIM);
|
|
pLeader->close();
|
|
}
|
|
else
|
|
{
|
|
delete pLeader;
|
|
return Adesk::kFalse;
|
|
}
|
|
}
|
|
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
void CBaseHoleOperation::AddDimLabel(XPoint ptStart, XPoint ptEnd, int dBaseLineDist)
|
|
{
|
|
double m_dScale = 2.0;
|
|
TDbDimension2* pDim = new TDbDimension2;
|
|
pDim->setLayer(InitLayer(LAY_DIM));
|
|
pDim->SetPScale(g_nVPipeHeight*20);
|
|
pDim->SetLocation(ptStart);
|
|
pDim->SetStyleId(InitDimStyle(DS_LINEAR));
|
|
pDim->SetRotation(ads_angle(ptEnd, ptStart));
|
|
pDim->SetLayoutRotation(Ucs2Wcs(0.0));
|
|
|
|
CString sLabel;
|
|
pDim->AddSegment(ptStart);
|
|
pDim->AddSegment(ptEnd);
|
|
|
|
sLabel.Format(_T("%d"),dBaseLineDist);
|
|
pDim->SetTextContent(0,sLabel);
|
|
|
|
double dDist2DimLine = 0.0;
|
|
pDim->SetDist2DimLine(dDist2DimLine, FALSE);
|
|
|
|
TDimensionEdJig jig(pDim, _T("\n请点取尺寸线位置<退出>:"));
|
|
jig.m_nFlag=1;
|
|
if(jig.doIt() != RTNORM){
|
|
delete pDim;
|
|
return;
|
|
}
|
|
dDist2DimLine = pDim->GetDist2DimLine(FALSE);
|
|
|
|
AddToModelSpace(pDim, Adesk::kTrue);
|
|
}
|
|
|
|
void CBaseHoleOperation::CreateBaseHole(CBaseHoleDlg &baseHoleDlg,Entity entWall, Entity entBaseLine)
|
|
{
|
|
AcDbObjectId id2d = NULL;
|
|
CString str = baseHoleDlg.m_strInsBlkName;
|
|
id2d = GetBlkIdByName(baseHoleDlg.m_strInsBlkName);
|
|
if (!id2d.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
TDbOpening *pWin = new TDbOpening();
|
|
if (pWin == NULL)
|
|
return;
|
|
|
|
pWin->m_nIdStyle2d=id2d;
|
|
|
|
pWin->SetKind(TOpeningData::OP_WINDOW);
|
|
pWin->setLinetype(_T("DASHED"));
|
|
pWin->InitHardPointerId();
|
|
pWin->m_pBayWin = new XBayWindow();
|
|
pWin->SetWidth(baseHoleDlg.getHoleWidth());
|
|
pWin->SetHeight(baseHoleDlg.getHoleHigh());
|
|
|
|
//基础洞插入点
|
|
XPoint ptInsert;
|
|
OPENOBJ_BEGIN(entWall, AcDb::kForWrite, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
//将选取点转化到墙体中心线上对应的一点
|
|
XCurveSegment segL,segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
XPoint ptStart, ptEnd;
|
|
ptStart = Mid(segL.GetStartPoint(), segR.GetStartPoint());
|
|
ptEnd = Mid(segL.GetEndPoint(), segR.GetEndPoint());
|
|
|
|
XCurveSegment segCen(ptStart,ptEnd,segL.GetBulge());
|
|
|
|
//检查基准线与墙体的位置关系
|
|
XPoint ptBaseLineToWall;
|
|
if (m_bDimLabel)
|
|
{
|
|
m_ptWallLine = segCen.MidPoint();
|
|
|
|
if (pWall->Is(CURVE_ARC))
|
|
{
|
|
AdjustBaseHoleInsPt(entBaseLine, pWall, m_nDist);
|
|
m_bArcWall = TRUE;
|
|
}
|
|
else
|
|
{
|
|
segCen.ProjectToMe(m_ptWallLine,ptInsert);
|
|
segCen.ProjectToMe(m_ptBaseLine, ptBaseLineToWall);
|
|
AcGeVector3d vtDir = ptInsert - ptBaseLineToWall;
|
|
vtDir.normalize();
|
|
m_ptWallLine = ptBaseLineToWall + vtDir * m_nDist;
|
|
m_ptBaseLine = ptBaseLineToWall;
|
|
}
|
|
|
|
ptInsert = m_ptWallLine;
|
|
}
|
|
|
|
segCen.ProjectToMe(m_ptWallLine,ptInsert);
|
|
|
|
//检查选取的墙体上的经变化后是否仍在墙上
|
|
BOOL bFlag = FALSE;
|
|
if (m_bArcWall) //弧墙
|
|
{
|
|
IsInArcWall(bFlag, entBaseLine, pWall, baseHoleDlg);
|
|
}
|
|
else //直墙
|
|
{
|
|
if (ptInsert.Distance(segCen.MidPoint()) <= ptStart.Distance(segCen.MidPoint()))
|
|
{
|
|
bFlag = FALSE;
|
|
}
|
|
}
|
|
|
|
//检验待插入基础洞的宽度
|
|
if (ptStart.Distance(ptInsert) < baseHoleDlg.getHoleWidth() / 2 ||
|
|
ptEnd.Distance(ptInsert) < baseHoleDlg.getHoleWidth() /2 ||
|
|
bFlag)
|
|
{
|
|
adsout << _T("\n不能插到该墙上(宽度超出墙体或基准线距离过短)!");
|
|
delete pWin;
|
|
m_bDimLabel = FALSE;
|
|
m_bLabel = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pWin->SetLocation(ptInsert);
|
|
pWin->SetSill(baseHoleDlg.getBottomHigh());
|
|
|
|
if (pWall->Is(CURVE_ARC))
|
|
{
|
|
pWin->SetKind(TOpeningData::OP_HOLE);
|
|
pWin->m_nIdStyle2d = NULL;
|
|
}
|
|
|
|
if(pWall->CanInsertOpening(*pWin))
|
|
{
|
|
pWin->SetWallId(pWall->objectId());
|
|
//设置旋转角度
|
|
pWin->SetRotation(segCen.Direction(ptInsert));
|
|
|
|
pWin->InitHardPointerId();
|
|
pWin->AddToMSpace(Adesk::kFalse);
|
|
|
|
pWin->setLayer(InitLayer(LAY_TWT_HOLE));
|
|
pWall->assertWriteEnabled();
|
|
pWall->AddOpeningId(pWin->objectId());
|
|
pWin->close();
|
|
}
|
|
else
|
|
{
|
|
adsout << _T("\n不能插到该墙上(门窗高度或宽度方向超出墙体)!");
|
|
delete pWin;
|
|
m_bDimLabel = FALSE;
|
|
m_bLabel = FALSE;
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
//弧墙时调整基准线上的选取点和基础洞插入点位置
|
|
void CBaseHoleOperation::AdjustBaseHoleInsPt(Entity entBaseLine , TDbWall *pWall, int nDist)
|
|
{
|
|
if (pWall != NULL)
|
|
{
|
|
XCurveSegment segL, segR;
|
|
|
|
pWall->GetSideCurve(segL, segR);
|
|
AcGePoint3d ptCir = segL.GetArc().GetCenterPt();
|
|
double dRadius = (segL.GetArc().GetRadius() + segR.GetArc().GetRadius()) / 2;
|
|
double dStartAngle = segL.GetArc().GetStarAngle();
|
|
double dEndAngle = segL.GetArc().GetEndAngle();
|
|
|
|
AcGePoint3d ptBaseLineIns;
|
|
AcGePoint3d ptNearToBaseLine;
|
|
AcGePoint3d ptInsert;
|
|
|
|
AcDbArc *pArc = new AcDbArc(ptCir, dRadius, dStartAngle, dEndAngle);
|
|
|
|
if (pArc != NULL)
|
|
{
|
|
OPENOBJ_BEGIN(entBaseLine, AcDb::kForRead, AcDbLine, pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3dArray arPt;
|
|
pLine->intersectWith(pArc, AcDb::kExtendArg, arPt);
|
|
if (arPt.length() > 0)
|
|
{
|
|
ptBaseLineIns = arPt[0];
|
|
AcGePoint3d pt1, pt2;
|
|
AcGePoint3d ptStart, ptEnd;
|
|
pArc->getStartPoint(ptStart);
|
|
pArc->getEndPoint(ptEnd);
|
|
pLine->getClosestPointTo(ptStart, AcGeVector3d::kZAxis, pt1);
|
|
pLine->getClosestPointTo(ptEnd, AcGeVector3d::kZAxis, pt2);
|
|
|
|
BOOL bNearToStartPt = FALSE;
|
|
if (ptStart.distanceTo(pt1) < ptEnd.distanceTo(pt2))
|
|
{
|
|
ptNearToBaseLine = ptStart;
|
|
bNearToStartPt = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ptNearToBaseLine = ptEnd;
|
|
bNearToStartPt = FALSE;
|
|
}
|
|
|
|
double dArcLen = 0.0;
|
|
pArc->getDistAtPoint(ptEnd, dArcLen);
|
|
double dlen = nDist - ptNearToBaseLine.distanceTo(ptBaseLineIns);
|
|
if (bNearToStartPt)//与弧线起点重合
|
|
{
|
|
pArc->getPointAtDist(dlen, ptInsert);
|
|
pArc->getPointAtDist(nDist / 2 -ptNearToBaseLine.distanceTo(ptBaseLineIns), m_ptMid);
|
|
}
|
|
else
|
|
{
|
|
pArc->getPointAtDist(dArcLen - dlen, ptInsert);
|
|
pArc->getPointAtDist(dArcLen - nDist / 2 + ptNearToBaseLine.distanceTo(ptBaseLineIns), m_ptMid);
|
|
}
|
|
m_ptWallLine = ptInsert;
|
|
m_ptBaseLine = ptBaseLineIns;
|
|
m_pArc = pArc;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::addArcLabel()
|
|
{
|
|
// 已经取得标注弧
|
|
XArc ar(m_ptBaseLine, m_ptMid, m_ptWallLine);
|
|
|
|
InitLayer(LAY_DIM, TRUE);
|
|
TDbDimension2 dim;
|
|
XCurveSegment segDim;
|
|
segDim=ar;
|
|
XPushVar<int> osmode1(_T("OSMODE"),(OS_PER|OS_INT|OS_END));
|
|
TDbDimension2 *pDim=&dim;
|
|
pDim->setLayer(LAY_DIM);
|
|
pDim->SetStyleId(InitDimStyle(DS_ANGLE));
|
|
pDim->SetDist2DimLine(-6.0);
|
|
XPoint ptFix;
|
|
ads_polar(segDim.GetStartPoint(), segDim.IDirection(0)-PI/2, 2.0*DocGetPScale(), ptFix);
|
|
pDim->SetLocation(ptFix);
|
|
pDim->SetRotation(segDim.IDirection(0));
|
|
pDim->SetAngular(TRUE);
|
|
pDim->SetDimArcLen(TRUE);
|
|
pDim->SetObjRadius(ar.GetRadius());
|
|
pDim->SetDimRadius(ar.GetRadius()+8.0*DocGetPScale());
|
|
XArc arDimLine=ar;
|
|
arDimLine.SetRadius(arDimLine.GetRadius() + 8.0*DocGetPScale());
|
|
pDim->AppendSegment(arDimLine.GetLength());
|
|
|
|
TDimensionEdJig jig(pDim, _T("\n请点取尺寸线位置<退出>: "));
|
|
jig.m_nFlag=1;
|
|
jig.doIt();
|
|
int nRetCode=jig.GetRetCode();
|
|
if(nRetCode!=RTNORM)
|
|
return;
|
|
if(pDim->IsValid() && jig.GetRetCode()!=RTCAN) {
|
|
TDbDimension2 *pDimNew=(TDbDimension2 *)pDim->clone();
|
|
ASSERT(pDimNew);
|
|
pDimNew->AddToCSpace(Adesk::kTrue);
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::IsInArcWall(BOOL &bFlag, Entity entBaseLine, TDbWall *pWall, CBaseHoleDlg &baseHoleDlg)
|
|
{
|
|
AcGePoint3dArray arPt;
|
|
BOOL bNearToStartPt = FALSE;
|
|
AcGePoint3d ptStart, ptEnd;
|
|
|
|
double dLen = 0; //弧墙距基准线距离
|
|
|
|
if (pWall != NULL)
|
|
{
|
|
OPENOBJ_BEGIN(entBaseLine, AcDb::kForRead, AcDbLine, pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d pt1, pt2;
|
|
m_pArc->getStartPoint(ptStart);
|
|
m_pArc->getEndPoint(ptEnd);
|
|
|
|
XCurveSegment segL , segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
|
|
AcGePoint3d ptS, ptE;
|
|
|
|
pLine->getClosestPointTo(segL.StartPoint(), ptS);
|
|
pLine->getClosestPointTo(segL.EndPoint(), ptE);
|
|
|
|
dLen = ptS.distanceTo(segL.StartPoint()) < ptE.distanceTo(segL.EndPoint()) ? ptS.distanceTo(segL.StartPoint()) : ptE.distanceTo(segL.EndPoint());
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
else
|
|
{
|
|
bFlag = TRUE;
|
|
return;
|
|
}
|
|
|
|
double dArcLen ;
|
|
m_pArc->getDistAtPoint(ptEnd, dArcLen);
|
|
|
|
//是否基础洞超出弧墙
|
|
if ((dLen + dArcLen - baseHoleDlg.getHoleWidth() / 2) >= m_nDist
|
|
&&(dLen + baseHoleDlg.getHoleWidth() / 2) <= m_nDist)
|
|
{
|
|
bFlag = FALSE;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
bFlag = TRUE;
|
|
return;
|
|
}
|
|
}
|
|
|
|
BOOL CBaseHoleOperation::IsInWall(Entity &entBaseLine, Entity &entWall)
|
|
{
|
|
BOOL bFlag = FALSE;
|
|
|
|
OPENOBJ_BEGIN(entWall, AcDb::kForWrite, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
OPENOBJ_BEGIN(entBaseLine, AcDb::kForRead, AcDbLine, pLine);
|
|
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d ptStart ,ptEnd;
|
|
ptStart = pWall->StartPoint();
|
|
ptEnd = pWall->EndPoint();
|
|
|
|
AcGePoint3d ptStoLine, ptEtoLine;
|
|
pLine->getClosestPointTo(ptStart,ptStoLine);
|
|
pLine->getClosestPointTo(ptEnd, ptEtoLine);
|
|
if (ptEtoLine.distanceTo(ptEnd) < 1E-3 || ptStoLine.distanceTo(ptStart) < 1E-3)
|
|
{
|
|
bFlag = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bFlag = FALSE;
|
|
}
|
|
}
|
|
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return bFlag;
|
|
}
|
|
|
|
BOOL CBaseHoleOperation::IsInWall(Entity &ent, std::map<AcDbObjectId,AcDbObjectId> &mapEnt)
|
|
{
|
|
PickSet ssSel(SS_FREE);
|
|
XPoint ptIns;
|
|
AcDbObjectId idH = NULL, idW = NULL;
|
|
AcGePoint3d ptOnHydrant1, ptOnHydrant2;
|
|
|
|
AcGePoint3d ptGeLB ,ptGeLT, ptGeRB, ptGeRT;
|
|
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEqu);
|
|
if (pEqu)
|
|
{
|
|
idH = pEqu->objectId();
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis;
|
|
AcGeVector3d vtY;
|
|
|
|
ptIns = pEqu->GetLocation();
|
|
AcGeScale3d sca = pEqu->GetInsertScale();
|
|
double dAngle = pEqu->GetAngle();
|
|
vtX.rotateBy(dAngle,AcGeVector3d::kZAxis);
|
|
vtY = vtX;
|
|
vtY.rotateBy(PI/2,AcGeVector3d::kZAxis);
|
|
|
|
const double dDist = 100;
|
|
ptGeLB = ptIns - vtX * (sca.sx + dDist) / 2;
|
|
ptGeLB = ptGeLB - vtY * (sca.sy + dDist) / 2;
|
|
ptGeLT = ptGeLB + vtY * (sca.sy + dDist);
|
|
ptGeRB = ptGeLB + vtX * (sca.sx + dDist);
|
|
ptGeRT = ptGeRB + vtY * (sca.sy + dDist);
|
|
|
|
ptOnHydrant1 = ptGeLB + vtX * dDist / 2 + vtY * dDist / 2;
|
|
ptOnHydrant2 = ptGeLT - vtY * dDist + vtX * dDist / 2 + vtY * dDist / 2 ;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
//RBList rbFilter = acutBuildList(RTDXF0, _T("ATS_WALL"), 8, LAY_WALL,NULL); zxl 2013.07.23 modify 干掉图层
|
|
RBList rbFilter = acutBuildList(RTDXF0, _T("ATS_WALL"), NULL);
|
|
|
|
TADSGePoint3d _pt1 = Wcs2Ucs(ptGeLB)
|
|
, _pt2 = Wcs2Ucs(ptGeLT)
|
|
, _pt3 = Wcs2Ucs(ptGeRT)
|
|
, _pt4 = Wcs2Ucs(ptGeRB);
|
|
RBList rbPt = acutBuildList(RTPOINT,&_pt1,RTPOINT,&_pt2,RTPOINT,&_pt3, RTPOINT,&_pt4,NULL);
|
|
acedSSGet(_T("CP"),rbPt,NULL,rbFilter,ssSel);
|
|
|
|
if (ssSel.Length() > 0)
|
|
{
|
|
Entity entWall;
|
|
for (long i = 0; i < ssSel.Length(); i++)
|
|
{
|
|
entWall = ssSel[i];
|
|
OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
idW = pWall->objectId();
|
|
XCurveSegment segL, segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
|
|
if (IsIn2Line(segL, segR, ptOnHydrant1) && IsIn2Line(segL, segR, ptOnHydrant2))
|
|
{
|
|
mapEnt.insert(std::make_pair(idH, idW));
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// 为消火栓添加基础洞
|
|
void CBaseHoleOperation::AddHoleToHydrant(std::map<AcDbObjectId,AcDbObjectId> &mapEnt)
|
|
{
|
|
std::map<AcDbObjectId,AcDbObjectId>::iterator iter;
|
|
for (iter = mapEnt.begin(); iter != mapEnt.end(); iter++)
|
|
{
|
|
AcDbObjectId idHydrant, idWall;
|
|
idHydrant = iter->first;
|
|
idWall = iter->second;
|
|
XPoint ptIns; //基础洞插入点
|
|
BOOL bFlag = FALSE; // 判断操作是否正确
|
|
double dHoleWidth = 0.0; //洞宽
|
|
const double dHoleHigh = 1000.0; //洞高
|
|
double dBottomHigh = 0.0; //底高
|
|
|
|
OPENOBJ_BEGIN(idHydrant, AcDb::kForRead, TDbEquipment, pEquip);
|
|
if (pEquip)
|
|
{
|
|
ptIns = pEquip->GetLocation();
|
|
AcGeScale3d sca = pEquip->GetInsertScale();
|
|
dHoleWidth = fabs(sca.sx);
|
|
dBottomHigh = ptIns.z;
|
|
bFlag = TRUE;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
AcDbObjectId id2d = NULL;
|
|
XString xsBlk;
|
|
LoadDwbBlock(_T("TWTSYS"), _T("00000513"), xsBlk);
|
|
id2d = GetBlkIdByName(xsBlk);
|
|
if (!id2d.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
TDbOpening *pWin = new TDbOpening();
|
|
if (pWin == NULL)
|
|
return;
|
|
|
|
pWin->m_nIdStyle2d=id2d;
|
|
|
|
pWin->SetKind(TOpeningData::OP_WINDOW);
|
|
pWin->setLinetype(_T("DASHED"));
|
|
pWin->InitHardPointerId();
|
|
pWin->m_pBayWin = new XBayWindow();
|
|
pWin->SetWidth(dHoleWidth);
|
|
pWin->SetHeight(dHoleHigh);
|
|
|
|
if (bFlag)
|
|
{
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForWrite, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
//将选取点转化到墙体中心线上对应的一点
|
|
XCurveSegment segL,segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
XPoint ptStart , ptEnd;
|
|
ptStart = Mid(segL.GetStartPoint(), segR.GetStartPoint());
|
|
ptEnd = Mid(segL.GetEndPoint(), segR.GetEndPoint());
|
|
|
|
XCurveSegment segCen(ptStart,ptEnd,segL.GetBulge());
|
|
segCen.ProjectToMe(ptIns, ptIns);
|
|
|
|
pWin->SetLocation(ptIns);
|
|
pWin->SetSill(dBottomHigh);
|
|
|
|
if (pWall->Is(CURVE_ARC))
|
|
{
|
|
pWin->SetKind(TOpeningData::OP_HOLE);
|
|
pWin->m_nIdStyle2d = NULL;
|
|
}
|
|
|
|
if(pWall->CanInsertOpening(*pWin))
|
|
{
|
|
pWin->SetWallId(pWall->objectId());
|
|
//设置旋转角度
|
|
pWin->SetRotation(segCen.Direction(ptIns));
|
|
|
|
pWin->InitHardPointerId();
|
|
pWin->AddToMSpace(Adesk::kFalse);
|
|
|
|
pWin->setLayer(InitLayer(LAY_TWT_HOLE));
|
|
pWall->assertWriteEnabled();
|
|
pWall->AddOpeningId(pWin->objectId());
|
|
pWin->close();
|
|
}
|
|
else
|
|
{
|
|
adsout << _T("\n不能插到该墙上(门窗高度或宽度方向超出墙体)!");
|
|
delete pWin;
|
|
m_bDimLabel = FALSE;
|
|
m_bLabel = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete pWin;
|
|
pWin = NULL;
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
else
|
|
{
|
|
delete pWin;
|
|
pWin = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::AddBaseHole(AcDbObjectId idWall, XPoint ptIns, double dWidth, double dHeight, double dBottomHeight)
|
|
{
|
|
if (!idWall.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbObjectId id2d = AcDbObjectId::kNull;
|
|
XString xsBlk;
|
|
LoadDwbBlock(_T("TWTSYS"), _T("00000513"), xsBlk);
|
|
id2d = GetBlkIdByName(xsBlk);
|
|
if (!id2d.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
TDbOpening *pWin = new TDbOpening();
|
|
if (pWin == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
pWin->m_nIdStyle2d=id2d;
|
|
pWin->SetKind(TOpeningData::OP_WINDOW);
|
|
pWin->setLinetype(_T("DASHED"));
|
|
pWin->InitHardPointerId();
|
|
pWin->m_pBayWin = new XBayWindow();
|
|
pWin->SetWidth(dWidth);
|
|
pWin->SetHeight(dHeight);
|
|
|
|
TDbWall *pWall = NULL;
|
|
acdbOpenObject(pWall, idWall, AcDb::kForWrite);
|
|
if (pWall != NULL)
|
|
{
|
|
//将选取点转化到墙体中心线上对应的一点
|
|
XCurveSegment segL,segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
XPoint ptStart , ptEnd;
|
|
ptStart = Mid(segL.GetStartPoint(), segR.GetStartPoint());
|
|
ptEnd = Mid(segL.GetEndPoint(), segR.GetEndPoint());
|
|
|
|
XCurveSegment segCen(ptStart,ptEnd,segL.GetBulge());
|
|
segCen.ProjectToMe(ptIns, ptIns);
|
|
|
|
pWin->SetLocation(ptIns);
|
|
pWin->SetSill(dBottomHeight);
|
|
|
|
if (pWall->Is(CURVE_ARC))
|
|
{
|
|
pWin->SetKind(TOpeningData::OP_HOLE);
|
|
pWin->m_nIdStyle2d = NULL;
|
|
}
|
|
|
|
if(pWall->CanInsertOpening(*pWin))
|
|
{
|
|
pWin->SetWallId(pWall->objectId());
|
|
//设置旋转角度
|
|
pWin->SetRotation(segCen.Direction(ptIns));
|
|
|
|
pWin->InitHardPointerId();
|
|
pWin->AddToMSpace(Adesk::kFalse);
|
|
|
|
pWin->setLayer(InitLayer(LAY_TWT_HOLE));
|
|
pWall->assertWriteEnabled();
|
|
pWall->AddOpeningId(pWin->objectId());
|
|
pWin->close();
|
|
}
|
|
else
|
|
{
|
|
adsout << _T("\n不能插到该墙上(门窗高度或宽度方向超出墙体)!");
|
|
delete pWin;
|
|
m_bDimLabel = FALSE;
|
|
m_bLabel = FALSE;
|
|
}
|
|
pWall->close();
|
|
}
|
|
else
|
|
{
|
|
delete pWin;
|
|
pWin = NULL;
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::AddHoleToHydrant(AcDbObjectId idWall, AcDbObjectId idHydrant)
|
|
{
|
|
if (!idHydrant.isValid() || !idWall.isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
TDbEquipment *pEquip = NULL;
|
|
acdbOpenObject(pEquip, idHydrant, AcDb::kForRead);
|
|
if (pEquip != NULL)
|
|
{
|
|
AcGeScale3d sca = pEquip->GetInsertScale();
|
|
double dHydrantWidth = fabs(sca.sx);
|
|
AcGeVector3d vtr = Ucs2Wcs(AcGeVector3d::kXAxis);
|
|
vtr.rotateBy(pEquip->GetAngle(), Ucs2Wcs(AcGeVector3d::kZAxis));
|
|
|
|
BOOL bIsMirrorByY = pEquip->IsMirrorByY();
|
|
if (bIsMirrorByY)
|
|
{
|
|
vtr = -vtr;
|
|
}
|
|
|
|
XPoint ptIns; //基础洞插入点
|
|
ptIns = pEquip->GetLocation();
|
|
double dWidth = 0.0, dHeight = 0.0, dBottmHeight = 0.0; //基础洞的宽度，高度，底高
|
|
double dAngle = 0.0;
|
|
|
|
BOOL bHydrantType = FALSE; //消火栓类型是否为平接
|
|
double dLen = pEquip->GetPipeLength();
|
|
pEquip->close();
|
|
|
|
if (fabs(dLen) < 1e-6)
|
|
{
|
|
bHydrantType = TRUE;
|
|
}
|
|
|
|
if (bHydrantType) //消火栓类型是水平接
|
|
{
|
|
if (fabs(dHydrantWidth - 500) < 1e-6)
|
|
{
|
|
ptIns += vtr * (750 - 500 - 15 - 15) / 2;
|
|
dWidth = 750;
|
|
dHeight = 680;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (fabs(dHydrantWidth - 650) < 1e-6)
|
|
{
|
|
ptIns += vtr * (900 - 650 - 15 - 15) / 2;
|
|
dWidth = 900;
|
|
dHeight = 830;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (fabs(dHydrantWidth - 700) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入水平接消火栓箱的高度[1600/1700/1800]<1800>:"), &nHeight);
|
|
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1600)
|
|
{
|
|
ptIns += vtr * (950 - 700 - 15 - 15) / 2;
|
|
dWidth = 950;
|
|
dHeight = 1630;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1700)
|
|
{
|
|
ptIns += vtr * (950 - 700 - 15 - 15) / 2;
|
|
dWidth = 950;
|
|
dHeight = 1730;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1800)
|
|
{
|
|
ptIns += vtr * (950 - 700 - 15 - 15) / 2;
|
|
dWidth = 950;
|
|
dHeight = 1830;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
ptIns += vtr * (950 - 700 - 15 - 15) / 2;
|
|
dWidth = 950;
|
|
dHeight = 1830;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if(fabs(dHydrantWidth - 750) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入水平接消火栓箱的高度[1900/2000]<2000>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1900)
|
|
{
|
|
ptIns += vtr * (1000 - 750 - 15 - 15) / 2;
|
|
dWidth = 1000;
|
|
dHeight = 1930;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 2000)
|
|
{
|
|
ptIns += vtr * (1000 - 750 - 15 - 15) / 2;
|
|
dWidth = 1000;
|
|
dHeight = 2030;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
ptIns += vtr * (1000 - 750 - 15 - 15) / 2;
|
|
dWidth = 1000;
|
|
dHeight = 2030;
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TCHAR szSelChar[10];
|
|
int nStatus = acedGetString(0, _T("\n是否对非标准水平接消火栓箱进行开洞[Y/N]<N>:"), szSelChar);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (szSelChar[0] == 'Y' || szSelChar[0] == 'y')
|
|
{
|
|
dWidth = dHydrantWidth;
|
|
dHeight = 1000;
|
|
dBottmHeight = ptIns.z;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (szSelChar[0] == 'N' || szSelChar[0] == 'n')
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else //消火栓类型为 上接
|
|
{
|
|
if (fabs(dHydrantWidth - 650) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入上接消火栓箱的高度[800/950]<800>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 800)
|
|
{
|
|
ptIns += -vtr * (680 - 650 - 15 - 15) / 2;
|
|
dWidth = 680;
|
|
dHeight = 1050;
|
|
dBottmHeight = ptIns.z - (1050 - 800 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 950)
|
|
{
|
|
ptIns += -vtr * (680 - 650 - 15 - 15) / 2;
|
|
dWidth = 680;
|
|
dHeight = 1200;
|
|
dBottmHeight = ptIns.z - (1200 - 950 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
ptIns += -vtr * (680 - 650 - 15 - 15) / 2;
|
|
dWidth = 680;
|
|
dHeight = 1050;
|
|
dBottmHeight = ptIns.z - (1050 - 800 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (fabs(dHydrantWidth - 700) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入上接消火栓箱的高度[1000/1150/1600/1700/1800]<1000>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1000)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
dWidth = 730;
|
|
dHeight = 1250;
|
|
dBottmHeight = ptIns.z - (1250 - 1000 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1150)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
dWidth = 730;
|
|
dHeight = 1400;
|
|
dBottmHeight = ptIns.z - (1400 - 1150 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1600)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
dWidth = 730;
|
|
dHeight = 1630;
|
|
dBottmHeight = ptIns.z - (1630 - 1600 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1700)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
dWidth = 730;
|
|
dHeight = 1730;
|
|
dBottmHeight = ptIns.z - (1730 - 1700 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1800)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
dWidth = 730;
|
|
dHeight = 1830;
|
|
dBottmHeight = ptIns.z - (1830 - 1800 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
dWidth = 730;
|
|
dHeight = 1250;
|
|
dBottmHeight = ptIns.z - (1250 - 1000 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (fabs(dHydrantWidth - 750) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入上接消火栓箱的高度[1200/1350/1900]<1200>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1200)
|
|
{
|
|
ptIns += -vtr * (780 - 750 - 15 - 15) / 2;
|
|
dWidth = 780;
|
|
dHeight = 1450;
|
|
dBottmHeight = ptIns.z - (1450 - 1200 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1350)
|
|
{
|
|
ptIns += -vtr * (780 - 750 - 15 - 15) / 2;
|
|
dWidth = 780;
|
|
dHeight = 1600;
|
|
dBottmHeight = ptIns.z - (1600 - 1350 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (nHeight == 1900)
|
|
{
|
|
ptIns += -vtr * (780 - 750 - 15 - 15) / 2;
|
|
dWidth = 780;
|
|
dHeight = 1930;
|
|
dBottmHeight = ptIns.z - (1930 - 1900 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
ptIns += -vtr * (780 - 750 - 15 - 15) / 2;
|
|
dWidth = 780;
|
|
dHeight = 1450;
|
|
dBottmHeight = ptIns.z - (1450 - 1200 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TCHAR szSelChar[10];
|
|
int nStatus = acedGetString(0, _T("\n是否对非标准上接消火栓箱进行开洞[Y/N]<N>:"), szSelChar);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (szSelChar[0] == 'Y' || szSelChar[0] == 'y')
|
|
{
|
|
dWidth = dHydrantWidth;
|
|
dHeight = 1000;
|
|
dBottmHeight = ptIns.z;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
AddLabel(ptIns, dAngle);
|
|
}
|
|
else if (szSelChar[0] == 'N' || szSelChar[0] == 'n')
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CBaseHoleOperation::IsIn2Line(const XCurveSegment &segL, const XCurveSegment &segR, XPoint ptTemp)
|
|
{
|
|
|
|
XPoint ptPro1, ptPro2; //投影点
|
|
segL.ProjectToMe(ptTemp, ptPro1);
|
|
segR.ProjectToMe(ptTemp, ptPro2);
|
|
|
|
ptPro1.z = ptTemp.z;
|
|
ptPro2.z = ptTemp.z;
|
|
|
|
double dLen1 = ptPro1.Distance(ptPro2);
|
|
double dlen2 = ptPro1.Distance(ptTemp) + ptPro2.Distance(ptTemp);
|
|
|
|
if (fabs(dLen1 - dlen2) < 1E-6)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CBaseHoleOperation::AddBaseHoleByBatch(std::map<AcDbObjectId,AcDbObjectId> &mapEnt)
|
|
{
|
|
CHydrantSetting hydrantSet;
|
|
std::vector<AcDbObjectId> vecId1; //保存水平接消火栓id
|
|
std::vector<AcDbObjectId> vecId2; //保存上接消火栓id
|
|
|
|
//将消火栓分类
|
|
hydrantSet.Sort(mapEnt, vecId1, vecId2);
|
|
//将消火栓根据其宽度排序
|
|
std::multimap<double,AcDbObjectId> mapId; //保存排序结果(<宽度,id>)按宽度排序
|
|
hydrantSet.Compositor(vecId1, mapId); // 排序
|
|
|
|
//为水平接消火栓开基础洞
|
|
double dB = 500.0;
|
|
AddBaseHole(mapEnt, mapId, dB);
|
|
dB = 650.0;
|
|
AddBaseHole(mapEnt, mapId, dB);
|
|
dB = 700.0;
|
|
AddBaseHole(mapEnt, mapId, dB);
|
|
dB = 750.0;
|
|
AddBaseHole(mapEnt, mapId, dB);
|
|
|
|
std::map<AcDbObjectId,AcDbObjectId> mapTmp;
|
|
std::vector<AcDbObjectId> vecTmp;
|
|
std::multimap<double,AcDbObjectId>::iterator iter1;
|
|
std::map<AcDbObjectId,AcDbObjectId>::iterator iter2;
|
|
|
|
for (iter1 = mapId.begin(); iter1 != mapId.end(); iter1++)
|
|
{
|
|
iter2 = mapEnt.find(iter1->second);
|
|
if (iter2 != mapEnt.end())
|
|
{
|
|
mapTmp.insert(std::make_pair(iter1->second, iter2->second));
|
|
vecTmp.push_back(iter1->second);
|
|
}
|
|
}
|
|
|
|
//为上接消火栓开基础洞
|
|
mapId.clear();
|
|
hydrantSet.Compositor(vecId2, mapId); // 排序
|
|
dB = 650.0;
|
|
AddBaseHole(mapEnt, mapId, dB, FALSE);
|
|
dB = 700.0;
|
|
AddBaseHole(mapEnt, mapId, dB, FALSE);
|
|
dB = 750.0;
|
|
AddBaseHole(mapEnt, mapId, dB, FALSE);
|
|
|
|
//处理非标准消火栓
|
|
if (!mapId.empty())
|
|
{
|
|
for (iter1 = mapId.begin(); iter1 != mapId.end(); iter1++)
|
|
{
|
|
iter2 = mapEnt.find(iter1->second);
|
|
if (iter2 != mapEnt.end())
|
|
{
|
|
mapTmp.insert(std::make_pair(iter1->second, iter2->second));
|
|
vecTmp.push_back(iter1->second);
|
|
}
|
|
}
|
|
|
|
TCHAR szSelChar[10];
|
|
CHydrantSetting hydrantSet;
|
|
int nColor = 1;
|
|
|
|
hydrantSet.SetHydrantColor(vecTmp, nColor);
|
|
int nStatus = acedGetString(0, _T("\n是否对非标准消火栓开洞[Y/N]<Y>:"), szSelChar);
|
|
if (nStatus == RTNORM)
|
|
{
|
|
if (szSelChar[0] == 'Y' || szSelChar[0] == 'y' || szSelChar[0] == '\0')
|
|
{
|
|
AddHoleToHydrant(mapTmp); //统一开大小相同的基础洞
|
|
}
|
|
}
|
|
|
|
hydrantSet.SetHydrantColor(vecTmp, 256);
|
|
}
|
|
}
|
|
|
|
void CBaseHoleOperation::AddBaseHoleByBatch(std::map<AcDbObjectId,AcDbObjectId> &mapEnt, std::vector<AcDbObjectId> &vecId)
|
|
{
|
|
if (mapEnt.empty() || vecId.empty())
|
|
{
|
|
return;
|
|
}
|
|
TDbEquipment *pEquip = NULL;
|
|
AcDbObjectId idHydrant = vecId[0];
|
|
acdbOpenObject(pEquip, idHydrant, AcDb::kForRead);
|
|
if (pEquip != NULL)
|
|
{
|
|
AcGeScale3d sca = pEquip->GetInsertScale();
|
|
double dHydrantWidth = fabs(sca.sx);
|
|
|
|
XPoint ptIns; //基础洞插入点
|
|
double dWidth = 0.0, dHeight = 0.0, dBottmHeight = 0.0; //基础洞的宽度，高度，底高
|
|
|
|
BOOL bHydrantType = FALSE; //消火栓类型是否为平接
|
|
double dLen = pEquip->GetPipeLength();
|
|
pEquip->close();
|
|
|
|
if (fabs(dLen) < 1e-6)
|
|
{
|
|
bHydrantType = TRUE;
|
|
}
|
|
|
|
AcDbObjectId idWall = AcDbObjectId::kNull;
|
|
int nSize = (int)vecId.size();
|
|
int i = 0;
|
|
std::map<AcDbObjectId,AcDbObjectId>::iterator iter;
|
|
|
|
if (bHydrantType) //消火栓类型是水平接
|
|
{
|
|
if (fabs(dHydrantWidth - 500) < 1e-6)
|
|
{
|
|
dWidth = 750;
|
|
dHeight = 680;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (fabs(dHydrantWidth - 650) < 1e-6)
|
|
{
|
|
dWidth = 900;
|
|
dHeight = 830;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (fabs(dHydrantWidth - 700) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入水平接消火栓箱的高度[1600/1700/1800]<1800>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1600)
|
|
{
|
|
dWidth = 950;
|
|
dHeight = 1630;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1700)
|
|
{
|
|
dWidth = 950;
|
|
dHeight = 1730;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1800)
|
|
{
|
|
dWidth = 950;
|
|
dHeight = 1830;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
dWidth = 950;
|
|
dHeight = 1830;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(fabs(dHydrantWidth - 750) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入水平接消火栓箱的高度[1900/2000]<2000>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1900)
|
|
{
|
|
dWidth = 1000;
|
|
dHeight = 1930;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 2000)
|
|
{
|
|
dWidth = 1000;
|
|
dHeight = 2030;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
dWidth = 1000;
|
|
dHeight = 2030;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - 15;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TCHAR szSelChar[10];
|
|
int nStatus = acedGetString(0, _T("\n是否对非标准水平接消火栓箱进行开洞[Y/N]<N>:"), szSelChar);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (szSelChar[0] == 'Y' || szSelChar[0] == 'y')
|
|
{
|
|
dWidth = dHydrantWidth;
|
|
dHeight = 1000;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (szSelChar[0] == 'N' || szSelChar[0] == 'n')
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else //消火栓类型为 上接
|
|
{
|
|
if (fabs(dHydrantWidth - 650) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入上接消火栓箱的高度[800/950]<800>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 800)
|
|
{
|
|
dWidth = 680;
|
|
dHeight = 1050;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1050 - 800 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 950)
|
|
{
|
|
dWidth = 680;
|
|
dHeight = 1200;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1200 - 950 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
dWidth = 680;
|
|
dHeight = 1050;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1050 - 800 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (fabs(dHydrantWidth - 700) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入上接消火栓箱的高度[1000/1150/1600/1700/1800]<1000>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1000)
|
|
{
|
|
dWidth = 730;
|
|
dHeight = 1250;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1250 - 1000 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1150)
|
|
{
|
|
dWidth = 730;
|
|
dHeight = 1400;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1400 - 1150 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1600)
|
|
{
|
|
dWidth = 730;
|
|
dHeight = 1630;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1630 - 1600 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1700)
|
|
{
|
|
dWidth = 730;
|
|
dHeight = 1730;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1730 - 1700 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1800)
|
|
{
|
|
dWidth = 730;
|
|
dHeight = 1830;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1830 - 1800 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
dWidth = 730;
|
|
dHeight = 1250;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1250 - 1000 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (fabs(dHydrantWidth - 750) < 1e-6)
|
|
{
|
|
int nHeight = 0;
|
|
int nStatus = acedGetInt(_T("\n请输入上接消火栓箱的高度[1200/1350/1900]<1200>:"), &nHeight);
|
|
if (nStatus == RTCAN)
|
|
{
|
|
return;
|
|
}
|
|
else if (nStatus == RTNORM)
|
|
{
|
|
if (nHeight == 1200)
|
|
{
|
|
dWidth = 780;
|
|
dHeight = 1450;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1450 - 1200 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1350)
|
|
{
|
|
dWidth = 780;
|
|
dHeight = 1600;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1600 - 1350 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
else if (nHeight == 1900)
|
|
{
|
|
dWidth = 780;
|
|
dHeight = 1930;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1930 - 1900 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nStatus == RTNONE)
|
|
{
|
|
dWidth = 780;
|
|
dHeight = 1450;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z - (1450 - 1200 - 15);
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dWidth = dHydrantWidth;
|
|
dHeight = 1000;
|
|
for (i = 0; i < nSize; i++)
|
|
{
|
|
idHydrant = vecId[i];
|
|
iter = mapEnt.find(idHydrant);
|
|
if (iter != mapEnt.end())
|
|
{
|
|
idWall = iter->second;
|
|
getInsertPoint(idHydrant, ptIns);
|
|
dBottmHeight = ptIns.z;
|
|
AddBaseHole(idWall, ptIns, dWidth, dHeight, dBottmHeight);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CBaseHoleOperation::getInsertPoint(AcDbObjectId idHydrant, XPoint &ptIns)
|
|
{
|
|
if(!idHydrant.isValid())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
TDbEquipment *pEquip = NULL;
|
|
acdbOpenObject(pEquip, idHydrant, AcDb::kForRead);
|
|
if (pEquip != NULL)
|
|
{
|
|
AcGeScale3d sca = pEquip->GetInsertScale();
|
|
double dHydrantWidth = fabs(sca.sx); //消火栓宽度
|
|
AcGeVector3d vtr = Ucs2Wcs(AcGeVector3d::kXAxis);
|
|
vtr.rotateBy(pEquip->GetAngle(), Ucs2Wcs(AcGeVector3d::kZAxis));
|
|
|
|
BOOL bIsMirrorByY = pEquip->IsMirrorByY();
|
|
if (bIsMirrorByY)
|
|
{
|
|
vtr = -vtr;
|
|
}
|
|
|
|
ptIns = pEquip->GetLocation();
|
|
|
|
BOOL bHydrantType = FALSE; //消火栓类型是否为平接
|
|
double dLen = pEquip->GetPipeLength();
|
|
if (fabs(dLen) < 1e-6)
|
|
{
|
|
bHydrantType = TRUE;
|
|
}
|
|
|
|
if (bHydrantType) //消火栓类型是水平接
|
|
{
|
|
if (fabs(dHydrantWidth - 500) < 1e-6)
|
|
{
|
|
ptIns += vtr * (750 - 500 - 15 - 15) / 2;
|
|
}
|
|
else if (fabs(dHydrantWidth - 650) < 1e-6)
|
|
{
|
|
ptIns += vtr * (900 - 650 - 15 - 15) / 2;
|
|
|
|
}
|
|
else if (fabs(dHydrantWidth - 700) < 1e-6)
|
|
{
|
|
ptIns += vtr * (950 - 700 - 15 - 15) / 2;
|
|
}
|
|
else if(fabs(dHydrantWidth - 750) < 1e-6)
|
|
{
|
|
ptIns += vtr * (1000 - 750 - 15 - 15) / 2;
|
|
}
|
|
}
|
|
else //消火栓类型为 上接
|
|
{
|
|
if (fabs(dHydrantWidth - 650) < 1e-6)
|
|
{
|
|
ptIns += -vtr * (680 - 650 - 15 - 15) / 2;
|
|
}
|
|
else if (fabs(dHydrantWidth - 700) < 1e-6)
|
|
{
|
|
ptIns += -vtr * (730 - 700 - 15 - 15) / 2;
|
|
}
|
|
else if (fabs(dHydrantWidth - 750) < 1e-6)
|
|
{
|
|
ptIns += -vtr * (780 - 750 - 15 - 15) / 2;
|
|
}
|
|
}
|
|
|
|
pEquip->close();
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CBaseHoleOperation::AddBaseHole(std::map<AcDbObjectId,AcDbObjectId> &mapEnt, std::multimap<double,AcDbObjectId> &mapId, double dB, BOOL bLevelHydrant)
|
|
{
|
|
std::vector<AcDbObjectId> vec;
|
|
std::multimap<double,AcDbObjectId>::iterator itr = mapId.begin();
|
|
typedef std::multimap<double, AcDbObjectId>::iterator Iterator;
|
|
std::pair<Iterator, Iterator> pair;
|
|
|
|
// 查询B = dB 的消火栓
|
|
pair = mapId.equal_range(dB);
|
|
itr = pair.first;
|
|
for (; itr != pair.second; itr++)
|
|
{
|
|
vec.push_back(itr->second);
|
|
}
|
|
|
|
if (!vec.empty())
|
|
{
|
|
CString strPromt;
|
|
strPromt.Format(_T("\n是否对B = %.0f"), dB);
|
|
if (bLevelHydrant)
|
|
{
|
|
strPromt += _T("水平接消火栓箱精确开洞[Y/N]<Y>:");
|
|
}
|
|
else
|
|
{
|
|
strPromt += _T("上接消火栓箱精确开洞[Y/N]<Y>:");
|
|
}
|
|
|
|
TCHAR szSelChar[10];
|
|
CHydrantSetting hydrantSet;
|
|
int nColor = 1;
|
|
|
|
hydrantSet.SetHydrantColor(vec, nColor);
|
|
int nStatus = acedGetString(0, strPromt, szSelChar);
|
|
|
|
if (nStatus == RTNORM)
|
|
{
|
|
if (szSelChar[0] == 'Y' || szSelChar[0] == 'y')
|
|
{
|
|
AddBaseHoleByBatch(mapEnt, vec);
|
|
}
|
|
else if (szSelChar[0] == '\0') //默认操作
|
|
{
|
|
AddBaseHoleByBatch(mapEnt, vec);
|
|
}
|
|
}
|
|
|
|
mapId.erase(pair.first, pair.second);
|
|
hydrantSet.SetHydrantColor(vec, 256);
|
|
acedUpdateDisplay();
|
|
actrTransactionManager->flushGraphics();
|
|
}
|
|
}
|