2040 lines
46 KiB
C++
2040 lines
46 KiB
C++
#include "StdAfx.h"
|
|
#include "StdArx.h"
|
|
#include "CoreTools.h"
|
|
#include "KTCADUtilityEx.h"
|
|
#include "KTModelLayoutXData.h"
|
|
#include "AecDb3dRoadAxisLine.h"
|
|
#include "AecDbEwFlexiblePipe.h"
|
|
#include "AcPolylineJig.h"
|
|
#include "CSWGXDlg.h"
|
|
#include "KTSetting.h"
|
|
#include "SMLOBJDlg.h"
|
|
#include "AecDbAssembleWell.h"
|
|
#include "ZJCJDlg.h"
|
|
#include "HydrantCalcDlg.h"
|
|
#include "LayoutExtinguisher.h"
|
|
#include "CSXHDlg.h"
|
|
#include "AecDbEwEquipment.h"
|
|
#include <AecDbEarthWorm.h>
|
|
#include <EquInsDirJig.h>
|
|
#include <AecDbWall.h>
|
|
#include <AecDbColumn.h>
|
|
#include <KTCadUtility.h>
|
|
#include <dbobjptr.h>
|
|
#include "CPenLinSetDlg.h"
|
|
#include "CJXPTDlg.h"
|
|
#include "CHXPTDlg.h"
|
|
#include "CZXPTDlg.h"
|
|
#include "CRYPTDlg.h"
|
|
#include "gearc2d.h"
|
|
#include "geometry2json.h"
|
|
|
|
|
|
|
|
namespace
|
|
{
|
|
template <typename T>
|
|
void setData(AecEqui::XPrimData* pXPData, void* pData)
|
|
{
|
|
::Sleep(30);
|
|
pXPData->m_nID = ::GetTickCount();
|
|
switch (pXPData->m_eType)
|
|
{
|
|
case AecEqui::kExtrude:
|
|
case AecEqui::kRevolve:
|
|
pXPData->m_nSize = ((AecEqui::XBuffer*)pData)->nSize;
|
|
if (pXPData->m_nSize > 0)
|
|
{
|
|
pXPData->m_pData = new byte[pXPData->m_nSize];
|
|
::memcpy(pXPData->m_pData, ((AecEqui::XBuffer*)pData)->pData, pXPData->m_nSize);
|
|
}
|
|
break;
|
|
default:
|
|
pXPData->m_pData = new T;
|
|
::memcpy(pXPData->m_pData, pData, sizeof(T));
|
|
pXPData->m_nSize = sizeof(T);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void clearData(AecEqui::XPrimData& data)
|
|
{
|
|
switch (data.m_eType)
|
|
{
|
|
case AecEqui::kExtrude:
|
|
case AecEqui::kRevolve:
|
|
DELETE_ARR_(data.m_pData);
|
|
break;
|
|
default:
|
|
DELETE_PTR(data.m_pData);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
|
|
, const double& dL
|
|
, const double& dW
|
|
, const AcGeVector3d& vecL
|
|
, const AcGeVector3d& vecW
|
|
)
|
|
{
|
|
AcGePoint3d ptGe[5];
|
|
|
|
ptGe[0] = ptOrg + vecW * dW * .5;
|
|
ptGe[0] += vecL * dL * .5;
|
|
ptGe[1] = ptGe[0] - vecW * dW;
|
|
ptGe[2] = ptGe[1] - vecL * dL;
|
|
ptGe[3] = ptGe[2] + vecW * dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
return AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
|
}
|
|
|
|
AcDbRegion* makeCirReg(const AcGePoint3d& ptMid, const AcGeVector3d& vtZ, const double& dR)
|
|
{
|
|
AcDbCircle* pCir(new AcDbCircle(ptMid, vtZ, dR));
|
|
if (!pCir) return NULL;
|
|
return CoreTools::createRegion(pCir);
|
|
}
|
|
|
|
AcDbCurve* makeOffsetCurveByDir(AcDbCurve* pCurve, const double& dOffset)
|
|
{
|
|
if (!pCurve) return NULL;
|
|
|
|
AcDbVoidPtrArray ar;
|
|
ar.removeAll();
|
|
|
|
pCurve->getOffsetCurves(dOffset, ar);
|
|
if (ar.isEmpty()) return NULL;
|
|
|
|
AcDbCurve* pNewCurve = (AcDbCurve*)(((AcDbEntity*)ar.first())->clone());
|
|
deleteArrayVoidPtrs< AcDbEntity>(ar);
|
|
|
|
return pNewCurve;
|
|
}
|
|
|
|
double CurveInOut(AcDbCurve* pCurveTop
|
|
, AcDbCurve* pCurveBottom
|
|
, const AcGePoint3d& pt
|
|
, const double& dWallDist)
|
|
{
|
|
double dDist(.0);
|
|
|
|
if (!pCurveTop || !pCurveBottom)
|
|
{
|
|
return dDist;
|
|
}
|
|
|
|
AcGePoint3d ptCurveTop, ptCurveBottom;
|
|
double dDistTop(.0), dDistBottom(.0);
|
|
Acad::ErrorStatus es = pCurveTop->getClosestPointTo(pt, ptCurveTop);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return dDist;
|
|
}
|
|
es = pCurveBottom->getClosestPointTo(pt, ptCurveBottom);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return dDist;
|
|
}
|
|
dDistTop = pt.distanceTo(ptCurveTop);
|
|
dDistBottom = pt.distanceTo(ptCurveBottom);
|
|
|
|
if (dDistBottom < dDistTop)
|
|
{
|
|
// 点在基点下方
|
|
dDist = -dWallDist;
|
|
}
|
|
else
|
|
{
|
|
dDist = dWallDist;
|
|
}
|
|
|
|
return dDist;
|
|
}
|
|
|
|
double getDistByOffCurve(AcDbCurve* pCurve
|
|
, const double& dOffDist
|
|
, const AcGePoint3d& pt
|
|
, const double& dEquW)
|
|
{
|
|
double dDist(.0);
|
|
|
|
if (!pCurve)
|
|
{
|
|
return dDist;
|
|
}
|
|
|
|
AcDbCurve* pCurveCln = (AcDbCurve*)pCurve->clone();
|
|
if (!pCurveCln)
|
|
{
|
|
return dDist;
|
|
}
|
|
|
|
AcDbCurve* pLineOffTop = (AcDbCurve*)makeOffsetCurveByDir(pCurveCln, dOffDist);
|
|
if (!pLineOffTop)
|
|
{
|
|
DELETE_PTR(pCurveCln);
|
|
return dDist;
|
|
}
|
|
AcDbCurve* pLineOffBottom = (AcDbCurve*)makeOffsetCurveByDir(pCurveCln, -dOffDist);
|
|
if (!pLineOffBottom)
|
|
{
|
|
DELETE_PTR(pCurveCln);
|
|
DELETE_PTR(pLineOffTop);
|
|
return dDist;
|
|
}
|
|
|
|
dDist = CurveInOut(pLineOffTop, pLineOffBottom, pt, dEquW);
|
|
|
|
DELETE_PTR(pCurveCln);
|
|
DELETE_PTR(pLineOffTop);
|
|
DELETE_PTR(pLineOffBottom);
|
|
|
|
return dDist;
|
|
}
|
|
|
|
void creatXHSEqu(const AcGePoint3dArray& ptAr
|
|
, const AcGeVector3dArray& vtAr
|
|
, LPCTSTR pszBlkPath
|
|
, const BOOL& bType
|
|
, const double& dL
|
|
, const double& dW
|
|
, const double& dProtectR)
|
|
{
|
|
if (ptAr.length() < 1 || vtAr.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
if (ptAr.length() != vtAr.length())
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin);
|
|
|
|
AecDbEwEquipment* pEqu = new AecDbEwEquipment();
|
|
|
|
AcGePoint3d pt, ptNozz;
|
|
AcGeVector3d vt, vtDir;
|
|
for (int i(0); i < ptAr.length(); ++i)
|
|
{
|
|
pt = ptAr.at(i);
|
|
vt = vtAr.at(i);
|
|
|
|
AcDbCircle* pCirProtect = new AcDbCircle(pt, Z, dProtectR);
|
|
pCirProtect->setColorIndex(6);
|
|
CoreTools::AddToModelSpace(pCirProtect);
|
|
|
|
vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
// 消火栓
|
|
AcDbRegion* pReg = makeRectRegion(pt, dL, dW, vt, vtDir);
|
|
if (!pReg)
|
|
{
|
|
DELETE_PTR(pEqu);
|
|
return;
|
|
}
|
|
NewExtrude extrudeXHS(true, pReg, dW);
|
|
DELETE_PTR(pReg);
|
|
AecEqui::XPrimData dataXHS;
|
|
dataXHS.m_eType = AecEqui::kNewExtrude;
|
|
dataXHS.m_bBoolSubtract = false;
|
|
dataXHS.m_iClr = 100;
|
|
extrudeXHS.toData(dataXHS.m_pData, dataXHS.m_nSize);
|
|
pEqu->AddSubPrimObj(&dataXHS);
|
|
clearData(dataXHS);
|
|
|
|
if (!bType)
|
|
{
|
|
ptNozz = pt + Z * dW;
|
|
CoreTools::addNozzForEqu_Rect(pEqu
|
|
, Z
|
|
, ptNozz
|
|
, dL * .1
|
|
, dL * .15
|
|
, dW * .1
|
|
, dW * .1
|
|
, dW * .1
|
|
, 0
|
|
, true
|
|
, false);
|
|
}
|
|
}
|
|
|
|
// 设置一些基本数据
|
|
pEqu->GetSpecialtyData()->SetAt(AecDbEwEquipment::_DRAW_2D_BY_BLK_LENGTH_, .5);
|
|
pEqu->GetSpecialtyData()->SetAt(AecDbEwEquipment::_DRAW_2D_BY_BLK_WIDTH_, .5);
|
|
pEqu->GetSpecialtyData()->SetAt(AecDbEwEquipment::_DRAW_2D_BY_BLK_PATH_, pszBlkPath);
|
|
|
|
CoreTools::AddToModelSpace(pEqu);
|
|
|
|
return;
|
|
}
|
|
|
|
void creatExtEqu(const AecDbEwEquipment* pEqu
|
|
, LPCTSTR pszBlkPath
|
|
, const AcGePoint3d& ptBox
|
|
, const AcGePoint3dArray& ptAr
|
|
, const AcGePoint3dArray& ptProtectAr
|
|
, const AcGeVector3dArray& vtAr
|
|
, const double& dScale
|
|
, const BOOL& bDrawBox
|
|
, const double& dBoxL
|
|
, const double& dBoxW
|
|
, const BOOL& bShowProtectR
|
|
, const double& dProtectR)
|
|
{
|
|
if (ptAr.length() < 1 || ptProtectAr.length() < 1 || vtAr.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
if (ptAr.length() != vtAr.length() || ptAr.length() != ptProtectAr.length() || ptProtectAr.length() != vtAr.length())
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin);
|
|
|
|
AcGePoint3d pt, ptProtect;
|
|
AcGeVector3d vt, vtDir;
|
|
for (int i(0); i < ptAr.length(); ++i)
|
|
{
|
|
pt = ptAr.at(i);
|
|
ptProtect = ptProtectAr.at(i);
|
|
vt = vtAr.at(i);
|
|
|
|
if (bShowProtectR)
|
|
{
|
|
AcDbCircle* pCir = new AcDbCircle(ptProtect, Z, dProtectR);
|
|
pCir->setColorIndex(6);
|
|
CoreTools::AddToModelSpace(pCir);
|
|
}
|
|
|
|
AecDbEwEquipment* pEquCl = (AecDbEwEquipment*)pEqu->clone();
|
|
if (!pEquCl)
|
|
{
|
|
return;
|
|
}
|
|
|
|
pEquCl->SetInsert(pt, vt);
|
|
|
|
// 设置一些基本数据
|
|
pEquCl->GetSpecialtyData()->SetAt(AecDbEwEquipment::_DRAW_2D_BY_BLK_WIDTH_, dScale);
|
|
pEquCl->GetSpecialtyData()->SetAt(AecDbEwEquipment::_DRAW_2D_BY_BLK_LENGTH_, dScale);
|
|
pEquCl->GetSpecialtyData()->SetAt(AecDbEwEquipment::_DRAW_2D_BY_BLK_PATH_, pszBlkPath);
|
|
|
|
CoreTools::AddToModelSpace(pEquCl);
|
|
|
|
AcDbCircle* pCir = new AcDbCircle(pt, AcGeVector3d::kZAxis, 50);
|
|
pCir->setColorIndex(3);
|
|
CoreTools::AddToModelSpace(pCir);
|
|
}
|
|
|
|
if (bDrawBox)
|
|
{
|
|
// 灭火器箱体
|
|
AecDbEwEquipment* pEquBox = new AecDbEwEquipment();
|
|
AcDbRegion* pReg = makeRectRegion(ptBox, dBoxL, dBoxW, X, Y);
|
|
if (!pReg)
|
|
{
|
|
return;
|
|
}
|
|
NewExtrude extrudeBox(true, pReg, dBoxW);
|
|
DELETE_PTR(pReg);
|
|
AecEqui::XPrimData dataBox;
|
|
dataBox.m_eType = AecEqui::kNewExtrude;
|
|
dataBox.m_bBoolSubtract = false;
|
|
dataBox.m_iClr = 100;
|
|
extrudeBox.toData(dataBox.m_pData, dataBox.m_nSize);
|
|
pEquBox->AddSubPrimObj(&dataBox);
|
|
clearData(dataBox);
|
|
CoreTools::AddToModelSpace(pEquBox);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void creatExtinguish(const AecDbEwEquipment* pEqu
|
|
, LPCTSTR pszBlkPath
|
|
, const AcDbCurve* pCurve
|
|
, const AcGePoint3d& ptOnCurveOut
|
|
, const AcGePoint3d& ptOnCurve
|
|
, const int& nNum
|
|
, const double& dScale
|
|
, const BOOL& bDrawBox
|
|
, const double& dBoxL
|
|
, const double& dBoxW
|
|
, const BOOL& bShowProtectR
|
|
, const double& dProtectR)
|
|
{
|
|
if (!pCurve || !pEqu)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin);
|
|
|
|
AecDbEwEquipment* _pEquClone = (AecDbEwEquipment*)pEqu->clone();
|
|
if (!_pEquClone)
|
|
{
|
|
return;
|
|
}
|
|
AcDbCurve* pCurveClone = (AcDbCurve*)pCurve->clone();
|
|
if (!pCurveClone)
|
|
{
|
|
DELETE_PTR(_pEquClone);
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<AecDbEwEquipment>pEquClone(_pEquClone);
|
|
|
|
AcGePoint3d ptEquInsert;
|
|
AcGeVector3d vtEquInsert;
|
|
pEquClone->GetInsert(ptEquInsert, vtEquInsert);
|
|
AcDbCircle* pCir1 = new AcDbCircle(ptEquInsert, AcGeVector3d::kZAxis, 50);
|
|
pCir1->setColorIndex(6);
|
|
CoreTools::AddToModelSpace(pCir1);
|
|
CoreTools::CloneAndAddToModelSpace(_pEquClone);
|
|
|
|
AcDbExtents exts;
|
|
pEquClone->getGeomExtents(exts);
|
|
double dEquL = exts.maxPoint().x - exts.minPoint().x;
|
|
double dEquW = exts.maxPoint().y - exts.minPoint().y;
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(pCurveClone);
|
|
AcDbArc* pArc = AcDbArc::cast(pCurveClone);
|
|
AcDbCircle* pCir = AcDbCircle::cast(pCurveClone);
|
|
if (!pLine && !pArc && !pCir)
|
|
{
|
|
acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
|
|
DELETE_PTR(pCurveClone);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3dArray ptAr, ptProtectAr;
|
|
AcGeVector3dArray vtAr;
|
|
ptAr.removeAll();
|
|
ptProtectAr.removeAll();
|
|
vtAr.removeAll();
|
|
|
|
AcGePoint3d ptBox;
|
|
if (pLine)
|
|
{
|
|
AcGePoint3d ptS, ptE, ptEqu, ptCurveOut, ptCurve;
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
AcGeVector3d vt = (ptE - ptS).normalize();
|
|
|
|
pLine->getClosestPointTo(ptOnCurveOut, ptCurveOut);
|
|
double dOutDist = ptOnCurveOut.distanceTo(ptCurveOut);
|
|
|
|
pLine->getClosestPointTo(ptOnCurve, ptCurve);
|
|
|
|
double dDistOff(.0);
|
|
AcDbLine* pLineOff(NULL);
|
|
if (dOutDist < 1e-6)
|
|
{
|
|
dDistOff = .0;
|
|
}
|
|
else
|
|
{
|
|
dDistOff = getDistByOffCurve(pLine, dOutDist, ptOnCurveOut, dEquW * .5);
|
|
}
|
|
pLineOff = (AcDbLine*)makeOffsetCurveByDir(pLine, dDistOff);
|
|
if (!pLineOff)
|
|
{
|
|
DELETE_PTR(pCurveClone);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptInsert, ptProtect;
|
|
pLineOff->getClosestPointTo(ptCurve, ptInsert);
|
|
|
|
ptInsert -= vt * (dEquL * nNum * .5);
|
|
ptProtect = ptInsert + vt * dEquL * .5;
|
|
for (int i(0); i < nNum; ++i)
|
|
{
|
|
ptAr.append(ptInsert);
|
|
ptProtectAr.append(ptProtect);
|
|
vtAr.append(vt);
|
|
|
|
ptInsert += vt * dEquL;
|
|
ptProtect += vt * dEquL;
|
|
}
|
|
|
|
DELETE_PTR(pLineOff);
|
|
}
|
|
if (pArc)
|
|
{
|
|
AcGePoint3d ptS, ptE, ptC, pt;
|
|
pArc->getStartPoint(ptS);
|
|
pArc->getEndPoint(ptE);
|
|
ptC = pArc->center();
|
|
double dLenSE(.0);
|
|
pArc->getDistAtPoint(ptE, dLenSE);
|
|
|
|
AcGePoint3d ptCurveOut, ptCurve;
|
|
ptC = pArc->center();
|
|
|
|
pArc->getClosestPointTo(ptOnCurveOut, ptCurveOut);
|
|
double dOutDist = ptOnCurveOut.distanceTo(ptCurveOut);
|
|
|
|
pArc->getClosestPointTo(ptOnCurve, ptCurve);
|
|
|
|
double dDistOff(.0);
|
|
AcDbArc* pArcOff(NULL);
|
|
if (dOutDist < 1e-6)
|
|
{
|
|
dDistOff = .0;
|
|
}
|
|
else
|
|
{
|
|
dDistOff = getDistByOffCurve(pArc, dOutDist, ptOnCurveOut, dEquW * .5);
|
|
}
|
|
pArcOff = (AcDbArc*)makeOffsetCurveByDir(pArc, dDistOff);
|
|
if (!pArcOff)
|
|
{
|
|
DELETE_PTR(pCurveClone);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptInsert, ptProtect;
|
|
pArcOff->getClosestPointTo(ptCurve, ptInsert);
|
|
|
|
AcGeVector3d vt = (ptC - ptCurve).normalize();
|
|
AcGeVector3d vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
ptInsert -= vtDir * (dEquL * nNum * .5);
|
|
ptProtect = ptInsert + vtDir * dEquL * .5;
|
|
|
|
for (int i(0); i < nNum; ++i)
|
|
{
|
|
ptAr.append(ptInsert);
|
|
ptProtectAr.append(ptProtect);
|
|
vtAr.append(vtDir);
|
|
|
|
ptInsert += vtDir * dEquL;
|
|
ptProtect += vtDir * dEquL;
|
|
}
|
|
|
|
DELETE_PTR(pArcOff);
|
|
}
|
|
if (pCir)
|
|
{
|
|
}
|
|
|
|
DELETE_PTR(pCurveClone);
|
|
|
|
creatExtEqu(pEqu, pszBlkPath, ptBox, ptAr, ptProtectAr, vtAr, dScale, bDrawBox, dBoxL, dBoxW, bShowProtectR, dProtectR);
|
|
|
|
return;
|
|
}
|
|
|
|
void creatXHS(const AcDbCurve* pCurve
|
|
, const AcGePoint3d& ptOnCurveOut
|
|
, const AcGePoint3d& ptOnCurve
|
|
, LPCTSTR pszBlkPath
|
|
, const BOOL& bType
|
|
, const double& dL
|
|
, const double& dW
|
|
, const double& dProtectR
|
|
, const double& dEquOffDist)
|
|
{
|
|
if (!pCurve)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin);
|
|
|
|
AcDbCurve* pCurveClone = (AcDbCurve*)pCurve->clone();
|
|
if (!pCurveClone)
|
|
{
|
|
return;
|
|
}
|
|
AcDbLine* pLine = AcDbLine::cast(pCurveClone);
|
|
AcDbArc* pArc = AcDbArc::cast(pCurveClone);
|
|
AcDbCircle* pCir = AcDbCircle::cast(pCurveClone);
|
|
if (!pLine && !pArc && !pCir)
|
|
{
|
|
acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
|
|
DELETE_PTR(pCurveClone);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3dArray ptAr;
|
|
AcGeVector3dArray vtAr;
|
|
ptAr.removeAll();
|
|
vtAr.removeAll();
|
|
|
|
if (pLine)
|
|
{
|
|
AcGePoint3d ptS, ptE, ptEqu, ptCurveOut, ptCurve;
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
AcGeVector3d vt = (ptS - ptE).normalize();
|
|
AcGeVector3d vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
pLine->getClosestPointTo(ptOnCurveOut, ptCurveOut);
|
|
double dOutDist = ptOnCurveOut.distanceTo(ptCurveOut);
|
|
|
|
pLine->getClosestPointTo(ptOnCurve, ptCurve);
|
|
|
|
if (dOutDist < 1e-6)
|
|
{
|
|
ptEqu = ptCurve;
|
|
}
|
|
else
|
|
{
|
|
double dOffDist = getDistByOffCurve(pLine, dOutDist, ptOnCurveOut, dEquOffDist);
|
|
|
|
ptEqu = ptCurve - vtDir * dOffDist;
|
|
}
|
|
|
|
ptAr.append(ptEqu);
|
|
vtAr.append(vt);
|
|
|
|
}
|
|
if (pArc)
|
|
{
|
|
AcGePoint3d ptC, ptEqu, ptCurveOut, ptCurve;
|
|
ptC = pArc->center();
|
|
|
|
pArc->getClosestPointTo(ptOnCurveOut, ptCurveOut);
|
|
double dOutDist = ptOnCurveOut.distanceTo(ptCurveOut);
|
|
|
|
pArc->getClosestPointTo(ptOnCurve, ptCurve);
|
|
|
|
AcGeVector3d vt = (ptOnCurve - ptC).normalize();
|
|
AcGeVector3d vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
if (dOutDist < 1e-6)
|
|
{
|
|
ptEqu = ptCurve;
|
|
}
|
|
else
|
|
{
|
|
double dOffDist = getDistByOffCurve(pArc, dOutDist, ptOnCurveOut, dEquOffDist);
|
|
|
|
ptEqu = ptCurve + vt * dOffDist;
|
|
}
|
|
|
|
ptAr.append(ptEqu);
|
|
vtAr.append(vtDir);
|
|
}
|
|
if (pCir)
|
|
{
|
|
AcGePoint3d ptC, ptEqu, ptCurveOut, ptCurve;
|
|
ptC = pCir->center();
|
|
|
|
pCir->getClosestPointTo(ptOnCurveOut, ptCurveOut);
|
|
double dOutDist = ptOnCurveOut.distanceTo(ptCurveOut);
|
|
|
|
pCir->getClosestPointTo(ptOnCurve, ptCurve);
|
|
|
|
AcGeVector3d vt = (ptOnCurve - ptC).normalize();
|
|
AcGeVector3d vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
if (dOutDist < 1e-6)
|
|
{
|
|
ptEqu = ptCurve;
|
|
}
|
|
else
|
|
{
|
|
double dOffDist = getDistByOffCurve(pCir, dOutDist, ptOnCurveOut, dEquOffDist);
|
|
|
|
ptEqu = ptCurve + vt * dOffDist;
|
|
}
|
|
|
|
ptAr.append(ptEqu);
|
|
vtAr.append(vtDir);
|
|
}
|
|
|
|
creatXHSEqu(ptAr, vtAr, pszBlkPath, bType, dL, dW, dProtectR);
|
|
|
|
DELETE_PTR(pCurveClone);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
#define DXF_PIPE_ONLY _T("AEC_EWPIPE")
|
|
|
|
void CR_SCGXCmdFnc()
|
|
{
|
|
}
|
|
|
|
//默认给排水设置
|
|
void WD_CSSZCmdFnc()
|
|
{
|
|
AecDbObjXDataMap xDataMap;
|
|
|
|
//读取上次
|
|
KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap);
|
|
|
|
//设置成给排水要求
|
|
{
|
|
xDataMap.SetAt(DOC_TRADE, WPipe::eCivial); //市政
|
|
xDataMap.SetAt(DOC_SCALE, _T("1:100")); //出图比例
|
|
xDataMap.SetAt(DOC_PLOTWIDTH, 0.5); //最小打印线宽
|
|
xDataMap.SetAt(DOC_DPLOTWIDTH, 0.0); //双线打印线宽
|
|
|
|
xDataMap.SetAt(DOC_WELDDIA, 0.0); //焊点直径
|
|
xDataMap.SetAt(DOC_PIPEMINDIA, 1.0); //最小管道直径
|
|
xDataMap.SetAt(DOC_PIPEMAXDIA, 1000.0); //管子最小双线直径
|
|
xDataMap.SetAt(DOC_PERELBOWDIA,100.0); //直角弯头直径
|
|
|
|
xDataMap.SetAt(DOC_BREAKSPACE, 2.0); //交叉断线间距
|
|
xDataMap.SetAt(DOC_UNIT, 0); //单位
|
|
xDataMap.SetAt(DOC_DIMTERM, 0); //标注端符
|
|
|
|
xDataMap.SetAt(DOC_DIMTXTH, 2.0); //标注文字高度
|
|
xDataMap.SetAt(DOC_DIMTXTF, 0.7); //标注文字宽度系数
|
|
|
|
xDataMap.SetAt(DOC_EQPTXTH, 2.0); //设备标注文字高度
|
|
xDataMap.SetAt(DOC_EQPTXTF, 1.0); //设备标注文字宽度系数
|
|
|
|
xDataMap.SetAt(DOC_STRTXTH, 2.0); //结构标注文字高度
|
|
xDataMap.SetAt(DOC_STRTXTF, 0.7); //结构标注文字宽度系数
|
|
|
|
//公称直径-系统
|
|
xDataMap.SetAt(DOC_SCRIPTT, _T("{0}{-}{12}"));//上标脚本
|
|
|
|
//标高
|
|
xDataMap.SetAt(DOC_SCRIPTB, _T("{5}")); //下标脚本
|
|
|
|
xDataMap.SetAt(DOC_ELTYPE, 0); //标高设置
|
|
xDataMap.SetAt(DOC_ELDESCR, _T("--")); //标高文本
|
|
|
|
// pid
|
|
xDataMap.SetAt(DOC_PIDMPIPE1W, 1.0); //主管道线宽
|
|
xDataMap.SetAt(DOC_PIDSPIPE1W, 0.25); //次管道线宽
|
|
xDataMap.SetAt(DOC_PIDINSRDN, 12); //仪表泡直径
|
|
|
|
xDataMap.SetAt(DOC_CONSIGN, 30.0); //续接符号
|
|
xDataMap.SetAt(DOC_EQUSCALE, 6.0); //设备比例
|
|
xDataMap.SetAt(DOC_LINEARSCALE, 10.0); //线性比例
|
|
xDataMap.SetAt(DOC_VALVESCALE, 100.0); //阀门比例
|
|
xDataMap.SetAt(DOC_NODESCALE, 6.0); //管嘴比例
|
|
|
|
xDataMap.SetAt(DOC_PIDBARROW, 6.0); //大箭头
|
|
xDataMap.SetAt(DOC_PIDMARROW, 3.0); //中箭头
|
|
xDataMap.SetAt(DOC_PIDSARROW, 1.5); //小箭头
|
|
|
|
xDataMap.SetAt(DOC_PIDEWITHDIM, TRUE); //设备插入标注
|
|
xDataMap.SetAt(DOC_PIDVWITHDIM, TRUE); //阀门插入标注
|
|
xDataMap.SetAt(DOC_PIDBRKSTYLE, 1); //管线打断样式，0-断开 1-绕过
|
|
xDataMap.SetAt(PID_PIPE_DPRESS,1.0); //设计压力
|
|
}
|
|
|
|
//默认写入本次
|
|
KTModelLayoutXData::WriteModelXData(KT_PIPEINIT,xDataMap);
|
|
}
|
|
|
|
//绘制管线
|
|
void WD_HZGXCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_DHGD "));
|
|
}
|
|
|
|
//引出管线
|
|
void WD_YCGXCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_YCGX "));
|
|
}
|
|
|
|
//管径变更
|
|
void WD_GJBGCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_GJBG "));
|
|
}
|
|
|
|
//管线套管
|
|
void WD_GXTGCmdFnc()
|
|
{
|
|
//选择管线,弹出界面
|
|
}
|
|
|
|
//端加弯头
|
|
void WD_DJWTCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_DJWT "));
|
|
}
|
|
|
|
//弯头连管
|
|
void WD_WTLGCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_WTLG1 "));
|
|
}
|
|
|
|
//管线连接
|
|
void WD_GXLJCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_WTLG1 "));
|
|
}
|
|
|
|
//管线变径
|
|
void WD_GXBJCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_GXBJ "));
|
|
}
|
|
|
|
//三通连接
|
|
void WD_STLJCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_TJST1 "));
|
|
}
|
|
|
|
//添加三通
|
|
void WD_DJSTCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_DJST "));
|
|
}
|
|
|
|
//添加四通
|
|
void WD_TJSTCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_TJST2 "));
|
|
}
|
|
|
|
//添加堵头
|
|
void WD_TJDTCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_TJDT "));
|
|
}
|
|
|
|
//插入法兰
|
|
void WD_CRFLCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_CRFL "));
|
|
}
|
|
|
|
//插对法兰
|
|
void WD_CDFLCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_CDFL "));
|
|
}
|
|
|
|
//遮挡断开
|
|
void WD_ZDDKCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_wBreak "));
|
|
}
|
|
|
|
//去除断开
|
|
void WD_QCDKCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_wDelbrk "));
|
|
}
|
|
|
|
//管端断管
|
|
void WD_GDDGCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_wBreakt "));
|
|
}
|
|
|
|
//管线虚段
|
|
void WD_GXXDCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_GXXD "));
|
|
}
|
|
|
|
//去除虚段
|
|
void WD_QCXDCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_QCXD "));
|
|
}
|
|
|
|
//合并管线
|
|
void WD_HBGXCmdFnc()
|
|
{
|
|
acedPostCommand(_T("PL_wmerge "));
|
|
}
|
|
|
|
//放置水箱
|
|
void WD_FZSXCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//放置水泵
|
|
void WD_FZSBCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//放置洁具
|
|
void WD_FZJJCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//消火栓箱
|
|
void WD_XHSXCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CSXHDlg dlg;
|
|
if (dlg.DoModal() != IDOK) return;
|
|
|
|
CString str = dlg.m_sListBoxValue;
|
|
std::vector<CString> vec;
|
|
vec.clear();
|
|
CoreTools::SplitString(str, _T('*'), vec);
|
|
if (vec.size() < 1) return;
|
|
|
|
double dL = TypeConvert::s2d(vec[0]);
|
|
double dW = TypeConvert::s2d(vec[1]);
|
|
|
|
double dProtectR = dlg.m_dProtectR * 1000;
|
|
double dXHSDist = dlg.m_dDist * 1000;
|
|
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin);
|
|
|
|
if (dlg.m_iLayout == 0)
|
|
{
|
|
ads_name ent;
|
|
ads_point adsPt;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL,LINE,ARC"), 0);
|
|
int nRes = CKTCadUtility::SelectEntity(_T("\n请选择墙体, 直线, 弧线:"), ent, pRb, adsPt);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ads_point adsPt1;
|
|
nRes = acedGetPoint(adsPt, _T("\n请选择方向:"), adsPt1);
|
|
if (nRes != RTNORM) return;
|
|
AcGePoint3d pt, pt1;
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt), pt);
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt1), pt1);
|
|
|
|
AcDbObjectId idWall;
|
|
Acad::ErrorStatus es = acdbGetObjectId(idWall, ent);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbEntityPointer entPtr(idWall, AcDb::kForRead);
|
|
if (entPtr.openStatus() != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AecDbXWall* pWall = AecDbXWall::cast(entPtr);
|
|
AcDbLine* pLine = AcDbLine::cast(entPtr);
|
|
AcDbArc* pArc = AcDbArc::cast(entPtr);
|
|
if (!pWall && !pLine && !pArc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (pWall)
|
|
{
|
|
WallData data;
|
|
memset(&data, 0, sizeof(WallData));
|
|
pWall->GetWallData(data);
|
|
|
|
AcDbCurve* pCurve = pWall->GetBaseCurve();
|
|
if (!pCurve)
|
|
{
|
|
return;
|
|
}
|
|
|
|
creatXHS(pCurve, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, (data.dThick + dW) * .5 + dlg.m_dWallDist);
|
|
|
|
DELETE_PTR(pCurve);
|
|
}
|
|
if (pLine)
|
|
{
|
|
creatXHS(pLine, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, dW * .5);
|
|
}
|
|
if (pArc)
|
|
{
|
|
creatXHS(pArc, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, dW * .5);
|
|
}
|
|
}
|
|
else if (dlg.m_iLayout == 1)
|
|
{
|
|
ads_point adsPt, adsPt1;
|
|
if (acedGetPoint(NULL, _T("\n请选择插入点:"), adsPt) != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
int nRes = acedGetPoint(adsPt, _T("\n请选择方向:"), adsPt1);
|
|
if (nRes != RTNORM) return;
|
|
|
|
AcGePoint3d pt, pt1;
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt), pt);
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt1), pt1);
|
|
|
|
AcGeVector3d vt = (pt - pt1).normalize();
|
|
AcGeVector3d vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
AcGePoint3dArray ptAr;
|
|
AcGeVector3dArray vtAr;
|
|
ptAr.removeAll();
|
|
vtAr.removeAll();
|
|
|
|
ptAr.append(pt);
|
|
vtAr.append(vt);
|
|
|
|
creatXHSEqu(ptAr, vtAr, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR);
|
|
}
|
|
else
|
|
{
|
|
ads_name ent;
|
|
ads_point adsPt;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL,LINE,ARC"), 0);
|
|
int nRes = CKTCadUtility::SelectEntity(_T("\n请选择墙体, 直线, 弧线:"), ent, pRb, adsPt);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ads_point adsPt1;
|
|
nRes = acedGetPoint(adsPt, _T("\n请选择方向:"), adsPt1);
|
|
if (nRes != RTNORM) return;
|
|
AcGePoint3d pt, pt1;
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt), pt);
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt1), pt1);
|
|
|
|
AcDbObjectId idWall;
|
|
Acad::ErrorStatus es = acdbGetObjectId(idWall, ent);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbEntityPointer entPtr(idWall, AcDb::kForRead);
|
|
if (entPtr.openStatus() != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AecDbXWall* pWall = AecDbXWall::cast(entPtr);
|
|
AcDbLine* pLine = AcDbLine::cast(entPtr);
|
|
AcDbArc* pArc = AcDbArc::cast(entPtr);
|
|
if (!pWall && !pLine && !pArc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (pWall)
|
|
{
|
|
WallData data;
|
|
memset(&data, 0, sizeof(WallData));
|
|
pWall->GetWallData(data);
|
|
|
|
AcDbCurve* pCurve = pWall->GetBaseCurve();
|
|
if (!pCurve)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbLine* pLineWall = AcDbLine::cast(pCurve);
|
|
AcDbArc* pArcWall = AcDbArc::cast(pCurve);
|
|
AcDbCircle* pCirWall = AcDbCircle::cast(pCurve);
|
|
if (!pLineWall && !pArcWall && !pCirWall)
|
|
{
|
|
acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
|
|
DELETE_PTR(pCurve);
|
|
return;
|
|
}
|
|
|
|
pCurve->getClosestPointTo(pt, pt);
|
|
|
|
double dPtDist(.0);
|
|
pCurve->getDistAtPoint(pt, dPtDist);
|
|
|
|
if (pLineWall)
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
pLineWall->getStartPoint(ptS);
|
|
pLineWall->getEndPoint(ptE);
|
|
double dLenSE(.0);
|
|
pLineWall->getDistAtPoint(ptE, dLenSE);
|
|
double dDist = dLenSE - dXHSDist;
|
|
|
|
if (dPtDist < dDist)
|
|
{
|
|
pLineWall->getPointAtDist(dPtDist + dXHSDist, pt);
|
|
}
|
|
else
|
|
{
|
|
pLineWall->getPointAtDist(dPtDist - dXHSDist, pt);
|
|
}
|
|
|
|
creatXHS(pLineWall, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, (data.dThick + dW) * .5 + dlg.m_dWallDist);
|
|
}
|
|
if (pArcWall)
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
pArcWall->getStartPoint(ptS);
|
|
pArcWall->getEndPoint(ptE);
|
|
double dLenSE(.0);
|
|
pArcWall->getDistAtPoint(ptE, dLenSE);
|
|
double dDist = dLenSE - dXHSDist;
|
|
|
|
if (dPtDist < dDist)
|
|
{
|
|
pArcWall->getPointAtDist(dPtDist + dXHSDist, pt);
|
|
}
|
|
else
|
|
{
|
|
pArcWall->getPointAtDist(dPtDist - dXHSDist, pt);
|
|
}
|
|
|
|
creatXHS(pArcWall, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, (data.dThick + dW) * .5 + dlg.m_dWallDist);
|
|
}
|
|
if (pCirWall)
|
|
{
|
|
pCirWall->getPointAtDist(dPtDist + dXHSDist, pt);
|
|
|
|
creatXHS(pCirWall, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, (data.dThick + dW) * .5 + dlg.m_dWallDist);
|
|
}
|
|
|
|
DELETE_PTR(pCurve);
|
|
}
|
|
if (pLine)
|
|
{
|
|
AcGePoint3d ptS, ptE, ptEqu;
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
AcGeVector3d vt = (ptS - ptE).normalize();
|
|
AcGeVector3d vtDir = vt;
|
|
vtDir.rotateBy(PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
double dLenSE(.0);
|
|
pLine->getDistAtPoint(ptE, dLenSE);
|
|
double dDist = dLenSE - dXHSDist;
|
|
|
|
pLine->getClosestPointTo(pt, pt);
|
|
|
|
double dPtDist(.0);
|
|
pLine->getDistAtPoint(pt, dPtDist);
|
|
|
|
if (dPtDist < dDist)
|
|
{
|
|
pLine->getPointAtDist(dPtDist + dXHSDist, pt);
|
|
}
|
|
else
|
|
{
|
|
pLine->getPointAtDist(dPtDist - dXHSDist, pt);
|
|
}
|
|
|
|
creatXHS(pLine, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, dW * .5);
|
|
}
|
|
if (pArc)
|
|
{
|
|
AcGePoint3d ptC, ptS, ptE;
|
|
ptC = pArc->center();
|
|
pArc->getStartPoint(ptS);
|
|
pArc->getEndPoint(ptE);
|
|
double dLenSE(.0);
|
|
pArc->getDistAtPoint(ptE, dLenSE);
|
|
double dDist = dLenSE - dXHSDist;
|
|
|
|
pArc->getClosestPointTo(pt, pt);
|
|
|
|
double dPtDist(.0);
|
|
pArc->getDistAtPoint(pt, dPtDist);
|
|
|
|
if (dPtDist < dDist)
|
|
{
|
|
pArc->getPointAtDist(dPtDist + dXHSDist, pt);
|
|
}
|
|
else
|
|
{
|
|
pArc->getPointAtDist(dPtDist - dXHSDist, pt);
|
|
}
|
|
|
|
creatXHS(pArc, pt1, pt, dlg.m_s2DSel, dlg.m_iType, dL, dW, dProtectR, dW * .5);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//布置喷头
|
|
void WD_PZPTCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//布雨水斗
|
|
void WD_BYSDCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//置灭火器
|
|
void WD_ZMHQCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CLayoutExtinguisher dlg;
|
|
if (dlg.DoModal() != IDOK) return;
|
|
|
|
AcGeVector3d X(AcGeVector3d::kXAxis), Y(AcGeVector3d::kYAxis), Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d pt0(AcGePoint3d::kOrigin);
|
|
|
|
double dExtProtectR = dlg.m_dExtProtectR * 1000;
|
|
|
|
AecDbEwEquipment* pEqu = dlg.getEquPtr();
|
|
if (!pEqu) return;
|
|
|
|
if (dlg.m_iLayout == 0)
|
|
{
|
|
ads_point adsPt;
|
|
int nRes = acedGetPoint(NULL, _T("\n请选择灭火器的插入点:"), adsPt);
|
|
if (nRes != RTNORM) return;
|
|
AcGePoint3d pt;
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt), pt);
|
|
|
|
AcDbExtents exts;
|
|
pEqu->getGeomExtents(exts);
|
|
double dL = exts.maxPoint().x - exts.minPoint().x;
|
|
double dW = exts.maxPoint().y - exts.minPoint().y;
|
|
|
|
AcGePoint3dArray ptAr, ptProtectAr;
|
|
AcGeVector3dArray vtAr;
|
|
ptAr.removeAll();
|
|
ptProtectAr.removeAll();
|
|
vtAr.removeAll();
|
|
|
|
AcGePoint3d ptInsert = pt + X * dlg.m_iExtCount * dL * -.5;
|
|
AcGePoint3d ptProtect = pt + X * (dlg.m_iExtCount * dL * -.5 + dL * .5);
|
|
|
|
for (int i(0); i < dlg.m_iExtCount; ++i)
|
|
{
|
|
ptAr.append(ptInsert);
|
|
ptProtectAr.append(ptProtect);
|
|
vtAr.append(X);
|
|
|
|
ptInsert += X * dL;
|
|
ptProtect += X * dL;
|
|
}
|
|
|
|
AcGePoint3d ptEquInsert;
|
|
AcGeVector3d vtEquInsert;
|
|
pEqu->GetInsert(ptEquInsert, vtEquInsert);
|
|
AcDbCircle* pCir1 = new AcDbCircle(ptEquInsert, AcGeVector3d::kZAxis, 50);
|
|
pCir1->setColorIndex(6);
|
|
CoreTools::AddToModelSpace(pCir1);
|
|
CoreTools::CloneAndAddToModelSpace(pEqu);
|
|
|
|
creatExtEqu(pEqu, dlg.m_s2DSel, pt, ptAr, ptProtectAr, vtAr, dlg.m_dExtScale, dlg.m_bDrawBox, dlg.m_dBoxL, dlg.m_dBoxW, dlg.m_bShowProtectR, dExtProtectR);
|
|
}
|
|
else
|
|
{
|
|
ads_name ent;
|
|
ads_point adsPt, adsPt1;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("LINE,ARC"), 0);
|
|
int nRes = CKTCadUtility::SelectEntity(_T("\n请选择直线, 弧线:"), ent, pRb, adsPt);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
DELETE_PTR(pEqu);
|
|
return;
|
|
}
|
|
nRes = acedGetPoint(adsPt, _T("\n请选择方向:"), adsPt1);
|
|
if (nRes != RTNORM)
|
|
{
|
|
DELETE_PTR(pEqu);
|
|
return;
|
|
}
|
|
AcGePoint3d pt, pt1;
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt), pt);
|
|
CoreTools::UCS2WCS(asPnt3d(adsPt1), pt1);
|
|
|
|
AcDbObjectId idWall;
|
|
Acad::ErrorStatus es = acdbGetObjectId(idWall, ent);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pEqu);
|
|
return;
|
|
}
|
|
|
|
AcDbEntityPointer entPtr(idWall, AcDb::kForRead);
|
|
if (entPtr.openStatus() != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pEqu);
|
|
return;
|
|
}
|
|
|
|
AcDbCurve* pCurve = AcDbCurve::cast(entPtr);
|
|
if (!pCurve)
|
|
{
|
|
DELETE_PTR(pEqu);
|
|
return;
|
|
}
|
|
|
|
creatExtinguish(pEqu, dlg.m_s2DSel, pCurve, pt1, pt, dlg.m_iExtCount, dlg.m_dExtScale, dlg.m_bDrawBox, dlg.m_dBoxL, dlg.m_dBoxW, dlg.m_bShowProtectR, dExtProtectR);
|
|
}
|
|
|
|
DELETE_PTR(pEqu);
|
|
|
|
return;
|
|
}
|
|
|
|
//排水附件
|
|
void WD_PSFJCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//给水附件
|
|
void WD_GSFJCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//消防附件
|
|
void WD_XFFJCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//设备连管
|
|
void WD_SBLGCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//设备占位
|
|
void WD_SBZWCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//设备设计
|
|
void WD_SBSJCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//设备族库
|
|
void WD_SBZKCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//室外管线
|
|
void WD_SWGXCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CSWGXDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
WPipe::PipeParam param;
|
|
memset(¶m, 0, sizeof(WPipe::PipeParam));
|
|
dlg.GetPipeParam(¶m);
|
|
|
|
AcPolylineJig jig;
|
|
jig.InitStatusRecsFor3dRoadAxisLine();
|
|
if (jig.DoIt())
|
|
{
|
|
AcDbObjectId id = jig.GetRoadAxisLineId();
|
|
|
|
AcDbEntity *pEnt = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
|
|
{
|
|
AecDb3dRoadAxisLine *pRoadAxLn = AecDb3dRoadAxisLine::cast(pEnt);
|
|
if (pRoadAxLn != NULL)
|
|
{
|
|
//TEST
|
|
//AecDb3dRoadAxisLine *pRoadAxLnCln2 = (AecDb3dRoadAxisLine *)pRoadAxLn->clone();
|
|
//pRoadAxLnCln2->setColorIndex(2);
|
|
//CoreTools::AddToModelSpace(pRoadAxLnCln2);
|
|
|
|
pRoadAxLn->SaveDandRatio(param.m_dD, param.m_dRRatio);
|
|
//pRoadAxLn->Create3dRoadAxisLine(param.m_dD, param.m_dRRatio);
|
|
|
|
AecDb3dRoadAxisLine *pRoadAxLnCln = (AecDb3dRoadAxisLine *)pRoadAxLn->clone();
|
|
if (pRoadAxLnCln != NULL)
|
|
{
|
|
AecDbEwFlexiblePipe *pFlexiblePipe = new AecDbEwFlexiblePipe;
|
|
pFlexiblePipe->SetBaseCurve(pRoadAxLnCln);
|
|
pFlexiblePipe->SetSection(param.m_dD, 0.0);
|
|
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(KEY_DRAWGRAD, 1);//坡度 0不显示 1显示
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(KEY_NAME, _T("管线"));
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(KEY_YS, param.szSys);
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(PIPE_D, param.m_dD);
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(PIPE_RATIO, param.m_dRRatio);
|
|
|
|
//其他参数设置,参考pipelinecmd
|
|
//...
|
|
|
|
//通过全局设置提取
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);//0单线 2双线
|
|
pFlexiblePipe->GetSpecialtyData()->SetAt(KEY_SINGLEW, 0);//单线宽度, 单线打印线宽
|
|
|
|
// 示例
|
|
AcDbObjectId idPipe = KTSetting::InitLayer(LAY_PIPE_SINGLE);
|
|
pFlexiblePipe->setLayer(idPipe);
|
|
|
|
CoreTools::AddToModelSpace(pFlexiblePipe);
|
|
}
|
|
}
|
|
|
|
//TEST
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//置检查井
|
|
void WD_ZJCJCmdFnc()
|
|
{
|
|
//
|
|
CAcModuleResourceOverride myResources;
|
|
CZJCJDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
//选择一点
|
|
|
|
}
|
|
}
|
|
|
|
//管线接井
|
|
void WD_GXJJCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//置消火栓
|
|
void WD_ZXHSCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//栓连管线
|
|
void WD_SLGXCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//双击井
|
|
DLLIMPEXP bool GetDoubleClickEnt(LPCTSTR pszCmd, AcDbObjectId &id);
|
|
void DBL_AEC_ASMBLWELL()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_ASMBLWELL"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbAssembleWell, pWell)
|
|
|
|
if (pWell != NULL)
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CSMLOBJDlg dlg;
|
|
|
|
CStringArray arLines;
|
|
pWell->GetScriptLines(arLines);
|
|
dlg.AddCodeLines(arLines);
|
|
dlg.SetXDataMap(pWell->GetSpecialtyData());
|
|
|
|
if (dlg.DoModal())
|
|
{
|
|
AecDbObjXDataMap::It it = dlg.m_xData.Begin();
|
|
AecDbObjXDataMap::It end = dlg.m_xData.End();
|
|
|
|
CString sKey;
|
|
AecXData xdata;
|
|
memset(&xdata, 0, sizeof(AecXData));
|
|
|
|
AecDbObjXDataMap* pMap = pWell->GetSpecialtyData();
|
|
|
|
for (; it != end; )
|
|
{
|
|
if (!dlg.m_xData.GetNext(it, sKey, xdata))
|
|
break;
|
|
pMap->SetAt(sKey, xdata);
|
|
}
|
|
}
|
|
}
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void WD_SKJS()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CHydrantCalcDlg dlg;
|
|
dlg.DoModal();
|
|
}
|
|
|
|
void WD_PLSZ()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CPenLinSetDlg dlg;
|
|
if (!dlg.DoModal() != IDOK) return;
|
|
|
|
}
|
|
|
|
|
|
|
|
//插入模型空间函数
|
|
void Insert_Model_Space(AcDbEntity* pEnt)
|
|
{
|
|
AcDbBlockTable* pBlkTbl = NULL;
|
|
Acad::ErrorStatus es;
|
|
AcDbDatabase* pDb = NULL;
|
|
pDb = acdbHostApplicationServices()->workingDatabase();
|
|
es = pDb->getBlockTable(pBlkTbl, AcDb::kForRead);
|
|
if (es != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n块表打开失败，错误代码：%s"), acadErrorStatusText(es));
|
|
return;
|
|
}
|
|
AcDbBlockTableRecord* pBlkTblRcd = NULL;
|
|
es = pBlkTbl->getAt(ACDB_MODEL_SPACE, pBlkTblRcd, AcDb::kForWrite);
|
|
if (es != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n模型空间块表记录打开失败，错误代码：%s"), acadErrorStatusText(es));
|
|
pBlkTbl->close();
|
|
return;
|
|
}
|
|
pBlkTbl->close();
|
|
AcDbObjectId outId;
|
|
es = pBlkTblRcd->appendAcDbEntity(outId, pEnt);
|
|
if (es != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n无法添加实体到模型空间，错误代码：%s"), acadErrorStatusText(es));
|
|
pBlkTblRcd->close();
|
|
return;
|
|
}
|
|
pEnt->close();
|
|
pBlkTblRcd->close();
|
|
|
|
}
|
|
|
|
// 任意布置
|
|
void WD_BZPT_RY()
|
|
{/*
|
|
AecDbObjXDataMap xDataMap;
|
|
if (!CPenLinSetDlg::getPLSZData(xDataMap))
|
|
{
|
|
acedAlert(_T("\n喷淋系统没有初始化!请运行\"喷淋设置\"命令!"));
|
|
acedPostCommand(_T("wd_plsz "));
|
|
return;
|
|
}
|
|
|
|
|
|
int iDN(0);
|
|
xDataMap.GetAt(CPenLinSetDlg::_WD_PLSZ_CONNECT_DN_, iDN);
|
|
*/
|
|
CAcModuleResourceOverride myResources;
|
|
CRYPTDlg dlg;
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
//装点数组
|
|
AcGePoint3dArray points_arr;
|
|
//统计点数
|
|
int ptnumber = 0;
|
|
while (TRUE)
|
|
{
|
|
ads_point pt1;
|
|
int rtn1 = acedGetPoint(NULL, _T("\n 请选取喷头插入点"), pt1);
|
|
if (rtn1 == RTNORM)
|
|
{
|
|
points_arr.append(asPnt3d(pt1));
|
|
ptnumber++;
|
|
}
|
|
|
|
else if(rtn1 != RTNORM)
|
|
|
|
{
|
|
//测试
|
|
for (int i = 0; i < ptnumber; i++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcDbCircle* pCir = new AcDbCircle(points_arr[i], vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// 矩形布置
|
|
void WD_BZPT_JX()
|
|
{/*
|
|
AecDbObjXDataMap xDataMap;
|
|
if (!CPenLinSetDlg::getPLSZData(xDataMap))
|
|
{
|
|
acedAlert(_T("\n喷淋系统没有初始化!请运行\"喷淋设置\"命令!"));
|
|
acedPostCommand(_T("wd_plsz "));
|
|
return;
|
|
}
|
|
*/
|
|
//对话框测试
|
|
CAcModuleResourceOverride myResources;
|
|
CJXPTDlg dlg;
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
int nRow, nColumn=0;
|
|
ads_point pt1, pt2;
|
|
int rtn1 = acedGetPoint(NULL, _T("\n 请指定起点"), pt1);
|
|
int rtn2 = acedGetPoint(NULL, _T("\n 请指定对角点"), pt2);
|
|
if (rtn1 != RTNORM || rtn2 != RTNORM)
|
|
{
|
|
acutPrintf(_T("\n获取起点或者对角点失败"));
|
|
return;
|
|
}
|
|
//根据对角点找出四个角的顶点
|
|
ads_real x1 = pt1[X];
|
|
ads_real x2 = pt2[X];
|
|
ads_real y1 = pt1[Y];
|
|
ads_real y2 = pt2[Y];
|
|
//得到矩形的四个角
|
|
AcGePoint2d ptLeftBottom(min(x1, x2), min(y1, y2));
|
|
AcGePoint2d ptRightBottom(max(x1, x2), min(y1, y2));
|
|
AcGePoint2d ptRightTop(max(x1, x2), max(y1, y2));
|
|
AcGePoint2d ptLeftTop(min(x1, x2), max(y1, y2));
|
|
ads_real nRow_Dist = (ptRightTop[X] - ptLeftTop[X]);
|
|
ads_real nColumn_Dist = (ptRightTop[Y] - ptRightBottom[Y]);
|
|
//行列已知
|
|
AcArray<AcGePoint2dArray> arrs_Row;
|
|
AcArray<AcGePoint2dArray> arrs_Column;
|
|
if (dlg.m_ihlyz == 0)
|
|
{
|
|
nRow = dlg.m_iRow;
|
|
nColumn = dlg.m_iColumn;
|
|
//将行列已知的点均匀分布在矩形中
|
|
nRow_Dist = (ptRightTop[X] - ptLeftTop[X]) / nColumn;
|
|
nColumn_Dist = (ptRightTop[Y] - ptRightBottom[Y]) / nRow;
|
|
//将点按行放进数组
|
|
for (int j = 0; j < nRow; j++)
|
|
{
|
|
//ptFist为左上角第一点
|
|
AcGePoint2d ptFist(ptLeftTop[X] + 0.5 * nRow_Dist, ptLeftTop[Y] - 0.5 * nColumn_Dist - j * nColumn_Dist);
|
|
AcGePoint2dArray points_Row;
|
|
for (int i = 0; i < nColumn; i++)
|
|
{
|
|
AcGePoint2d pt_temp(ptFist[X] + i * nRow_Dist, ptFist[Y]);
|
|
points_Row.append(pt_temp);
|
|
}
|
|
arrs_Row.append(points_Row);
|
|
}
|
|
//将点按列放进数组
|
|
for (int j = 0; j < nColumn; j++)
|
|
{
|
|
AcGePoint2d ptFist(ptLeftTop[X] + 0.5 * nRow_Dist+j* nRow_Dist, ptLeftTop[Y] - 0.5 * nColumn_Dist );
|
|
AcGePoint2dArray points_Column;
|
|
for (int i = 0; i < nRow; i++)
|
|
{
|
|
AcGePoint2d pt_temp(ptFist[X] , ptFist[Y]-i* nColumn_Dist);
|
|
points_Column.append(pt_temp);
|
|
}
|
|
arrs_Column.append(points_Column);
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************************************************/
|
|
//测试
|
|
if (dlg.m_iJGWay == 0)
|
|
{
|
|
for (int i = 0; i < nRow; i++)
|
|
{
|
|
for (int j = 0; j < nColumn; j++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcGePoint3d temp(arrs_Row[i][j][X], arrs_Row[i][j][Y], 0);
|
|
AcDbCircle* pCir = new AcDbCircle(temp, vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < nRow; i++)
|
|
{
|
|
AcGePoint2dArray points = arrs_Row[i];
|
|
int numVerts = points.length();
|
|
AcDbPolyline* pPline = new AcDbPolyline(numVerts);
|
|
for (int i = 0; i < points.length(); i++)
|
|
{
|
|
pPline->addVertexAt(i, points.at(i));
|
|
}
|
|
pPline->setClosed(true);
|
|
Insert_Model_Space(pPline);
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < nColumn; i++)
|
|
{
|
|
for (int j = 0; j < nRow; j++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcGePoint3d temp(arrs_Column[i][j][X], arrs_Column[i][j][Y], 0);
|
|
AcDbCircle* pCir = new AcDbCircle(temp, vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < nColumn; i++)
|
|
{
|
|
AcGePoint2dArray points = arrs_Column[i];
|
|
int numVerts = points.length();
|
|
AcDbPolyline* pPline = new AcDbPolyline(numVerts);
|
|
for (int i = 0; i < points.length(); i++)
|
|
{
|
|
pPline->addVertexAt(i, points.at(i));
|
|
}
|
|
pPline->setClosed(true);
|
|
Insert_Model_Space(pPline);
|
|
}
|
|
|
|
}
|
|
/**********************************************************************************************************************************/
|
|
|
|
|
|
}
|
|
//行列未知
|
|
else
|
|
{
|
|
//确定好需要的行列数
|
|
nRow = (nColumn_Dist / dlg.m_dMaxColumnDistance)+1;
|
|
nColumn = (nRow_Dist / dlg.m_dMaxRowDistance)+1;
|
|
//确定好左上角第一点
|
|
double Row_Dist_Temp = 0.5 * ( nRow_Dist- (nColumn - 1)* dlg.m_dMaxRowDistance);
|
|
double Column_Dist_Temp = 0.5 * ( nColumn_Dist- (nRow - 1) * dlg.m_dMaxColumnDistance);
|
|
//将点按行放进数组
|
|
for (int j = 0; j < nRow; j++)
|
|
{
|
|
//ptFist为左上角第一点
|
|
AcGePoint2d ptFist(ptLeftTop[X] + Row_Dist_Temp, ptLeftTop[Y] - Column_Dist_Temp - j * dlg.m_dMaxColumnDistance);
|
|
AcGePoint2dArray points_Row;
|
|
for (int i = 0; i < nColumn; i++)
|
|
{
|
|
AcGePoint2d pt_temp(ptFist[X] + i * dlg.m_dMaxRowDistance, ptFist[Y]);
|
|
points_Row.append(pt_temp);
|
|
}
|
|
arrs_Row.append(points_Row);
|
|
}
|
|
//将点按列放进数组
|
|
for (int j = 0; j < nColumn; j++)
|
|
{
|
|
AcGePoint2d ptFist(ptLeftTop[X] + Row_Dist_Temp + j * dlg.m_dMaxRowDistance, ptLeftTop[Y] - Column_Dist_Temp);
|
|
AcGePoint2dArray points_Column;
|
|
for (int i = 0; i < nRow; i++)
|
|
{
|
|
AcGePoint2d pt_temp(ptFist[X], ptFist[Y] - i * dlg.m_dMaxColumnDistance);
|
|
points_Column.append(pt_temp);
|
|
}
|
|
arrs_Column.append(points_Column);
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************************************************/
|
|
//测试
|
|
if (dlg.m_iJGWay == 0)
|
|
{
|
|
for (int i = 0; i < nRow; i++)
|
|
{
|
|
for (int j = 0; j < nColumn; j++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcGePoint3d temp(arrs_Row[i][j][X], arrs_Row[i][j][Y], 0);
|
|
AcDbCircle* pCir = new AcDbCircle(temp, vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < nRow; i++)
|
|
{
|
|
AcGePoint2dArray points = arrs_Row[i];
|
|
int numVerts = points.length();
|
|
AcDbPolyline* pPline = new AcDbPolyline(numVerts);
|
|
for (int i = 0; i < points.length(); i++)
|
|
{
|
|
pPline->addVertexAt(i, points.at(i));
|
|
}
|
|
pPline->setClosed(true);
|
|
Insert_Model_Space(pPline);
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < nColumn; i++)
|
|
{
|
|
for (int j = 0; j < nRow; j++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcGePoint3d temp(arrs_Column[i][j][X], arrs_Column[i][j][Y], 0);
|
|
AcDbCircle* pCir = new AcDbCircle(temp, vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < nColumn; i++)
|
|
{
|
|
AcGePoint2dArray points = arrs_Column[i];
|
|
int numVerts = points.length();
|
|
AcDbPolyline* pPline = new AcDbPolyline(numVerts);
|
|
for (int i = 0; i < points.length(); i++)
|
|
{
|
|
pPline->addVertexAt(i, points.at(i));
|
|
}
|
|
pPline->setClosed(true);
|
|
Insert_Model_Space(pPline);
|
|
}
|
|
|
|
}
|
|
/**********************************************************************************************************************************/
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// 直线布置
|
|
void WD_BZPT_ZX()
|
|
{/*
|
|
AecDbObjXDataMap xDataMap;
|
|
if (!CPenLinSetDlg::getPLSZData(xDataMap))
|
|
{
|
|
acedAlert(_T("\n喷淋系统没有初始化!请运行\"喷淋设置\"命令!"));
|
|
acedPostCommand(_T("wd_plsz "));
|
|
return;
|
|
}
|
|
*/
|
|
CAcModuleResourceOverride myResources;
|
|
CZXPTDlg dlg;
|
|
//dlg.DoModal();
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
double LineDist = 0;
|
|
ads_point pt1, pt2;
|
|
int rtn1 = acedGetPoint(NULL, _T("\n 请指定起点"), pt1);
|
|
int rtn2 = acedGetPoint(NULL, _T("\n 请指定终点"), pt2);
|
|
if (rtn1 != RTNORM || rtn2 != RTNORM)
|
|
{
|
|
acutPrintf(_T("\n获取起点或者终点失败"));
|
|
return;
|
|
}
|
|
AcDbLine* pLine = new AcDbLine(asPnt3d(pt1), asPnt3d(pt2));
|
|
//获取直线长度
|
|
pLine->getDistAtPoint(asPnt3d(pt2), LineDist);
|
|
AcGePoint3dArray points_arr;
|
|
//已知点之间距离不知数量
|
|
AcGePoint3d ptDist;
|
|
int ptNumber = (LineDist / dlg.m_dMaxPTDistance) + 1;
|
|
double DistTopt1 = (LineDist - (dlg.m_dMaxPTDistance) * (ptNumber - 1)) * 0.5;
|
|
for (int i = 0; i < ptNumber; i++)
|
|
{
|
|
es = pLine->getPointAtDist(DistTopt1 + (dlg.m_dMaxPTDistance * i), ptDist);
|
|
if (es != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n获取失败，错误代码：%s"), acadErrorStatusText(es));
|
|
return;
|
|
}
|
|
points_arr.append(ptDist);
|
|
|
|
}
|
|
//测试
|
|
for (int i = 0; i < ptNumber; i++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcDbCircle* pCir = new AcDbCircle(points_arr[i], vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
}
|
|
Insert_Model_Space(pLine);
|
|
|
|
|
|
|
|
|
|
|
|
//已知数量不知点的距离
|
|
|
|
|
|
}
|
|
}
|
|
|
|
// 弧线布置
|
|
void WD_BZPT_HX()
|
|
{/*
|
|
AecDbObjXDataMap xDataMap;
|
|
if (!CPenLinSetDlg::getPLSZData(xDataMap))
|
|
{
|
|
acedAlert(_T("\n喷淋系统没有初始化!请运行\"喷淋设置\"命令!"));
|
|
acedPostCommand(_T("wd_plsz "));
|
|
return;
|
|
}
|
|
*/
|
|
//测试
|
|
CAcModuleResourceOverride myResources;
|
|
CHXPTDlg dlg;
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
Acad::ErrorStatus es;
|
|
double CurveDist = 0;
|
|
ads_point pt1, pt2, pt3;
|
|
int rtn1 = acedGetPoint(NULL, _T("\n 请指定起点"), pt1);
|
|
int rtn2 = acedGetPoint(NULL, _T("\n 请指定终点"), pt2);
|
|
int rtn3 = acedGetPoint(NULL, _T("\n 请指定圆弧上的点"), pt3);
|
|
if (rtn1 != RTNORM || rtn2 != RTNORM|| rtn3!= RTNORM)
|
|
{
|
|
acutPrintf(_T("\n获取圆弧失败"));
|
|
return;
|
|
}
|
|
//创造圆弧
|
|
AcGeCircArc3d geArc(asPnt3d(pt1), asPnt3d(pt3), asPnt3d(pt2));
|
|
AcDbArc* pArc = CoreTools::geArc2DbArc(geArc);
|
|
//强制类型转化
|
|
AcDbCurve* pCure = AcDbCurve::cast(pArc);
|
|
//获得弧长
|
|
pCure->getDistAtPoint(asPnt3d(pt2), CurveDist);
|
|
AcGePoint3dArray points_arr;
|
|
AcGePoint3d ptDist;
|
|
if (dlg.m_iDistance == 0)
|
|
{
|
|
//距离已知
|
|
int ptNumber = (CurveDist / dlg.m_dDistanceEdit) + 1;
|
|
double DistTopt1 = (CurveDist - (dlg.m_dDistanceEdit) * (ptNumber - 1)) * 0.5;
|
|
for (int i = 0; i < ptNumber; i++)
|
|
{
|
|
es = pCure->getPointAtDist(DistTopt1 + (dlg.m_dDistanceEdit * i), ptDist);
|
|
if (es != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n获取失败，错误代码：%s"), acadErrorStatusText(es));
|
|
return;
|
|
}
|
|
points_arr.append(ptDist);
|
|
|
|
}
|
|
//测试代码
|
|
for (int i = 0; i < ptNumber; i++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcDbCircle* pCir = new AcDbCircle(points_arr[i], vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
}
|
|
Insert_Model_Space(pArc);
|
|
}
|
|
else
|
|
{
|
|
//数量已知
|
|
double CurveDistSeg = CurveDist / (dlg.m_dNumberEdit - 1);
|
|
for (int i = 0; i < dlg.m_dNumberEdit; i++)
|
|
{
|
|
es = pCure->getPointAtDist(CurveDistSeg * i, ptDist);
|
|
if (es != Acad::eOk)
|
|
{
|
|
acutPrintf(_T("\n获取失败，错误代码：%s"), acadErrorStatusText(es));
|
|
return;
|
|
}
|
|
points_arr.append(ptDist);
|
|
|
|
}
|
|
//测试代码
|
|
for (int i = 0; i < dlg.m_dNumberEdit; i++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcDbCircle* pCir = new AcDbCircle(points_arr[i], vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
|
|
}
|
|
Insert_Model_Space(pArc);
|
|
//测试代码结束
|
|
}
|
|
}
|
|
}
|
|
|
|
// 交点布置
|
|
void WD_BZPT_JD()
|
|
{
|
|
ads_point pt1,pt2;
|
|
ads_name ssName;
|
|
Adesk::Int32 len = 0;
|
|
int rtn1 = acedGetPoint(NULL, _T("\n 请选取起点"), pt1);
|
|
int rtn2 = acedGetPoint(NULL, _T("\n 请选取终点"), pt2);
|
|
acedSSGet(_T("W"),pt1, pt2, NULL, ssName);//参数W选择从点pt1到点pt2的窗口中的实体
|
|
acedSSLength(ssName, &len);
|
|
ads_name entName;
|
|
AcDbObjectId id;
|
|
AcDbEntity* pEnt = NULL;
|
|
//实体ID数组
|
|
AcDbObjectIdArray arrLines;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
if (acedSSName(ssName, i, entName) == RTNORM)
|
|
{
|
|
acdbGetObjectId(id, entName);
|
|
acdbOpenObject(pEnt, id, AcDb::OpenMode::kForRead);
|
|
if (pEnt->isKindOf(AcDbCurve::desc()))
|
|
{
|
|
arrLines.append(pEnt->objectId());
|
|
}
|
|
}
|
|
pEnt->close();
|
|
}
|
|
AcGePoint3dArray ptArr;
|
|
int temp = arrLines.length();
|
|
acdbTransactionManager->startTransaction();
|
|
for (int i = 0; i < arrLines.length() - 1; i++)
|
|
{
|
|
AcDbCurve* pLineA = NULL;
|
|
if (acdbTransactionManager->getObject((AcDbObject*&)pLineA, arrLines[i], AcDb::kForRead) == Acad::eOk);
|
|
{
|
|
for (int j = i + 1; j < arrLines.length(); j++)
|
|
{
|
|
AcDbCurve* pLineB = NULL;
|
|
if (acdbTransactionManager->getObject((AcDbObject*&)pLineB, arrLines[j], AcDb::kForRead) == Acad::eOk)
|
|
{
|
|
pLineA->intersectWith(pLineB, AcDb::kOnBothOperands, ptArr);
|
|
//画圆测试交点代码
|
|
for (int i = 0; i < ptArr.length(); i++)
|
|
{
|
|
AcGeVector3d vec(0, 0, 1);
|
|
AcDbCircle* pCir = new AcDbCircle(ptArr[i], vec, 50);
|
|
Insert_Model_Space(pCir);
|
|
}
|
|
//测试结束
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
acdbTransactionManager->endTransaction();
|
|
}
|