937 lines
25 KiB
C++
937 lines
25 KiB
C++
#include "StdAfx.h"
|
|
#include "SanitarySysForFeedWater.h"
|
|
#include "WallIdentify.h"
|
|
#include "NewSanitaryDefineDlg.h"
|
|
|
|
extern double GetEntDriection(const XPoint &ptStart, const XPoint &ptEnd);
|
|
extern int GetSanitaryDataSourceType(Entity ent);
|
|
extern bool GetLocSanitaryData(Entity ent, CSanitaryInfo &data, AcGePoint3d &ptFeed,
|
|
AcGePoint3d &ptHeatFeed, AcGePoint3d &ptDrain, AcGePoint3d &ptDir);
|
|
|
|
#define WALL_MAX_THICK (DocGetCurMeterUnitDraw() ? 1 : 1000) // 墙体最大厚度
|
|
SanitarySysForFeedWater::SanitarySysForFeedWater()
|
|
{
|
|
m_nId = 0;
|
|
BOOL bMeterUnit = DocGetCurMeterUnitDraw();
|
|
m_dDistPipe2Wall = (bMeterUnit ? 0.12 : 120);
|
|
m_dDistPipe2Pipe = (bMeterUnit ? 0.07 : 70);
|
|
m_dDistSearchWall = (bMeterUnit ? 1 : 1000);
|
|
m_tolVec.setEqualVector(0.001);
|
|
}
|
|
|
|
double SanitarySysForFeedWater::SetDistPipe2Wall(const double dDist)
|
|
{
|
|
BOOL bMeterUnit = DocGetCurMeterUnitDraw();
|
|
m_dDistPipe2Wall = (bMeterUnit ? dDist / 1000 : dDist);
|
|
return m_dDistPipe2Wall;
|
|
}
|
|
|
|
SanitarySysForFeedWater::~SanitarySysForFeedWater()
|
|
{
|
|
DeleteLine();
|
|
}
|
|
|
|
void SanitarySysForFeedWater::GetLinkedPipe( std::vector<AcDbLine*> &vecPipe )
|
|
{
|
|
std::vector<PipeData>::iterator it;
|
|
for (it = m_vecPipeData.begin(); it != m_vecPipeData.end(); it++)
|
|
{
|
|
if (it->drection == eParallelX || it->drection == eParallelY)
|
|
{
|
|
AcDbLine *pLine = it->pLine;
|
|
if (pLine == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
vecPipe.push_back(new AcDbLine(pLine->startPoint(), pLine->endPoint()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void SanitarySysForFeedWater::SetCollidePipe( const std::vector<AcDbLine*> &vecLine )
|
|
{
|
|
DeleteLine();
|
|
std::vector<AcDbLine*>::const_iterator it;
|
|
for (it = vecLine.begin(); it != vecLine.end(); it++)
|
|
{
|
|
m_vecCollidePipe.push_back(new AcDbLine((*it)->startPoint(), (*it)->endPoint()));
|
|
}
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::GetNearestWall( const AcGePoint3d &pt, const AcGeVector3d &vtDir, AcDbLine &line, double &dWallThick )
|
|
{
|
|
// 在XOY平面内与vtDir平行的墙体
|
|
AcGeVector3d vt = vtDir;
|
|
vt.z = 0.0;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> > vecWall;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it;
|
|
AcGeVector3d vtWall;
|
|
for (it = m_vecWallSide.begin(); it != m_vecWallSide.end(); it++)
|
|
{
|
|
if (it->first.GetCurveType() == CURVE_LINE)
|
|
{
|
|
vtWall = it->first.StartPoint() - it->first.EndPoint();
|
|
vtWall.z = 0.0;
|
|
if (vtWall.isParallelTo(vt, m_tolVec))
|
|
{
|
|
vecWall.push_back(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 找到距离pt最近的墙体
|
|
XCurveSegment segNear, segFar;
|
|
if (GetWallSide(pt, vecWall, segNear, segFar))
|
|
{
|
|
// 是否在规定范围内
|
|
AcDbLine lineNear(segNear.StartPoint(), segNear.EndPoint());
|
|
if (!IsInBound(pt, lineNear, WALL_MAX_THICK))
|
|
{
|
|
return false;
|
|
}
|
|
// 墙体厚度
|
|
AcGePoint3d ptS = segFar.StartPoint();
|
|
AcGePoint3d ptE = segFar.EndPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine lineTemp(ptS, ptE);
|
|
AcGePoint3d pt = segNear.StartPoint();
|
|
pt.z = 0.0;
|
|
AcGePoint3d ptPrj;
|
|
if (lineTemp.getClosestPointTo(pt, ptPrj, Adesk::kTrue) == Acad::eOk)
|
|
{
|
|
dWallThick = pt.distanceTo(ptPrj);
|
|
AcGeVector3d vt = pt - ptPrj;
|
|
vt.normalize();
|
|
line.setStartPoint(segFar.StartPoint() + vt * dWallThick * 0.5);
|
|
line.setEndPoint(segFar.EndPoint() + vt * dWallThick * 0.5);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::GetNearestWall( const AcGePoint3d &pt, double dDist, XCurveSegment &segNear, XCurveSegment &segFar )
|
|
{
|
|
// 找到距离pt最近的墙体
|
|
if (GetWallSide(pt, m_vecWallSide, segNear, segFar))
|
|
{
|
|
// 是否在规定范围内
|
|
AcDbLine lineNear(segNear.StartPoint(), segNear.EndPoint());
|
|
if (IsInBound(pt, lineNear, WALL_MAX_THICK))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
double SanitarySysForFeedWater::GetDistLines( const AcDbLine *pLine1, const AcDbLine *pLine2 )
|
|
{
|
|
ASSERT(pLine1 != NULL && pLine2 != NULL);
|
|
// 构造xoy平面上的直线
|
|
AcGePoint3d ptS = pLine1->startPoint();
|
|
AcGePoint3d ptE = pLine1->endPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine line1(ptS, ptE);
|
|
|
|
ptS = pLine2->startPoint();
|
|
ptE = pLine2->endPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine line2(ptS, ptE);
|
|
|
|
// 求两直线间的实际最短距离
|
|
ptS = line1.startPoint();
|
|
ptE = line1.endPoint();
|
|
AcGePoint3d ptSPrj, ptEPrj;
|
|
line2.getClosestPointTo(ptS, ptSPrj);
|
|
line2.getClosestPointTo(ptE, ptEPrj);
|
|
double dDist1 = ptS.distanceTo(ptSPrj);
|
|
double dDist2 = ptE.distanceTo(ptEPrj);
|
|
double dDist6 = 0.0;
|
|
dDist6 = dDist1 > dDist2 ? dDist2 : dDist1;
|
|
|
|
ptS = line2.startPoint();
|
|
ptE = line2.endPoint();
|
|
line1.getClosestPointTo(ptS, ptSPrj);
|
|
line1.getClosestPointTo(ptE, ptEPrj);
|
|
double dDist3 = ptS.distanceTo(ptSPrj);
|
|
double dDist4 = ptE.distanceTo(ptEPrj);
|
|
double dDist5 = 0.0;
|
|
dDist5 = dDist3 > dDist4 ? dDist4 : dDist3;
|
|
return (dDist5 > dDist6 ? dDist6 : dDist5);
|
|
}
|
|
|
|
void SanitarySysForFeedWater::CopyLine( const std::vector<AcDbLine*> &vecSrc, std::vector<AcDbLine*> &vecDes )
|
|
{
|
|
std::vector<AcDbLine*>::const_iterator it;
|
|
for (it = vecSrc.begin(); it != vecSrc.end(); it++)
|
|
{
|
|
AcDbLine *pLine = new AcDbLine((*it)->startPoint(), (*it)->endPoint());
|
|
vecDes.push_back(pLine);
|
|
}
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::IsCollidePipe( const AcDbLine *pLine, double dDist )
|
|
{
|
|
ASSERT(pLine != NULL);
|
|
AcGeVector3d vtDir = pLine->startPoint() - pLine->endPoint();
|
|
vtDir.z = 0.0;
|
|
|
|
std::vector<AcDbLine*>::iterator it;
|
|
AcGeVector3d vtTemp;
|
|
for(it = m_vecCollidePipe.begin(); it != m_vecCollidePipe.end(); it++)
|
|
{
|
|
vtTemp = (*it)->startPoint() - (*it)->endPoint();
|
|
vtTemp.z = 0.0;
|
|
if (vtTemp.isParallelTo(vtDir, m_tolVec))
|
|
{
|
|
double dDist = GetDistLines(pLine, *it);
|
|
if (dDist < m_dDistPipe2Pipe - 0.001)
|
|
{
|
|
// XLine line(asDblArray((*it)->startPoint()), asDblArray((*it)->endPoint()));
|
|
// line.Make();
|
|
// XCircle cir1(asDblArray((*it)->startPoint()), 50);
|
|
// cir1.Make();
|
|
// XCircle cir2(asDblArray((*it)->endPoint()), 50);
|
|
// cir2.Make();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::MovePipe( AcGePoint3d &pt, const AcDbLine &line, const AcGeVector3d &vtDir, double dDist )
|
|
{
|
|
double dZ = pt.z;
|
|
AcGePoint3d ptS = line.startPoint();
|
|
AcGePoint3d ptE = line.endPoint();
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
AcDbLine lineTemp(ptS, ptE);
|
|
AcGePoint3d ptPrj = pt;
|
|
pt.z = 0.0;
|
|
if (lineTemp.getClosestPointTo(pt, ptPrj, Adesk::kTrue) == Acad::eOk)
|
|
{
|
|
pt = ptPrj + vtDir * dDist;
|
|
}
|
|
pt.z = dZ;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::SetOtherSanitaryPoint( const std::vector<AcGePoint3d> &vecPt )
|
|
{
|
|
m_vecOtherSanitaryPoint = vecPt;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::IsPassOtherSanitarySysPt( const AcGePoint3d &ptS, const AcGePoint3d &ptE )
|
|
{
|
|
AcGePoint3d pt1 = ptS, pt2 = ptE;
|
|
pt1.z = 0.0;
|
|
pt2.z = 0.0;
|
|
AcDbLine line(pt1, pt2);
|
|
std::vector<AcGePoint3d>::iterator it;
|
|
AcGePoint3d ptPrj, pt;
|
|
for (it = m_vecOtherSanitaryPoint.begin(); it != m_vecOtherSanitaryPoint.end(); it++)
|
|
{
|
|
pt = *it;
|
|
pt.z = 0.0;
|
|
if (line.getClosestPointTo(pt, ptPrj) == Acad::eOk)
|
|
{
|
|
ptPrj.z = 0.0;
|
|
if (ptPrj.distanceTo(pt) < 0.001)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
extern bool GetSanitaryDriection(Entity ent, double &dSanitaryDriec);
|
|
bool SanitarySysForFeedWater::GetSanitaryDir( AcGeVector3d &vtDir, const AcDbObjectId &idSan )
|
|
{
|
|
bool bRet = false;
|
|
double dAngle = 0.0;
|
|
ads_name name;
|
|
acdbGetAdsName(name, idSan);
|
|
Entity ent(name);
|
|
if (GetSanitaryDriection(ent, dAngle)) // 定义了洁具方向
|
|
{
|
|
vtDir = AcGeVector3d::kXAxis;
|
|
vtDir.rotateBy(/*Ucs2Wcs*/(dAngle), AcGeVector3d::kZAxis);
|
|
bRet = true;
|
|
}
|
|
else // 没有定义洁具方向
|
|
{
|
|
// 洁具插入点
|
|
AcGePoint3d pt;
|
|
AcDbBlockReference *pRef = NULL;
|
|
Acad::ErrorStatus st = acdbOpenObject(pRef, idSan, AcDb::kForRead);
|
|
if (pRef != NULL)
|
|
{
|
|
pt = pRef->position();
|
|
pRef->close();
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
XCurveSegment segNaer, segFar;
|
|
if (GetNearestWall(pt, WALL_MAX_THICK, segNaer, segFar))
|
|
{
|
|
AcGePoint3d ptPrj;
|
|
GetPtProjectToWall(pt, segNaer, segFar, ptPrj);
|
|
vtDir = pt - ptPrj;
|
|
vtDir.z = 0.0;
|
|
vtDir.normalize();
|
|
bRet = true;
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::GetWallSide( Entity &entWall, std::vector<XCurveSegment> &vecSeg )
|
|
{
|
|
bool bRet = false;
|
|
if (entWall.Is(_T("LINE"))) // 老版墙线
|
|
{
|
|
OPENOBJ_BEGIN(entWall, AcDb::kForRead, AcDbLine, pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
XLine line(asDblArray(pLine->startPoint()), asDblArray(pLine->endPoint()));
|
|
XCurveSegment seg;
|
|
seg = line;
|
|
vecSeg.push_back(seg);
|
|
bRet = true;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
else
|
|
{
|
|
OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
XCurveSegment segL,segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
vecSeg.push_back(segL);
|
|
vecSeg.push_back(segR);
|
|
bRet = true;
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::IsConflicting( const AcGePoint3d &ptS, const AcGePoint3d &ptE, double dDist )
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(ptS, ptE);
|
|
if ((!PassParallelWall(ptS, ptE)) // 没有穿过平行墙体
|
|
&& (PassVertivalPipeNumByLine(ptS,ptE) == 0) // 没有穿过立管
|
|
&& !IsPassOtherSanitarySysPt(ptS, ptE) // 没有穿过其他系统洁具点
|
|
&& !IsCollidePipe(pLine, dDist)) // 没有与其他系统平行管线发生碰撞
|
|
{
|
|
delete pLine;
|
|
return false;
|
|
}
|
|
delete pLine;
|
|
return true;
|
|
}
|
|
|
|
extern bool GetSanitaryInfo(Entity ent, XPoint &ptRet, CString &csBlk, CString &csSysBlk, double &nRadius, double &nDang, double &nBigQ, double &dEle, int iType, CString &sDwbName, CString &sFeedElev, CString &sHotElev);
|
|
double SanitarySysForFeedWater::GetSanitaryPtEle( const AcDbObjectId &idSan )
|
|
{
|
|
double dPtFeedEle = 0.0;
|
|
ads_name name;
|
|
acdbGetAdsName(name, idSan);
|
|
XPoint ptFeed;
|
|
CString sTmp1, sTmp2, sDwbName, sFeedElev, sHotElev;
|
|
double dRadius = 0.0, dDang = 0.0, dRateQ = 0.0;
|
|
Entity ent = name;
|
|
|
|
// zxl 2012.12.11 modify 获取洁具数据源
|
|
int nDataSourceType = GetSanitaryDataSourceType(ent);
|
|
if (nDataSourceType == 1 || nDataSourceType == 0)
|
|
{
|
|
GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dPtFeedEle, 0, sDwbName, sFeedElev, sHotElev);
|
|
}
|
|
else
|
|
{
|
|
CSanitaryInfo sanInfo;
|
|
XPoint ptFeed, ptHeatFeed, ptDir, ptDrain;
|
|
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
|
|
dPtFeedEle = ptFeed.z;
|
|
}
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dPtFeedEle *= 1000;
|
|
}
|
|
return dPtFeedEle;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::IsSanitaryPtEleSamePipe( const AcDbObjectId &idSan )
|
|
{
|
|
double dPtFeedEle = 0.0;
|
|
dPtFeedEle = GetSanitaryPtEle(idSan);
|
|
double dRefVal = DocGetMeterUnitDraw() ? 1 : 1000;
|
|
if (fabs(dPtFeedEle + dRefVal) < 0.001)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int SanitarySysForFeedWater::GetID()
|
|
{
|
|
return m_nId++;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::DeleteLine()
|
|
{
|
|
std::vector<AcDbLine*>::iterator it;
|
|
for (it = m_vecCollidePipe.begin(); it != m_vecCollidePipe.end(); it++)
|
|
{
|
|
delete *it;
|
|
}
|
|
m_vecCollidePipe.clear();
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::GetWallSide( const AcGePoint3d &pt, const std::vector<std::pair<XCurveSegment, XCurveSegment> > &vecWall, XCurveSegment &segNear, XCurveSegment &segFar )
|
|
{
|
|
// 点距墙距离
|
|
std::multimap<double, std::pair<XCurveSegment, XCurveSegment> > mapWallDist;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::const_iterator it;
|
|
AcDbLine line;
|
|
AcGePoint3d ptS, ptE, ptPrj, pt1 = pt;
|
|
pt1.z = 0.0;
|
|
XCurveSegment segR, segL;
|
|
for (it = vecWall.begin(); it != vecWall.end(); it++)
|
|
{
|
|
segL = it->first;
|
|
segR = it->second;
|
|
segL.SetElevation(0.0);
|
|
segR.SetElevation(0.0);
|
|
// 求点到墙体的最近距离
|
|
line.setStartPoint(segL.StartPoint());
|
|
line.setEndPoint(segL.EndPoint());
|
|
line.getClosestPointTo(pt1, ptS);
|
|
|
|
line.setStartPoint(segR.StartPoint());
|
|
line.setEndPoint(segR.EndPoint());
|
|
line.getClosestPointTo(pt1, ptE);
|
|
|
|
double dDistL = pt1.distanceTo(ptS);
|
|
double dDistR = pt1.distanceTo(ptE);
|
|
if (dDistL < dDistR)
|
|
{
|
|
mapWallDist.insert(std::make_pair(dDistL, std::make_pair(segL, segR)));
|
|
}
|
|
else
|
|
{
|
|
mapWallDist.insert(std::make_pair(dDistR, std::make_pair(segR, segL)));
|
|
}
|
|
}
|
|
|
|
bool bRet = false;
|
|
// 最近的墙
|
|
if (!mapWallDist.empty())
|
|
{
|
|
std::multimap<double, std::pair<XCurveSegment, XCurveSegment> >::iterator itM;
|
|
itM = mapWallDist.begin();
|
|
segNear = (itM->second).first;
|
|
segFar = (itM->second).second;
|
|
bRet = true;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::GetWallSide( PickSet &ss, std::vector<std::pair<XCurveSegment, XCurveSegment> > &vecWall )
|
|
{
|
|
XCurveSegment segL, segR;
|
|
for (long i = 0; i < ss.Length(); i++)
|
|
{
|
|
OPENOBJ_BEGIN(ss[i], AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->GetCurveType() == CURVE_LINE)
|
|
{
|
|
pWall->GetSideCurve(segL, segR);
|
|
vecWall.push_back(std::make_pair(segL, segR));
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void SanitarySysForFeedWater::GetPtProjectToWall( const AcGePoint3d &pt, const XCurveSegment &segNear, const XCurveSegment &segFar, AcGePoint3d &ptPrj )
|
|
{
|
|
AcGePoint3d ptTemp = pt;
|
|
ptTemp.z = 0;
|
|
XPoint ptMid;
|
|
Midpoint(segNear.StartPoint(), segFar.StartPoint(), ptMid);
|
|
ptMid.z = 0.0;
|
|
AcGePoint3d ptS = ptMid;
|
|
Midpoint(segNear.EndPoint(), segFar.EndPoint(), ptMid);
|
|
ptMid.z = 0.0;
|
|
AcGePoint3d ptE = ptMid;
|
|
AcDbLine line(ptS, ptE);
|
|
if (line.getClosestPointTo(ptTemp, ptPrj) == Acad::eOk)
|
|
{
|
|
ptPrj.z = pt.z;
|
|
}
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::PassParallelWall( const AcGePoint3d &ptS, const AcGePoint3d &ptE )
|
|
{
|
|
// 得到与直线平行的墙体
|
|
AcGeVector3d vtDir = ptS - ptE;
|
|
vtDir.z = 0.0;
|
|
AcGeVector3d vtWall;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> > vecWall;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it;
|
|
for (it = m_vecWallSide.begin(); it != m_vecWallSide.end(); it++)
|
|
{
|
|
if (it->first.GetCurveType() == CURVE_LINE)
|
|
{
|
|
vtWall = it->first.StartPoint() - it->first.EndPoint();
|
|
vtWall.z = 0.0;
|
|
if (vtWall.isParallelTo(vtDir, m_tolVec))
|
|
{
|
|
vecWall.push_back(*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 检查直线是否在墙体内
|
|
XPoint pt1 = ptS, pt2 = ptE;
|
|
pt1.z = 0.0;
|
|
pt2.z = 0.0;
|
|
AcDbLine line(pt1, pt2);
|
|
if (PassParallelWall(vecWall, line))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::PassParallelWall( const std::vector<std::pair<XCurveSegment, XCurveSegment> > &vecWall, const AcDbLine &line )
|
|
{
|
|
// 直线与墙线构成的墙体是否有交集
|
|
XPoly2D poly;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::const_iterator it;
|
|
for (it = vecWall.begin(); it != vecWall.end(); it++)
|
|
{
|
|
if (GetWallOutLine(poly, it->first, it->second) && ExistIntersection(line, poly))
|
|
{
|
|
//poly.Make();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::GetWall( PickSet &ss, std::vector<std::pair<XCurveSegment, XCurveSegment> > &vecWall )
|
|
{
|
|
// 墙体边线
|
|
std::vector<XCurveSegment> vecSeg;
|
|
for (long i = 0; i < ss.Length(); i++)
|
|
{
|
|
Entity ent(ss[i]);
|
|
GetWallSide(ent, vecSeg);
|
|
}
|
|
|
|
DList<XCurveSegment> lstSeg;
|
|
std::vector<XCurveSegment>::iterator it;
|
|
for (it = vecSeg.begin(); it != vecSeg.end(); it++)
|
|
{
|
|
lstSeg.Append(new XCurveSegment(*it));
|
|
}
|
|
|
|
//上华3.0墙识别，将所有线两两匹配。
|
|
CWallIdentify wallIdentify;
|
|
wallIdentify.DoIdentify(lstSeg);
|
|
XCurveSegment seg1, seg2;
|
|
for (int nPos = wallIdentify.m_arpData.length() - 1; nPos >= 0; nPos--)
|
|
{
|
|
if(wallIdentify.m_arpData[nPos]->m_cSide1.isLinear() && wallIdentify.m_arpData[nPos]->m_cSide2.isLinear()) //直墙
|
|
{
|
|
XLine line1(XPoint(wallIdentify.m_arpData[nPos]->m_cSide1.startPoint()), XPoint(wallIdentify.m_arpData[nPos]->m_cSide1.endPoint()));
|
|
XLine line2(XPoint(wallIdentify.m_arpData[nPos]->m_cSide2.startPoint()), XPoint(wallIdentify.m_arpData[nPos]->m_cSide2.endPoint()));
|
|
seg1 = line1;
|
|
seg2 = line2;
|
|
vecWall.push_back(std::make_pair(seg1, seg2));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::GetWallOutLine( XPoly2D &poly, const XCurveSegment &seg1, const XCurveSegment &seg2 )
|
|
{
|
|
if (seg1.GetCurveType() != CURVE_LINE || seg2.GetCurveType() != CURVE_LINE)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
poly.Reset();
|
|
// 获取直线的端点
|
|
AcGePoint3d ptS1 = seg1.StartPoint(), ptE1 = seg1.EndPoint();
|
|
AcGePoint3d ptS2 = seg2.StartPoint(), ptE2 = seg2.EndPoint();
|
|
|
|
// 墙体两墙线需平行
|
|
AcGeVector3d vt1 = ptS1 - ptE1;
|
|
AcGeVector3d vt2 = ptS2 - ptE2;
|
|
if (vt1.isParallelTo(vt2, m_tolVec)) // 平行
|
|
{
|
|
poly.AppendNode(ptS1);
|
|
poly.AppendNode(ptE1);
|
|
if (vt1.isCodirectionalTo(vt2, m_tolVec)) // 同向
|
|
{
|
|
poly.AppendNode(ptE2);
|
|
poly.AppendNode(ptS2);
|
|
}
|
|
else // 异向
|
|
{
|
|
poly.AppendNode(ptS2);
|
|
poly.AppendNode(ptE2);
|
|
}
|
|
poly.SetClosed();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::ExistIntersection( const AcDbLine &line, const XPoly2D &poly )
|
|
{
|
|
XPoint pt = line.startPoint();
|
|
if (((pt & poly) == PR_EDGE)
|
|
|| ((pt & poly) == PR_INSIDE)) // 点在PLine线内或在线上
|
|
{
|
|
return true;
|
|
}
|
|
else // 判断直线与PLine是否相交
|
|
{
|
|
AcDbCurve *pCurve = poly.AsAcDbCurve();
|
|
if (pCurve != NULL)
|
|
{
|
|
AcGePoint3dArray arrPts;
|
|
pCurve->intersectWith(&line, AcDb::kOnBothOperands, arrPts);
|
|
delete pCurve;
|
|
if (arrPts.length() > 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::InitWallEnt()
|
|
{
|
|
// 搜集墙体
|
|
Entity ent;
|
|
PickSet ssWall(SS_FREE), ssWallLine(SS_FREE);
|
|
for(long i = 0; i < m_ssDoorWall.Length(); i++)
|
|
{
|
|
ent = m_ssDoorWall[i];
|
|
if (ent.Is(_T("TCH_Wall")))
|
|
{
|
|
ssWall += ent;
|
|
}
|
|
else if (ent.Is(_T("LINE")))
|
|
{
|
|
ssWallLine += ent;
|
|
}
|
|
}
|
|
|
|
m_vecWallSide.clear();
|
|
// 将墙线分组构成墙体
|
|
GetWall(ssWallLine, m_vecWallSide);
|
|
// 过滤掉无用墙体
|
|
FiltrateWall(m_vecWallSide);
|
|
// 将墙体拆分成墙线
|
|
GetWallSide(ssWall, m_vecWallSide);
|
|
}
|
|
|
|
void SanitarySysForFeedWater::DrawWall()
|
|
{
|
|
XPoly2D poly;
|
|
XLine line1, line2;
|
|
XCurveSegment seg1, seg2;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it;
|
|
for (it = m_vecWallSide.begin(); it < m_vecWallSide.end(); it++)
|
|
{
|
|
line1 = it->first;
|
|
line2 = it->second;
|
|
seg1 = line1;
|
|
seg2 = line2;
|
|
if (GetWallOutLine(poly, seg1, seg2))
|
|
{
|
|
poly.Make();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::IsInBound( const AcGePoint3d &pt, const AcDbLine &line, double dDist )
|
|
{
|
|
AcGePoint3d ptS = line.startPoint();
|
|
AcGePoint3d ptE = line.endPoint();
|
|
AcGePoint3d ptTemp = pt;
|
|
ptS.z = 0.0;
|
|
ptE.z = 0.0;
|
|
ptTemp.z = 0.0;
|
|
AcDbLine lineTemp(ptS, ptE);
|
|
AcGePoint3d ptPrj;
|
|
if (lineTemp.getClosestPointTo(ptTemp, ptPrj) == Acad::eOk)
|
|
{
|
|
double dLen = ptTemp.distanceTo(ptPrj);
|
|
if ( dLen < dDist + 0.001)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool SanitarySysForFeedWater::GetSanitaryOffsetDir(AcGeVector3d &vtDir, const AcGePoint3d &ptSan, const AcDbObjectId &idSan)
|
|
{
|
|
XPoint ptFeed, ptHotFeed;
|
|
CString csTmp1, csTmp2, sDwbName;
|
|
double nTmp(0), nDang(0), nBigQ(0), dEle(0), dAngle(0);
|
|
|
|
ads_name name;
|
|
acdbGetAdsName(name, idSan);
|
|
Entity ent = name;
|
|
CString sHotElev, sFeedElev;
|
|
// zxl 2012.12.11 modify 获取洁具数据源
|
|
int nDataSourceType = GetSanitaryDataSourceType(ent);
|
|
if (nDataSourceType == 1 || nDataSourceType == 0)
|
|
{
|
|
if (!GetSanitaryInfo(ent, ptFeed, csTmp1, csTmp2, nTmp, nDang, nBigQ, dEle,0, sDwbName, sFeedElev, sHotElev)
|
|
|| !GetSanitaryInfo(ent, ptHotFeed, csTmp1, csTmp2, nTmp, nDang, nBigQ, dEle,1, sDwbName, sFeedElev, sHotElev))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CSanitaryInfo sanInfo;
|
|
XPoint ptDir, ptDrain;
|
|
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHotFeed, ptDrain, ptDir);
|
|
}
|
|
|
|
if (ptFeed.Distance2d(ptSan) < 0.001)
|
|
{
|
|
vtDir = ptFeed - ptHotFeed;
|
|
vtDir.z = 0.0;
|
|
vtDir.normalize();
|
|
return true;
|
|
}
|
|
else if (ptHotFeed.Distance2d(ptSan) < 0.001 )
|
|
{
|
|
vtDir = ptHotFeed - ptFeed;
|
|
vtDir.z = 0.0;
|
|
vtDir.normalize();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SanitarySysForFeedWater::FiltrateWall( std::vector<std::pair<XCurveSegment, XCurveSegment> > &vecWall )
|
|
{
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> > vecData, vecTemp;
|
|
std::vector<std::pair<XCurveSegment, XCurveSegment> >::iterator it, itC;
|
|
std::multimap<double,std::pair<XCurveSegment, XCurveSegment> > mapData;
|
|
std::multimap<double,std::pair<XCurveSegment, XCurveSegment> >::iterator itD;
|
|
while(true)
|
|
{
|
|
for(it = vecWall.begin(); it != vecWall.end(); it++)
|
|
{
|
|
itC = it;
|
|
++itC;
|
|
for(; itC != vecWall.end(); itC++)
|
|
{
|
|
if (it->first == itC->first || it->first == itC->second
|
|
|| it->second == itC->first || it->second == itC->second)
|
|
{
|
|
double dDist = GetParallelDist(itC->first, itC->second);
|
|
mapData.insert(std::make_pair(dDist, *itC));
|
|
continue;
|
|
}
|
|
vecTemp.push_back(*itC);
|
|
}
|
|
|
|
if (!mapData.empty()) // 存在边线重合的墙体，取宽度最小的墙体
|
|
{
|
|
double dDist = GetParallelDist(it->first, it->second);
|
|
mapData.insert(std::make_pair(dDist, *it));
|
|
dDist = mapData.begin()->first;
|
|
for(itD = mapData.begin(); itD != mapData.end(); itD++)
|
|
{
|
|
if (fabs(itD->first - dDist) < 0.001)
|
|
{
|
|
vecData.push_back(itD->second);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
vecData.push_back(*it);
|
|
}
|
|
}
|
|
|
|
if (!vecWall.empty())
|
|
{
|
|
vecWall = vecTemp;
|
|
vecTemp.clear();
|
|
mapData.clear();
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
vecWall = vecData;
|
|
}
|
|
|
|
double SanitarySysForFeedWater::GetParallelDist( const XCurveSegment &seg1, const XCurveSegment &seg2 )
|
|
{
|
|
XLine line1 = seg1.GetLine();
|
|
XLine line2 = seg2.GetLine();
|
|
line1.SetElevation(0.0);
|
|
line2.SetElevation(0.0);
|
|
XPoint ptS = line1.StartPoint();
|
|
XPoint ptPrj;
|
|
ptS.Project(&line2, ptPrj);
|
|
return ptS.Distance(ptPrj);
|
|
}
|
|
|
|
void SanitarySysForFeedWater::DrawFeedEquip(const AcDbObjectId &idSan, const AcGePoint3d &ptSan)
|
|
{
|
|
ads_name name;
|
|
acdbGetAdsName(name, idSan);
|
|
Entity ent(name);
|
|
|
|
CString sDwbName, sHotElev, sFeedElev, sBlk, sSysBlk;
|
|
double dEle = 0.0, dRadius = 0.0, dDang = 0.0, dBigQ = 0.0;
|
|
XPoint pt = ptSan;
|
|
int nType = -1;
|
|
if (m_sysPipe == TPipeSys::kHeatFeedWater
|
|
|| m_sysPipe == TPipeSys::kHeatFeedWater2
|
|
|| m_sysPipe == TPipeSys::kHeatFeedWater3)
|
|
{
|
|
nType = 1;
|
|
}
|
|
else if (m_sysPipe == TPipeSys::kFeedWater
|
|
|| m_sysPipe == TPipeSys::kFeedWater2
|
|
|| m_sysPipe == TPipeSys::kFeedWater3) // 给水
|
|
{
|
|
nType = 0;
|
|
}
|
|
else if (m_sysPipe == TPipeSys::kUsedWater
|
|
|| m_sysPipe == TPipeSys::kUsedWater2
|
|
|| m_sysPipe == TPipeSys::kUsedWater3) // 中水
|
|
{
|
|
nType = 0;
|
|
}
|
|
|
|
double dAngle = 0.0;
|
|
// zxl 2012.12.11 modify 获取洁具数据源
|
|
int nDataSourceType = GetSanitaryDataSourceType(ent);
|
|
if (nDataSourceType == 1 || nDataSourceType == 0)
|
|
{
|
|
GetSanitaryInfo(ent, pt, sBlk, sSysBlk, dRadius, dDang, dBigQ, dEle, nType,
|
|
sDwbName, sFeedElev, sHotElev);
|
|
ent.GetData(50, &dAngle);
|
|
if (GetSanitaryDriection(ent, dAngle))
|
|
{
|
|
dAngle += PI / 2;
|
|
}
|
|
pt.z *= 1000;
|
|
}
|
|
else
|
|
{
|
|
CSanitaryInfo sanInfo;
|
|
XPoint ptFeed, ptHeatFeed, ptDir, ptBlk;
|
|
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, pt, ptDir);
|
|
sBlk = sanInfo.sFeedSys;
|
|
sSysBlk = sanInfo.sSysBlk1;
|
|
dDang = sanInfo.dDang;
|
|
dBigQ = sanInfo.dRateQ;
|
|
if (nType == 1 || nType == 0)
|
|
{
|
|
pt = ptSan;
|
|
pt.z = ptFeed.z * 1000;
|
|
}
|
|
|
|
AcDbObjectId Id = NULL;
|
|
acdbGetObjectId(Id, ent);
|
|
AcDbBlockReference *pBlkRef = NULL;
|
|
acdbOpenObject(pBlkRef, Id, AcDb::kForRead);
|
|
if(!pBlkRef)
|
|
return;
|
|
ptBlk = pBlkRef->position();
|
|
pBlkRef->close();
|
|
dAngle = GetEntDriection(ptBlk, ptDir);
|
|
dAngle += PI / 2;
|
|
}
|
|
|
|
// 加载图块
|
|
LoadTkBlock(sBlk);
|
|
LoadTkBlock(sSysBlk);
|
|
|
|
TDbEquipment *pEquip = new TDbEquipment;
|
|
pEquip->SetBlock2d(GetBlkIdByName(sBlk));
|
|
pEquip->SetDang(dDang);
|
|
pEquip->SetSpare(dBigQ);
|
|
pEquip->SetLocation(pt);
|
|
pEquip->SetHidePipe(FALSE);
|
|
pEquip->SetAngle(dAngle);
|
|
if(_tcsicmp(sSysBlk, _T("twtsys(00000322)")) == 0){
|
|
if(g_bBlk3D){
|
|
CString csDwb = g_csDwbPath + _T("TwtSys");
|
|
XString xsTmp6;
|
|
if(LoadDwbBlock(csDwb, _T("00000364"), xsTmp6) != RTNORM)//3d水龙头
|
|
return;
|
|
pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
|
|
}
|
|
}
|
|
else if(_tcsicmp(sSysBlk, _T("twtsys(00000005)")) == 0){
|
|
if(g_bBlk3D){
|
|
CString csDwb = g_csDwbPath + _T("TwtSys");
|
|
XString xsTmp6;
|
|
if(LoadDwbBlock(csDwb, _T("00000416"), xsTmp6) != RTNORM)//3d水龙头
|
|
return;
|
|
pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
|
|
}
|
|
}
|
|
else if(_tcsicmp(sSysBlk, _T("twtsys(00000352)")) == 0 || _tcsicmp(sSysBlk, _T("twtsys(00000014)")) == 0){//小便器自闭式冲洗阀
|
|
if(g_bBlk3D){
|
|
CString csDwb = g_csDwbPath + _T("TwtSys");
|
|
XString xsTmp7;
|
|
if(LoadDwbBlock(csDwb, _T("00000368"), xsTmp7) != RTNORM)//3d自闭式冲洗阀
|
|
return;
|
|
pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
|
|
}
|
|
}
|
|
else if(g_bBlk3D && _tcsicmp(sSysBlk, _T("twtsys(00000293)")) == 0){ //大便器自闭式冲洗阀
|
|
CString csDwb = g_csDwbPath + _T("TwtSys");
|
|
XString xsTmp7;
|
|
if(LoadDwbBlock(csDwb, _T("00000369"), xsTmp7) != RTNORM)//3d自闭式冲洗阀
|
|
return;
|
|
pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
|
|
}
|
|
if (_tcsicmp(sBlk, _T("$TWTSYS$00000519")) == 0)// 给水圆比例 zxl 2012.04.16 add
|
|
{
|
|
pEquip->SetScale(g_nFeedCircleScale);
|
|
}
|
|
|
|
pEquip->SetSysBlock((const TCHAR*)sSysBlk);
|
|
pEquip->setLayer(InitLayer(LAY_EQ_FEED));
|
|
pEquip->setColor(AcCmColor()); //随层
|
|
AddToCurrentSpace(pEquip, Adesk::kTrue);
|
|
|
|
} |