1455 lines
37 KiB
C++
1455 lines
37 KiB
C++
#include "StdAfx.h"
|
|
#include "UnfoldInstallAdjustElevation.h"
|
|
#include "DbEquipment.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);
|
|
|
|
UnfoldInstallAdjustElevation::UnfoldInstallAdjustElevation()
|
|
{
|
|
m_pLinkNode = NULL;
|
|
m_dToWallDist = 100;
|
|
m_dFeedEle = 1000;
|
|
}
|
|
|
|
UnfoldInstallAdjustElevation::~UnfoldInstallAdjustElevation()
|
|
{
|
|
// 找出根节点
|
|
LinkNode *pNode = m_pLinkNode;
|
|
while(pNode->pPreNode != NULL)
|
|
{
|
|
pNode = pNode->pPreNode;
|
|
}
|
|
// 从供水点开始依次删除本节点和其子节点
|
|
DeleteNode(m_pLinkNode);
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::AdjustElevation()
|
|
{
|
|
// 排序变高洁具顺序
|
|
std::vector<LinkNode*> vecNode;
|
|
SanitarySort(vecNode);
|
|
if (vecNode.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 先变高第一个洁具到供水点整条路径
|
|
LinkNode *pFirstNode = vecNode[0];
|
|
AdjustFirstSanEle(pFirstNode);
|
|
vecNode.erase(vecNode.begin());
|
|
|
|
// 其余洁具高过程中止于存在多个分支的点
|
|
AdjustSanitaryElevation(vecNode);
|
|
|
|
// DrawLine();
|
|
DrawPipe();
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::AdjustFirstSanEle(LinkNode *pFirstNode)
|
|
{
|
|
AcGePoint3d ptCur, ptPre, ptSan; // 当前节点和上一个节点
|
|
AcGePoint3d ptS, ptE; // 产生的直线的起始点
|
|
double dSanEle = 0.0, dPipeEle = 0.0; // 洁具点标高，洁具支管标高
|
|
int nType;
|
|
while(pFirstNode != NULL)
|
|
{
|
|
ptCur = pFirstNode->ptCur;
|
|
nType = pFirstNode->type;
|
|
if (SearchPointType(Point_Sanitary, nType)) // 洁具点
|
|
{
|
|
ptPre = ptCur; // 保存当前节点
|
|
// 洁具点标高
|
|
AcDbObjectId idSan = GetSanitaryId(ptCur);
|
|
if (IsSanitaryPtEleSamePipe(idSan)) // 洁具点标高随支管
|
|
{
|
|
if (!GetPipeEleForSanitary(idSan, dSanEle)) // 洁具标高随供水点标高
|
|
{
|
|
// 未定义标高时，以供水点标高为准
|
|
dSanEle = GetFeedPtEle();
|
|
}
|
|
dPipeEle = dSanEle;
|
|
ptPre.z = dSanEle;
|
|
}
|
|
else // 用户指定了洁具点标高
|
|
{
|
|
if (!GetPipeEleForSanitary(idSan, dPipeEle))
|
|
{
|
|
// 未定义支管标高时，支管标高随供水管标高
|
|
dPipeEle = GetFeedPtEle();
|
|
}
|
|
|
|
if (!GetSanitaryPtEle(idSan, dSanEle))
|
|
{
|
|
// 未定义洁具点标高时，随支管标高
|
|
dSanEle = dPipeEle;
|
|
}
|
|
|
|
if (SearchPointType(Point_KW, nType)) // 在洁具点处产生扣弯, 水平连接方式
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptCur;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dSanEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptCur, dSanEle);
|
|
}
|
|
}
|
|
ptSan = ptCur;
|
|
ptSan.z = dSanEle;
|
|
ModifySanitaryPt(ptSan);
|
|
}
|
|
else if (SearchPointType(Point_Int, nType)) // 普通交点
|
|
{
|
|
if (SearchPointType(Point_KW, nType)) // 扣弯，垂直连接方式
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dSanEle;
|
|
ptE.z = dSanEle;
|
|
CreateLine(ptS, ptE, eSmallPipe);
|
|
ptS = ptCur;
|
|
ptE = ptCur;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dSanEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(ptCur, dSanEle);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptPre, dSanEle);
|
|
}
|
|
else
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
ptPre = ptCur;
|
|
}
|
|
else if (SearchPointType(Point_Feed, nType)) // 供水点
|
|
{
|
|
double dFeedEle = GetFeedPtEle();
|
|
if (IsFeedVPipe() || fabs(dFeedEle - dPipeEle) < 0.001) // 供水管为立管或供水点标高与洁具支管标高相同
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
else // 供水点标高与洁具支管标高不一致，需变高产生扣弯
|
|
{
|
|
AdjustEleBetweenPts(ptCur, ptPre, dFeedEle, dPipeEle);
|
|
}
|
|
ptPre = ptCur;
|
|
}
|
|
pFirstNode = pFirstNode->pPreNode;
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::AdjustSanitaryElevation(const std::vector<LinkNode*> vecNode)
|
|
{
|
|
AcGePoint3d ptCur, ptPre, ptSan; // 当前节点和子节点
|
|
AcGePoint3d ptS, ptE; // 产生的直线的起始点
|
|
double dSanEle = 0.0, dPipeEle = 0.0; // 洁具点标高，洁具支管标高
|
|
int nType; // 点类型
|
|
LinkNode *pNode = NULL;
|
|
std::set<double> setEle; // 点的标高值
|
|
std::vector<LinkNode*>::const_iterator it;
|
|
for (it = vecNode.begin(); it != vecNode.end(); it++)
|
|
{
|
|
pNode = *it;
|
|
while(pNode != NULL)
|
|
{
|
|
ptCur = pNode->ptCur;
|
|
nType = pNode->type;
|
|
if (IsAdjustPointEle(ptCur)) // 该点已经被处理过
|
|
{
|
|
AdjustEleBetweenPts(ptCur, ptPre, dPipeEle);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (SearchPointType(Point_Sanitary, nType)) // 洁具点
|
|
{
|
|
ptPre = ptCur; // 保存当前节点
|
|
// 洁具点标高
|
|
AcDbObjectId idSan = GetSanitaryId(ptCur);
|
|
if (IsSanitaryPtEleSamePipe(idSan)) // 洁具点标高随支管
|
|
{
|
|
if (!GetPipeEleForSanitary(idSan, dSanEle)) // 洁具标高随供水点标高
|
|
{
|
|
dSanEle = GetParentNodeEle(ptCur);
|
|
}
|
|
dPipeEle = dSanEle;
|
|
ptPre.z = dSanEle;
|
|
}
|
|
else // 用户指定了洁具点标高
|
|
{
|
|
if (!GetPipeEleForSanitary(idSan, dPipeEle))
|
|
{
|
|
dPipeEle = GetParentNodeEle(ptCur);
|
|
}
|
|
|
|
if(!GetSanitaryPtEle(idSan, dSanEle))
|
|
{
|
|
dSanEle = dPipeEle;
|
|
}
|
|
|
|
if (SearchPointType(Point_KW, nType)) // 在洁具点处产生扣弯, 水平连接方式
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptCur;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dSanEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptCur, dSanEle);
|
|
}
|
|
}
|
|
ptSan = ptCur;
|
|
ptSan.z = dSanEle;
|
|
ModifySanitaryPt(ptSan);
|
|
}
|
|
else if (SearchPointType(Point_Int, nType)) // 普通交点
|
|
{
|
|
if (SearchPointType(Point_KW, nType)) // 扣弯，垂直连接方式
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dSanEle;
|
|
ptE.z = dSanEle;
|
|
CreateLine(ptS, ptE, eSmallPipe);
|
|
ptS = ptCur;
|
|
ptE = ptCur;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dSanEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(ptCur, dSanEle);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptPre, dSanEle);
|
|
}
|
|
else
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
ptPre = ptCur;
|
|
}
|
|
}
|
|
pNode = pNode->pPreNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::SetLinkNode( LinkNode *pNode )
|
|
{
|
|
m_pLinkNode = pNode;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::SetFeedElevation( double dEle )
|
|
{
|
|
m_dFeedEle = dEle;
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
m_dFeedEle *= 1000;
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::SetFeedPipe( const AcDbObjectId &idPipe )
|
|
{
|
|
m_idFeedPipe = idPipe;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::SetSanitaryPt( const std::map<AcDbObjectId,AcGePoint3d> &mapSan )
|
|
{
|
|
m_mapSanPt = mapSan;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::SetPipeSysType( TPipeSys::SysType sys )
|
|
{
|
|
m_sysPipeType = sys;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::SanitarySort(std::vector<LinkNode*> &vecNode)
|
|
{
|
|
// 找出供水点
|
|
LinkNode *pNode = m_pLinkNode;
|
|
while(pNode->pPreNode != NULL)
|
|
{
|
|
pNode = pNode->pPreNode;
|
|
}
|
|
// 按流经洁具点先后顺序获得洁具点
|
|
GetSanitaryNode(pNode, vecNode);
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::SearchPointType( int nType, int nOrignType )
|
|
{
|
|
bool bRet = ((nOrignType & nType) != 0) ? true : false;
|
|
return bRet;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::DeleteNode( LinkNode *pNode )
|
|
{
|
|
if (pNode != NULL)
|
|
{
|
|
for (int i = 0; i < pNode->m_vecNode.size(); i++)
|
|
{
|
|
DeleteNode(pNode->m_vecNode[i]);
|
|
}
|
|
delete pNode;
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::GetSanitaryNode( LinkNode *pNode, std::vector<LinkNode*> &vecNode )
|
|
{
|
|
if (pNode != NULL)
|
|
{
|
|
if (SearchPointType(Point_Sanitary, pNode->type)) // 洁具点
|
|
{
|
|
vecNode.push_back(pNode);
|
|
}
|
|
else if (pNode->m_vecNode.size() != 0)
|
|
{
|
|
int nLinkNum = pNode->m_vecNode.size();
|
|
if (nLinkNum == 1)
|
|
{
|
|
GetSanitaryNode(pNode->m_vecNode[0], vecNode);
|
|
}
|
|
else
|
|
{
|
|
if (pNode->pPreNode != NULL) // 前向节点存在，其中后续节点，前向节点，本节点共线的分支最后处理
|
|
{
|
|
LinkNode *pParallelNode = NULL; // 平行节点
|
|
AcGePoint3d ptPre = pNode->pPreNode->ptCur;
|
|
AcGePoint3d ptNext;
|
|
for(int i = 0; i < pNode->m_vecNode.size(); i++)
|
|
{
|
|
ptNext = pNode->m_vecNode[i]->ptCur;
|
|
if (!IsSameOnLine(ptNext, ptPre, pNode->ptCur))
|
|
{
|
|
GetSanitaryNode(pNode->m_vecNode[i], vecNode);
|
|
}
|
|
else
|
|
{
|
|
pParallelNode = pNode->m_vecNode[i];
|
|
}
|
|
}
|
|
|
|
// 后处理平行节点
|
|
if (pParallelNode != NULL)
|
|
{
|
|
GetSanitaryNode(pParallelNode, vecNode);
|
|
}
|
|
}
|
|
else // 前向节点不存在
|
|
{
|
|
for(int i = 0; i < pNode->m_vecNode.size(); i++)
|
|
{
|
|
GetSanitaryNode(pNode->m_vecNode[i], vecNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsSameOnLine( const AcGePoint3d &pt1, const AcGePoint3d &pt2, const AcGePoint3d &pt3 )
|
|
{
|
|
if (pt1.distanceTo(pt3) < 0.001)
|
|
{
|
|
return false;
|
|
}
|
|
AcGeVector3d vt1 = pt1 - pt2;
|
|
AcGeVector3d vt2 = pt3 - pt2;
|
|
AcGeTol tol;
|
|
tol.setEqualVector(0.001);
|
|
if (vt1.isParallelTo(vt2, tol))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsFeedVPipe()
|
|
{
|
|
bool bRet = false;
|
|
TDbPipe *pPipe = NULL;
|
|
acdbOpenObject(pPipe, m_idFeedPipe, AcDb::kForRead);
|
|
if (pPipe != NULL)
|
|
{
|
|
bRet = pPipe->IsVertical() ? true : false;
|
|
pPipe->close();
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
double UnfoldInstallAdjustElevation::GetFeedPtEle()
|
|
{
|
|
double dEle = 0.0;
|
|
TDbPipe *pPipe = NULL;
|
|
acdbOpenObject(pPipe, m_idFeedPipe, AcDb::kForRead);
|
|
if (pPipe != NULL)
|
|
{
|
|
if (pPipe->IsVertical()) // 供水管为立管
|
|
{
|
|
dEle = m_dFeedEle;
|
|
}
|
|
else // 供水管为管线时，标高随管线标高
|
|
{
|
|
dEle = pPipe->StartPoint().z;
|
|
}
|
|
pPipe->close();
|
|
}
|
|
return dEle;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsSanitaryPtEleSamePipe( const AcDbObjectId &idSan )
|
|
{
|
|
double dPtFeedEle = 0.0;
|
|
if (!GetSanitaryPtEle(idSan, dPtFeedEle))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
double dRefVal = DocGetMeterUnitDraw() ? 1 : 1000;
|
|
if (fabs(dPtFeedEle + dRefVal) < 0.001)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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);
|
|
bool UnfoldInstallAdjustElevation::GetSanitaryPtEle( const AcDbObjectId &idSan, double &dSanEle )
|
|
{
|
|
ads_name name;
|
|
acdbGetAdsName(name, idSan);
|
|
XPoint ptFeed;
|
|
CString sTmp1, sTmp2, sDwbName, sFeedElev, sHotElev;
|
|
double dRadius = 0.0, dDang = 0.0, dRateQ = 0.0, dSanPtEle;
|
|
Entity ent = name;
|
|
|
|
// zxl 2012.12.11 modify 获取洁具数据源
|
|
int nDataSourceType = GetSanitaryDataSourceType(ent);
|
|
if (nDataSourceType == 1 || nDataSourceType == 0)
|
|
{
|
|
if (!GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dSanPtEle, 0, sDwbName, sFeedElev, sHotElev))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CSanitaryInfo sanInfo;
|
|
XPoint ptFeed, ptHeatFeed, ptDir, ptDrain;
|
|
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
|
|
dSanPtEle = ptFeed.z;
|
|
}
|
|
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dSanPtEle *= 1000;
|
|
}
|
|
dSanEle = dSanPtEle;
|
|
return true;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::GetPipeEleForSanitary( const AcDbObjectId &idSan, double &dPipeEle)
|
|
{
|
|
ads_name name;
|
|
acdbGetAdsName(name, idSan);
|
|
XPoint ptFeed;
|
|
CString sTmp1, sTmp2, sDwbName, sFeedElev, sHotElev;
|
|
double dRadius = 0.0, dDang = 0.0, dRateQ = 0.0, dSanEle = 0.0;
|
|
Entity ent = name;
|
|
|
|
// zxl 2012.12.11 modify 获取洁具数据源
|
|
int nDataSourceType = GetSanitaryDataSourceType(ent);
|
|
if (nDataSourceType == 1 || nDataSourceType == 0)// 图纸取数据
|
|
{
|
|
if (m_sysPipeType == TPipeSys::kFeedWater || m_sysPipeType == TPipeSys::kFeedWater2 || m_sysPipeType == TPipeSys::kFeedWater3
|
|
|| m_sysPipeType == TPipeSys::kUsedWater || m_sysPipeType == TPipeSys::kUsedWater2 || m_sysPipeType == TPipeSys::kUsedWater3)
|
|
{
|
|
if (!GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dSanEle, 0, sDwbName, sFeedElev, sHotElev))
|
|
{
|
|
return false;
|
|
}
|
|
dPipeEle = _tstof(sFeedElev);
|
|
}
|
|
else
|
|
{
|
|
if (!GetSanitaryInfo(ent, ptFeed, sTmp1, sTmp2, dRadius, dDang, dRateQ, dSanEle, 1, sDwbName, sFeedElev, sHotElev))
|
|
{
|
|
return false;
|
|
}
|
|
dPipeEle = _tstof(sHotElev);
|
|
}
|
|
}
|
|
else// 本地取数据
|
|
{
|
|
CSanitaryInfo sanInfo;
|
|
XPoint ptFeed, ptHeatFeed, ptDir, ptDrain;
|
|
GetLocSanitaryData(ent, sanInfo, ptFeed, ptHeatFeed, ptDrain, ptDir);
|
|
if (m_sysPipeType == TPipeSys::kFeedWater || m_sysPipeType == TPipeSys::kFeedWater2 || m_sysPipeType == TPipeSys::kFeedWater3
|
|
|| m_sysPipeType == TPipeSys::kUsedWater || m_sysPipeType == TPipeSys::kUsedWater2 || m_sysPipeType == TPipeSys::kUsedWater3)
|
|
{
|
|
dPipeEle = _tstof(sanInfo.sFeedElev);
|
|
}
|
|
else
|
|
{
|
|
dPipeEle = _tstof(sanInfo.sHotElev);
|
|
}
|
|
}
|
|
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dPipeEle *= 1000;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
AcDbObjectId UnfoldInstallAdjustElevation::GetSanitaryId( const AcGePoint3d &ptSan )
|
|
{
|
|
AcDbObjectId idSan = AcDbObjectId::kNull;
|
|
std::map<AcDbObjectId,AcGePoint3d>::iterator it;
|
|
AcGePoint3d ptTemp;
|
|
for (it = m_mapSanPt.begin(); it != m_mapSanPt.end(); it++)
|
|
{
|
|
ptTemp = it->second;
|
|
ptTemp.z = 0.0;
|
|
if (ptSan.distanceTo(ptTemp) < 0.001)
|
|
{
|
|
idSan = it->first;
|
|
break;
|
|
}
|
|
}
|
|
return idSan;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::CreateLine( const AcGePoint3d &ptS, const AcGePoint3d &ptE, LineType type)
|
|
{
|
|
LineInfo info;
|
|
info.ptS = ptS;
|
|
info.ptE = ptE;
|
|
info.type = type;
|
|
m_vecLineInfo.push_back(info);
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::AddPointElevation( const AcGePoint3d &pt, double dEle )
|
|
{
|
|
std::vector<PointNode>::iterator it;
|
|
AcGePoint3d ptTemp = pt;
|
|
ptTemp.z = 0.0;
|
|
for (it = m_vecPtEle.begin(); it != m_vecPtEle.end(); it++)
|
|
{
|
|
if (ptTemp.distanceTo(it->pt) < 0.001)
|
|
{
|
|
it->setEle.insert(dEle);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (it == m_vecPtEle.end())
|
|
{
|
|
PointNode node;
|
|
node.pt = ptTemp;
|
|
node.setEle.insert(dEle);
|
|
m_vecPtEle.push_back(node);
|
|
}
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::GetPointElevation( const AcGePoint3d &pt, std::set<double> &setEle )
|
|
{
|
|
std::vector<PointNode>::iterator it;
|
|
AcGePoint3d ptTemp = pt;
|
|
ptTemp.z = 0.0;
|
|
for (it = m_vecPtEle.begin(); it != m_vecPtEle.end(); it++)
|
|
{
|
|
if (ptTemp.distanceTo(it->pt) < 0.001)
|
|
{
|
|
setEle = it->setEle;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsCorner( const AcGePoint3d &pt )
|
|
{
|
|
LinkNode *pNode = GetLinkNode(pt);
|
|
if (pNode != NULL)
|
|
{
|
|
LinkNode *pPreNode = pNode->pPreNode;
|
|
if (pPreNode != NULL && pNode->m_vecNode.size() == 1)
|
|
{
|
|
AcGePoint3d ptPre = pPreNode->ptCur;
|
|
AcGePoint3d ptNext = pNode->m_vecNode[0]->ptCur;
|
|
AcGePoint3d ptCur = pt;
|
|
AcGeVector3d vt1 = ptPre - ptCur;
|
|
AcGeVector3d vt2 = ptCur - ptNext;
|
|
vt1.z = 0.0;
|
|
vt2.z = 0.0;
|
|
AcGeTol tol;
|
|
tol.setEqualVector(0.001);
|
|
if (!vt1.isParallelTo(vt2, tol))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsPointKw( const AcGePoint3d &pt )
|
|
{
|
|
bool bRet = false;
|
|
LinkNode *pNode = GetLinkNode(pt);
|
|
if (pNode != NULL && SearchPointType(Point_KW, pNode->type))
|
|
{
|
|
bRet = true;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
LinkNode* UnfoldInstallAdjustElevation::GetLinkNode( const AcGePoint3d &pt )
|
|
{
|
|
if (m_pLinkNode == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
LinkNode *pRetNode = NULL;
|
|
LinkNode *pTemp = m_pLinkNode;
|
|
std::vector<LinkNode*> vecNode;
|
|
vecNode.push_back(pTemp);
|
|
while(!vecNode.empty())
|
|
{
|
|
pTemp = *(vecNode.begin());
|
|
vecNode.erase(vecNode.begin());
|
|
if (pt.distanceTo(pTemp->ptCur) < 0.001)
|
|
{
|
|
pRetNode = pTemp;
|
|
break;
|
|
}
|
|
|
|
for (int i = 0; i < pTemp->m_vecNode.size(); i++)
|
|
{
|
|
vecNode.push_back(pTemp->m_vecNode[i]);
|
|
}
|
|
}
|
|
return pRetNode;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsExistPerpendicularWall( const AcGePoint3d &pt1, const AcGePoint3d &pt2, AcDbObjectId &idWall )
|
|
{
|
|
PickSet ssName(SS_FREE);
|
|
RBList rbMake = acutBuildList(RTDXF0, _T("ATS_WALL"), NULL);
|
|
acedSSGet(_T("C"), Wcs2Ucs(pt1), Wcs2Ucs(pt2), rbMake, ssName);
|
|
|
|
bool bRet = false;
|
|
AcDbObjectId id;
|
|
XCurveSegment segL,segR;
|
|
AcGeVector3d vtWall;
|
|
AcGeVector3d vt = pt1 - pt2; // 两点直线方向
|
|
vt.z = 0.0;
|
|
AcGeTol tol;
|
|
tol.setEqualVector(0.001);
|
|
for (long i = 0; (i < ssName.Length()) && !bRet; i++)
|
|
{
|
|
acdbGetObjectId(id, ssName[i]);
|
|
TDbWall *pWall = NULL;
|
|
acdbOpenObject(pWall, id, AcDb::kForRead);
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->Is(CURVE_LINE))
|
|
{
|
|
pWall->GetSideCurve(segL,segR);
|
|
vtWall = segR.StartPoint() - segR.EndPoint();
|
|
vtWall.z = 0.0;
|
|
if (vt.isPerpendicularTo(vtWall, tol))
|
|
{
|
|
bRet = true;
|
|
idWall = id;
|
|
}
|
|
}
|
|
pWall->close();
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::GetAdjustPoint( const AcGePoint3d &ptS, const AcGePoint3d &ptE, const AcDbObjectId &idWall, AcGePoint3d &pt )
|
|
{
|
|
bool bRet = false;
|
|
TDbWall *pWall = NULL;
|
|
acdbOpenObject(pWall, idWall, AcDb::kForRead);
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->Is(CURVE_LINE))
|
|
{
|
|
XCurveSegment segL,segR;
|
|
pWall->GetSideCurve(segL,segR);
|
|
XPoint pt1, pt2;
|
|
Midpoint(segL.StartPoint(), segR.StartPoint(), pt1);
|
|
Midpoint(segL.EndPoint(), segR.EndPoint(), pt2);
|
|
pt1.z = 0.0;
|
|
pt2.z = 0.0;
|
|
AcDbLine line1(pt1, pt2);
|
|
AcGePoint3d pt3 = ptS, pt4 = ptE;
|
|
pt3.z = 0.0;
|
|
pt4.z = 0.0;
|
|
AcDbLine line2(pt3, pt4);
|
|
AcGePoint3dArray arrPt;
|
|
line1.intersectWith(&line2, AcDb::kOnBothOperands, arrPt);
|
|
if (arrPt.length() == 1)
|
|
{
|
|
AcGePoint3d ptInt = arrPt[0];
|
|
pt1 = segL.StartPoint();
|
|
pt2 = segR.StartPoint();
|
|
double dWitdh = pt1.Distance2d(pt2);
|
|
double dDist = dWitdh / 2 + m_dToWallDist;
|
|
double dMinDist = 0.1; // 变高点距端点的最小距离
|
|
if (!DocGetMeterUnitDraw())
|
|
{
|
|
dMinDist *= 1000;
|
|
}
|
|
|
|
if (pt3.distanceTo(ptInt) > dDist + dMinDist)
|
|
{
|
|
AcGeVector3d vtDir = ptS - ptInt;
|
|
vtDir.z = 0.0;
|
|
vtDir.normalize();
|
|
pt = ptInt + vtDir * dDist;
|
|
bRet = true;
|
|
}
|
|
else if (pt4.distanceTo(ptInt) > dDist + dMinDist)
|
|
{
|
|
AcGeVector3d vtDir = ptE - ptInt;
|
|
vtDir.z = 0.0;
|
|
vtDir.normalize();
|
|
pt = ptInt + vtDir * dDist;
|
|
bRet = true;
|
|
}
|
|
}
|
|
}
|
|
pWall->close();
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::DrawLine()
|
|
{
|
|
std::vector<LineInfo>::iterator it;
|
|
for (it = m_vecLineInfo.begin(); it != m_vecLineInfo.end(); it++)
|
|
{
|
|
AcGePoint3d ptS = it->ptS, ptE = it->ptE;
|
|
if (ptS.distanceTo(ptE) < 0.001)
|
|
{
|
|
continue;
|
|
}
|
|
AcDbLine *pLine = new AcDbLine;
|
|
pLine->setStartPoint(ptS);
|
|
pLine->setEndPoint(ptE);
|
|
AddToCurrentSpace(pLine, Adesk::kTrue);
|
|
}
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::IsAdjustPointEle( const AcGePoint3d &pt )
|
|
{
|
|
bool bRet = false;
|
|
std::vector<PointNode>::iterator it;
|
|
AcGePoint3d ptTemp = pt;
|
|
ptTemp.z = 0.0;
|
|
for (it = m_vecPtEle.begin(); it != m_vecPtEle.end(); it++)
|
|
{
|
|
if (ptTemp.distanceTo(it->pt) < 0.001)
|
|
{
|
|
bRet = true;
|
|
break;
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
bool UnfoldInstallAdjustElevation::FindParallelLine( const AcGePoint3d &ptS, const AcGePoint3d &ptE, double &dPipeEle )
|
|
{
|
|
bool bRet = false;
|
|
AcGePoint3d pt1 = ptS, pt2 = ptE;
|
|
pt1.z = 0.0;
|
|
pt2.z = 0.0;
|
|
std::vector<LineInfo>::iterator it;
|
|
AcGePoint3d ptTemp, ptTemp2;
|
|
AcGeVector3d vt1 = pt1 - pt2, vt2;
|
|
AcGeTol tol;
|
|
tol.setEqualVector(0.001);
|
|
for (it = m_vecLineInfo.begin(); it != m_vecLineInfo.end(); it++)
|
|
{
|
|
if (it->type == eKWPipe)
|
|
{
|
|
continue;
|
|
}
|
|
ptTemp = it->ptE;
|
|
ptTemp2 = it->ptS;
|
|
ptTemp.z = 0.0;
|
|
ptTemp2.z = 0.0;
|
|
if(ptTemp.distanceTo(pt1) < 0.001 || ptTemp2.distanceTo(pt1) < 0.001)
|
|
{
|
|
vt2 = it->ptE - it->ptS;
|
|
vt2.z = 0.0;
|
|
if (vt1.isParallelTo(vt2, tol))
|
|
{
|
|
dPipeEle = it->ptS.z;
|
|
bRet = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::AdjustEleBetweenPts( const AcGePoint3d &ptCur, const AcGePoint3d &ptPre, double dFeedEle, double dPipeEle )
|
|
{
|
|
AcGePoint3d ptS, ptE;
|
|
AcDbObjectId idWall = AcDbObjectId::kNull;
|
|
if (IsCorner(ptPre) && !IsPointKw(ptPre)) // 转角位置并且转角点不具有Point_KW类型
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dFeedEle;
|
|
ptE.z = dFeedEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
ptS = ptPre;
|
|
ptE = ptPre;
|
|
ptS.z = dFeedEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(ptCur, dFeedEle);
|
|
AddPointElevation(ptPre, dFeedEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
else if (IsExistPerpendicularWall(ptCur, ptPre, idWall)) // 两点穿过墙体，在墙边上变高
|
|
{
|
|
AcGePoint3d ptTemp;
|
|
if (!GetAdjustPoint(ptCur, ptPre, idWall, ptTemp)) // 得到变高点
|
|
{
|
|
ptTemp = ptCur;
|
|
}
|
|
|
|
ptS = ptCur;
|
|
ptS.z = dFeedEle;
|
|
ptTemp.z = dFeedEle;
|
|
CreateLine(ptS, ptTemp, ePipe);
|
|
ptE = ptTemp;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptTemp, ptE, eKWPipe);
|
|
ptS = ptTemp;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
AddPointElevation(ptCur, dFeedEle);
|
|
AddPointElevation(ptTemp, dFeedEle);
|
|
AddPointElevation(ptTemp, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
else // 取两点中点变高
|
|
{
|
|
AcGePoint3d ptMid;
|
|
ptMid.x = (ptCur.x + ptPre.x) / 2;
|
|
ptMid.y = (ptCur.y + ptPre.y) / 2;
|
|
ptMid.z = 0.0;
|
|
|
|
ptS = ptCur;
|
|
ptS.z = dFeedEle;
|
|
ptMid.z = dFeedEle;
|
|
CreateLine(ptS, ptMid, ePipe);
|
|
ptE = ptMid;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptMid, ptE, eKWPipe);
|
|
ptS = ptMid;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
AddPointElevation(ptCur, dFeedEle);
|
|
AddPointElevation(ptMid, dFeedEle);
|
|
AddPointElevation(ptMid, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::AdjustEleBetweenPts(const AcGePoint3d &ptCur, const AcGePoint3d &ptPre, double dPipeEle)
|
|
{
|
|
// 获取当前节点
|
|
LinkNode *pCurNode = GetLinkNode(ptCur);
|
|
if (pCurNode == NULL)
|
|
{
|
|
AfxMessageBox(_T("恭喜你发现了错误，哈哈！"));
|
|
return;
|
|
}
|
|
|
|
// 确定当前点标高值
|
|
double dCurEle = 0.0;
|
|
// 不存在端点与ptCur重合且与ptPre共线已变高管线
|
|
if (!FindParallelLine(ptCur, ptPre, dCurEle))
|
|
{
|
|
// 获得ptCur点目前已确定的标高值
|
|
std::set<double> setEle;
|
|
GetPointElevation(ptCur, setEle);
|
|
// 取标高最小值
|
|
dCurEle = *setEle.begin();
|
|
}
|
|
|
|
AcGePoint3d ptS, ptE;
|
|
AcDbObjectId idWall = AcDbObjectId::kNull;
|
|
if (IsCorner(ptPre) && !IsPointKw(ptPre)) // 转角位置且转角点不能具有Point_KW类型
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dCurEle;
|
|
ptE.z = dCurEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
// 更新点的连接
|
|
UpdateNodeLink(ptPre, dCurEle);
|
|
UpdateNodeLink(ptPre, dPipeEle);
|
|
AddPointElevation(ptCur, dCurEle);
|
|
AddPointElevation(ptPre, dCurEle);
|
|
}
|
|
else if (IsExistPerpendicularWall(ptCur, ptPre, idWall)) // 两点穿过墙体，在墙边上变高
|
|
{
|
|
AcGePoint3d ptTemp;
|
|
if (GetAdjustPoint(ptCur, ptPre, idWall, ptTemp)) // 得到变高点
|
|
{
|
|
ptS = ptCur;
|
|
ptS.z = dCurEle;
|
|
ptTemp.z = dCurEle;
|
|
CreateLine(ptS, ptTemp, ePipe);
|
|
ptE = ptTemp;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptTemp, ptE, eKWPipe);
|
|
ptS = ptTemp;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
AddPointElevation(ptCur, dCurEle);
|
|
AddPointElevation(ptTemp, dCurEle);
|
|
AddPointElevation(ptTemp, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
else // 无法获得标高点，在父节点处变高
|
|
{
|
|
ptS = ptCur;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
// 更新点的连接
|
|
UpdateNodeLink(ptCur, dCurEle);
|
|
UpdateNodeLink(ptCur, dPipeEle);
|
|
|
|
AddPointElevation(ptCur, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
}
|
|
else // 取两点中点变高
|
|
{
|
|
AcGePoint3d ptMid;
|
|
ptMid.x = (ptCur.x + ptPre.x) / 2;
|
|
ptMid.y = (ptCur.y + ptPre.y) / 2;
|
|
ptMid.z = 0.0;
|
|
|
|
ptS = ptCur;
|
|
ptS.z = dCurEle;
|
|
ptMid.z = dCurEle;
|
|
CreateLine(ptS, ptMid, ePipe);
|
|
ptE = ptMid;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptMid, ptE, eKWPipe);
|
|
ptS = ptMid;
|
|
ptE = ptPre;
|
|
ptS.z = dPipeEle;
|
|
ptE.z = dPipeEle;
|
|
CreateLine(ptS, ptE, ePipe);
|
|
|
|
AddPointElevation(ptCur, dCurEle);
|
|
AddPointElevation(ptMid, dCurEle);
|
|
AddPointElevation(ptMid, dPipeEle);
|
|
AddPointElevation(ptPre, dPipeEle);
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::UpdateNodeLink( const AcGePoint3d &pt, double dEle )
|
|
{
|
|
// 获得pt点已确定的标高值
|
|
std::set<double> setEle;
|
|
GetPointElevation(pt, setEle);
|
|
if (setEle.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
double dMinEle = *setEle.begin();
|
|
double dMaxEle = *setEle.rbegin();
|
|
if (setEle.size() == 1) // pt点只确定了一个标高值
|
|
{
|
|
AcGePoint3d ptS = pt;
|
|
AcGePoint3d ptE = pt;
|
|
ptS.z = dEle;
|
|
ptE.z = dMinEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(pt, dEle);
|
|
}
|
|
else if (dEle < dMinEle + 0.001)
|
|
{
|
|
AcGePoint3d ptS = pt;
|
|
AcGePoint3d ptE = pt;
|
|
ptS.z = dMinEle;
|
|
ptE.z = dEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(pt, dEle);
|
|
}
|
|
else if (dEle > dMaxEle + 0.001)
|
|
{
|
|
AcGePoint3d ptS = pt;
|
|
AcGePoint3d ptE = pt;
|
|
ptS.z = dMaxEle;
|
|
ptE.z = dEle;
|
|
CreateLine(ptS, ptE, eKWPipe);
|
|
AddPointElevation(pt, dEle);
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::DrawPipe()
|
|
{
|
|
// 获取管线信息
|
|
CString sPipeLayer = GetPipeLayer(m_sysPipeType);
|
|
CString sVPipeLayer = GetVPipeLayer(m_sysPipeType);
|
|
InitLayer(sPipeLayer);
|
|
InitLayer(sVPipeLayer);
|
|
int iPipeIdx = GetPipeLayerIdxByName(sPipeLayer);
|
|
CString sLineType = GetPipeWireLayLineType(sPipeLayer);
|
|
CString sMaterial = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
|
|
CString sDnType = GetDnByMat(sMaterial);
|
|
double dPipeDn = 20;
|
|
TDbPipe *pPipe = NULL;
|
|
acdbOpenObject(pPipe, m_idFeedPipe, AcDb::kForRead);
|
|
if (pPipe != NULL)
|
|
{
|
|
dPipeDn = pPipe->GetDnDiameter();
|
|
pPipe->close();
|
|
}
|
|
|
|
CString sLineType2 = GetLayerLineType(sPipeLayer);
|
|
AcGePoint3d ptS, ptE;
|
|
std::vector<LineInfo>::iterator it;
|
|
for (it = m_vecLineInfo.begin(); it != m_vecLineInfo.end(); it++)
|
|
{
|
|
ptS = it->ptS;
|
|
ptE = it->ptE;
|
|
if (ptS.distanceTo(ptE) < 0.001) // 可能存在重合点
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TDbPipe *pPipe = new TDbPipe();
|
|
int iPipeIdx = GetPipeLayerIdxByName(sPipeLayer);
|
|
pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
|
|
if (it->type == eKWPipe)//设置立管显示半径
|
|
{
|
|
if(g_bPipeDouble[iPipeIdx])
|
|
{
|
|
pPipe->SetRadiusIn(g_nPipeRadius[iPipeIdx] / 2);
|
|
}
|
|
else
|
|
{
|
|
if(!g_bStandPipeArc)//传统扣弯
|
|
pPipe->SetRadiusIn(-2);
|
|
}
|
|
}
|
|
pPipe->SetStartPoint(ptS);
|
|
pPipe->SetEndPoint(ptE);
|
|
pPipe->SetFlowDir(TPipeSys::kFromStart);
|
|
if(sLineType2.Find(_T("TG")) > -1)
|
|
{
|
|
XLine line(asDblArray(ptS), asDblArray(ptE));
|
|
double nAng = line.Direction();
|
|
if(nAng > PI/2 && nAng < (PI/2*3 + 0.001))
|
|
{
|
|
pPipe->SetStartPoint(ptE);
|
|
pPipe->SetEndPoint(ptS);
|
|
pPipe->SetFlowDir(TPipeSys::kFromEnd);
|
|
}
|
|
}
|
|
pPipe->SetDnDiameter(dPipeDn);
|
|
pPipe->setLayer(sPipeLayer);
|
|
pPipe->SetSysType(GetPipeSysByLayer(sPipeLayer));
|
|
pPipe->setColor(AcCmColor()); //随层
|
|
pPipe->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
|
|
pPipe->setLinetype(sLineType);
|
|
pPipe->setLineWeight(AcDb::kLnWtByLayer);
|
|
pPipe->SetMaterial(g_iPipeMaterial[iPipeIdx]);
|
|
pPipe->SetLabel(sDnType);
|
|
AddToCurrentSpace(pPipe, Adesk::kTrue);
|
|
}
|
|
|
|
InsertSanitaryEquip();
|
|
}
|
|
|
|
CString UnfoldInstallAdjustElevation::GetPipeLayer(TPipeSys::SysType sys)
|
|
{
|
|
CString sLayer;
|
|
if(sys == TPipeSys::kFeedWater)
|
|
sLayer = LAY_PIPE_FEED;
|
|
else if (sys == TPipeSys::kFeedWater2)
|
|
sLayer = LAY_PIPE_FEED2;
|
|
else if (sys == TPipeSys::kFeedWater3)
|
|
sLayer = LAY_PIPE_FEED3;
|
|
else if(sys == TPipeSys::kHeatFeedWater)
|
|
sLayer = LAY_PIPE_HEADFEED;
|
|
else if(sys == TPipeSys::kHeatFeedWater2)
|
|
sLayer = LAY_PIPE_HEADFEED2;
|
|
else if(sys == TPipeSys::kHeatFeedWater3)
|
|
sLayer = LAY_PIPE_HEADFEED3;
|
|
else if(sys == TPipeSys::kHeatBackWater)
|
|
sLayer = LAY_PIPE_HEADBACK;
|
|
else if(sys == TPipeSys::kHeatBackWater2)
|
|
sLayer = LAY_PIPE_HEADBACK2;
|
|
else if(sys == TPipeSys::kHeatBackWater3)
|
|
sLayer = LAY_PIPE_HEADBACK3;
|
|
else if(sys == TPipeSys::kDirtWater)
|
|
sLayer = LAY_PIPE_DIRT;
|
|
else if(sys == TPipeSys::kUselessWater)
|
|
sLayer = LAY_PIPE_USELESS;
|
|
else if(sys == TPipeSys::kRainWater)
|
|
sLayer = LAY_PIPE_RAIN;
|
|
else if(sys == TPipeSys::kUsedWater)
|
|
sLayer = LAY_PIPE_USED;
|
|
else if(sys == TPipeSys::kUsedWater2)
|
|
sLayer = LAY_PIPE_USED2;
|
|
else if(sys == TPipeSys::kUsedWater3)
|
|
sLayer = LAY_PIPE_USED3;
|
|
else if(sys == TPipeSys::kFireFighting)
|
|
sLayer = LAY_PIPE_FIRE;
|
|
else if(sys == TPipeSys::kFireFighting2)
|
|
sLayer = LAY_PIPE_FIRE2;
|
|
else if(sys == TPipeSys::kFireFighting3)
|
|
sLayer = LAY_PIPE_FIRE3;
|
|
else if(sys == TPipeSys::kSprinkle)
|
|
sLayer = LAY_PIPE_SPRINKLE;
|
|
else if(sys == TPipeSys::kSprinkle2)
|
|
sLayer = LAY_PIPE_SPRINKLE2;
|
|
else if(sys == TPipeSys::kSprinkle3)
|
|
sLayer = LAY_PIPE_SPRINKLE3;
|
|
else if(sys == TPipeSys::kCoagulate)
|
|
sLayer = LAY_PIPE_COAGULATE;
|
|
else if(sys == TPipeSys::kDrink)
|
|
sLayer = LAY_PIPE_DRINK;
|
|
else if(sys == TPipeSys::kPressDirt)
|
|
sLayer = LAY_PIPE_PRESSDIRT;
|
|
else if(sys == TPipeSys::kPressUseless)
|
|
sLayer = LAY_PIPE_PRESSUSELESS;
|
|
else if(sys == TPipeSys::kPressRain)
|
|
sLayer = LAY_PIPE_PRESSRAIN;
|
|
else if(sys == TPipeSys::kCivilFeed)
|
|
sLayer = LAY_PIPE_USER1;
|
|
else if(sys == TPipeSys::kCycleFeed)
|
|
sLayer = LAY_PIPE_USER2;
|
|
else if(sys == TPipeSys::kOther)
|
|
sLayer = LAY_PIPE_OTHER;
|
|
else if (sys == TPipeSys::kUser3)
|
|
sLayer = LAY_PIPE_USER3;
|
|
else if (sys == TPipeSys::kUser4)
|
|
sLayer = LAY_PIPE_USER4;
|
|
else if (sys == TPipeSys::kUser5)
|
|
sLayer = LAY_PIPE_USER5;
|
|
else if (sys == TPipeSys::kUser6)
|
|
sLayer = LAY_PIPE_USER6;
|
|
else if (sys == TPipeSys::kUser7)
|
|
sLayer = LAY_PIPE_USER7;
|
|
else if (sys == TPipeSys::kUser8)
|
|
sLayer = LAY_PIPE_USER8;
|
|
return sLayer;
|
|
}
|
|
|
|
CString UnfoldInstallAdjustElevation::GetVPipeLayer(TPipeSys::SysType sys)
|
|
{
|
|
CString sLayer;
|
|
if(sys == TPipeSys::kFeedWater)
|
|
sLayer = LAY_VPIPE_FEED;
|
|
else if (sys == TPipeSys::kFeedWater2)
|
|
sLayer = LAY_VPIPE_FEED2;
|
|
else if (sys == TPipeSys::kFeedWater3)
|
|
sLayer = LAY_VPIPE_FEED3;
|
|
else if(sys == TPipeSys::kHeatFeedWater)
|
|
sLayer = LAY_VPIPE_HEADFEED;
|
|
else if(sys == TPipeSys::kHeatFeedWater2)
|
|
sLayer = LAY_VPIPE_HEADFEED2;
|
|
else if(sys == TPipeSys::kHeatFeedWater3)
|
|
sLayer = LAY_VPIPE_HEADFEED3;
|
|
else if(sys == TPipeSys::kHeatBackWater)
|
|
sLayer = LAY_VPIPE_HEADBACK;
|
|
else if(sys == TPipeSys::kHeatBackWater2)
|
|
sLayer = LAY_VPIPE_HEADBACK2;
|
|
else if(sys == TPipeSys::kHeatBackWater3)
|
|
sLayer = LAY_VPIPE_HEADBACK3;
|
|
else if(sys == TPipeSys::kDirtWater)
|
|
sLayer = LAY_VPIPE_DIRT;
|
|
else if(sys == TPipeSys::kUselessWater)
|
|
sLayer = LAY_VPIPE_USELESS;
|
|
else if(sys == TPipeSys::kRainWater)
|
|
sLayer = LAY_VPIPE_RAIN;
|
|
else if(sys == TPipeSys::kUsedWater)
|
|
sLayer = LAY_VPIPE_USED;
|
|
else if(sys == TPipeSys::kUsedWater2)
|
|
sLayer = LAY_VPIPE_USED2;
|
|
else if(sys == TPipeSys::kUsedWater3)
|
|
sLayer = LAY_VPIPE_USED3;
|
|
else if(sys == TPipeSys::kFireFighting)
|
|
sLayer = LAY_VPIPE_FIRE;
|
|
else if(sys == TPipeSys::kFireFighting2)
|
|
sLayer = LAY_VPIPE_FIRE2;
|
|
else if(sys == TPipeSys::kFireFighting3)
|
|
sLayer = LAY_VPIPE_FIRE3;
|
|
else if(sys == TPipeSys::kSprinkle)
|
|
sLayer = LAY_VPIPE_SPRINKLE;
|
|
else if(sys == TPipeSys::kSprinkle2)
|
|
sLayer = LAY_VPIPE_SPRINKLE2;
|
|
else if(sys == TPipeSys::kSprinkle3)
|
|
sLayer = LAY_VPIPE_SPRINKLE3;
|
|
else if(sys == TPipeSys::kCoagulate)
|
|
sLayer = LAY_VPIPE_COAGULATE;
|
|
else if(sys == TPipeSys::kDrink)
|
|
sLayer = LAY_VPIPE_DRINK;
|
|
else if(sys == TPipeSys::kPressDirt)
|
|
sLayer = LAY_VPIPE_PRESSDIRT;
|
|
else if(sys == TPipeSys::kPressUseless)
|
|
sLayer = LAY_VPIPE_PRESSUSELESS;
|
|
else if(sys == TPipeSys::kPressRain)
|
|
sLayer = LAY_VPIPE_PRESSRAIN;
|
|
else if(sys == TPipeSys::kCivilFeed)
|
|
sLayer = LAY_VPIPE_USER1;
|
|
else if(sys == TPipeSys::kCycleFeed)
|
|
sLayer = LAY_VPIPE_USER2;
|
|
else if(sys == TPipeSys::kOther)
|
|
sLayer = LAY_VPIPE_OTHER;
|
|
else if (sys == TPipeSys::kUser3)
|
|
sLayer = LAY_VPIPE_USER3;
|
|
else if (sys == TPipeSys::kUser4)
|
|
sLayer = LAY_VPIPE_USER4;
|
|
else if (sys == TPipeSys::kUser5)
|
|
sLayer = LAY_VPIPE_USER5;
|
|
else if (sys == TPipeSys::kUser6)
|
|
sLayer = LAY_VPIPE_USER6;
|
|
else if (sys == TPipeSys::kUser7)
|
|
sLayer = LAY_VPIPE_USER7;
|
|
else if (sys == TPipeSys::kUser8)
|
|
sLayer = LAY_VPIPE_USER8;
|
|
return sLayer;
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::ModifySanitaryPt( const AcGePoint3d &ptSan )
|
|
{
|
|
AcGePoint3d ptTemp = ptSan;
|
|
std::map<AcDbObjectId,AcGePoint3d>::iterator it;
|
|
for (it = m_mapSanPt.begin(); it != m_mapSanPt.end(); it++)
|
|
{
|
|
ptTemp.z = it->second.z;
|
|
if (ptTemp.distanceTo(it->second) < 0.001)
|
|
{
|
|
it->second.z = ptSan.z;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void UnfoldInstallAdjustElevation::InsertSanitaryEquip()
|
|
{
|
|
std::map<AcDbObjectId,AcGePoint3d>::iterator it;
|
|
for (it = m_mapSanPt.begin(); it != m_mapSanPt.end(); it++)
|
|
{
|
|
DrawFeedEquip(it->first, it->second);
|
|
}
|
|
}
|
|
|
|
extern bool GetSanitaryDriection(Entity ent, double &dSanitaryDriec);
|
|
void UnfoldInstallAdjustElevation::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;
|
|
int nType = 0;
|
|
if (m_sysPipeType == TPipeSys::kHeatFeedWater
|
|
|| m_sysPipeType == TPipeSys::kHeatFeedWater2
|
|
|| m_sysPipeType == TPipeSys::kHeatFeedWater3)
|
|
{
|
|
nType = 1;
|
|
}
|
|
else if (m_sysPipeType == TPipeSys::kFeedWater
|
|
|| m_sysPipeType == TPipeSys::kFeedWater2
|
|
|| m_sysPipeType == TPipeSys::kFeedWater3) // 给水
|
|
{
|
|
nType = 0;
|
|
}
|
|
else if (m_sysPipeType == TPipeSys::kUsedWater
|
|
|| m_sysPipeType == TPipeSys::kUsedWater2
|
|
|| m_sysPipeType == 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;
|
|
}
|
|
}
|
|
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(ptSan);
|
|
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);
|
|
|
|
}
|
|
|
|
double UnfoldInstallAdjustElevation::GetParentNodeEle( const AcGePoint3d &ptCur )
|
|
{
|
|
double dEle = 0.0;
|
|
LinkNode *pNode = GetLinkNode(ptCur);
|
|
if(pNode == NULL)
|
|
{
|
|
return dEle;
|
|
}
|
|
|
|
AcGePoint3d ptPre = pNode->ptCur;
|
|
pNode = pNode->pPreNode;
|
|
while(pNode != NULL)
|
|
{
|
|
if (IsAdjustPointEle(pNode->ptCur))
|
|
{
|
|
// 不存在端点与ptCur重合且与ptPre共线已变高管线
|
|
if (!FindParallelLine(pNode->ptCur, ptPre, dEle))
|
|
{
|
|
// 获得ptCur点目前已确定的标高值
|
|
std::set<double> setEle;
|
|
GetPointElevation(ptCur, setEle);
|
|
// 取标高最小值
|
|
dEle = *setEle.begin();
|
|
}
|
|
break;
|
|
}
|
|
ptPre = pNode->ptCur;
|
|
pNode = pNode->pPreNode;
|
|
}
|
|
return dEle;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|