3212 lines
85 KiB
C++
3212 lines
85 KiB
C++
#include "stdafx.h"
|
||
#include "dbobjptr.h"
|
||
#include "AcDbObjectPtr.h"
|
||
#include "PickEntSet.h"
|
||
#include "ElevationCalcDlg.h"
|
||
#include "ElevationCalc.h"
|
||
#include "DbWell.h"
|
||
#include "WellCalcModifyEleDlg.h"
|
||
#include "ElevationCheckDlg.h"
|
||
#include "EditWellLayingDepthDlg.h"
|
||
#include "EditPipeDnGradientDlg.h"
|
||
#include "DbPool.h"
|
||
#include <stack>
|
||
#include <algorithm>
|
||
|
||
#include "PositiveElevationCalc.h"
|
||
#include "ReverseElevationCalc.h"
|
||
#include "dbgridsheet.h"
|
||
#include "XText.h"
|
||
#include "layerdef.h"
|
||
|
||
#include "DbPipe.h"
|
||
#include <set>
|
||
#include "TGAs.h"
|
||
|
||
bool IsCalced(SSearchPipeList *pList, bool bFromImport = true);
|
||
AcDbObjectId InitLayer(const TCHAR *szLayer, BOOL bApplyChange = TRUE);
|
||
namespace
|
||
{
|
||
void ResetPipeDir(SSearchPipeList *pListAll)
|
||
{
|
||
long len = pListAll->m_lstNode.Length();
|
||
if (pListAll->m_iType == 0) {
|
||
XPoint ptFront;
|
||
if (pListAll->m_pPrevious != NULL) {
|
||
OPENOBJ_BEGIN(pListAll->m_pPrevious->m_ID, AcDb::kForRead, CDbPipeNode, pNode);
|
||
if (pNode) {
|
||
ptFront = pNode->GetLocation();
|
||
// cet 2012.7.26 add 考虑化粪池
|
||
CDbPool *pPool = CDbPool::cast(pNode);
|
||
if (pPool != NULL)
|
||
{
|
||
int nNum = pPool->GetInterfaceNum();
|
||
for (int i = 0; i < nNum; i++)
|
||
{
|
||
const CPipeInterface &face = pPool->GetInterface(i);
|
||
if (face.m_idPipe == pListAll->m_ID)
|
||
{
|
||
ptFront = face.m_ptLocation;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
OPENOBJ_BEGIN(pListAll->m_ID, AcDb::kForWrite, CDbPipe, pPipe);
|
||
if (pPipe && !!ptFront) {
|
||
XPoint p1 = ptFront;
|
||
p1.z = 0;
|
||
XPoint p2 = pPipe->StartPoint();
|
||
p2.z = 0;
|
||
if (pPipe->IsVertical()) // 考虑立管 cet 2011.9.15 add
|
||
{
|
||
if (pPipe->StartPoint().z > pPipe->EndPoint().z)
|
||
{
|
||
pPipe->SetFlowDir(TPipeSys::kFromStart);
|
||
}
|
||
else
|
||
{
|
||
pPipe->SetFlowDir(TPipeSys::kFromEnd);
|
||
}
|
||
}
|
||
else if (p1 == p2)
|
||
pPipe->SetFlowDir(TPipeSys::kFromEnd);
|
||
else
|
||
pPipe->SetFlowDir(TPipeSys::kFromStart);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
for (long i = 0; i < len; i++) {
|
||
SSearchPipeList *pList = pListAll->m_lstNode[i];
|
||
ResetPipeDir(pList);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CloseLayer(const CString &strLayer, BOOL bOff)
|
||
{
|
||
AcDbObjectId idLayer = GlobalFunc::GetLayerRecordId(strLayer);
|
||
AcDbLayerTableRecord *pLayer = NULL;
|
||
acdbOpenObject(pLayer, idLayer, AcDb::kForWrite);
|
||
if (pLayer != NULL)
|
||
{
|
||
pLayer->setIsOff(bOff ? false : true);
|
||
pLayer->close();
|
||
}
|
||
}
|
||
|
||
void SetLayer(std::vector<BOOL> &vec)
|
||
{
|
||
CloseLayer(LAY_PIPE_FEED, vec[0]);
|
||
CloseLayer(LAY_PIPE_FEED2, vec[0]);
|
||
CloseLayer(LAY_PIPE_FEED3, vec[0]);
|
||
CloseLayer(LAY_VPIPE_FEED, vec[0]);
|
||
CloseLayer(LAY_VPIPE_FEED2, vec[0]);
|
||
CloseLayer(LAY_VPIPE_FEED3, vec[0]);
|
||
|
||
CloseLayer(LAY_WELL_FEED, vec[0]);
|
||
CloseLayer(LAY_TEXT_FEED, vec[0]);
|
||
CloseLayer(LAY_VALVE_FEED, vec[0]);
|
||
CloseLayer(LAY_DIM_FEED, vec[0]);
|
||
|
||
CloseLayer(LAY_PIPE_HEADFEED, vec[1]);
|
||
CloseLayer(LAY_VPIPE_HEADFEED, vec[1]);
|
||
CloseLayer(LAY_PIPE_HEADFEED2, vec[1]);
|
||
CloseLayer(LAY_VPIPE_HEADFEED2, vec[1]);
|
||
CloseLayer(LAY_PIPE_HEADFEED3, vec[1]);
|
||
CloseLayer(LAY_VPIPE_HEADFEED3, vec[1]);
|
||
|
||
CloseLayer(LAY_TEXT_HEADFEED, vec[1]);
|
||
CloseLayer(LAY_VALVE_HEADFEED, vec[1]);
|
||
CloseLayer(LAY_DIM_HEADFEED, vec[1]);
|
||
|
||
CloseLayer(LAY_PIPE_HEADBACK, vec[2]);
|
||
CloseLayer(LAY_VPIPE_HEADBACK, vec[2]);
|
||
CloseLayer(LAY_PIPE_HEADBACK2, vec[2]);
|
||
CloseLayer(LAY_VPIPE_HEADBACK2, vec[2]);
|
||
CloseLayer(LAY_PIPE_HEADBACK3, vec[2]);
|
||
CloseLayer(LAY_VPIPE_HEADBACK3, vec[2]);
|
||
|
||
CloseLayer(LAY_TEXT_HEADBACK, vec[2]);
|
||
CloseLayer(LAY_VALVE_HEADBACK, vec[2]);
|
||
CloseLayer(LAY_DIM_HEADBACK, vec[2]);
|
||
|
||
CloseLayer(LAY_PIPE_DIRT, vec[3]);
|
||
CloseLayer(LAY_VPIPE_DIRT, vec[3]);
|
||
|
||
CloseLayer(LAY_TEXT_DIRT, vec[3]);
|
||
CloseLayer(LAY_VALVE_DIRT, vec[3]);
|
||
CloseLayer(LAY_DIM_DIRT, vec[3]);
|
||
CloseLayer(LAY_WELL_DIRT, vec[3]);
|
||
|
||
CloseLayer(LAY_PIPE_USELESS, vec[4]);
|
||
CloseLayer(LAY_VPIPE_USELESS, vec[4]);
|
||
|
||
CloseLayer(LAY_TEXT_USELESS, vec[4]);
|
||
CloseLayer(LAY_VALVE_USELESS, vec[4]);
|
||
CloseLayer(LAY_DIM_USELESS, vec[4]);
|
||
CloseLayer(LAY_WELL_USELESS, vec[4]);
|
||
|
||
CloseLayer(LAY_PIPE_RAIN, vec[5]);
|
||
CloseLayer(LAY_VPIPE_RAIN, vec[5]);
|
||
|
||
CloseLayer(LAY_TEXT_RAIN, vec[5]);
|
||
CloseLayer(LAY_VALVE_RAIN, vec[5]);
|
||
CloseLayer(LAY_DIM_RAIN, vec[5]);
|
||
CloseLayer(LAY_WELL_RAIN, vec[5]);
|
||
|
||
CloseLayer(LAY_PIPE_USED, vec[6]);
|
||
CloseLayer(LAY_VPIPE_USED, vec[6]);
|
||
|
||
CloseLayer(LAY_TEXT_USED, vec[6]);
|
||
CloseLayer(LAY_VALVE_USED, vec[6]);
|
||
CloseLayer(LAY_DIM_USED, vec[6]);
|
||
CloseLayer(LAY_WELL_USED, vec[6]);
|
||
|
||
CloseLayer(LAY_PIPE_FIRE, vec[7]);
|
||
CloseLayer(LAY_VPIPE_FIRE, vec[7]);
|
||
CloseLayer(LAY_PIPE_FIRE2, vec[7]);
|
||
CloseLayer(LAY_VPIPE_FIRE2, vec[7]);
|
||
CloseLayer(LAY_PIPE_FIRE3, vec[7]);
|
||
CloseLayer(LAY_VPIPE_FIRE3, vec[7]);
|
||
|
||
CloseLayer(LAY_TEXT_FIRE, vec[7]);
|
||
CloseLayer(LAY_VALVE_FIRE, vec[7]);
|
||
CloseLayer(LAY_DIM_FIRE, vec[7]);
|
||
CloseLayer(LAY_WELL_FIRE, vec[7]);
|
||
|
||
CloseLayer(LAY_PIPE_SPRINKLE, vec[8]);
|
||
CloseLayer(LAY_VPIPE_SPRINKLE, vec[8]);
|
||
|
||
CloseLayer(LAY_TEXT_SPRINKLE, vec[8]);
|
||
CloseLayer(LAY_VALVE_SPRINKLE, vec[8]);
|
||
CloseLayer(LAY_DIM_SPRINKLE, vec[8]);
|
||
|
||
CloseLayer(LAY_PIPE_COAGULATE, vec[9]);
|
||
CloseLayer(LAY_VPIPE_COAGULATE, vec[9]);
|
||
|
||
CloseLayer(LAY_TEXT_COAGULATE, vec[9]);
|
||
CloseLayer(LAY_VALVE_COAGULATE, vec[9]);
|
||
CloseLayer(LAY_DIM_COAGULATE, vec[9]);
|
||
|
||
CloseLayer(LAY_PIPE_DRINK, vec[10]);
|
||
CloseLayer(LAY_VPIPE_DRINK, vec[10]);
|
||
|
||
CloseLayer(LAY_TEXT_DRINK, vec[10]);
|
||
CloseLayer(LAY_VALVE_DRINK, vec[10]);
|
||
CloseLayer(LAY_DIM_DRINK, vec[10]);
|
||
|
||
CloseLayer(LAY_PIPE_PRESSDIRT, vec[11]);
|
||
CloseLayer(LAY_VPIPE_PRESSDIRT, vec[11]);
|
||
|
||
CloseLayer(LAY_TEXT_PRESSDIRT, vec[11]);
|
||
CloseLayer(LAY_VALVE_PRESSDIRT, vec[11]);
|
||
CloseLayer(LAY_DIM_PRESSDIRT, vec[11]);
|
||
|
||
CloseLayer(LAY_PIPE_PRESSUSELESS, vec[12]);
|
||
CloseLayer(LAY_VPIPE_PRESSUSELESS, vec[12]);
|
||
|
||
CloseLayer(LAY_TEXT_PRESSUSELESS, vec[12]);
|
||
CloseLayer(LAY_VALVE_PRESSUSELESS, vec[12]);
|
||
CloseLayer(LAY_DIM_PRESSUSELESS, vec[12]);
|
||
|
||
CloseLayer(LAY_PIPE_PRESSRAIN, vec[13]);
|
||
CloseLayer(LAY_VPIPE_PRESSRAIN, vec[13]);
|
||
|
||
CloseLayer(LAY_TEXT_PRESSRAIN, vec[13]);
|
||
CloseLayer(LAY_VALVE_PRESSRAIN, vec[13]);
|
||
CloseLayer(LAY_DIM_PRESSRAIN, vec[13]);
|
||
|
||
|
||
CloseLayer(LAY_PIPE_OTHER, vec[14]);
|
||
CloseLayer(LAY_VPIPE_OTHER, vec[14]);
|
||
|
||
CloseLayer(LAY_TEXT_OTHER, vec[14]);
|
||
CloseLayer(LAY_VALVE_OTHER, vec[14]);
|
||
CloseLayer(LAY_DIM_OTHER, vec[14]);
|
||
CloseLayer(LAY_WELL_OTHER, vec[14]);
|
||
}
|
||
|
||
CString GetPipeLayer(SSearchPipeList *pList)
|
||
{
|
||
CString strPipeLayer;
|
||
std::stack<SSearchPipeList *> data;
|
||
data.push(pList);
|
||
while (!data.empty())
|
||
{
|
||
SSearchPipeList *pTemp = data.top();
|
||
data.pop();
|
||
if (pTemp->m_iType == 0)
|
||
{
|
||
CDbPipe *pPipe = NULL;
|
||
acdbOpenObject(pPipe, pTemp->m_ID, AcDb::kForRead);
|
||
if (pPipe != NULL)
|
||
{
|
||
strPipeLayer = pPipe->layer();
|
||
pPipe->close();
|
||
}
|
||
break;
|
||
}
|
||
|
||
for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
|
||
{
|
||
data.push(pTemp->m_lstNode[i]);
|
||
}
|
||
}
|
||
return strPipeLayer;
|
||
}
|
||
|
||
// 设置各图层开关 bClosed = true 时 关闭与strPipeLayer 图层无关的图层
|
||
// bClosed = false 时 打开所有图层
|
||
void SetLayerOpenClose(const CString strPipeLayer, BOOL bClosed)
|
||
{
|
||
if (!strPipeLayer.IsEmpty())
|
||
{
|
||
std::vector<BOOL> vec; // 各图层开关值
|
||
for (int i = 0; i < 15; i++)
|
||
{
|
||
vec.push_back(!bClosed);
|
||
}
|
||
|
||
if (bClosed) //需关闭其他图层时
|
||
{
|
||
if (strPipeLayer.Compare(LAY_PIPE_FEED) == 0 || strPipeLayer.Compare(LAY_PIPE_FEED2) == 0 || strPipeLayer.Compare(LAY_PIPE_FEED3) == 0 ||
|
||
strPipeLayer.Compare(LAY_VPIPE_FEED) == 0 || strPipeLayer.Compare(LAY_VPIPE_FEED2) == 0 || strPipeLayer.Compare(LAY_VPIPE_FEED3) == 0)
|
||
{
|
||
vec[0] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_HEADFEED) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADFEED) == 0 ||
|
||
strPipeLayer.Compare(LAY_PIPE_HEADFEED2) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADFEED3) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADFEED3) == 0)
|
||
{
|
||
vec[1] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_HEADBACK) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADBACK) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADBACK2) == 0 ||
|
||
strPipeLayer.Compare(LAY_VPIPE_HEADBACK2) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADBACK3) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADBACK3) == 0)
|
||
{
|
||
vec[2] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_DIRT) == 0 || strPipeLayer.Compare(LAY_VPIPE_DIRT) == 0)
|
||
{
|
||
vec[3] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_USELESS) == 0 || strPipeLayer.Compare(LAY_VPIPE_USELESS) == 0)
|
||
{
|
||
vec[4] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_RAIN) == 0 || strPipeLayer.Compare(LAY_VPIPE_RAIN) == 0)
|
||
{
|
||
vec[5] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_USED) == 0 || strPipeLayer.Compare(LAY_VPIPE_USED) == 0)
|
||
{
|
||
vec[6] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_FIRE) == 0 || strPipeLayer.Compare(LAY_VPIPE_FIRE) == 0 || strPipeLayer.Compare(LAY_PIPE_FIRE2) == 0 ||
|
||
strPipeLayer.Compare(LAY_VPIPE_FIRE2) == 0 || strPipeLayer.Compare(LAY_PIPE_FIRE3) == 0 || strPipeLayer.Compare(LAY_VPIPE_FIRE3) == 0)
|
||
{
|
||
vec[7] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_SPRINKLE) == 0 || strPipeLayer.Compare(LAY_VPIPE_SPRINKLE) == 0)
|
||
{
|
||
vec[8] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_COAGULATE) == 0 || strPipeLayer.Compare(LAY_VPIPE_COAGULATE) == 0)
|
||
{
|
||
vec[9] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_DRINK) == 0 || strPipeLayer.Compare(LAY_VPIPE_DRINK) == 0)
|
||
{
|
||
vec[10] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_PRESSDIRT) == 0 || strPipeLayer.Compare(LAY_VPIPE_PRESSDIRT) == 0)
|
||
{
|
||
vec[11] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_PRESSUSELESS) == 0 || strPipeLayer.Compare(LAY_VPIPE_PRESSUSELESS) == 0)
|
||
{
|
||
vec[12] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_PRESSRAIN) == 0 || strPipeLayer.Compare(LAY_VPIPE_PRESSRAIN) == 0)
|
||
{
|
||
vec[13] = TRUE;
|
||
}
|
||
else if (strPipeLayer.Compare(LAY_PIPE_OTHER) == 0 || strPipeLayer.Compare(LAY_VPIPE_OTHER) == 0)
|
||
{
|
||
vec[14] = TRUE;
|
||
}
|
||
}
|
||
|
||
SetLayer(vec);
|
||
}
|
||
}
|
||
|
||
// cet 2012.10.10 add 删除plist中存在stackData中的节点
|
||
void DelNode(std::stack<SSearchPipeList*> &stackData, SSearchPipeList *pList)
|
||
{
|
||
if (stackData.empty() || pList == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
std::vector<SSearchPipeList*> vecSrc;
|
||
while (!stackData.empty())
|
||
{
|
||
vecSrc.push_back(stackData.top());
|
||
stackData.pop();
|
||
}
|
||
|
||
std::stack<SSearchPipeList*> stkTemp;
|
||
stkTemp.push(pList);
|
||
SSearchPipeList *pTemp = NULL;
|
||
std::vector<SSearchPipeList*>::iterator it;
|
||
while (!stkTemp.empty())
|
||
{
|
||
pTemp = stkTemp.top();
|
||
stkTemp.pop();
|
||
it = std::find(vecSrc.begin(), vecSrc.end(), pTemp);
|
||
if (it != vecSrc.end())
|
||
{
|
||
vecSrc.erase(it);
|
||
}
|
||
|
||
for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
|
||
{
|
||
stkTemp.push(pTemp->m_lstNode[i]);
|
||
}
|
||
}
|
||
|
||
for (it = vecSrc.begin(); it != vecSrc.end(); it++)
|
||
{
|
||
stackData.push(*it);
|
||
}
|
||
|
||
}
|
||
|
||
// cet 2011.10.28 add 检查管网系统，保证待计算管网末端均为井
|
||
void CheckPipeSys(SSearchPipeList *pListAll)
|
||
{
|
||
if (pListAll == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SSearchPipeList *pTemp = NULL;
|
||
std::stack<SSearchPipeList*> stackData;
|
||
stackData.push(pListAll);
|
||
while (!stackData.empty())
|
||
{
|
||
pTemp = stackData.top();
|
||
stackData.pop();
|
||
if (pTemp->m_iType != 3 && pTemp->m_lstNode.Length() == 0) // 叶子非井
|
||
{
|
||
while (pTemp->m_pPrevious != NULL && pTemp->m_pPrevious->m_iType != 3) // 找出父节点为井的节点
|
||
{
|
||
pTemp = pTemp->m_pPrevious;
|
||
}
|
||
|
||
if (pTemp->m_pPrevious != NULL) // 父节点为井
|
||
{
|
||
for (int i = 0; i < pTemp->m_pPrevious->m_lstNode.Length(); i++)
|
||
{
|
||
if (pTemp->m_pPrevious->m_lstNode[i] == pTemp)
|
||
{
|
||
DelNode(stackData, pTemp); // 删除堆栈中ptemp链的节点
|
||
pTemp->m_pPrevious->m_lstNode.Remove(i);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 将当前节点的子节点放入栈中
|
||
for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
|
||
{
|
||
stackData.push(pTemp->m_lstNode[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// cet 2012.10.10 add 在缺少井的地方打叉提示
|
||
void DrawTipLabel(PickSet &ss)
|
||
{
|
||
std::vector<AcGePoint3d> vecPts;
|
||
for (long i = 0; i < ss.Length(); i++)
|
||
{
|
||
OPENOBJ_BEGIN(ss[i], AcDb::kForWrite, CDbPipe, pPipe);
|
||
if (pPipe != NULL)
|
||
{
|
||
ads_name name0;
|
||
acdbGetAdsName(name0, pPipe->GetNode(0));
|
||
Entity ent0(name0);
|
||
if (!ent0.Is(_T("AEC_ZT_WELL")) && !ent0.Is(_T("AEC_ZT_POOL")))
|
||
{
|
||
vecPts.push_back(pPipe->StartPoint());
|
||
}
|
||
|
||
ads_name name1;
|
||
acdbGetAdsName(name1, pPipe->GetNode(1));
|
||
Entity ent1(name1);
|
||
if (!ent1.Is(_T("AEC_ZT_WELL")) && !ent1.Is(_T("AEC_ZT_POOL")))
|
||
{
|
||
vecPts.push_back(pPipe->EndPoint());
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
CString sLayer = GlobalFunc::GetPipeLayer(ss[0l]);
|
||
ss.Free();
|
||
std::unique(vecPts.begin(), vecPts.end());
|
||
std::vector<AcGePoint3d>::iterator it;
|
||
double dDist = 13 * GlobalFunc::DocGetPScale();
|
||
XPoint pt1, pt2, pt3, pt4, ptMid;
|
||
for (it = vecPts.begin(); it != vecPts.end(); it++)
|
||
{
|
||
ptMid = *it;
|
||
ptMid = GlobalFunc::Wcs2Ucs(ptMid);
|
||
ads_polar(ptMid, 0, dDist, pt1);
|
||
ads_polar(pt1, PI / 2, dDist, pt1);
|
||
ads_polar(ptMid, PI, dDist, pt2);
|
||
ads_polar(pt2, PI / 2, -dDist, pt2);
|
||
|
||
AcDbLine *pLine1 = new AcDbLine(GlobalFunc::Wcs2Ucs(pt1), GlobalFunc::Wcs2Ucs(pt2));
|
||
pLine1->setLayer(sLayer);
|
||
pLine1->setColorIndex(1);
|
||
ss += GlobalFunc::AddToCurrentSpace(pLine1, Adesk::kTrue);
|
||
|
||
ads_polar(ptMid, PI / 2, dDist, pt3);
|
||
ads_polar(pt3, PI, dDist, pt3);
|
||
ads_polar(ptMid, PI / 2, -dDist, pt4);
|
||
ads_polar(pt4, 0, dDist, pt4);
|
||
AcDbLine *pLine2 = new AcDbLine(GlobalFunc::Wcs2Ucs(pt3), GlobalFunc::Wcs2Ucs(pt4));
|
||
pLine2->setLayer(sLayer);
|
||
pLine2->setColorIndex(1);
|
||
ss += GlobalFunc::AddToCurrentSpace(pLine2, Adesk::kTrue);
|
||
}
|
||
}
|
||
|
||
|
||
// 检查管网中管线两端是否都连接着井或化粪池 cet 2012.10.10 add
|
||
bool CheckSysLink(SSearchPipeList *pList, PickSet &ss)
|
||
{
|
||
ss.Free();
|
||
if (pList == NULL)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
std::stack<SSearchPipeList*> stackData;
|
||
stackData.push(pList);
|
||
SSearchPipeList *pTemp = NULL;
|
||
while (!stackData.empty())
|
||
{
|
||
pTemp = stackData.top();
|
||
stackData.pop();
|
||
|
||
if (pTemp->m_iType == 0) // 管线
|
||
{
|
||
if (pTemp->m_pPrevious != NULL && pTemp->m_pPrevious->m_iType != 3 && pTemp->m_pPrevious->m_iType != 4)
|
||
{
|
||
ss += pTemp->m_ID;
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
|
||
{
|
||
stackData.push(pTemp->m_lstNode[i]);
|
||
if (pTemp->m_iType == 0 && pTemp->m_lstNode[i]->m_iType != 3 && pTemp->m_lstNode[i]->m_iType != 4)
|
||
{
|
||
ss += pTemp->m_ID;
|
||
}
|
||
}
|
||
}
|
||
return ss.Length() == 0 ? true : false;
|
||
}
|
||
|
||
void ElevationCalc()
|
||
{
|
||
RBList rbMask = ads_buildlist(-4, _T("<or"),
|
||
-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_DIRT, -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_RAIN, -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_USELESS, -4, _T("and>"),
|
||
-4, _T("or>"), NULL);
|
||
|
||
Entity entMain;
|
||
if (GlobalFunc::SelectEntity(_T("\n请选择排出井<退出>:"), entMain, rbMask) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
SSearchPipeList *pListAll = new SSearchPipeList();
|
||
PickSet ssAll(SS_FREE);
|
||
ssAll += entMain;
|
||
|
||
if (!GlobalFunc::SearchSprinkPipeSys(entMain, NULL, pListAll, ssAll))
|
||
{
|
||
acutPrintf(_T("\n系统有回路！"));
|
||
delete pListAll;
|
||
return;
|
||
}
|
||
|
||
if (entMain.Is(_T("AEC_ZT_WELL")))
|
||
{
|
||
pListAll->m_iType = 3;
|
||
}
|
||
|
||
// 处理计算过的管网 cet 2012.7.26 add
|
||
if (IsCalced(pListAll, false))
|
||
{
|
||
ssAll.Redraw(3);
|
||
TCHAR szTmp[256];
|
||
int nRet = 0;
|
||
INITGET_BEG(0, _T("A"));
|
||
nRet = ads_getkword(_T("\n需要计算的管网系统已高亮显示[读取已经算信息(A)]<重新计算>:"), szTmp);
|
||
INITGET_END();
|
||
if (nRet == RTNORM)
|
||
{
|
||
ssAll.Redraw(4);
|
||
// 关闭无关图层
|
||
CString strPipeLayer = GetPipeLayer(pListAll);
|
||
SetLayerOpenClose(strPipeLayer, TRUE);
|
||
// 检查管网系统，保证待计算管网末端(叶子节点)均为井
|
||
CheckPipeSys(pListAll);
|
||
// cet 2012.10.10 add 检查管网连接
|
||
PickSet ss(SS_FREE);
|
||
if (!CheckSysLink(pListAll, ss))
|
||
{
|
||
delete pListAll;
|
||
AfxMessageBox(_T("管线间缺少井，无法计算！"));
|
||
DrawTipLabel(ss);
|
||
GlobalFunc::AnyKeyReturn(_T("\n按任意键清除错误标记:"));
|
||
ss.Erase();
|
||
// 打开所有图层
|
||
SetLayerOpenClose(strPipeLayer, FALSE);
|
||
return;
|
||
}
|
||
|
||
CTemporaryResourceOverride vTemp2;
|
||
CElevationCalcDlg dlg;
|
||
dlg.SetCalced(TRUE);
|
||
dlg.SetPipeSysList(pListAll);
|
||
dlg.SetPipeType(strPipeLayer);
|
||
dlg.DoModal();
|
||
delete pListAll;
|
||
// 打开所有图层
|
||
SetLayerOpenClose(strPipeLayer, FALSE);
|
||
return;
|
||
}
|
||
else if (nRet == RTCAN)
|
||
{
|
||
ssAll.Redraw(4);
|
||
delete pListAll;
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 关闭无关图层
|
||
CString strPipeLayer = GetPipeLayer(pListAll);
|
||
SetLayerOpenClose(strPipeLayer, TRUE);
|
||
|
||
// 设置管径坡度
|
||
CTemporaryResourceOverride vTemp1;
|
||
CEditPipeDnGradientDlg dlg1(0, acedGetAcadFrame());
|
||
dlg1.SetPipeList(pListAll);
|
||
dlg1.Create(IDD_PIPE_RADIUSGRADIENT);
|
||
dlg1.ShowWindow(SW_SHOW);
|
||
dlg1.ModifyPipe();
|
||
|
||
// cet 2011.10.28 add 检查管网系统，保证待计算管网末端(叶子节点)均为井
|
||
CheckPipeSys(pListAll);
|
||
// cet 2012.10.10 add 检查管网连接
|
||
PickSet ss(SS_FREE);
|
||
if (!CheckSysLink(pListAll, ss))
|
||
{
|
||
delete pListAll;
|
||
AfxMessageBox(_T("管线间缺少井，无法计算！"));
|
||
DrawTipLabel(ss);
|
||
GlobalFunc::AnyKeyReturn(_T("\n按任意键清除错误标记:"));
|
||
ss.Erase();
|
||
// 打开所有图层
|
||
SetLayerOpenClose(strPipeLayer, FALSE);
|
||
return;
|
||
}
|
||
|
||
CTemporaryResourceOverride vTemp2;
|
||
CElevationCalcDlg dlg;
|
||
dlg.SetPipeSysList(pListAll);
|
||
dlg.SetPipeType(strPipeLayer);
|
||
dlg.DoModal();
|
||
delete pListAll;
|
||
|
||
// 打开所有图层
|
||
SetLayerOpenClose(strPipeLayer, FALSE);
|
||
}
|
||
|
||
CElevationCalcGrid::CElevationCalcGrid()
|
||
{
|
||
m_nRowForEndWell = -1;
|
||
m_bModifyColor = FALSE;
|
||
}
|
||
|
||
BEGIN_MESSAGE_MAP(CElevationCalcGrid, WDGrid)
|
||
//{{AFX_MSG_MAP(CElevationCalcGrid)
|
||
ON_WM_MOUSEMOVE()
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
void CElevationCalcGrid::SetWnd(CElevationCalcDlg* pWnd)
|
||
{
|
||
m_pWnd = pWnd;
|
||
}
|
||
|
||
void CElevationCalcGrid::OnDblClick(WDGridRow&row)
|
||
{
|
||
if (m_pWnd != NULL)
|
||
{
|
||
m_pWnd->DblClickLst();
|
||
}
|
||
}
|
||
|
||
bool CElevationCalcGrid::OnModified(WDGridCell&cell, CString &text)
|
||
{
|
||
long i = cell.GetColIndex();
|
||
if ((i == 4 || i == 3) && m_pWnd != NULL)
|
||
{
|
||
m_pWnd->UpdatePipeInfo(cell.GetRowIndex(), i, _tstof(text));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void CElevationCalcGrid::OnBeforeRefresh(WDGridCell &cell)
|
||
{
|
||
if (cell.GetColIndex() == 0 || cell.GetColIndex() == 1)
|
||
{
|
||
std::set<int>::iterator it;
|
||
it = m_setRow.find(cell.GetRowIndex());
|
||
if (it != m_setRow.end())
|
||
{
|
||
CDC&dc = GetDC();
|
||
COLORREF color = acedGetRGB(6);
|
||
dc.SetTextColor(color);
|
||
dc.SetBkMode(TRANSPARENT);
|
||
}
|
||
|
||
// cet 2011.7.26 modify
|
||
// else
|
||
// WDGrid::OnBeforeRefresh(cell);
|
||
|
||
// cet 2011.11.28 modify 为满足不同情况跌水井设置
|
||
// std::vector<CString>::iterator it1;
|
||
// it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), cell.GetText());
|
||
// if (it1 != m_vecWellName.end())
|
||
// {
|
||
// CDC&dc=GetDC();
|
||
// COLORREF color=acedGetRGB(2);
|
||
// dc.SetBkColor(color);
|
||
// dc.SetBkMode(TRANSPARENT);
|
||
// }
|
||
//
|
||
// if (it == m_setRow.end() && it1 == m_vecWellName.end())
|
||
// {
|
||
// WDGrid::OnBeforeRefresh(cell);
|
||
// }
|
||
std::map<CString, int>::iterator itS;
|
||
CString sWellName = (LPCTSTR)cell.GetText();
|
||
itS = m_mapWellColor.find(sWellName);
|
||
if (itS != m_mapWellColor.end())
|
||
{
|
||
CDC&dc = GetDC();
|
||
COLORREF color = acedGetRGB((*itS).second);
|
||
dc.SetBkColor(color);
|
||
dc.SetBkMode(TRANSPARENT);
|
||
}
|
||
|
||
if (it == m_setRow.end() && itS == m_mapWellColor.end())
|
||
{
|
||
WDGrid::OnBeforeRefresh(cell);
|
||
}
|
||
}
|
||
else if (cell.GetColIndex() == 9 && cell.GetRowIndex() == m_nRowForEndWell &&
|
||
m_bModifyColor)
|
||
{
|
||
CDC&dc = GetDC();
|
||
COLORREF color = acedGetRGB(6);
|
||
dc.SetTextColor(color);
|
||
dc.SetBkMode(TRANSPARENT);
|
||
}
|
||
else
|
||
WDGrid::OnBeforeRefresh(cell);
|
||
}
|
||
|
||
void CElevationCalcGrid::SetColorPipe(const std::vector<AcDbObjectId> &data)
|
||
{
|
||
m_setRow.clear();
|
||
std::vector<AcDbObjectId>::const_iterator it;
|
||
for (it = data.begin(); it != data.end(); it++)
|
||
{
|
||
std::map<AcDbObjectId, int>::iterator it2;
|
||
it2 = m_mapRow.find(*it);
|
||
if (it2 != m_mapRow.end())
|
||
{
|
||
m_setRow.insert((*it2).second);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcGrid::SetRowforEndWell(int nRow)
|
||
{
|
||
m_nRowForEndWell = nRow;
|
||
}
|
||
|
||
void CElevationCalcGrid::SetPipeRow(const std::map<AcDbObjectId, int> &data)
|
||
{
|
||
m_mapRow = data;
|
||
}
|
||
|
||
void CElevationCalcGrid::SetModifyColorforEndWell(BOOL bModify)
|
||
{
|
||
m_bModifyColor = bModify;
|
||
}
|
||
|
||
// void CElevationCalcGrid::SetDropWell(const std::vector<CString> &data)
|
||
// {
|
||
// m_vecWellName.clear();
|
||
// m_vecWellName = data;
|
||
// }
|
||
|
||
void CElevationCalcGrid::setWellColor(const std::map<CString, int> &mapWellColor)
|
||
{
|
||
m_mapWellColor = mapWellColor;
|
||
}
|
||
|
||
void CElevationCalcGrid::setWellTip(const std::map<CString, CString> &mapWellTip)
|
||
{
|
||
m_mapWellTip = mapWellTip;
|
||
}
|
||
|
||
void CElevationCalcGrid::OnCellComboString(WDGridCell&cell, CComboBox&combo)
|
||
{
|
||
if (cell.GetColIndex() == 3)
|
||
{
|
||
combo.AddString(_T("200"));
|
||
combo.AddString(_T("250"));
|
||
combo.AddString(_T("300"));
|
||
combo.AddString(_T("350"));
|
||
combo.AddString(_T("400"));
|
||
combo.AddString(_T("450"));
|
||
combo.AddString(_T("500"));
|
||
combo.AddString(_T("600"));
|
||
}
|
||
else if (cell.GetColIndex() == 4)
|
||
{
|
||
combo.AddString(_T("1"));
|
||
combo.AddString(_T("2"));
|
||
combo.AddString(_T("3"));
|
||
combo.AddString(_T("4"));
|
||
combo.AddString(_T("5"));
|
||
combo.AddString(_T("6"));
|
||
}
|
||
}
|
||
|
||
BOOL CElevationCalcGrid::PreTranslateMessage(MSG* pMsg)
|
||
{
|
||
if (pMsg->message == WM_MOUSEMOVE)
|
||
{
|
||
if (m_ToolTip.m_hWnd != NULL)
|
||
{
|
||
m_ToolTip.RelayEvent(pMsg);
|
||
}
|
||
}
|
||
|
||
return WDGrid::PreTranslateMessage(pMsg);
|
||
}
|
||
|
||
void CElevationCalcGrid::OnMouseMove(UINT nFlags, CPoint point)
|
||
{
|
||
CString sCellText = _T("");
|
||
long lRow = -1, lCol = -1;
|
||
PtToCell(point, lRow, lCol);
|
||
std::map<CString, CString>::iterator it; // cet 2011.11.28 add
|
||
if (IsValidRow(lRow) && IsValidCol(lCol) && (lCol == 0 || lCol == 1))
|
||
{
|
||
CString sText = (LPCTSTR)GetCell(lRow, lCol).GetText();
|
||
// cet 2011.11.28 modify
|
||
// std::vector<CString>::iterator it;
|
||
// it = std::find(m_vecWellName.begin(), m_vecWellName.end(), sText);
|
||
// if (it != m_vecWellName.end())
|
||
// {
|
||
// sCellText = _T("计算中产生的跌水井");
|
||
// }
|
||
|
||
it = m_mapWellTip.find(sText);
|
||
if (it != m_mapWellTip.end())
|
||
{
|
||
sCellText = (*it).second;
|
||
}
|
||
}
|
||
|
||
SetToolTipText(sCellText, TRUE);
|
||
|
||
WDGrid::OnMouseMove(nFlags, point);
|
||
}
|
||
|
||
void CElevationCalcGrid::SetToolTipText(LPCTSTR pspText, BOOL bActivate)
|
||
{
|
||
if (pspText == NULL) return;
|
||
|
||
if (m_ToolTip.m_hWnd == NULL)
|
||
{
|
||
m_ToolTip.Create(this);
|
||
m_ToolTip.SetMaxTipWidth(500);
|
||
CRect rect;
|
||
GetClientRect(rect);
|
||
m_ToolTip.AddTool(this, LPSTR_TEXTCALLBACK, rect);
|
||
}
|
||
|
||
m_ToolTip.UpdateTipText(pspText, this);
|
||
m_ToolTip.Activate(bActivate);
|
||
}
|
||
|
||
|
||
CElevationCalcDlg::CElevationCalcDlg(CWnd* pParent /*=NULL*/)
|
||
: CDialog(CElevationCalcDlg::IDD, pParent)
|
||
{
|
||
//{{AFX_DATA_INIT(CElevationCalcDlg)
|
||
m_dWndEdtLayingDepth = 1.1;
|
||
m_dMinThick = 0.7;
|
||
m_bWndChkReverseCalc = FALSE;
|
||
m_bWndChkLayingDepth = FALSE;
|
||
m_bWndChkMinThick = FALSE;
|
||
m_strPipeEleDown = _T("");
|
||
//}}AFX_DATA_INIT
|
||
m_bCalc = FALSE;
|
||
// m_pPositiveCalc = new PositiveElevationCalc;
|
||
m_pPositiveCalc = NULL;
|
||
m_pReverseCalc = NULL;
|
||
m_pElevationCalc = NULL;
|
||
m_bFirstRunCmd = false; // cet 2012.6.21 add
|
||
m_bOnlySWell = false; // cet 2012.6.26 add
|
||
}
|
||
|
||
CElevationCalcDlg::~CElevationCalcDlg()
|
||
{
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
delete m_pReverseCalc;
|
||
}
|
||
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
delete m_pPositiveCalc;
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
CDialog::DoDataExchange(pDX);
|
||
//{{AFX_DATA_MAP(CElevationCalcDlg)
|
||
DDX_Control(pDX, IDC_LIST_PIPE, m_lstCtrl);
|
||
DDX_Text(pDX, IDC_EDIT_STARTDEEP, m_dWndEdtLayingDepth);
|
||
DDX_Text(pDX, IDC_EDIT_MINTHICK, m_dMinThick);
|
||
DDX_Check(pDX, IDC_CHECK_EDOWNELE, m_bWndChkReverseCalc);
|
||
DDX_Text(pDX, IDC_EDIT_ENDDOWNELE, m_strPipeEleDown);
|
||
//}}AFX_DATA_MAP
|
||
}
|
||
|
||
|
||
BEGIN_MESSAGE_MAP(CElevationCalcDlg, CDialog)
|
||
//{{AFX_MSG_MAP(CElevationCalcDlg)
|
||
ON_BN_CLICKED(IDC_BTN_MODIFYELE, OnBtnModifyele)
|
||
ON_BN_CLICKED(IDC_BTN_CALC, OnBtnCalc)
|
||
ON_BN_CLICKED(IDC_BTN_LAYINGDEPTH, OnBtnLayingdepth)
|
||
ON_BN_CLICKED(IDC_BTN_TODWG, OnBtnTodwg)
|
||
ON_BN_CLICKED(IDC_BTN_TABLE, OnBtnTable)
|
||
ON_BN_CLICKED(IDC_CHECK_EDOWNELE, OnCheckEdownele)
|
||
ON_BN_CLICKED(IDC_BTN_LOOK, OnBtnLook)
|
||
ON_EN_CHANGE(IDC_EDIT_STARTDEEP, OnChangeEditStartdeep)
|
||
ON_EN_CHANGE(IDC_EDIT_MINTHICK, OnChangeEditMinthick)
|
||
ON_WM_CLOSE()
|
||
ON_EN_CHANGE(IDC_EDIT_ENDDOWNELE, OnChangeEditEnddownele)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
|
||
void CElevationCalcDlg::SetPipeSysList(SSearchPipeList *pList)
|
||
{
|
||
m_pAllList = pList;
|
||
}
|
||
|
||
void CElevationCalcDlg::SetPipeType(CString &sPipeLayer)
|
||
{
|
||
if (sPipeLayer.Compare(LAY_PIPE_DIRT) == 0)
|
||
{
|
||
m_sPipeType = _T("污水管道高程表");
|
||
}
|
||
else if (sPipeLayer.Compare(LAY_PIPE_USELESS) == 0)
|
||
{
|
||
m_sPipeType = _T("废水管道高程表");
|
||
}
|
||
else
|
||
{
|
||
m_sPipeType = _T("雨水管道高程表");
|
||
}
|
||
}
|
||
|
||
CString CElevationCalcDlg::GetPipeType()
|
||
{
|
||
return m_sPipeType;
|
||
}
|
||
|
||
BOOL CElevationCalcDlg::OnInitDialog()
|
||
{
|
||
CDialog::OnInitDialog();
|
||
|
||
m_lstCtrl.Clear();
|
||
m_lstCtrl.Create(this, IDC_LIST_PIPE);
|
||
m_lstCtrl.FitLastCol();
|
||
m_lstCtrl.SetNoAppendButton(TRUE);
|
||
m_lstCtrl.SetNoDefaultMenu(true);
|
||
m_lstCtrl.SetWnd(this);
|
||
|
||
m_lstCtrl.AppendCol(_T("起点"), 35);
|
||
m_lstCtrl.AppendCol(_T("终点"), 35);
|
||
m_lstCtrl.AppendCol(_T("管长m"), 50);
|
||
m_lstCtrl.AppendCol(_T("管径mm"), 50);
|
||
|
||
m_lstCtrl.AppendCol(_T("坡度‰"), 50);
|
||
m_lstCtrl.AppendCol(_T("管底坡降"), 56);
|
||
|
||
m_lstCtrl.AppendCol(_T("起点"), 45);
|
||
m_lstCtrl.AppendCol(_T("终点"), 45);
|
||
|
||
m_lstCtrl.AppendCol(_T("起点"), 45);
|
||
m_lstCtrl.AppendCol(_T("终点"), 45);
|
||
m_lstCtrl.AppendCol(_T("起点"), 46);
|
||
m_lstCtrl.AppendCol(_T("终点"), 46);
|
||
|
||
m_lstCtrl.GetCol(0).SetReadOnly();
|
||
m_lstCtrl.GetCol(1).SetReadOnly();
|
||
m_lstCtrl.GetCol(2).SetReadOnly();
|
||
m_lstCtrl.GetCol(5).SetReadOnly();
|
||
m_lstCtrl.GetCol(6).SetReadOnly();
|
||
m_lstCtrl.GetCol(7).SetReadOnly();
|
||
m_lstCtrl.GetCol(8).SetReadOnly();
|
||
m_lstCtrl.GetCol(9).SetReadOnly();
|
||
m_lstCtrl.GetCol(10).SetReadOnly();
|
||
m_lstCtrl.GetCol(11).SetReadOnly();
|
||
// cet 2011.6.16 add
|
||
m_lstCtrl.GetCol(3).SetComboEdit();
|
||
m_lstCtrl.GetCol(4).SetComboEdit();
|
||
|
||
COLORREF color = RGB(255, 0, 0);
|
||
m_lstCtrl.GetCol(3).SetTextColor(color);
|
||
m_lstCtrl.GetCol(4).SetTextColor(color);
|
||
|
||
color = RGB(0, 0, 255);
|
||
m_lstCtrl.GetCol(5).SetTextColor(color);
|
||
m_lstCtrl.GetCol(11).SetTextColor(color);
|
||
m_lstCtrl.GetCol(8).SetTextColor(color);
|
||
m_lstCtrl.GetCol(9).SetTextColor(color);
|
||
m_lstCtrl.GetCol(10).SetTextColor(color);
|
||
|
||
// cet 2012.6.21 add 初始化系统起点井埋深数据
|
||
InitSWellLayDepth();
|
||
|
||
m_pPositiveCalc = new PositiveElevationCalc;
|
||
m_pElevationCalc = m_pPositiveCalc;
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
m_pPositiveCalc->SetPipeSys(m_pAllList);
|
||
m_pPositiveCalc->SetLayingDepth(m_dWndEdtLayingDepth);
|
||
m_pPositiveCalc->SetMinThick(m_dMinThick);
|
||
m_pPositiveCalc->UpDatePipeSys();
|
||
m_pPositiveCalc->CalcLenStartWellToEnd(m_pAllList, 0);
|
||
|
||
m_pPositiveCalc->InitCalcSys();
|
||
m_pPositiveCalc->EnableSetLayDepth(!m_bFirstRunCmd); // cet 2012.6.21 add
|
||
m_pPositiveCalc->SetLayDepthData(&m_mapSWellLayDepth); // cet 2012.6.21 add
|
||
m_pPositiveCalc->SetOnlySWell(m_bOnlySWell); // cet 2012.6.26 add
|
||
|
||
std::vector<CALCNODE> data;
|
||
m_pPositiveCalc->Sort(data);
|
||
std::map<AcDbObjectId, int> mapRow;
|
||
for (size_t i = 0; i < data.size(); i++)
|
||
{
|
||
mapRow.insert(std::make_pair(data[i].idP, i));
|
||
if (data[i].idE == m_pAllList->m_ID) // 排出井
|
||
{
|
||
m_lstCtrl.SetRowforEndWell(i);
|
||
}
|
||
}
|
||
m_lstCtrl.SetPipeRow(mapRow);
|
||
}
|
||
|
||
m_pReverseCalc = new ReverseElevationCalc;
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
m_pReverseCalc->SetPipeSys(m_pAllList);
|
||
m_pReverseCalc->SetLayingDepth(m_dWndEdtLayingDepth);
|
||
m_pReverseCalc->SetMinThick(m_dMinThick);
|
||
m_pReverseCalc->UpDatePipeSys();
|
||
m_pReverseCalc->CalcLenStartWellToEnd(m_pAllList, 0);
|
||
|
||
m_pReverseCalc->InitCalcSys();
|
||
m_pReverseCalc->EnableSetLayDepth(!m_bFirstRunCmd); // cet 2012.6.21 add
|
||
m_pReverseCalc->SetLayDepthData(&m_mapSWellLayDepth); // cet 2012.6.21 add
|
||
m_pReverseCalc->SetOnlySWell(m_bOnlySWell); // cet 2012.6.26 add
|
||
}
|
||
|
||
// 管网已经计算过 cet 2012.7.26 add
|
||
if (m_bCalc)
|
||
{
|
||
UpdateCalcedData();
|
||
}
|
||
|
||
GetWellNodeInfo();
|
||
UpdateGrid();
|
||
|
||
OnCheckEdownele();
|
||
|
||
// cet 2011.7.26 add 获得跌水井
|
||
GetDropWell(m_vecWellName);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateGrid()
|
||
{
|
||
std::vector<CALCNODE> data;
|
||
m_pElevationCalc->Sort(data);
|
||
std::vector<CALCNODE>::iterator it;
|
||
int nIndex = 0;
|
||
m_lstCtrl.Clear();
|
||
for (it = data.begin(); it != data.end(); it++)
|
||
{
|
||
m_lstCtrl.AppendRow();
|
||
m_lstCtrl.GetCell(nIndex, 0).SetText((*it).strSWellName);
|
||
m_lstCtrl.GetCell(nIndex, 1).SetText((*it).strEWellName);
|
||
CString strTemp;
|
||
strTemp.Format(_T("%.2f"), (*it).dPipeLen);
|
||
m_lstCtrl.GetCell(nIndex, 2).SetText(strTemp);
|
||
strTemp.Format(_T("%.0f"), (*it).dPipeDn);
|
||
m_lstCtrl.GetCell(nIndex, 3).SetText(strTemp);
|
||
strTemp.Format(_T("%.3f"), (*it).dGradient * 1000);
|
||
m_lstCtrl.GetCell(nIndex, 4).SetText(strTemp);
|
||
strTemp.Format(_T("%.3f"), (*it).dGradientDist);
|
||
m_lstCtrl.GetCell(nIndex, 5).SetText(strTemp);
|
||
strTemp.Format(_T("%.3f"), (*it).dWellEleUpS);
|
||
m_lstCtrl.GetCell(nIndex, 6).SetText(strTemp);
|
||
strTemp.Format(_T("%.3f"), (*it).dWellEleUpE);
|
||
m_lstCtrl.GetCell(nIndex, 7).SetText(strTemp);
|
||
|
||
strTemp.Format(_T("%.3f"), (*it).dPipeEleS);
|
||
m_lstCtrl.GetCell(nIndex, 8).SetText(strTemp);
|
||
|
||
strTemp.Format(_T("%.3f"), (*it).dPipeEleE);
|
||
m_lstCtrl.GetCell(nIndex, 9).SetText(strTemp);
|
||
|
||
strTemp.Format(_T("%.3f"), (*it).dDeepS);
|
||
m_lstCtrl.GetCell(nIndex, 10).SetText(strTemp);
|
||
|
||
strTemp.Format(_T("%.3f"), (*it).dDeepE);
|
||
m_lstCtrl.GetCell(nIndex, 11).SetText(strTemp);
|
||
++nIndex;
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateGroundEleForGrid()
|
||
{
|
||
std::vector<CALCNODE> data;
|
||
m_pElevationCalc->Sort(data);
|
||
std::vector<CALCNODE>::iterator it;
|
||
int nIndex = 0;
|
||
for (it = data.begin(); it != data.end(); it++)
|
||
{
|
||
CString strTemp;
|
||
strTemp.Format(_T("%.3f"), (*it).dWellEleUpS);
|
||
m_lstCtrl.GetCell(nIndex, 6).SetText(strTemp);
|
||
strTemp.Format(_T("%.3f"), (*it).dWellEleUpE);
|
||
m_lstCtrl.GetCell(nIndex, 7).SetText(strTemp);
|
||
++nIndex;
|
||
}
|
||
}
|
||
|
||
//vector 排序函数 zxl 2011.11.15 add
|
||
bool CompareHeight(double dLen1, double dLen2)
|
||
{
|
||
if (dLen1 - dLen2 > 0.0001)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//计算井的跌落高度 zxl 2011.11.15 add
|
||
bool CElevationCalcDlg::GetWellDropHeight(AcDbObjectId &id, CString &sWellDorp)
|
||
{
|
||
std::vector<CALCNODE> vecData = m_pElevationCalc->GetLstData();
|
||
std::vector<double> vec;
|
||
std::vector<CALCNODE>::iterator it;
|
||
CString sTemp;
|
||
for (it = vecData.begin(); it != vecData.end(); it++)
|
||
{
|
||
sTemp.Empty();
|
||
if ((*it).idS == id)
|
||
{
|
||
sTemp.Format(_T("%0.3f"), (*it).dPipeEleS);
|
||
}
|
||
else if ((*it).idE == id)
|
||
{
|
||
sTemp.Format(_T("%0.3f"), (*it).dPipeEleE);
|
||
}
|
||
if (!sTemp.IsEmpty())
|
||
{
|
||
double dEle = _tstof(sTemp);
|
||
vec.push_back(dEle);
|
||
}
|
||
}
|
||
|
||
if (vec.size() > 1)
|
||
{
|
||
sTemp.Empty();
|
||
std::sort(vec.begin(), vec.end(), CompareHeight);
|
||
double dEleS = vec.front();
|
||
double dEleE = vec.back();
|
||
double dEle = fabs(dEleE - dEleS);
|
||
sTemp.Format(_T("%0.3f"), dEle);
|
||
if (fabs(dEle - 0.0) > 0.001)
|
||
{
|
||
sWellDorp = sTemp;
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void CElevationCalcDlg::OnBtnModifyele()
|
||
{
|
||
CTemporaryResourceOverride vTemp;
|
||
CWellCalcModifyEleDlg dlg(0);
|
||
dlg.SetDropWell(m_vecWellName);//获取跌水井信息 zxl 2012.01.16 add
|
||
dlg.SetDlgType(true);
|
||
|
||
std::vector<WELLNODE>::iterator it;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
TWellData *pList = new TWellData;
|
||
pList->m_ID = (*it).id;
|
||
pList->m_bIsWell = TRUE;
|
||
pList->m_nGroundEle = (*it).dGroundEle;
|
||
pList->m_bIsDropWell = (*it).bIsDropWell;
|
||
pList->m_csName = (*it).strWellName;
|
||
pList->m_nUpEle = (*it).dWellEleUp;
|
||
pList->m_nDownEle = (*it).dWellEleDown;
|
||
pList->m_nWellRadius = (*it).dWellRadius;
|
||
pList->m_nSpare = (*it).dSand * 1000;
|
||
pList->m_nFrondDownEle = -9999;
|
||
|
||
//zxl 2011.11.15 add 设置跌落高度
|
||
GetWellDropHeight((*it).id, pList->m_csSpare);
|
||
dlg.m_lstWellSys.Append(pList);
|
||
}
|
||
|
||
if (dlg.DoModal() == IDOK)
|
||
{
|
||
// cet 2011.7.26 add 修改前的跌水井信息
|
||
std::vector<CString> vecOrigin;
|
||
GetDropWell(vecOrigin);
|
||
|
||
std::map<AcDbObjectId, double> data;
|
||
for (int i = 0; i < dlg.m_lstWellSys.Length(); i++)
|
||
{
|
||
TWellData *plist = dlg.m_lstWellSys[i];
|
||
|
||
if (plist->m_csName == _T("HC")) // 防止乱改出错
|
||
{
|
||
plist->m_nDownEle = 0.0;
|
||
plist->m_bIsDropWell = FALSE;
|
||
}
|
||
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
m_pPositiveCalc->ModifyWellInfo(plist->m_ID, plist->m_nUpEle, plist->m_nDownEle, plist->m_bIsDropWell); // 修改井面标高
|
||
}
|
||
|
||
if (plist->m_bIsDropWell)
|
||
{
|
||
data.insert(std::make_pair(plist->m_ID, plist->m_nDownEle));
|
||
}
|
||
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
m_pReverseCalc->ModifyWellInfo(plist->m_ID, plist->m_nUpEle, plist->m_nDownEle, plist->m_bIsDropWell); // 修改井面标高
|
||
m_pReverseCalc->UpdateDropWell(data);
|
||
}
|
||
UpdateWellNode(plist->m_ID, plist->m_nGroundEle, plist->m_nUpEle, plist->m_nWellRadius, plist->m_nSpare, plist->m_nDownEle, plist->m_bIsDropWell);
|
||
}
|
||
|
||
// // cet 2011.7.26 add 获得跌水井
|
||
// std::vector<CString> vecNew;
|
||
// GetDropWell(vecNew);
|
||
// std::vector<CString>::iterator it, it1;
|
||
// for (it = vecNew.begin(); it != vecNew.end(); it++)
|
||
// {
|
||
// it1 = std::find(vecOrigin.begin(), vecOrigin.end(), *it);
|
||
// if (it1 == vecOrigin.end()) // 用户增加的跌水井
|
||
// {
|
||
// m_vecWellName.push_back(*it);
|
||
// }
|
||
// }
|
||
//
|
||
// for (it = vecOrigin.begin(); it != vecOrigin.end(); it++)
|
||
// {
|
||
// it1 = std::find(vecNew.begin(), vecNew.end(), *it);
|
||
// if (it1 == vecNew.end()) // 用户删除的跌水井
|
||
// {
|
||
// it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), *it);
|
||
// if (it1 != m_vecWellName.end())
|
||
// {
|
||
// m_vecWellName.erase(it1);
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
dlg.GetDropWellByCustom(m_vecWellName);//zxl 2012.01.18 add
|
||
|
||
SetDropWellColor();
|
||
UpdateGroundEleForGrid(); //更新表格地面标高值
|
||
m_lstCtrl.Invalidate();
|
||
UpdateData(FALSE);
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::OnBtnCalc()
|
||
{
|
||
//zxl 2012.01.18 add
|
||
std::vector<CString> vecOld;
|
||
GetDropWell(vecOld);
|
||
std::map<CString, double> mapDropWellEle;
|
||
GetDropWellEle(vecOld, mapDropWellEle);
|
||
|
||
if (m_pReverseCalc == m_pElevationCalc) // 反算
|
||
{
|
||
if (m_strPipeEleDown.IsEmpty())
|
||
{
|
||
AfxMessageBox(_T("请输入终点管内底标高！"));
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (m_pElevationCalc != NULL)
|
||
{
|
||
// cet 2011.7.26 add
|
||
SetDropWellColor();
|
||
|
||
m_bCalc = TRUE;
|
||
m_lstCtrl.SetModifyColorforEndWell(FALSE);
|
||
m_pElevationCalc->LayingDepthCalc(); // 埋深计算
|
||
m_pElevationCalc->CheckSys(this);
|
||
std::vector<AcDbObjectId> data;
|
||
m_pElevationCalc->GetCheckInfoforPipe(data);
|
||
m_lstCtrl.SetColorPipe(data);
|
||
|
||
// 反算时计算排出井管内底标高是否与用户设定值相同
|
||
m_lstCtrl.SetModifyColorforEndWell(FALSE);
|
||
if (m_pElevationCalc == m_pReverseCalc)
|
||
{
|
||
ReverseElevationCalc *pCalc = static_cast<ReverseElevationCalc*>(m_pReverseCalc);
|
||
if (pCalc != NULL && pCalc->IsModifyEleforEndWell())
|
||
{
|
||
m_lstCtrl.SetModifyColorforEndWell(TRUE);
|
||
}
|
||
}
|
||
UpdateWellNode();
|
||
// cet 2012.6.21 add 更新起点井埋深数据
|
||
UpdatelayDepthData();
|
||
|
||
//获取当前所有跌水井并更新计算后的跌水井信息 zxl 2012.01.18 add
|
||
std::vector<CString> vecCalc;
|
||
GetDropWell(vecCalc);
|
||
UpdateDropWellByCustom(mapDropWellEle, vecCalc);
|
||
|
||
// cet 2011.7.26 add
|
||
SetDropWellColor();
|
||
|
||
UpdateGrid(); // 在表格中显示信息
|
||
}
|
||
}
|
||
|
||
//获取跌水井井底标高
|
||
void CElevationCalcDlg::GetDropWellEle(std::vector<CString> &vecWell, std::map<CString, double> &mapEle)
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
std::vector<CString>::iterator itWell;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
itWell = std::find(vecWell.begin(), vecWell.end(), (*it).strWellName);
|
||
if (itWell != vecWell.end())
|
||
{
|
||
mapEle.insert(std::make_pair(*itWell, (*it).dWellEleDown));
|
||
}
|
||
}
|
||
}
|
||
|
||
//设置计算后生成的跌水井
|
||
void CElevationCalcDlg::UpdateDropWellByCustom(std::map<CString, double> &mapEle, std::vector<CString> &vecCalc)
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
std::vector<CString>::iterator itWell;
|
||
std::map<CString, double>::iterator itmap;
|
||
ads_name name;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
itWell = std::find(vecCalc.begin(), vecCalc.end(), (*it).strWellName);
|
||
if (itWell != vecCalc.end())
|
||
{
|
||
itmap = mapEle.find((*it).strWellName);
|
||
if ((itmap != mapEle.end() && fabs((*it).dWellEleDown - itmap->second) > 0.001) || itmap == mapEle.end())
|
||
{
|
||
acdbGetAdsName(name, (*it).id);
|
||
GlobalFunc::WriteXdata(name, _T("DropWellType"), _T("calc"));
|
||
itWell = std::find(m_vecWellName.begin(), m_vecWellName.end(), (*it).strWellName);
|
||
if (itWell != m_vecWellName.end())//清除计算后生成的跌水井
|
||
{
|
||
m_vecWellName.erase(itWell);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::OnBtnLayingdepth()
|
||
{
|
||
GlobalFunc::HideDialog(this, TRUE);
|
||
RBList rbMask = ads_buildlist(-4, _T("<or"),
|
||
-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_DIRT, -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_RAIN, -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_USELESS, -4, _T("and>"),
|
||
-4, _T("or>"), NULL);
|
||
|
||
//显示井埋设深度标注
|
||
if (m_mapWellDim.empty())
|
||
{
|
||
std::vector<SSearchPipeList*> &m_vecWell = m_pReverseCalc->GetStartWell();
|
||
std::vector<SSearchPipeList*>::iterator it;
|
||
for (it = m_vecWell.begin(); it != m_vecWell.end(); it++)
|
||
{
|
||
double dLayingDepth = m_pElevationCalc->GetWellLayDepth((*it)->m_ID);
|
||
CString strLayingDepth;
|
||
strLayingDepth.Format(_T("%.3f"), dLayingDepth);
|
||
AcDbObjectId id = InsertWellDim(GetWellLayingDepthDimPt((*it)->m_ID), strLayingDepth);
|
||
m_mapWellDim.insert(std::make_pair((*it)->m_ID, id));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
UpdateWellDim();
|
||
ShowWellDim(TRUE);
|
||
}
|
||
|
||
PickSet ss(SS_FREE);
|
||
while (TRUE)
|
||
{
|
||
AcDbObjectId id;
|
||
CString strTip = _T("\n请选择需要更改埋深的起点井<退出>：");
|
||
while (TRUE)
|
||
{
|
||
if (GlobalFunc::SelectEntities(strTip, ss, rbMask) == RTNORM)
|
||
{
|
||
std::vector<SSearchPipeList*> &m_vecWell = m_pPositiveCalc->GetStartWell();
|
||
BOOL bSysSWell = TRUE;
|
||
for (long i = 0; i < ss.Length(); i++)
|
||
{
|
||
Entity ent = ss[i];
|
||
acdbGetObjectId(id, ent);
|
||
std::vector<SSearchPipeList*>::iterator it;
|
||
for (it = m_vecWell.begin(); it != m_vecWell.end(); it++)
|
||
{
|
||
if ((*it)->m_ID == id)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (it == m_vecWell.end())
|
||
{
|
||
strTip = _T("\n请选择起点井<退出>：");
|
||
bSysSWell = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (bSysSWell)
|
||
{
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
ShowWellDim(FALSE);
|
||
GlobalFunc::HideDialog(this, FALSE);
|
||
acedUpdateDisplay();
|
||
actrTransactionManager->flushGraphics(); //acad 刷新
|
||
return;
|
||
}
|
||
}
|
||
|
||
double dLayingDepth = m_dWndEdtLayingDepth;
|
||
CTemporaryResourceOverride vTemp;
|
||
CEditWellLayingDepthDlg dlg;
|
||
dlg.SetLayingDepth(dLayingDepth);
|
||
dlg.SetFocus();
|
||
if (dlg.DoModal() == IDOK)
|
||
{
|
||
dLayingDepth = dlg.GetLayingDepth();
|
||
for (long i = 0; i < ss.Length(); i++)
|
||
{
|
||
acdbGetObjectId(id, ss[i]);
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
m_pPositiveCalc->ModifyWellLayingDepth(id, dLayingDepth);
|
||
}
|
||
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
m_pReverseCalc->ModifyWellLayingDepth(id, dLayingDepth);
|
||
}
|
||
|
||
UpdateWellNode(id, dLayingDepth);
|
||
UpdatelayDepthData(id, dLayingDepth); // cet 2012.6.21 add
|
||
|
||
// 更新井埋设深度标注值
|
||
CString strLayingDepth;
|
||
strLayingDepth.Format(_T("%.3f"), dLayingDepth);
|
||
std::map<AcDbObjectId, AcDbObjectId>::iterator it;
|
||
for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
|
||
{
|
||
if ((*it).first == id)
|
||
{
|
||
UpdateWellDim((*it).second, strLayingDepth);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// cet 2011.8.30 add 获取文字宽度
|
||
double GetTextLength(const TCHAR* fontName, const TCHAR* bigFontName, const double textSize, const double xScale, const CString &sText)
|
||
{
|
||
AcGePoint2d ptMin, ptMax;
|
||
AcGiTextStyle style(fontName, bigFontName, textSize, xScale, 0, 0, Adesk::kFalse, Adesk::kFalse, Adesk::kFalse, Adesk::kFalse, Adesk::kFalse);
|
||
style.extentsBox(sText, FALSE, sText.GetLength(), FALSE, ptMin, ptMax);
|
||
return fabs(ptMax.x - ptMin.x);
|
||
}
|
||
|
||
// cet 2012.1.6 add 获取管线标注文字宽度
|
||
double GetPipeDimLen(CDbPipe *pPipe)
|
||
{
|
||
AecXDbText text;
|
||
text.setPropertiesFrom(pPipe);
|
||
text.SetHeight(pPipe->GetTextHeight());
|
||
AcDbObjectId id = pPipe->GetTextStyle();
|
||
if (id.isNull())
|
||
{
|
||
id = GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csPipeDnStyle);
|
||
text.SetHeight(g_Option::instance().g_nPipeDnHeight);
|
||
}
|
||
text.SetStyleId(id);
|
||
CString sLabel = pPipe->GetLabel();
|
||
if (sLabel.IsEmpty()) // 无前缀时添加默认前缀以便获得正确的标注文字
|
||
{
|
||
pPipe->SetLabel(_T("DN"));
|
||
}
|
||
CString sText = (LPCTSTR)pPipe->GetLabelText();
|
||
|
||
// zxl add 2012.12.17 支持竖排情形
|
||
if (pPipe->GetPipeLableDrawType() == 1)
|
||
{
|
||
// int nIndex = sText.ReverseFind(_T('\n'));
|
||
// if (nIndex > 0)
|
||
// {
|
||
// sText = sText.Right(sText.GetLength() - nIndex - 1);
|
||
// }
|
||
CString sText1 = pPipe->GetPipeLenDimStr();
|
||
CString sText2 = pPipe->GetPipeDnDimStr();
|
||
CString sText3 = pPipe->GetPipeGradienDimtStr();
|
||
int nLen1 = sText1.GetLength();
|
||
int nLen2 = sText2.GetLength();
|
||
int nLen3 = sText3.GetLength();
|
||
int nLen = nLen1 > nLen2 ? nLen1 : nLen2;
|
||
nLen = nLen > nLen3 ? nLen : nLen3;
|
||
|
||
if (nLen == nLen1)
|
||
{
|
||
sText = sText1;
|
||
}
|
||
else if (nLen == nLen2)
|
||
{
|
||
sText = sText2;
|
||
}
|
||
else
|
||
{
|
||
sText = sText3;
|
||
}
|
||
}
|
||
pPipe->SetLabel(sLabel); // 恢复为默认前缀
|
||
text.SetText(sText);
|
||
|
||
text.SetRotation(0.0);
|
||
XPoint ptMin, ptMax;
|
||
text.GetExtents2d(ptMin, ptMax);
|
||
double dLen = fabs(ptMax.x - ptMin.x);
|
||
|
||
return dLen;
|
||
}
|
||
|
||
// cet 2011.8.30 add 根据默认标注样式和短管标注样式设置管标注样式
|
||
// 需比较管长和标注长度
|
||
void SetPipeLabelType(CDbPipe *pPipe)
|
||
{
|
||
if (pPipe == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// if (g_iDimPipeGradientType == -1) // 不标注
|
||
// {
|
||
// pPipe->SetSpare(-1);
|
||
// }
|
||
|
||
// 管长
|
||
XPoint ptS, ptE;
|
||
pPipe->getStartPoint(ptS);
|
||
pPipe->getEndPoint(ptE);
|
||
double dPipeLen = ptS.Distance2d(ptE);
|
||
|
||
// 遮挡长度
|
||
double dHideLen = 0.0;
|
||
AcDbObjectId id = pPipe->GetNode(0);
|
||
AecXDbWell *pWell = NULL;
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
dHideLen = pWell->GetScale() * 100;
|
||
pWell->close();
|
||
}
|
||
|
||
if (fabs(dHideLen) < g_Option::instance()._DIST_SNAP)
|
||
{
|
||
id = pPipe->GetNode(1);
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
dHideLen = pWell->GetScale() * 100;
|
||
pWell->close();
|
||
}
|
||
}
|
||
|
||
if (GlobalFunc::DocGetMeterUnitDraw())
|
||
{
|
||
dHideLen *= 0.01;
|
||
}
|
||
|
||
dPipeLen -= dHideLen;
|
||
|
||
// 管线标注新形式 zxl 2012.12.17 modify
|
||
// 默认标注管长
|
||
//int iType = g_iDimPipeGradientType == 0 ? g_iDimPipeGradientType : g_iDimPipeGradientType * 100 + g_iDimPipeLen + 1;
|
||
//pPipe->SetSpare(iType);
|
||
pPipe->SetPipeLableDrawType(g_Option::instance().g_nDimPipeDrawType);
|
||
pPipe->SetPipeDnDimType(g_Option::instance().g_nDimPipeDnType);
|
||
pPipe->SetPipeLenDimType(g_Option::instance().g_iDimPipeLen);
|
||
pPipe->SetPipeDimLableType(g_Option::instance().g_nDimPipeLabelType);
|
||
pPipe->SetPipeGradientDimType(g_Option::instance().g_nDimPipeGradientType);
|
||
pPipe->EnableDrawLabel(TRUE);
|
||
if (g_Option::instance().g_nDimPipeDnType == 0 && g_Option::instance().g_iDimPipeLen == 0 && g_Option::instance().g_nDimPipeGradientType == 0)
|
||
{
|
||
pPipe->EnableDrawLabel(FALSE);
|
||
pPipe->SetPipeDnDimType(1);
|
||
}
|
||
|
||
//cet 2012.1.9 modify 原方法存在计算误差
|
||
//CString sText = pPipe->GetLabelText();
|
||
//double dTextLen = GetTextLength(g_csPipeDnEng, g_csPipeDnChn, g_nPipeDnHeight * GlobalFunc::DocGetPScale(), g_nPipeDnScale, sText);
|
||
double dTextLen = GetPipeDimLen(pPipe);
|
||
if (dPipeLen > dTextLen)
|
||
{
|
||
return;
|
||
}
|
||
else if (g_Option::instance().g_iDimShortPipeGradientType != -1) // 短管标注
|
||
{
|
||
// 管线标注新形式 zxl 2012.12.17 modify
|
||
// iType = g_iDimShortPipeGradientType == 0 ? g_iDimShortPipeGradientType : g_iDimShortPipeGradientType * 100 + g_iDimPipeLen + 1;
|
||
// pPipe->SetSpare(iType);
|
||
pPipe->SetPipeLableDrawType(g_Option::instance().g_nDimPipeDrawType);
|
||
pPipe->SetPipeDnDimType(g_Option::instance().g_nDimShortPipeDnType);
|
||
pPipe->SetPipeLenDimType(g_Option::instance().g_nDimShortPipeLenType);
|
||
pPipe->SetPipeDimLableType(g_Option::instance().g_nDimPipeLabelType);
|
||
pPipe->SetPipeGradientDimType(g_Option::instance().g_nDimShortPipeGradientType);
|
||
if (g_Option::instance().g_nDimShortPipeDnType == 0
|
||
&& g_Option::instance().g_nDimShortPipeLenType == 0
|
||
&& g_Option::instance().g_nDimShortPipeGradientType == 0)
|
||
{
|
||
pPipe->EnableDrawLabel(FALSE);
|
||
}
|
||
|
||
//cet 2012.1.9 modify 原方法存在计算误差
|
||
//sText = pPipe->GetLabelText();
|
||
//dTextLen = GetTextLength(g_csPipeDnEng, g_csPipeDnChn, g_nPipeDnHeight * GlobalFunc::DocGetPScale(), g_nPipeDnScale, sText);
|
||
dTextLen = GetPipeDimLen(pPipe);
|
||
if (dPipeLen > dTextLen)
|
||
{
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
//pPipe->SetSpare(-1); zxl 2012.12.18 modify
|
||
pPipe->SetPipeDnDimType(1);
|
||
pPipe->SetPipeLenDimType(0);
|
||
pPipe->SetPipeGradientDimType(0);
|
||
pPipe->EnableDrawLabel(FALSE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//pPipe->SetSpare(-1); zxl 2012.12.18 modify
|
||
pPipe->SetPipeDnDimType(1);
|
||
pPipe->SetPipeLenDimType(0);
|
||
pPipe->SetPipeGradientDimType(0);
|
||
pPipe->EnableDrawLabel(FALSE);
|
||
}
|
||
}
|
||
|
||
// cet 2012.1.5 add 根据初始设置中管线标注样式,计算管线可进行的标注样式
|
||
int GetPipeDimType(CDbPipe *pPipe)
|
||
{
|
||
if (g_Option::instance().g_iDimPipeGradientType == -1) // 不标注
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
// 管长
|
||
XPoint ptS, ptE;
|
||
pPipe->getStartPoint(ptS);
|
||
pPipe->getEndPoint(ptE);
|
||
double dPipeLen = ptS.Distance2d(ptE);
|
||
|
||
// 遮挡长度
|
||
double dHideLen = 0.0;
|
||
AcDbObjectId id = pPipe->GetNode(0);
|
||
AecXDbWell *pWell = NULL;
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
dHideLen = pWell->GetScale() * 100;
|
||
pWell->close();
|
||
}
|
||
|
||
if (fabs(dHideLen) < g_Option::instance()._DIST_SNAP)
|
||
{
|
||
id = pPipe->GetNode(1);
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
dHideLen = pWell->GetScale() * 100;
|
||
pWell->close();
|
||
}
|
||
}
|
||
|
||
if (GlobalFunc::DocGetMeterUnitDraw())
|
||
{
|
||
dHideLen *= 0.01;
|
||
}
|
||
|
||
dPipeLen -= dHideLen;
|
||
|
||
// 默认标注管长
|
||
int nOriginType = static_cast<int>(pPipe->GetSpare());
|
||
int nType = g_Option::instance().g_iDimPipeGradientType == 0 ? g_Option::instance().g_iDimPipeGradientType : g_Option::instance().g_iDimPipeGradientType * 100 + g_Option::instance().g_iDimPipeLen + 1;
|
||
pPipe->SetSpare(nType);
|
||
double dTextLen = GetPipeDimLen(pPipe);
|
||
pPipe->SetSpare(nOriginType);
|
||
if (dPipeLen > dTextLen)
|
||
{
|
||
return nType;
|
||
}
|
||
else if (g_Option::instance().g_iDimShortPipeGradientType != -1) // 短管标注
|
||
{
|
||
nType = g_Option::instance().g_iDimShortPipeGradientType == 0 ? g_Option::instance().g_iDimShortPipeGradientType : g_Option::instance().g_iDimShortPipeGradientType * 100 + g_Option::instance().g_iDimPipeLen + 1;
|
||
pPipe->SetSpare(nType);
|
||
dTextLen = GetPipeDimLen(pPipe);
|
||
pPipe->SetSpare(nOriginType);
|
||
if (dPipeLen > dTextLen)
|
||
{
|
||
return nType;
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
// 检查管线标注样式是否和默认样式相同 zxl 2012.12.19 add
|
||
bool CheckPipeDimTypeChanged(CDbPipe *pPipe)
|
||
{
|
||
Adesk::UInt16 nDnType = pPipe->GetPipeDnDimType();
|
||
Adesk::UInt16 nLenType = pPipe->GetPipeLenDimType();
|
||
Adesk::UInt16 nLabelType = pPipe->GetPipeDimLableType();
|
||
Adesk::UInt16 nDrawType = pPipe->GetPipeLableDrawType();
|
||
Adesk::UInt16 nGradientType = pPipe->GetPipeGradientDimType();
|
||
|
||
if ((nDnType == g_Option::instance().g_nDimPipeDnType
|
||
&& nLenType == g_Option::instance().g_iDimPipeLen
|
||
&& nLabelType == g_Option::instance().g_nDimPipeLabelType
|
||
&& nDrawType == g_Option::instance().g_nDimPipeDrawType
|
||
&& nGradientType == g_Option::instance().g_nDimPipeGradientType)
|
||
|| (nDnType == g_Option::instance().g_nDimShortPipeDnType
|
||
&& nLenType == g_Option::instance().g_nDimShortPipeLenType
|
||
&& nLabelType == g_Option::instance().g_nDimPipeLabelType
|
||
&& nDrawType == g_Option::instance().g_nDimPipeDrawType
|
||
&& nGradientType == g_Option::instance().g_nDimShortPipeGradientType))
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
// cet 2012.1.5 add 交叉显示管线
|
||
void ShowPipe(CDbPipe *pPipe)
|
||
{
|
||
XPoint ptCen, p1, p2, p3, p4;
|
||
ptCen = pPipe->MidPoint();
|
||
double nDist = pPipe->Length() * 2000;
|
||
if (GlobalFunc::DocGetMeterUnitDraw())
|
||
{
|
||
nDist *= 0.001;
|
||
}
|
||
GlobalFunc::ArxZoomTo(ptCen, nDist, nDist);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), 0, nDist / 5, p1);
|
||
ads_polar(p1, PI / 2, nDist / 5, p1);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI, nDist / 5, p2);
|
||
ads_polar(p2, PI / 2, -nDist / 5, p2);
|
||
ads_grdraw(p1, p2, 2, 0);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, nDist / 5, p3);
|
||
ads_polar(p3, PI, nDist / 5, p3);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, -nDist / 5, p4);
|
||
ads_polar(p4, 0, nDist / 5, p4);
|
||
ads_grdraw(p3, p4, 2, 0);
|
||
}
|
||
|
||
// cet 2012.1.9 add
|
||
void ShowPipe(const AcDbObjectId &idPipe)
|
||
{
|
||
OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
|
||
if (pPipe != NULL)
|
||
{
|
||
ShowPipe(pPipe);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
|
||
// cet 2012.1.5 add 根据管线原有标注与初始设置获得的标注样式，用户选择标注操作
|
||
int GetSelHandle(CDbPipe *pPipe)
|
||
{
|
||
// 显示待修改管线
|
||
ShowPipe(pPipe);
|
||
static CString sDefaultSel = _T("<当前管线N>:");
|
||
static int nDefaultSel = 1;
|
||
int nRet = -1;
|
||
TCHAR szKey[20];
|
||
CString sTip = _T("\n是否按初始设置进行管径样式标注[当前管线是(Y)/当前管线否(N)/全部管线是(A)/全部管线否(D)]");
|
||
sTip += sDefaultSel;
|
||
XPoint pt;
|
||
while (true)
|
||
{
|
||
int nStatus = 0;
|
||
INITGET_BEG(0, _T("Y N A D"));
|
||
nStatus = acedGetPoint(0, sTip, pt);
|
||
INITGET_END();
|
||
if (nStatus == RTNORM)
|
||
{
|
||
acedPrompt(_T("\n无效操作,请重新选择!"));
|
||
continue;
|
||
}
|
||
else if (nStatus == RTKWORD)
|
||
{
|
||
acedGetInput(szKey);
|
||
if (szKey[0] == _T('Y') || szKey[0] == _T('y'))
|
||
{
|
||
nRet = 0;
|
||
sDefaultSel = _T("<当前管线Y>:");
|
||
nDefaultSel = 0;
|
||
}
|
||
else if (szKey[0] == _T('N') || szKey[0] == _T('n'))
|
||
{
|
||
nRet = 1;
|
||
sDefaultSel = _T("<当前管线N>:");
|
||
nDefaultSel = 1;
|
||
}
|
||
else if (szKey[0] == _T('A') || szKey[0] == _T('a'))
|
||
{
|
||
nRet = 2;
|
||
sDefaultSel = _T("<全部管线A>:");
|
||
nDefaultSel = 2;
|
||
}
|
||
else if (szKey[0] == _T('D') || szKey[0] == _T('d'))
|
||
{
|
||
nRet = 3;
|
||
sDefaultSel = _T("<全部管线D>:");
|
||
nDefaultSel = 3;
|
||
}
|
||
}
|
||
else if (nStatus == RTCAN)
|
||
{
|
||
nRet = 3;
|
||
}
|
||
else if (nStatus == RTNONE)
|
||
{
|
||
nRet = nDefaultSel;
|
||
}
|
||
break;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
// 2012.1.6 add 管线原本有标注时，处理方式
|
||
// 返回值表示是否交叉显示处理的管线，nSelType 记录上次选择的操作及返回本次操作选择
|
||
bool HandlePipeDimType(CDbPipe *pPipe, int &nSelType)
|
||
{
|
||
bool bShow = false;
|
||
// 更改标注样式 zxl 2012.12.19 modify
|
||
//int nOriginType = static_cast<int>(pPipe->GetSpare()); // 原有标注样式
|
||
//int nType = GetPipeDimType(pPipe); // 按初始设置标注管线时样式
|
||
//if (nOriginType != nType)
|
||
if (CheckPipeDimTypeChanged(pPipe))
|
||
{
|
||
if (nSelType == 2) // 全部修改
|
||
{
|
||
//pPipe->SetSpare(nType);
|
||
SetPipeLabelType(pPipe);
|
||
}
|
||
else if (nSelType != 3) // 用户重新选择
|
||
{
|
||
pPipe->downgradeOpen();
|
||
nSelType = GetSelHandle(pPipe);
|
||
pPipe->upgradeOpen();
|
||
if (nSelType == 0 || nSelType == 2)
|
||
{
|
||
//pPipe->SetSpare(nType);
|
||
SetPipeLabelType(pPipe);
|
||
}
|
||
|
||
if (nSelType == 0)
|
||
{
|
||
bShow = true;
|
||
}
|
||
}
|
||
}
|
||
return bShow;
|
||
}
|
||
|
||
// cet 2012.1.9 add
|
||
// cet 2012.1.9 add 按任意键返回
|
||
|
||
void CElevationCalcDlg::OnBtnTodwg()
|
||
{
|
||
if (m_bCalc) // 已进行埋深计算
|
||
{
|
||
GlobalFunc::HideDialog(this, TRUE);
|
||
|
||
// cet 2012.7.26 add 更改管道流向
|
||
ResetPipeDir(m_pAllList);
|
||
|
||
// 更新图面井信息
|
||
acedSetStatusBarProgressMeter(_T("标注中..."), 0, m_vecWellInfo.size());
|
||
RBList rbMaskDim(RTDXF0, _T("AEC_ZT_WELLDIM"), NULL);
|
||
std::vector<WELLNODE>::iterator it;
|
||
int i = 0;
|
||
std::vector<XPoint> vecPoolPts; // cet 2012.10.25 add 池子插入点
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
acedSetStatusBarProgressMeterPos(i++);
|
||
if (!(*it).bWell) // 化粪池
|
||
{
|
||
OPENOBJ_BEGIN((*it).id, AcDb::kForWrite, CDbPool, pEquip);
|
||
if (pEquip != NULL)
|
||
{
|
||
pEquip->SetGroundEle((*it).dWellEleUp);
|
||
vecPoolPts.push_back(pEquip->GetLocation()); // cet 2012.10.25 add 记录池子插入点以便更新池子连接的管底标注
|
||
}
|
||
OPENOBJ_END();
|
||
continue;
|
||
}
|
||
|
||
AecXDbWell *pWell = NULL;
|
||
XPoint pt;
|
||
acdbOpenObject(pWell, (*it).id, AcDb::kForWrite);
|
||
if (pWell != NULL)
|
||
{
|
||
XPoint ptLoc = pWell->GetLocation();
|
||
pWell->SetWellEleUp((*it).dWellEleUp);
|
||
pWell->SetDropWell((*it).bIsDropWell);
|
||
pWell->SetWellEleDown(GetWellEleDown((*it).id));
|
||
pt = pWell->GetLabelLocation();
|
||
if (m_pElevationCalc != NULL)
|
||
{
|
||
std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
|
||
std::vector<CALCNODE>::iterator it2;
|
||
for (it2 = vecLstData.begin(); it2 != vecLstData.end(); it2++)
|
||
{
|
||
// 设置前管道 管底标高
|
||
if ((*it2).idE == (*it).id)
|
||
{
|
||
pWell->SetPipeEndEle((*it2).idP, XString(_T("%.3f"), (*it2).dPipeEleE));
|
||
}
|
||
|
||
// 设置后管道 管底标高
|
||
if ((*it2).idS == (*it).id)
|
||
{
|
||
pWell->SetPipeEndEle((*it2).idP, XString(_T("%.3f"), (*it2).dPipeEleS));
|
||
}
|
||
}
|
||
}
|
||
|
||
// zxl 2013.06.17 add 更新管底标注时的搜索半径
|
||
double dR = pWell->GetScale() * pWell->GetPScale() / 2;
|
||
pWell->close();
|
||
|
||
PickSet ss2(SS_FREE);
|
||
XPoint ptUcs = GlobalFunc::Wcs2Ucs(ptLoc);
|
||
GlobalFunc::GetPointPickSet(ptUcs, ss2, rbMaskDim, dR);
|
||
GlobalFunc::UpdateGraphic(ss2);
|
||
}
|
||
acedRestoreStatusBar();
|
||
|
||
ads_name name;
|
||
acdbGetAdsName(name, (*it).id);
|
||
|
||
// 自然地面高度
|
||
CString strGroundEle;
|
||
strGroundEle.Format(_T("%f"), (*it).dGroundEle);
|
||
GlobalFunc::WriteXdata(name, _T("TG-WELL-GroundEle"), strGroundEle);
|
||
|
||
// 井半径
|
||
CString strWellRadius;
|
||
//strWellRadius.Format(_T("%f"), (*it).dWellRadius); cet 2011.5.3 modify "TG-WELL-RADIUS" 为直径值
|
||
strWellRadius.Format(_T("%f"), (*it).dWellRadius * 2);
|
||
GlobalFunc::WriteXdata(name, _T("TG-WELL-RADIUS"), strWellRadius);
|
||
|
||
// 沉沙量
|
||
CString strSand;
|
||
strSand.Format(_T("%f"), (*it).dSand * 1000);
|
||
GlobalFunc::WriteXdata(name, _T("TG-WELL-DeepSand"), strSand);
|
||
}
|
||
|
||
// 更新图面管段信息
|
||
double dMeter = 1.0, dMeter1 = 1000;
|
||
if (!GlobalFunc::DocGetMeterUnitDraw())
|
||
{
|
||
dMeter = 1000;
|
||
dMeter1 = 1.0; // cet 2011.9.1 add
|
||
}
|
||
|
||
std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
|
||
std::vector<CALCNODE>::iterator it1;
|
||
acedSetStatusBarProgressMeter(_T("标注中..."), 0, vecLstData.size());
|
||
i = 0;
|
||
CDbPool *pPool = NULL; // cet 2011.11.8 add
|
||
CPipeInterface face; // cet 2011.11.8 add
|
||
int nSelType = -1; // cet 2012.1.5 add 管线标注与管线原有标注不同时，用户的选择 0: Y 1: N 2: A 3: D
|
||
bool bShow = false; // cet 2012.1.5 add
|
||
for (it1 = vecLstData.begin(); it1 != vecLstData.end(); it1++)
|
||
{
|
||
bShow = false; // cet 2012.1.6 add
|
||
BOOL bDrawLabel = FALSE;// zxl 2012.12.26 add
|
||
acedSetStatusBarProgressMeterPos(i++);
|
||
ads_name ent;
|
||
acdbGetAdsName(ent, (*it1).idP);
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, CDbPipe, pPipe);
|
||
if (pPipe != NULL)
|
||
{
|
||
pPipe->SetDnDiameter((*it1).dPipeDn);
|
||
pPipe->SetPipeGradient((*it1).dGradient);
|
||
XPoint pt1(pPipe->GetStartPoint()), pt2(pPipe->GetEndPoint());
|
||
XPoint ptWell = GetWellpt((*it1).idS);
|
||
if (!ptWell) // cet 2011.10.8 add 管连化粪池
|
||
{
|
||
acdbOpenObject(pPool, (*it1).idS, AcDb::kForRead);
|
||
if (pPool != NULL)
|
||
{
|
||
int nNum = pPool->GetInterfaceNum();
|
||
for (int j = 0; j < nNum; j++)
|
||
{
|
||
pPool->GetInterface(j, face);
|
||
if (face.m_idPipe == pPipe->objectId())
|
||
{
|
||
ptWell = face.m_ptLocation;
|
||
break;
|
||
}
|
||
}
|
||
pPool->close();
|
||
}
|
||
}
|
||
|
||
double dLen1 = ptWell.Distance2d(pt1), dLen2 = ptWell.Distance2d(pt2);
|
||
// cet 2011.9.1 modify
|
||
// if (dLen1 < 1e-3)
|
||
// {
|
||
// pt1.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
|
||
// pt2.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
|
||
// }
|
||
// else if (dLen2 < 1e-3)
|
||
// {
|
||
// pt2.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
|
||
// pt1.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
|
||
// }
|
||
if (dLen1 < 1e-3)
|
||
{
|
||
pt1.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
|
||
pt2.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
|
||
}
|
||
else if (dLen2 < 1e-3)
|
||
{
|
||
pt2.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
|
||
pt1.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
|
||
}
|
||
|
||
XPoint ptDimTmp = pPipe->GetLabelLocation(); //先把标注点读出来，setstartpoint会修改这个点
|
||
pPipe->SetStartPoint(pt1);
|
||
pPipe->SetEndPoint(pt2);
|
||
if (!pPipe->IsDrawLabel())
|
||
{
|
||
SetPipeLabelType(pPipe);
|
||
}
|
||
else // cet 2012.1.5 add 管线存在标注时
|
||
{
|
||
bShow = HandlePipeDimType(pPipe, nSelType);
|
||
}
|
||
pPipe->SetLabelLocation(ptDimTmp);
|
||
// cet 2012.1.9 add 标注样式为-1时不标注
|
||
if (static_cast<int>(pPipe->GetSpare()) == -1)
|
||
{
|
||
pPipe->EnableDrawLabel(FALSE);
|
||
}
|
||
|
||
bDrawLabel = pPipe->IsDrawLabel();// zxl 2012.12.26 add
|
||
}
|
||
OPENOBJ_END();
|
||
// cet 2012.1.9 add 显示交叉线
|
||
if (bShow)
|
||
{
|
||
ShowPipe((*it1).idP);
|
||
GlobalFunc::AnyKeyReturn(_T("\n按任意键继续查找下一段待修改管标注..."));
|
||
}
|
||
|
||
// zxl 2012.12.25 modify
|
||
//DoDimPipeDn(ent, pListAll->m_iDn, _T("自动"), g_nPipeDnHeight, FALSE);
|
||
GlobalFunc::DoDimPipeDn(ent, (int)(*it1).dPipeDn, _T("自动"), g_Option::instance().g_nPipeDnHeight, FALSE, TRUE);
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, CDbPipe, pPipe);
|
||
if (pPipe)
|
||
{
|
||
pPipe->EnableDrawLabel(bDrawLabel);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
WriteXDataToWell(); // cet 2012.6.21 add
|
||
acedRedraw(0, 0); // cet 2012.1.6 add 刷新清除显示管线时的X
|
||
acedRestoreStatusBar();
|
||
|
||
// 更新化粪池连接的管底标注 cet 2012.10.25 add
|
||
std::vector<XPoint>::iterator itPt;
|
||
PickSet ss2(SS_FREE);
|
||
for (itPt = vecPoolPts.begin(); itPt != vecPoolPts.end(); itPt++)
|
||
{
|
||
GlobalFunc::GetPointPickSet(GlobalFunc::Wcs2Ucs(*itPt), ss2, rbMaskDim, 50);
|
||
GlobalFunc::UpdateGraphic(ss2);
|
||
ss2.Free();
|
||
}
|
||
|
||
actrTransactionManager->flushGraphics(); //acad 刷新
|
||
TCHAR szTmp[32];
|
||
ads_getstring(NULL, _T("\n按任意键返回对话框:<返回>"), szTmp);
|
||
|
||
GlobalFunc::HideDialog(this, FALSE);
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::GetWellNodeInfo()
|
||
{
|
||
std::stack<SSearchPipeList*> data;
|
||
data.push(m_pAllList);
|
||
while (!data.empty())
|
||
{
|
||
SSearchPipeList *pList = data.top();
|
||
data.pop();
|
||
|
||
if (pList->m_iType == 3 || pList->m_iType == 4)
|
||
{
|
||
WELLNODE node;
|
||
node.bWell = TRUE;
|
||
ads_name ent;
|
||
acdbGetAdsName(ent, pList->m_ID);
|
||
CString strGroundEle = GlobalFunc::ReadXdata(ent, _T("TG-WELL-GroundEle"));
|
||
node.dGroundEle = _tstof(strGroundEle);
|
||
CString strWellRadius = GlobalFunc::ReadXdata(ent, _T("TG-WELL-RADIUS"));
|
||
node.dWellRadius = _tstof(strWellRadius) * 0.5;
|
||
CString strSand = GlobalFunc::ReadXdata(ent, _T("TG-WELL-DeepSand")); // 沉沙量
|
||
node.dSand = _tstof(strSand) * 0.001;
|
||
|
||
if (pList->m_iType == 3) // 井
|
||
{
|
||
AecXDbWell *pWell = NULL;
|
||
acdbOpenObject(pWell, pList->m_ID, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
node.dWellEleDown = pWell->GetWellEleDown();
|
||
node.bIsDropWell = pWell->IsDropWell();
|
||
node.strWellName = pWell->GetWellName();
|
||
node.dWellEleUp = pWell->GetWellEleUp();
|
||
node.id = pWell->objectId();
|
||
pWell->close();
|
||
}
|
||
|
||
node.bSysSWell = FALSE;
|
||
std::vector<SSearchPipeList*> &m_vecWell = m_pPositiveCalc->GetStartWell();
|
||
if (std::find(m_vecWell.begin(), m_vecWell.end(), pList) != m_vecWell.end())
|
||
{
|
||
node.bSysSWell = TRUE;
|
||
node.dLayingDepth = m_dWndEdtLayingDepth;
|
||
}
|
||
}
|
||
else if (pList->m_iType == 4) // 化粪池
|
||
{
|
||
node.bWell = FALSE;
|
||
node.bIsDropWell = FALSE;
|
||
CDbPool *pPool = NULL;
|
||
acdbOpenObject(pPool, pList->m_ID, AcDb::kForRead);
|
||
if (pPool != NULL)
|
||
{
|
||
node.strWellName = pPool->GetLabel();
|
||
node.dWellEleUp = pPool->GetGroundEle();
|
||
pPool->close();
|
||
}
|
||
node.id = pList->m_ID;
|
||
}
|
||
|
||
m_vecWellInfo.push_back(node);
|
||
}
|
||
|
||
for (int i = 0; i < pList->m_lstNode.Length(); i++)
|
||
{
|
||
data.push(pList->m_lstNode[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateWellNode(const AcDbObjectId &id, double dGroundEle, double dEleUp, double dWellRadius, double dSand, double dEleDown, BOOL bDrop)
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
if ((*it).id == id)
|
||
{
|
||
(*it).dGroundEle = dGroundEle;
|
||
(*it).dWellEleUp = dEleUp;
|
||
(*it).dWellRadius = dWellRadius;
|
||
(*it).dSand = dSand * 0.001;
|
||
(*it).bIsDropWell = bDrop;
|
||
if (bDrop)
|
||
{
|
||
(*it).dWellEleDown = dEleDown;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateWellNode(const CalcNode &node)
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
if ((*it).id == node.idS)
|
||
{
|
||
(*it).bIsDropWell = node.bIsDropWell;
|
||
(*it).dWellEleDown = node.dWellEleDownS;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateWellNode(const AcDbObjectId &id, double dLayingDepth)
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
if ((*it).id == id)
|
||
{
|
||
(*it).bSysSWell = TRUE;
|
||
(*it).dLayingDepth = dLayingDepth;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::OnBtnTable()
|
||
{
|
||
UpdateData(TRUE);
|
||
GlobalFunc::HideDialog(this, TRUE);
|
||
XPoint pt;
|
||
if (acedGetPoint(NULL, _T("\n点取表格左上角位置"), pt) != RTNORM)
|
||
{
|
||
GlobalFunc::HideDialog(this, FALSE);
|
||
return;
|
||
}
|
||
|
||
double nTextSize = g_Option::instance().g_nSheetHeight; //字高
|
||
double nTableHeight = g_Option::instance().g_nSheetHeight + 2;
|
||
|
||
AcDbObjectId idTextStyle = GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
|
||
CDbSheet *pSheet = new CDbSheet;
|
||
|
||
GridStyle gridStyle;
|
||
gridStyle.SetOverrideAll(TRUE);
|
||
gridStyle.SetTextHeight(nTextSize);
|
||
gridStyle.SetTextStyleId(idTextStyle);
|
||
|
||
SheetTitle &title = pSheet->GetTitle();
|
||
title.SetHeight(7.0);
|
||
title.SetText(GetPipeType());//设置标题文字 zxl 2011.11.29 modify
|
||
|
||
GridStyle &gridStyle2 = title.GetGridStyle();
|
||
gridStyle2.SetTextHeight(7.0);//设置标题文字高度 zxl 2011.11.29 modify
|
||
gridStyle2.SetTextStyleId(idTextStyle);
|
||
|
||
DividerStyle &style = title.GetDividerStyle();
|
||
style.SetDividerFlag(DividerStyle::kNone);
|
||
|
||
gridStyle.SetHorMode(AcDb::kTextCenter);
|
||
gridStyle.SetVerMode(AcDb::kTextVertMid);
|
||
gridStyle.SetLineSpaceFactor(0.2);
|
||
gridStyle.SetTextWrap(FALSE);
|
||
pSheet->SetGridStyle(gridStyle);
|
||
pSheet->SetRowHeight(nTableHeight);
|
||
pSheet->SetLayoutRotation(GlobalFunc::Wcs2Ucs(0.0));
|
||
pSheet->SetLocation(GlobalFunc::Wcs2Ucs(pt));
|
||
int nAllRow = (int)m_lstCtrl.GetRowNum();
|
||
|
||
//pSheet->InitSheet(nAllRow + 3, 12, nTableHeight, 50); cet 2011.6.20 modify 增加备注
|
||
//pSheet->InitSheet(nAllRow + 3, 13, nTableHeight, 50); zxl 2011.11.25 modify 增加序号
|
||
pSheet->InitSheet(nAllRow + 3, 14, nTableHeight, 50);
|
||
|
||
//zxl 0.11.11.25 add 设置外框线宽为中粗
|
||
DividerStyle &styleBorder = pSheet->GetBorderStyle();
|
||
styleBorder.SetLineWidth(0.2);
|
||
SheetRow *pRow = pSheet->GetRow(2);
|
||
if (pRow != NULL)
|
||
{
|
||
DividerStyle &styleRow = pRow->GetDividerStyle();
|
||
styleRow.SetLineWidth(0.2);
|
||
styleRow.SetDividerFlag(DividerStyle::kLocal);
|
||
}
|
||
|
||
SheetColumn column;
|
||
// 序号 zxl 2011.11.25 add
|
||
column.SetWidth(15);
|
||
pSheet->SetColumnAt(0, column);
|
||
// 管段编号
|
||
column.SetWidth(15); // 起点
|
||
pSheet->SetColumnAt(1, column);
|
||
column.SetWidth(15); // 终点
|
||
pSheet->SetColumnAt(2, column);
|
||
// 管线信息
|
||
column.SetWidth(15); // 管长
|
||
pSheet->SetColumnAt(3, column);
|
||
column.SetWidth(15); // 管径
|
||
pSheet->SetColumnAt(4, column);
|
||
column.SetWidth(15); // 坡度
|
||
pSheet->SetColumnAt(5, column);
|
||
column.SetWidth(15); // 管底坡降
|
||
pSheet->SetColumnAt(6, column);
|
||
// 设计地面标高
|
||
column.SetWidth(15); // 起点
|
||
pSheet->SetColumnAt(7, column);
|
||
column.SetWidth(15); // 终点
|
||
pSheet->SetColumnAt(8, column);
|
||
// 管内底标高
|
||
column.SetWidth(15); // 起点
|
||
pSheet->SetColumnAt(9, column);
|
||
column.SetWidth(15); // 终点
|
||
pSheet->SetColumnAt(10, column);
|
||
// 埋深
|
||
column.SetWidth(15); // 起点
|
||
pSheet->SetColumnAt(11, column);
|
||
column.SetWidth(15); // 终点
|
||
pSheet->SetColumnAt(12, column);
|
||
// cet 2011.6.20 add
|
||
column.SetWidth(30);
|
||
pSheet->SetColumnAt(13, column);
|
||
|
||
pSheet->MergeCells(0, 0, 2, 0);//zxl 2011.11.25 add
|
||
pSheet->MergeCells(0, 1, 1, 2);
|
||
pSheet->MergeCells(0, 3, 1, 6);
|
||
pSheet->MergeCells(0, 7, 1, 8);
|
||
pSheet->MergeCells(0, 9, 1, 10);
|
||
pSheet->MergeCells(0, 11, 1, 12);
|
||
pSheet->MergeCells(0, 13, 2, 13); // cet 2011.6.20 add
|
||
|
||
//zxl 2011.11.25 add
|
||
GridCell &cellNum = *(*pSheet)(0, 0);
|
||
cellNum.SetText(_T("序号"));
|
||
|
||
GridCell &cell0 = *(*pSheet)(0, 1);
|
||
cell0.SetText(_T("管段编号"));
|
||
GridCell &cell1 = *(*pSheet)(0, 3);
|
||
cell1.SetText(_T("管线信息"));
|
||
GridCell &cell2 = *(*pSheet)(0, 7);
|
||
cell2.SetText(_T("设计地面标高(m)"));
|
||
GridCell &cell3 = *(*pSheet)(0, 9);
|
||
cell3.SetText(_T("管内底标高(m)"));
|
||
GridCell &cell4 = *(*pSheet)(0, 11);
|
||
cell4.SetText(_T("埋深(m)"));
|
||
|
||
GridCell &cell01 = *(*pSheet)(2, 1);
|
||
cell01.SetText(_T("起点"));
|
||
GridCell &cell02 = *(*pSheet)(2, 2);
|
||
cell02.SetText(_T("终点"));
|
||
GridCell &cell03 = *(*pSheet)(2, 3);
|
||
cell03.SetText(_T("管长m"));
|
||
GridCell &cell04 = *(*pSheet)(2, 4);
|
||
cell04.SetText(_T("管径mm"));
|
||
GridCell &cell05 = *(*pSheet)(2, 5);
|
||
cell05.SetText(_T("坡度‰"));
|
||
GridCell &cell06 = *(*pSheet)(2, 6);
|
||
cell06.SetText(_T("管底坡降"));
|
||
GridCell &cell = *(*pSheet)(2, 7);
|
||
cell.SetText(_T("起点"));
|
||
GridCell &cell07 = *(*pSheet)(2, 8);
|
||
cell07.SetText(_T("终点"));
|
||
GridCell &cell08 = *(*pSheet)(2, 9);
|
||
cell08.SetText(_T("起点"));
|
||
GridCell &cell09 = *(*pSheet)(2, 10);
|
||
cell09.SetText(_T("终点"));
|
||
GridCell &cell10 = *(*pSheet)(2, 11);
|
||
cell10.SetText(_T("起点"));
|
||
GridCell &cell11 = *(*pSheet)(2, 12);
|
||
cell11.SetText(_T("终点"));
|
||
// cet 2011.6.20 add
|
||
GridCell &cell12 = *(*pSheet)(0, 13);
|
||
cell12.SetText(_T("备注"));
|
||
std::vector<CALCNODE> data;
|
||
m_pElevationCalc->Sort(data);
|
||
|
||
for (int i = 0; i < nAllRow; i++)
|
||
{
|
||
//zxl 2011.11.25 add
|
||
GridCell &CellNO = *(*pSheet)(i + 3, 0);
|
||
CellNO.SetText(XString(_T("%d"), i));
|
||
|
||
GridCell &Cell11 = *(*pSheet)(i + 3, 1);
|
||
Cell11.SetText(m_lstCtrl.GetCell(i, 0).GetText());
|
||
|
||
GridCell &Cell12 = *(*pSheet)(i + 3, 2);
|
||
Cell12.SetText(m_lstCtrl.GetCell(i, 1).GetText());
|
||
|
||
GridCell &Cell13 = *(*pSheet)(i + 3, 3);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
CString sData = (LPCTSTR)m_lstCtrl.GetCell(i, 2).GetText();
|
||
double dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimPipeLen(dData);
|
||
Cell13.SetText(sData);
|
||
|
||
GridCell &Cell14 = *(*pSheet)(i + 3, 4);
|
||
Cell14.SetText(m_lstCtrl.GetCell(i, 3).GetText());
|
||
|
||
GridCell &Cell15 = *(*pSheet)(i + 3, 5);
|
||
Cell15.SetText(m_lstCtrl.GetCell(i, 4).GetText());
|
||
|
||
GridCell &Cell16 = *(*pSheet)(i + 3, 6);
|
||
Cell16.SetText(m_lstCtrl.GetCell(i, 5).GetText());
|
||
|
||
GridCell &Cell17 = *(*pSheet)(i + 3, 7);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
sData = m_lstCtrl.GetCell(i, 6).GetText();
|
||
dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimWellDeep(dData);
|
||
Cell17.SetText(sData);
|
||
|
||
GridCell &Cell18 = *(*pSheet)(i + 3, 8);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
sData = m_lstCtrl.GetCell(i, 7).GetText();
|
||
dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimWellDeep(dData);
|
||
Cell18.SetText(sData);
|
||
|
||
GridCell &Cell19 = *(*pSheet)(i + 3, 9);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
sData = m_lstCtrl.GetCell(i, 8).GetText();
|
||
dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimWellDeep(dData);
|
||
Cell19.SetText(sData);
|
||
|
||
GridCell &Cell110 = *(*pSheet)(i + 3, 10);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
sData = m_lstCtrl.GetCell(i, 9).GetText();
|
||
dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimWellDeep(dData);
|
||
Cell110.SetText(sData);
|
||
|
||
GridCell &Cell111 = *(*pSheet)(i + 3, 11);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
sData = m_lstCtrl.GetCell(i, 10).GetText();
|
||
dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimWellDeep(dData);
|
||
Cell111.SetText(sData);
|
||
|
||
GridCell &Cell112 = *(*pSheet)(i + 3, 12);
|
||
// zxl 2013.03.19 add 调整精度随初始设置
|
||
sData = m_lstCtrl.GetCell(i, 11).GetText();
|
||
dData = _tstof(sData);
|
||
sData = GlobalFunc::GetDimWellDeep(dData);
|
||
Cell112.SetText(sData);
|
||
|
||
// cet 2011.6.20 add
|
||
if (isDropWell(i, data))
|
||
{
|
||
GridCell &Cell113 = *(*pSheet)(i + 3, 13);
|
||
double dDeep = data[i].dDeepE; // 最大埋深
|
||
std::vector<CALCNODE>::iterator it;
|
||
for (it = data.begin(); it != data.end(); it++)
|
||
{
|
||
if ((*it).idS == data[i].idE && dDeep < (*it).dDeepS)
|
||
{
|
||
dDeep = (*it).dDeepS;
|
||
}
|
||
}
|
||
double dEle = data[i].dWellEleUpE;
|
||
double dFrontDownEle = data[i].dPipeEleE;
|
||
CString strTemp;
|
||
strTemp.Format(_T("跌水%.3f"), dDeep - (dEle - dFrontDownEle));
|
||
|
||
// 跌水0.000时,不显示跌水值 zxl 2011.11.16 add
|
||
double dDropHeight = dDeep - (dEle - dFrontDownEle);
|
||
if (fabs(dDropHeight - 0.0) < 0.001)
|
||
{
|
||
strTemp = _T("");
|
||
}
|
||
|
||
Cell113.SetText(strTemp);
|
||
}
|
||
}
|
||
GlobalFunc::AddToCurrentSpace(pSheet, TRUE);
|
||
//pSheet->AddToCSpace(TRUE);
|
||
TCHAR szTmp[32];
|
||
ads_getstring(NULL, _T("\n按任意键返回对话框:<返回>"), szTmp);
|
||
GlobalFunc::HideDialog(this, FALSE);
|
||
}
|
||
|
||
void CElevationCalcDlg::OnCheckEdownele()
|
||
{
|
||
UpdateData(TRUE);
|
||
CWnd *pWnd = GetDlgItem(IDC_EDIT_ENDDOWNELE);
|
||
if (m_bWndChkReverseCalc)
|
||
{
|
||
pWnd->EnableWindow(TRUE);
|
||
m_pElevationCalc = m_pReverseCalc;
|
||
}
|
||
else
|
||
{
|
||
pWnd->EnableWindow(FALSE);
|
||
m_pElevationCalc = m_pPositiveCalc;
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::OnBtnLook()
|
||
{
|
||
UpdateData(TRUE);
|
||
int nIndex = m_lstCtrl.GetCurRowIndex();
|
||
if (nIndex == -1)
|
||
{
|
||
return;
|
||
}
|
||
GlobalFunc::HideDialog(this, TRUE);
|
||
|
||
std::vector<CALCNODE> data;
|
||
m_pElevationCalc->Sort(data);
|
||
AcDbObjectId idPipe = data[nIndex].idP;
|
||
ShowPipe(idPipe);
|
||
|
||
TCHAR szTmp[32];
|
||
ads_getstring(NULL, _T("\n按任意键返回对话框:<返回>"), szTmp);
|
||
GlobalFunc::HideDialog(this, FALSE);
|
||
}
|
||
|
||
void CElevationCalcDlg::ShowPipe(AcDbObjectId &idPipe)
|
||
{
|
||
CDbPipe *pPipe = NULL;
|
||
acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
|
||
if (pPipe != NULL)
|
||
{
|
||
XPoint ptCen, p1, p2, p3, p4;
|
||
ptCen = pPipe->MidPoint();
|
||
double nDist = pPipe->Length() * 2000;
|
||
if (GlobalFunc::DocGetMeterUnitDraw())
|
||
{
|
||
nDist *= 0.001;
|
||
}
|
||
GlobalFunc::ArxZoomTo(ptCen, nDist, nDist);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), 0, nDist / 5, p1);
|
||
ads_polar(p1, PI / 2, nDist / 5, p1);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI, nDist / 5, p2);
|
||
ads_polar(p2, PI / 2, -nDist / 5, p2);
|
||
ads_grdraw(p1, p2, 2, 0);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, nDist / 5, p3);
|
||
ads_polar(p3, PI, nDist / 5, p3);
|
||
ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, -nDist / 5, p4);
|
||
ads_polar(p4, 0, nDist / 5, p4);
|
||
ads_grdraw(p3, p4, 2, 0);
|
||
pPipe->close();
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::DblClickLst()
|
||
{
|
||
OnBtnLook();
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdatePipeInfo(long nRow, long nCol, double dVal)
|
||
{
|
||
std::vector<CALCNODE> vec;
|
||
m_pElevationCalc->Sort(vec);
|
||
if (nRow > -1 && nRow < vec.size())
|
||
{
|
||
if (nCol == 3)
|
||
{
|
||
m_pPositiveCalc->ModifyPipe(vec[nRow].idP, dVal, TRUE);
|
||
m_pReverseCalc->ModifyPipe(vec[nRow].idP, dVal, TRUE);
|
||
}
|
||
else if (nCol == 4)
|
||
{
|
||
m_pPositiveCalc->ModifyPipe(vec[nRow].idP, dVal, FALSE);
|
||
m_pReverseCalc->ModifyPipe(vec[nRow].idP, dVal, FALSE);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::OnChangeEditStartdeep()
|
||
{
|
||
UpdateData(TRUE);
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
m_pPositiveCalc->SetLayingDepth(m_dWndEdtLayingDepth);
|
||
}
|
||
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
m_pReverseCalc->SetLayingDepth(m_dWndEdtLayingDepth);
|
||
}
|
||
|
||
// // 更新埋深 cet 2012.6.21 add
|
||
// std::map<AcDbObjectId,LayingDepthNode>::iterator it;
|
||
// for (it = m_mapSWellLayDepth.begin(); it != m_mapSWellLayDepth.end(); it++)
|
||
// {
|
||
// if (it->second.type == eLayingDepth)
|
||
// {
|
||
// it->second.dLayingDepth = m_dWndEdtLayingDepth;
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void CElevationCalcDlg::OnChangeEditMinthick()
|
||
{
|
||
UpdateData(TRUE);
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
m_pPositiveCalc->SetMinThick(m_dMinThick);
|
||
}
|
||
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
m_pReverseCalc->SetMinThick(m_dMinThick);
|
||
}
|
||
}
|
||
|
||
AcDbObjectId CElevationCalcDlg::InsertWellDim(const XPoint &ptIns, const CString &strText)
|
||
{
|
||
AcDbObjectId id;
|
||
AecXDbText *pText = new AecXDbText;
|
||
AcDbObjectId idTextStyle = GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
|
||
pText->SetStyleId(idTextStyle);
|
||
pText->SetHeight(4);
|
||
pText->SetAlignment(AcGiDraw::kBottomLeft);
|
||
pText->SetRotation(GlobalFunc::Wcs2Ucs(0.0));
|
||
pText->SetText(strText);
|
||
pText->setLayer(InitLayer(LAY_WELL_TEXT));
|
||
pText->SetLocation(ptIns);
|
||
pText->setColorIndex(1);
|
||
id = GlobalFunc::AddToCurrentSpace(pText, Adesk::kTrue);
|
||
return id;
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateWellDim(const AcDbObjectId &idDim, const CString &strText)
|
||
{
|
||
AecXDbText *pText = NULL;
|
||
acdbOpenObject(pText, idDim, AcDb::kForWrite);
|
||
if (pText != NULL)
|
||
{
|
||
pText->SetText(strText);
|
||
pText->close();
|
||
}
|
||
}
|
||
|
||
XPoint CElevationCalcDlg::GetWellpt(const AcDbObjectId &id)
|
||
{
|
||
XPoint ptLoc;
|
||
AecXDbWell *pWell = NULL;
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
ptLoc = pWell->GetLocation();
|
||
pWell->close();
|
||
}
|
||
|
||
return ptLoc;
|
||
}
|
||
|
||
XPoint CElevationCalcDlg::GetWellLayingDepthDimPt(const AcDbObjectId &id)
|
||
{
|
||
XPoint ptLoc;
|
||
AecXDbWell *pWell = NULL;
|
||
double dWellDn = 0.0;
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
ptLoc = pWell->GetLocation();
|
||
dWellDn = pWell->GetScale();
|
||
pWell->close();
|
||
}
|
||
|
||
dWellDn *= GlobalFunc::DocGetPScale();
|
||
ptLoc = GlobalFunc::Wcs2Ucs(ptLoc);
|
||
ptLoc += (AcGeVector3d::kXAxis + AcGeVector3d::kYAxis) * sqrt(dWellDn * dWellDn / 2);
|
||
ptLoc = GlobalFunc::Wcs2Ucs(ptLoc);
|
||
|
||
return ptLoc;
|
||
}
|
||
|
||
double CElevationCalcDlg::GetWellEleDown(const AcDbObjectId &id)
|
||
{
|
||
double dWellDownEle = 0.0;
|
||
if (m_pElevationCalc != NULL)
|
||
{
|
||
std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
|
||
std::vector<CALCNODE>::iterator it;
|
||
BOOL bFirst = TRUE;
|
||
for (it = vecLstData.begin(); it != vecLstData.end(); it++)
|
||
{
|
||
if ((*it).idS == id)
|
||
{
|
||
if (bFirst)
|
||
{
|
||
dWellDownEle = (*it).dPipeEleS;
|
||
bFirst = FALSE;
|
||
}
|
||
else if (dWellDownEle > (*it).dPipeEleS)
|
||
{
|
||
dWellDownEle = (*it).dPipeEleS;
|
||
}
|
||
}
|
||
else if ((*it).idE == id)
|
||
{
|
||
if (bFirst)
|
||
{
|
||
dWellDownEle = (*it).dPipeEleE;
|
||
bFirst = FALSE;
|
||
}
|
||
else if (dWellDownEle > (*it).dPipeEleE)
|
||
{
|
||
dWellDownEle = (*it).dPipeEleE;
|
||
}
|
||
}
|
||
}
|
||
|
||
double dSand = 0.0;
|
||
std::vector<WELLNODE>::iterator it2;
|
||
for (it2 = m_vecWellInfo.begin(); it2 != m_vecWellInfo.end(); it2++)
|
||
{
|
||
if ((*it2).id == id)
|
||
{
|
||
dSand = (*it2).dSand;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return dWellDownEle;
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateWellNode()
|
||
{
|
||
std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
|
||
std::vector<CALCNODE>::iterator it;
|
||
std::vector<WELLNODE>::iterator it2;
|
||
|
||
for (it2 = m_vecWellInfo.begin(); it2 != m_vecWellInfo.end(); it2++)
|
||
{
|
||
for (it = vecLstData.begin(); it != vecLstData.end(); it++)
|
||
{
|
||
if ((*it2).id == (*it).idS)
|
||
{
|
||
(*it2).bIsDropWell = (*it).bIsDropWell;
|
||
(*it2).dWellEleDown = (*it).dWellEleDownS;
|
||
(*it2).dLayingDepth = (*it).dDeepS; // cet 2012.6.21 add 更新埋深
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::DeleteWellDim()
|
||
{
|
||
std::map<AcDbObjectId, AcDbObjectId>::iterator it;
|
||
for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
|
||
{
|
||
AecXDbText *pText = NULL;
|
||
acdbOpenObject(pText, (*it).second, AcDb::kForWrite);
|
||
if (pText != NULL)
|
||
{
|
||
pText->erase();
|
||
pText->close();
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateWellDim()
|
||
{
|
||
std::map<AcDbObjectId, AcDbObjectId>::iterator it;
|
||
for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
|
||
{
|
||
double dLayingDepth = m_pElevationCalc->GetWellLayDepth((*it).first);
|
||
CString strLayingDepth;
|
||
strLayingDepth.Format(_T("%.3f"), dLayingDepth);
|
||
|
||
AecXDbText *pText = NULL;
|
||
acdbOpenObject(pText, (*it).second, AcDb::kForWrite);
|
||
if (pText != NULL)
|
||
{
|
||
pText->SetText(strLayingDepth);
|
||
pText->close();
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::ShowWellDim(BOOL bShow)
|
||
{
|
||
std::map<AcDbObjectId, AcDbObjectId>::iterator it;
|
||
for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
|
||
{
|
||
AecXDbText *pText = NULL;
|
||
acdbOpenObject(pText, (*it).second, AcDb::kForWrite);
|
||
if (pText != NULL)
|
||
{
|
||
pText->setVisibility(bShow ? AcDb::kVisible : AcDb::kInvisible);
|
||
pText->close();
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::OnClose()
|
||
{
|
||
DeleteWellDim();
|
||
CDialog::OnClose();
|
||
}
|
||
|
||
void CElevationCalcDlg::OnCancel()
|
||
{
|
||
DeleteWellDim();
|
||
CDialog::OnCancel();
|
||
}
|
||
|
||
void CElevationCalcDlg::OnChangeEditEnddownele()
|
||
{
|
||
UpdateData(TRUE);
|
||
if (m_pPositiveCalc != NULL)
|
||
{
|
||
m_pPositiveCalc->SetPipeEleDown(_tstof(m_strPipeEleDown));
|
||
}
|
||
|
||
if (m_pReverseCalc != NULL)
|
||
{
|
||
m_pReverseCalc->SetPipeEleDown(_tstof(m_strPipeEleDown));
|
||
}
|
||
}
|
||
|
||
bool CElevationCalcDlg::isDropWell(int nIndex, const std::vector<CALCNODE> data)
|
||
{
|
||
if (nIndex < 0 || nIndex >= data.size())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
bool bRet = false;
|
||
AcDbObjectId idWell = data[nIndex].idE;
|
||
std::vector<CALCNODE>::const_iterator it;
|
||
for (it = data.begin(); it != data.end(); it++)
|
||
{
|
||
if ((*it).idS == idWell && (*it).bIsDropWell)
|
||
{
|
||
bRet = true;
|
||
break;
|
||
}
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
void CElevationCalcDlg::GetDropWell(std::vector<CString> &vecWellName)
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
if (it->bIsDropWell)
|
||
{
|
||
vecWellName.push_back(it->strWellName);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::SetDropWellColor()
|
||
{
|
||
// cet 2011.11.28 modify 根据跌水井的情况进行颜色和提示更改
|
||
// std::vector<CString> vecData, data;
|
||
// GetDropWell(vecData);
|
||
// std::vector<CString>::iterator it, it1;
|
||
// for (it = vecData.begin(); it != vecData.end(); it++)
|
||
// {
|
||
// it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), *it);
|
||
// if (it1 == m_vecWellName.end()) // 新产生的跌水井
|
||
// {
|
||
// data.push_back(*it);
|
||
// }
|
||
// }
|
||
//
|
||
// m_lstCtrl.SetDropWell(data);
|
||
std::vector<CString> vecData;
|
||
GetDropWell(vecData);
|
||
std::map<CString, CString> mapWellTip;
|
||
std::map<CString, int> mapWellColor;
|
||
std::vector<CString>::iterator it, it1;
|
||
std::vector<WELLNODE>::iterator it2;
|
||
AcDbObjectId idWell;
|
||
CString sDrop;
|
||
for (it = vecData.begin(); it != vecData.end(); it++)
|
||
{
|
||
it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), *it);
|
||
if (it1 == m_vecWellName.end()) // 计算中产生的跌水井
|
||
{
|
||
|
||
for (it2 = m_vecWellInfo.begin(); it2 != m_vecWellInfo.end(); it2++)
|
||
{
|
||
if (it2->strWellName == *it)
|
||
{
|
||
idWell = it2->id;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (it2 != m_vecWellInfo.end())
|
||
{
|
||
// 跌水井跌落高度
|
||
if (!GetWellDropHeight(idWell, sDrop))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
double dDrop = _tstof(sDrop);
|
||
if (dDrop < 1.0) // 跌水井跌落高度小于1米
|
||
{
|
||
mapWellColor.insert(std::make_pair(*it, 2));
|
||
mapWellTip.insert(std::make_pair(*it, CString(_T("计算中产生的跌水井，跌落高度小于1米"))));
|
||
}
|
||
else
|
||
{
|
||
mapWellColor.insert(std::make_pair(*it, 3));
|
||
mapWellTip.insert(std::make_pair(*it, CString(_T("计算中产生的跌水井，跌落高度大于或等于1米"))));
|
||
}
|
||
}
|
||
}
|
||
else // 用户设置的跌水井
|
||
{
|
||
mapWellColor.insert(std::make_pair(*it, 4));
|
||
mapWellTip.insert(std::make_pair(*it, CString(_T("用户设定的跌水井"))));
|
||
}
|
||
}
|
||
|
||
m_lstCtrl.setWellColor(mapWellColor);
|
||
m_lstCtrl.setWellTip(mapWellTip);
|
||
|
||
}
|
||
|
||
void CElevationCalcDlg::InitSWellLayDepth()
|
||
{
|
||
std::stack<SSearchPipeList *> dataSt;
|
||
dataSt.push(m_pAllList);
|
||
ads_name name;
|
||
CString sLayDepth;
|
||
int nSWell = 0;
|
||
while (!dataSt.empty())
|
||
{
|
||
SSearchPipeList *pTemp = dataSt.top();
|
||
dataSt.pop();
|
||
if (pTemp->m_iType == 3 && pTemp->m_lstNode.Length() == 0) //起点井
|
||
{
|
||
++nSWell;
|
||
acdbGetAdsName(name, pTemp->m_ID);
|
||
Entity ent(name);
|
||
sLayDepth = GlobalFunc::ReadXdata(ent, _T("LAYDEPTH"));
|
||
if (!sLayDepth.IsEmpty())
|
||
{
|
||
LayingDepthNode node;
|
||
GetLayDepthData(sLayDepth, node.type, node.dLayingDepth);
|
||
double dWellDownEle = GetWellEleDown2(pTemp->m_ID);
|
||
if (fabs(dWellDownEle) > 0.001) // 检查埋深是否与扩展数据中的一样
|
||
{
|
||
double dLayDepth = GetWellEleUp(pTemp->m_ID) - dWellDownEle;
|
||
if (fabs(dLayDepth - node.dLayingDepth) > 0.001) // 不一致，说明用户更改了埋深
|
||
{
|
||
node.type = eUserSet;
|
||
node.dLayingDepth = dLayDepth;
|
||
}
|
||
}
|
||
m_mapSWellLayDepth.insert(std::make_pair(pTemp->m_ID, node));
|
||
}
|
||
else
|
||
{
|
||
double dWellDownEle = GetWellEleDown2(pTemp->m_ID);
|
||
if (fabs(dWellDownEle) > 0.001) // 用户设置了埋设深度
|
||
{
|
||
LayingDepthNode node;
|
||
node.type = eUserSet;
|
||
node.dLayingDepth = GetWellEleUp(pTemp->m_ID) - dWellDownEle;
|
||
m_mapSWellLayDepth.insert(std::make_pair(pTemp->m_ID, node));
|
||
}
|
||
else // 未设置埋设深度
|
||
{
|
||
LayingDepthNode node;
|
||
node.type = eLayingDepth;
|
||
node.dLayingDepth = m_dWndEdtLayingDepth;
|
||
m_mapSWellLayDepth.insert(std::make_pair(pTemp->m_ID, node));
|
||
m_bFirstRunCmd = true;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
|
||
{
|
||
dataSt.push(pTemp->m_lstNode[i]);
|
||
}
|
||
}
|
||
|
||
// 只有一个起点井
|
||
if (nSWell == 1)
|
||
{
|
||
m_bOnlySWell = true;
|
||
}
|
||
}
|
||
|
||
double CElevationCalcDlg::GetWellEleUp(const AcDbObjectId &id)
|
||
{
|
||
double dRet = 0.0;
|
||
AecXDbWell *pWell = NULL;
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
dRet = pWell->GetWellEleUp();
|
||
pWell->close();
|
||
}
|
||
|
||
return dRet;
|
||
}
|
||
|
||
void CElevationCalcDlg::GetLayDepthData(const CString &sLayDepth, LayingDepthType &type, double &dLayDepth)
|
||
{
|
||
CString sType, sEle;
|
||
int nIndex = sLayDepth.Find(_T("@"), 0);
|
||
if (nIndex != -1)
|
||
{
|
||
sType = sLayDepth.Left(nIndex);
|
||
sEle = sLayDepth.Right(sLayDepth.GetLength() - nIndex - 1);
|
||
dLayDepth = _tstof(sEle);
|
||
int nType = _ttoi(sType);
|
||
switch (nType)
|
||
{
|
||
case 0:
|
||
{
|
||
type = eUserSet;
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
type = eLayingDepth;
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
type = eCalc;
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
type = eUserModify;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdatelayDepthData(const AcDbObjectId &idWell, double dLayDepth)
|
||
{
|
||
std::map<AcDbObjectId, LayingDepthNode>::iterator it;
|
||
it = m_mapSWellLayDepth.find(idWell);
|
||
if (it != m_mapSWellLayDepth.end() && fabs(it->second.dLayingDepth - dLayDepth) > 0.001)
|
||
{
|
||
it->second.type = eUserModify;
|
||
it->second.dLayingDepth = dLayDepth;
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdatelayDepthData()
|
||
{
|
||
std::vector<WELLNODE>::iterator it;
|
||
std::map<AcDbObjectId, LayingDepthNode>::iterator itM;
|
||
for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
|
||
{
|
||
if (it->bSysSWell) // 系统起点井
|
||
{
|
||
itM = m_mapSWellLayDepth.find(it->id);
|
||
if (itM != m_mapSWellLayDepth.end() && fabs(itM->second.dLayingDepth - it->dLayingDepth) > 0.001)
|
||
{
|
||
itM->second.type = eCalc;
|
||
itM->second.dLayingDepth = it->dLayingDepth;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CElevationCalcDlg::WriteXDataToWell()
|
||
{
|
||
std::map<AcDbObjectId, LayingDepthNode>::iterator it;
|
||
ads_name name;
|
||
CString sData;
|
||
for (it = m_mapSWellLayDepth.begin(); it != m_mapSWellLayDepth.end(); it++)
|
||
{
|
||
acdbGetAdsName(name, it->first);
|
||
Entity ent(name);
|
||
sData.Format(_T("%d@%f"), it->second.type, it->second.dLayingDepth);
|
||
GlobalFunc::WriteXdata(ent, _T("LAYDEPTH"), sData);
|
||
}
|
||
}
|
||
|
||
double CElevationCalcDlg::GetWellEleDown2(const AcDbObjectId &id)
|
||
{
|
||
double dRet = 0.0;
|
||
AecXDbWell *pWell = NULL;
|
||
acdbOpenObject(pWell, id, AcDb::kForRead);
|
||
if (pWell != NULL)
|
||
{
|
||
dRet = pWell->GetWellEleDown();
|
||
pWell->close();
|
||
}
|
||
return dRet;
|
||
}
|
||
|
||
void CElevationCalcDlg::SetCalced(BOOL bCalced)
|
||
{
|
||
m_bCalc = bCalced;
|
||
}
|
||
|
||
void CElevationCalcDlg::UpdateCalcedData()
|
||
{
|
||
std::vector<CalcNode> &vecNode = m_pPositiveCalc->GetLstData();
|
||
std::vector<CalcNode>::iterator it;
|
||
CDbPipe *pPipe = NULL;
|
||
AecXDbWell *pWellS = NULL, *pWellE = NULL;
|
||
double dElevUp = 0.0, dElevDown = 0.0;
|
||
double dUnit = 0.001;
|
||
if (GlobalFunc::DocGetMeterUnitDraw())
|
||
{
|
||
dUnit = 1.0;
|
||
}
|
||
for (it = vecNode.begin(); it != vecNode.end(); it++)
|
||
{
|
||
acdbOpenObject(pPipe, (*it).idP, AcDb::kForRead);
|
||
if (pPipe != NULL)
|
||
{
|
||
double dDn = pPipe->GetDnDiameter();
|
||
|
||
// 内径改为工程直径，和图面赋值保持一致 zxl 2013.10.12 modify
|
||
//int iMaterial = pPipe->GetMaterial();
|
||
//CString csMat = GlobalFunc::GetPipeMaterialByIdx(iMaterial);
|
||
//dDn = GetPipeDjByDn(csMat, (int)dDn) / 2; //内径
|
||
dDn = dDn * 0.001 / 2;
|
||
|
||
TPipeSys::FlowDirection dir = pPipe->GetFlowDir();
|
||
if (dir == TPipeSys::kFromStart)
|
||
{
|
||
(*it).dPipeEleS = pPipe->StartPoint().z * dUnit - dDn;
|
||
(*it).dPipeEleE = pPipe->EndPoint().z * dUnit - dDn;
|
||
}
|
||
else
|
||
{
|
||
(*it).dPipeEleE = pPipe->StartPoint().z * dUnit - dDn;
|
||
(*it).dPipeEleS = pPipe->EndPoint().z * dUnit - dDn;
|
||
}
|
||
pPipe->close();
|
||
}
|
||
acdbOpenObject(pWellS, (*it).idS, AcDb::kForRead);
|
||
if (pWellS != NULL)
|
||
{
|
||
dElevUp = pWellS->GetWellEleUp();
|
||
dElevDown = pWellS->GetWellEleDown();
|
||
(*it).dDeepS = dElevUp - dElevDown;
|
||
pWellS->close();
|
||
}
|
||
|
||
acdbOpenObject(pWellE, (*it).idE, AcDb::kForRead);
|
||
if (pWellE != NULL)
|
||
{
|
||
dElevUp = pWellE->GetWellEleUp();
|
||
dElevDown = pWellE->GetWellEleDown();
|
||
if (pWellE->IsDropWell())
|
||
{
|
||
double dEle = (*it).dWellEleUpE;
|
||
double dFrontDownEle = (*it).dPipeEleE;
|
||
(*it).dDeepE += (dEle - dFrontDownEle);
|
||
}
|
||
else
|
||
{
|
||
(*it).dDeepE = dElevUp - dElevDown;
|
||
}
|
||
pWellE->close();
|
||
}
|
||
}
|
||
}
|