gjm/envi-code
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c7102cfe254439e5b0eeadf38973c9bb1d034532
envi-code/SourceCode/Code2026/PipelineCmd/AecPipeLineModify.cpp
T
gjm 345044cb46 初始化提交
2026-09-28 15:28:50 +08:00

2611 lines
62 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "StdArx.h"
#include "AecDbEwFitting.h"
#include "AecDbEwEquipment.h"
#include "AecPipeLineModify.h"
#include "AecPipeLine.h"
#include "AecPipeSupport.h"
#include "EquipManaDlg.h"
#include "EquipmentLibraryDlg.h"
#include "PipelineTools.h"
#ifndef DXF_PIPE_ONLY
#define DXF_PIPE_ONLY _T("AEC_EWPIPE")
#endif
#ifndef VALVE_FOLDER
#define VALVE_FOLDER _T("阀")
#endif
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt, AcDbDatabase* pDb/* = NULL*/, bool bClose/* = true*/);
AecPipeLineModify::AecPipeLineModify(void)
{
m_pADOServer = NULL;
m_bTeeStop = FALSE;
m_bUpdateMat = FALSE;
m_bCrossStop = FALSE;
memset(&m_paramOld,0,sizeof(WPipe::PipeParam));
}
AecPipeLineModify::~AecPipeLineModify(void)
{
}
void AecPipeLineModify::SetADOServer(CUIISQLiteServer* pADOServer)
{
m_pADOServer = pADOServer;
}
void AecPipeLineModify::SetPipeParamOld(const WPipe::PipeParam* pPipeParam)
{
if (pPipeParam != NULL)
{
memcpy(&m_paramOld,pPipeParam,sizeof(WPipe::PipeParam));
}
}
void AecPipeLineModify::SetPipeNetIds(AcDbObjectIdArray& arNetIds)
{
m_arNetIds.append(arNetIds);
}
CPoint AecPipeLineModify::PickAssocEqu(AcArray<AecInterface>& arInfs,AcDbObjectIdArray& arEquIds,AcArray<AcDbObjectIdInf>& arAssEquIds)
{
AcDbObjectId id;
AcDbEntity* pEnt = NULL;
AcDbObjectIdInf idInf;
idInf.pNext = NULL;
CPoint ptIndex(-1,-1);
int nFindEqu = -1;
for (int j = 0;j < arEquIds.length();j++)
{
id = arEquIds.at(j);
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
for (int i = 0;i < arInfs.length();i++)
{
AecInterface& inf = arInfs.at(i);
AecInterface infHit;
if (pMInfNew->GetInterface(inf.ptPos,infHit))
{
if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
{
AecInterface inf0,inf1;
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
{
idInf.id = id;
idInf.infFr = inf1;
nFindEqu = 0;
ptIndex.x = 0;
ptIndex.y = i;
}
else
{
idInf.id = id;
idInf.infFr = inf0;
nFindEqu = 1;
ptIndex.x = 1;
ptIndex.y = i;
}
arAssEquIds.append(idInf);
arEquIds.removeAt(j);
j -= 1;
}
}
}
pEnt->close();
}
}
if (nFindEqu != -1) break;
}
return ptIndex;
}
CPoint AecPipeLineModify::PickAssocFlange(AcArray<AecInterface>& arInfs,AcDbObjectIdArray& arFitIds,int iPos,AcArray<AcDbObjectIdInf>& arAssFlgs)
{
AcDbObjectId id;
AcDbEntity* pEnt = NULL;
AcDbObjectIdInf idInf;
idInf.pNext = NULL;
CPoint ptIndex(-1,-1);
int nFindFlange = -1;
for (int j = 0;j < arFitIds.length();j++)
{
if (j == iPos)
continue;
id = arFitIds.at(j);
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
{
AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
int nType = 0;
pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
EFittingType eType = (EFittingType)nType;
if (eType == eFlange)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);
for (int i = 0;i < arInfs.length();i++)
{
AecInterface& inf = arInfs.at(i);
AecInterface infHit;
if (pMInfNew->GetInterface(inf.ptPos,infHit))
{
AecInterface inf0,inf1;
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
{
idInf.id = id;
idInf.infFr = inf1;
nFindFlange = 0;
ptIndex.x = 0;
ptIndex.y = i;
}
else
{
idInf.id = id;
idInf.infFr = inf0;
nFindFlange = 1;
ptIndex.x = 1;
ptIndex.y = i;
}
arAssFlgs.append(idInf);
}
}
}
pEnt->close();
}
}
if (nFindFlange != -1) break;
}
return ptIndex;
}
bool AecPipeLineModify::ModifyPipeLineParamSys(AcDbObjectIdArray& arIds, WPipe::PipeParam &paramNew)
{
/*
* 不建议修改管线的材质，金属管,塑料管,衬塑管,水泥管等... 的管件的尺寸不一样
* 画法不一样，导致管子需要重新切割长度.
* 同样的金属材质的管线 由于国标 A B S 系列不同，管件的尺寸也不同，
* 画法不一样，导致管子需要重新切割长度. ！！！！！！！！！！！！！！！！！！!
*/
AcDbObjectId id1;
AcDbEntity *pEnt = NULL;
for (int i = 0; i < arIds.length(); i++)
{
id1 = arIds.at(i);
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id1, AcDb::kForWrite))
{
AecDbEwFitting *pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
pFit->SetAt(PIPE_SYS, paramNew.szSys);
}
AecDbEwPipe *pPipe = AecDbEwPipe::cast(pEnt);
if (pPipe != NULL)
{
pPipe->SetAt(PIPE_SYS, paramNew.szSys);
}
AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
pEqu->SetAt(PIPE_SYS, paramNew.szSys);
}
pEnt->close();
}
}
return true;
}
bool AecPipeLineModify::ModifyPipeLineParam(AcDbObjectIdArray& arPipeIds,AcDbObjectIdArray& arFitIds,AcDbObjectIdArray& arEquIds,WPipe::PipeParam& paramNew,BOOL bUpdateMat)
{
if (m_pADOServer == NULL)
return false;
m_bUpdateMat = bUpdateMat;
if (m_bUpdateMat)
{
ModifyPipeLineParamSys(arPipeIds, paramNew);
ModifyPipeLineParamSys(arFitIds, paramNew);
ModifyPipeLineParamSys(arEquIds, paramNew);
}
//1.先优先统一改管子的尺寸
ModifyPipeOnParam(arPipeIds,paramNew);
m_arPipeIds.append(arPipeIds);
AcDbObjectIdArray arFlangIds;
AcArray<AcDbObjectIdInf> arAssFlgs,arAssEquIds;
//2.先修改定位管件,定位管件的位置为绝对位置
//弯头,三通,四通,Wye,Lateral
//修改后导致接口位置改变,影响连接件
AcDbEntity* pEnt = NULL;
AcDbObjectId id1;
for (int i = 0;i < arFitIds.length();i++)
{
id1 = arFitIds.at(i);
if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id1,AcDb::kForRead))
{
AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
int nType = 0;
pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
EFittingType eType = (EFittingType)nType;
AcArray<AecInterface> arInfs;
pFit->GetInterface(arInfs);
switch(eType)
{
case eElbow:
case eTee:
case eWye:
case eLateral:
case eCross:
case eReduce:
{
//按阀门接口找出接口接的阀门
CPoint ptnPos1 = PickAssocEqu(arInfs,arEquIds,arAssEquIds);
//按照接口找出接口的法兰
CPoint ptnPos2 = PickAssocFlange(arInfs,arFitIds,i,arAssFlgs);
//改完Fit后，按接口对应改对接的管子或管件
if ( ModifyFitting(pFit,paramNew) )
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);
AecInterface infNew;
if (ptnPos1.x != -1)
{
pMInfNew->GetInterface(ptnPos1.y,infNew);
if (!arAssEquIds.isEmpty())
{
arAssEquIds.first().vtMove = infNew.ptPos - arInfs.at(ptnPos1.y).ptPos;
}
}
if (ptnPos2.x != -1)
{
pMInfNew->GetInterface(ptnPos2.y,infNew);
if (!arAssFlgs.isEmpty())
{
arAssFlgs.first().vtMove = infNew.ptPos - arInfs.at(ptnPos2.y).ptPos;
}
}
//按照接口路线修改
//一直到管子停止;
m_arNetIds.remove(id1);//修改一个移除当前Fit
pFit->LockInf(-1);
if ( !ModifyByInfAssoc(arInfs,pMInfNew,paramNew) )
{
pEnt->close();
return false;
}
}
break;
}
case eWcap:
{
if ( ModifyFitting(pFit,paramNew) )
{
}
pFit->LockInf(-1);
break;
}
case eFlxJoin:
{
if (ModifyFitting(pFit, paramNew))
{
}
pFit->LockInf(-1);
break;
}
case eFlange:
{
arFlangIds.append(id1);
break;
}
case eThrough://直通 PVC
case eUJoin://活接 PVC
case eRJoin://缩接 PVC 伸缩节
case eOJoin://外螺纹接头
case eIJoin://内螺纹接头
{
if (ModifyFitting(pFit, paramNew))
{
}
pFit->LockInf(-1);
break;
}
default:
break;
}
}
pEnt->close();
}
}
if ( fabs(m_paramOld.m_dDN - paramNew.m_dDN) > 1.0 ||
fabs(m_paramOld.m_dRRatio - paramNew.m_dRRatio) > 0.3)
{
//从某一个设备开始 建立方向串 法兰管线
if (!arAssEquIds.isEmpty())
{
MakeEquListStartByEqu(arAssEquIds,arEquIds);
}
//从某一个法兰开始 建立方向串 法兰管线
if (!arAssFlgs.isEmpty())
{
MakeEquListStartByFlang(arAssFlgs,arEquIds,arFlangIds);
}
//4.arEquIds 余下孤立的阀门建立方向串
AcArray<AcDbObjectIdInf> arIdInf;
MakeEquListTheRest(arEquIds,arFlangIds,arIdInf);
arIdInf.append(arAssEquIds);
arIdInf.append(arAssFlgs);
AcGePoint3d ptE;
AcDbObjectIdInf* pNext = NULL;
//测试
#ifdef _DEBUG
for (int k = 0;k < arIdInf.length();k++)
{
AcDbObjectIdInf& idInf = arIdInf.at(k);
pNext = &idInf;
int nColor = 1;
while(pNext != NULL)
{
AcDbCircle* pCir = new AcDbCircle;
pCir->setCenter(pNext->infFr.ptPos);
pCir->setRadius(10.0);
pCir->setColorIndex(nColor);
AddToModelSpace(pCir,NULL,true);
AcDbLine* pLn = new AcDbLine;
pLn->setStartPoint(pNext->infFr.ptPos);
pNext->infFr.vtDir.normalize();
ptE = pNext->infFr.ptPos + 5.0 * pNext->infFr.vtDir;
pLn->setEndPoint(ptE);
pLn->setColorIndex(nColor);
AddToModelSpace(pLn,NULL,true);
nColor++;
pNext = pNext->pNext;
}
}
#endif
//修改方向串中的阀门 [已经排序]
ModifyEquAlongList(arIdInf,paramNew);
//Free
AcDbObjectIdInf *pLast = NULL;
for (int k = 0;k < arIdInf.length();k++)
{
AcDbObjectIdInf& idInf = arIdInf.at(k);
pNext = idInf.pNext;
int nColor = 1;
while(pNext != NULL)
{
pLast = pNext;
pNext = pNext->pNext;
delete pLast;
}
}
}
return true;
}
void AecPipeLineModify::ModifyPipeOnNewInf(AecInterface& infOld,AecInterface& infTo)
{
AcGePoint3d ptS,ptE;
bool bSet = false;
AcDbEntity* pEnt = NULL;
for (int i = 0;i < m_arPipeIds.length();i++)
{
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,m_arPipeIds.at(i),AcDb::kForRead))
{
AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
if (pPipe != NULL)
{
ptS = pPipe->StartPoint();
ptE = pPipe->EndPoint();
if (ptS.distanceTo(infOld.ptPos) < 1.e-2)
{
pPipe->upgradeOpen();
pPipe->SetStartPoint(infTo.ptPos);
pPipe->downgradeOpen();
bSet = true;
}
if (ptE.distanceTo(infOld.ptPos) < 1.e-2)
{
pPipe->upgradeOpen();
pPipe->SetEndPoint(infTo.ptPos);
pPipe->downgradeOpen();
bSet = true;
}
}
pEnt->close();
if (bSet)
break;
}
}
}
void AecPipeLineModify::ModifyEquAlongList(AecInterface& infOld,AecInterface& infNewTo,AcDbObjectIdInf* pNext,const WPipe::PipeParam& paramNew)
{
AcDbEntity* pEnt = NULL;
AcDbObjectIdInf* pLast = pNext;
AecInterface infFr,infTo;
AcGePoint3d ptS;
AcGeVector3d vtDir,vtTmp;
Acad::ErrorStatus es;
while(pNext != NULL)
{
if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,pNext->id,AcDb::kForWrite)))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecDbEwEquipment* pNewEqu = CreateNewValve(pEqu,paramNew);
if (pNewEqu != NULL)
{
pNewEqu->GetInsert(ptS,vtDir);
//新阀门的接口位置必须和原有的对应
AcArray<AecInterface> arNewInfs;
AecInterface infNew0,infNew1;
pNewEqu->GetInterface(0,infNew0);
pNewEqu->GetInterface(1,infNew1);
if (infNew0.vtDir.isCodirectionalTo(infNewTo.vtDir))//和上次同向
{
//1为连接位置
pEqu->GetInterface(0,infOld);
vtTmp = infNewTo.ptPos - infNew1.ptPos;
ptS += vtTmp;
pNewEqu->SetInsert(ptS);
pNewEqu->GetInterface(0,infNewTo);//新的旧接口
infTo = infNewTo;
}
else if(infNew1.vtDir.isCodirectionalTo(infNewTo.vtDir))//和上次同向
{
//0为连接位置
pEqu->GetInterface(1,infOld);
vtTmp = infNewTo.ptPos - infNew0.ptPos;
ptS += vtTmp;
pNewEqu->SetInsert(ptS);
pNewEqu->GetInterface(1,infNewTo);//新的旧接口
infTo = infNewTo;
}
//替换
pEqu->copyFrom(pNewEqu);
delete pNewEqu;
}
}
AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
AecDbEwFitting* pFlang = CreateNewFlang(pFit,paramNew);
if (pFlang != NULL)
{
int nType = 0;
pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
EFittingType eType = (EFittingType)nType;
if (eType == eFlange)//是法兰
{
AecDbEwFitting* pFlang = CreateNewFlang(pFit,paramNew);
if (pFlang != NULL)
{
AecInterface infNew0,infNew1,infNew;
pFlang->GetInterface(0,infNew0);
pFlang->GetInterface(1,infNew1);
pFlang->GetSpecialtyData()->GetAt(KEY_START,ptS);
if (infNew0.vtDir.isCodirectionalTo(infNewTo.vtDir))
{
//1 为连接位置
pFit->GetInterface(0,infOld);//旧的连接下一个位置
vtTmp = infNewTo.ptPos - infNew1.ptPos;
ptS += vtTmp;
pFlang->GetSpecialtyData()->SetAt(KEY_START,ptS);
pFlang->GetInterface(0,infNewTo);//新的旧接口
infTo = infNewTo;
}
else if(infNew1.vtDir.isCodirectionalTo(infNewTo.vtDir))//和上次同向
{
//0 为连接位置
pFit->GetInterface(1,infOld);
vtTmp = infNewTo.ptPos - infNew0.ptPos;
ptS += vtTmp;
pFlang->GetSpecialtyData()->SetAt(KEY_START,ptS);
pFlang->GetInterface(1,infNewTo);//新的旧接口
infTo = infNewTo;
}
//替换
pFit->copyFrom(pFlang);
delete pFlang;
m_arNetIds.remove(pNext->id);
}
}
}
}
pEnt->close();
}
pLast = pNext;
pNext = pNext->pNext;
}
//可能更改两侧的管子
if (pLast != NULL)
{
ModifyPipeOnNewInf(infOld,infTo);
}
}
//沿着list修改阀门
void AecPipeLineModify::ModifyEquAlongList(AcArray<AcDbObjectIdInf>& arAssEquIds,const WPipe::PipeParam& paramNew)
{
//链的开头记录要整体移动
AcDbEntity* pEnt = NULL;
AcGeMatrix3d xMove;
AcGeVector3d vtDir,vtTmp;
AcGePoint3d ptS;
AecInterface infPipe,infTo,infPipeOther,infPipeOtherTo;
Acad::ErrorStatus es;
for (int i = 0;i < arAssEquIds.length();i++)
{
AcDbObjectIdInf& idInf = arAssEquIds.at(i);
xMove.setToTranslation(idInf.vtMove);
if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,idInf.id,AcDb::kForWrite)))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecDbEwEquipment* pNewEqu = CreateNewValve(pEqu,paramNew);
if (pNewEqu != NULL)
{
pNewEqu->GetInsert(ptS,vtDir);
ptS += idInf.vtMove;
//新阀门的接口位置必须和原有的对应
AecInterface infNew0,infNew1;
pNewEqu->GetInterface(0,infNew0);
pNewEqu->GetInterface(1,infNew1);
//idInf.infFr为链表开头的设备接口
int nOldTo = -1,nOldOther = -1;
if (infNew0.vtDir.isCodirectionalTo(idInf.infFr.vtDir))
{
vtTmp = infNew0.ptPos - idInf.infFr.ptPos;
ptS += vtTmp;
pNewEqu->SetInsert(ptS);
pNewEqu->GetInterface(0,infTo);
nOldTo = 0;
nOldOther = 1;
}
else if(infNew1.vtDir.isCodirectionalTo(idInf.infFr.vtDir))
{
vtTmp = infNew1.ptPos - idInf.infFr.ptPos;
ptS += vtTmp;
pNewEqu->SetInsert(ptS);
pNewEqu->GetInterface(1,infTo);
nOldTo = 1;
nOldOther = 0;
}
pEqu->GetInterface(nOldTo,infPipe);
pEqu->GetInterface(nOldOther,infPipeOther);
ModifyEquAlongList(idInf.infFr,infTo,idInf.pNext,paramNew);
//然后替换当前pEqu;
pEqu->copyFrom(pNewEqu);
pEqu->GetInterface(nOldTo,infTo);
pEqu->GetInterface(nOldOther,infPipeOtherTo);
//可能更改两侧的管子,法兰管的情况下
ModifyPipeOnNewInf(infPipe,infTo);
ModifyPipeOnNewInf(infPipeOther,infPipeOtherTo);
delete pNewEqu;
}
}
AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
int nType = 0;
pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
EFittingType eType = (EFittingType)nType;
if (eType == eFlange)//是法兰
{
AecDbEwFitting* pFlang = CreateNewFlang(pFit,paramNew);
if (pFlang != NULL)
{
AecInterface infNew0,infNew1,infNew;
pFlang->GetInterface(0,infNew0);
pFlang->GetInterface(1,infNew1);
//idInf.infFr为链表开头的Fit接口
int nOldTo = -1,nOldOther = -1;
if (infNew0.vtDir.isCodirectionalTo(idInf.infFr.vtDir))
{
infNew = infNew0;
nOldTo = 0;
nOldOther = 1;
}
else
{
infNew = infNew1;
nOldTo = 1;
nOldOther = 0;
}
pFit->GetInterface(nOldTo,infPipe);
pFit->GetInterface(nOldOther,infPipeOther);
pFlang->GetSpecialtyData()->GetAt(KEY_START,ptS);
//移动插入点
vtDir = infNew.ptPos - idInf.infFr.ptPos;
ptS += vtDir;
ptS += idInf.vtMove;
pFlang->GetSpecialtyData()->SetAt(KEY_START,ptS);
pFlang->GetInterface(nOldTo,infTo);
pFlang->GetInterface(nOldOther,infPipeOtherTo);
ModifyEquAlongList(idInf.infFr,infTo,idInf.pNext,paramNew);
//修改完法兰及连续
pFit->upgradeOpen();
pFit->copyFrom(pFlang);
pFit->downgradeOpen();
//可能更改两侧的管子
ModifyPipeOnNewInf(infPipeOther,infPipeOtherTo);
delete pFlang;
m_arNetIds.remove(idInf.id);
}
}
}
pEnt->close();
}
}
}
//弯头等fit直接接设备，法兰管线才有
void AecPipeLineModify::MakeEquListStartByEqu(AcArray<AcDbObjectIdInf>& arAssEquIds,AcDbObjectIdArray& arEquIds)
{
AcDbEntity* pEnt = NULL;
for (int i = 0;i < arAssEquIds.length();i++)
{
AcDbObjectIdInf& idInf = arAssEquIds.at(i);
AcDbObjectIdInf* pLast = &idInf;
for (int j = 0;j < arEquIds.length();j++)
{
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arEquIds.at(j),AcDb::kForRead))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
AecInterface infHit;
if (pMInfNew->GetInterface(idInf.infFr.ptPos,infHit))
{
if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
{
AecInterface inf0,inf1;
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
AcDbObjectIdInf* pIdInfThis = new AcDbObjectIdInf;
pIdInfThis->pNext = NULL;
pIdInfThis->vtMove.set(0,0,0);
if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
{
pIdInfThis->id = arEquIds.at(j);
pIdInfThis->infFr = inf1;
}
else
{
pIdInfThis->id = arEquIds.at(j);
pIdInfThis->infFr = inf0;
}
pLast->pNext = pIdInfThis;
pLast = pIdInfThis;
arEquIds.removeAt(j);
j -= 1;
}
}
}
pEnt->close();
}
}
}
}
//法兰开始的焊接阀门-法兰-阀门... 阀门含有法兰
void AecPipeLineModify::MakeEquListStartByFlang(AcArray<AcDbObjectIdInf>& arAssFlgs,AcDbObjectIdArray& arEquIds,AcDbObjectIdArray& arFlangIds)
{
AcDbEntity* pEnt = NULL;
for (int i = 0;i < arAssFlgs.length();i++)
{
AcDbObjectIdInf* pLast = &arAssFlgs[i];
//先设备
bool bFindEqu = false;
bool bFindFit = false;
while(true)
{
bFindEqu = false;
for (int j = 0;j < arEquIds.length();j++)
{
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arEquIds.at(j),AcDb::kForRead))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
AecInterface infHit;
if (pMInfNew->GetInterface(pLast->infFr.ptPos,infHit))
{
if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
{
AecInterface inf0,inf1;
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
AcDbObjectIdInf* pIdInfThis = new AcDbObjectIdInf;
pIdInfThis->pNext = NULL;
pIdInfThis->vtMove.set(0,0,0);
if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
{
pIdInfThis->id = arEquIds.at(j);
pIdInfThis->infFr = inf1;
}
else
{
pIdInfThis->id = arEquIds.at(j);
pIdInfThis->infFr = inf0;
}
pLast->pNext = pIdInfThis;
pLast = pIdInfThis;
arEquIds.removeAt(j);
j -= 1;
bFindEqu = true;
pEnt->close();
break;
}
}
}
pEnt->close();
}
}
//然后再法兰
bFindFit = false;
for (int n = 0;n < arFlangIds.length();n++)
{
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arFlangIds.at(n),AcDb::kForRead))
{
AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);
AecInterface infHit;
if (pMInfNew->GetInterface(pLast->infFr.ptPos,infHit))
{
if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
{
AecInterface inf0,inf1;
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
AcDbObjectIdInf* pIdInfThis = new AcDbObjectIdInf;
pIdInfThis->pNext = NULL;
pIdInfThis->vtMove.set(0,0,0);
if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
{
pIdInfThis->id = arFlangIds.at(n);
pIdInfThis->infFr = inf1;
}
else
{
pIdInfThis->id = arFlangIds.at(n);
pIdInfThis->infFr = inf0;
}
pLast->pNext = pIdInfThis;
pLast = pIdInfThis;
arFlangIds.removeAt(n);
n -= 1;
bFindFit = true;
}
}
}
pEnt->close();
}
}
if (!bFindEqu && !bFindFit)
break;
}
}
}
AcDbObjectIdInf* ReverIdInf(AcDbObjectIdInf& idInf0)
{
AcArray<AcDbObjectIdInf*> arInfPtrs;
AcDbObjectIdInf* pNext = idInf0.pNext;
while(pNext != NULL)
{
arInfPtrs.append(pNext);
pNext = pNext->pNext;
}
arInfPtrs.reverse();
AcDbObjectIdInf* pLast = NULL,*pHead = NULL;
for (int i = 0;i < arInfPtrs.length();i++)
{
pNext = arInfPtrs.at(i);
if (pLast != NULL)
{
pLast->pNext = pNext;
pLast = pNext;
}
else
{
pLast = pNext;
pHead = pLast;
pLast->pNext = NULL;
}
}
AcDbObjectIdInf* pLastBk = pLast;
if (pLast != NULL)
{
pLast->pNext = NULL;
pNext = new AcDbObjectIdInf;
pNext->id = idInf0.id;
pNext->infFr = idInf0.infFr;
pNext->vtMove = idInf0.vtMove;
pNext->pNext = NULL;
pLast->pNext = pNext;
pLast = pNext;
}
//Head由 idInf0代替
if (pHead != NULL)
{
idInf0.id = pHead->id;
idInf0.infFr = pHead->infFr;
idInf0.pNext = pHead->pNext;
delete pHead;
}
//TAIL
return pLast;
}
void ReverIdInfInf(AcDbObjectIdInf* pNext)
{
AecInterface inf0,inf1;
AcDbEntity* pEnt = NULL;
while(pNext != NULL)
{
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,pNext->id,AcDb::kForRead))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
if (pMInfNew->GetInterfaceCount() == 2)
{
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
if (inf0.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
{
pNext->infFr = inf1;
}
else if (inf1.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
{
pNext->infFr = inf0;
}
}
}
AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);
if (pMInfNew->GetInterfaceCount() == 2)
{
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
if (inf0.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
{
pNext->infFr = inf1;
}
else if (inf1.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
{
pNext->infFr = inf0;
}
}
}
pEnt->close();
}
pNext = pNext->pNext;
}
}
void AecPipeLineModify::MakeEquListTheRest(AcDbObjectIdArray& arEquIds,AcDbObjectIdArray& arFlangIds,AcArray<AcDbObjectIdInf>& arIdInf)
{
//先设备
AcDbEntity* pEnt = NULL;
AcDbObjectId id;
while( !arEquIds.isEmpty())
{
id = arEquIds.first();
arEquIds.removeFirst();
if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
{
AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
if (pEqu != NULL)
{
AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
if (pMInfNew->GetInterfaceCount() == 2)
{
AecInterface inf0,inf1;
pMInfNew->GetInterface(0,inf0);
pMInfNew->GetInterface(1,inf1);
AcDbObjectIdInf idInf0;
idInf0.pNext = NULL;
idInf0.id = id;
idInf0.infFr = inf0;
idInf0.vtMove.set(0,0,0);
//向左
AcArray<AcDbObjectIdInf> arIdInf0;
arIdInf0.append(idInf0);
MakeEquListStartByFlang(arIdInf0,arEquIds,arFlangIds);
//向右
AcDbObjectIdInf idInf1;
idInf1.pNext = NULL;
idInf1.id = id;
idInf1.infFr = inf1;
idInf0.vtMove.set(0,0,0);
AcArray<AcDbObjectIdInf> arIdInf1;
arIdInf1.append(idInf1);
MakeEquListStartByFlang(arIdInf1,arEquIds,arFlangIds);
//左右合成生成一条链
AcDbObjectIdInf* pTail = ReverIdInf(arIdInf0.first());
if (pTail != NULL)
{
//arIdInf0取右侧接口
AcDbObjectIdInf* pNext = &arIdInf0.first();
ReverIdInfInf(pNext);
pTail->pNext = arIdInf1.first().pNext;
//添加一条链
arIdInf.append(arIdInf0.first());
}
else
{
//...
//添加一条链
arIdInf.append(arIdInf1.first());
}
}
}
pEnt->close();
}
}
}
bool AecPipeLineModify::ModifyFitting(AecDbEwFitting* pFitting,const WPipe::PipeParam& paramNew)
{
bool bSuccesed = false;
WPipe::PipeParam* pParam = (WPipe::PipeParam*)&paramNew;
AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
if (m_bUpdateMat)
{
pXDataMap->SetAt(PIPE_MATERIAL,pParam->szMertial);
pXDataMap->SetAt(PIPE_MATERIALFT,pParam->szMertialFit);
pXDataMap->SetAt(PIPE_SYS, pParam->szSys);
pXDataMap->SetAt(PIPE_COLOR, pParam->m_nPipeColor);
//设置图层
TDbPipeLine::SetFittingLayer(pFitting, pParam->szSys);
}
//标准和外径系列
pXDataMap->SetAt(PIPE_ODSN, pParam->szODSn);
pXDataMap->SetAt(PIPE_SHTNO,pParam->szStdNo);
CString sODNo = pParam->szODSn;
bool bIsPvc = TDbPipeLine::IsPlasticsMat(pParam, sODNo);
int nType = 0,nLocked = -1;
pXDataMap->GetAt(KEY_RUNTIME,nType);
EFittingType eType = (EFittingType)nType;
//如果DN不变,仅仅改外径和壁厚
double dDNOld = 0.0;
pXDataMap->GetAt(PIPE_DN,dDNOld);
if ( fabs(dDNOld - pParam->m_dDN) < 1.e-2 )
{
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
//如果曲率半径改变
double dOldRatio = 2.0;
pXDataMap->GetAt(PIPE_RATIO,dOldRatio);
if ( fabs(dOldRatio - pParam->m_dRRatio) > 1.e-2)
{
if (eType != eElbow)//不是弯头
{
pXDataMap->SetAt(PIPE_RATIO,pParam->m_dRRatio);
return true;
}
else
{
//进行到弯头修改
}
}
else//曲率半径不变
{
return true;
}
}
int nConnectType = 0;
pXDataMap->GetAt(PIPE_CONNECT,nConnectType);
double dPre = 1.6;
pXDataMap->GetAt(PIPE_PRESSURE, dPre);
CString sProject;
pXDataMap->GetAt(DOC_PROJECT, sProject);
CString sLevel;
pXDataMap->GetAt(PIPE_LEVEL, sLevel);
CString sKey;
//弯头,三通,四通,变径
switch( eType )
{
case eElbow:
{
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eElbow,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pParam->m_dInterfaceD = dFD;
pParam->m_dInterfaceL = dFL;
if (pParam->m_nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject,sLevel,sODNo);
pParam->m_dWh = dWh;
pParam->m_dWn = dN;
}
}
TDbPipeLine pLn(NULL);
pLn.SetPipeParam(pParam);
pLn.SetInitDataMapPartFrom(pXDataMap);
pLn.FillConfigXDataMap(pXDataMap,pParam);
pXDataMap->SetAt(PIPE_WH,pParam->m_dWh);
pXDataMap->SetAt(PIPE_WN,pParam->m_dWn);
pXDataMap->SetAt(PIPE_RATIO,pParam->m_dRRatio);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
//结构长度
double dL = 0.0;
if (!bIsPvc)
{
pXDataMap->SetAt(KEY_RadRatio, pParam->m_nRadioOn);
TDbPipeSupport::QueryElbowL(m_pADOServer, pParam->m_dDN, dL, pParam->m_dRRatio, pParam->m_nConnectType, pParam->szLevel, pParam->szODSn, pXDataMap);
pXDataMap->SetAt(KEY_Length, dL);
}
else
{
TDbPipeSupport::QueryPVCElbow(m_pADOServer, pParam->m_dDN, pXDataMap, sODNo);
}
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
break;
}
case eTee:
{
if (m_bTeeStop) //三通分支管径不改尺寸; 主接口可修改.分支锁定
{
TeeStop:
double dTDN = 0.0;
pXDataMap->GetAt(PIPE_TDN,dTDN);
double dDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
nLocked = -1;
for(int k = 0;k < 3;k++)
{
sKey.Format(_T("LK_%d"),k);
if ( pXDataMap->GetAt(sKey,nLocked) )
{
if (nLocked > -1)
{
break;
}
}
}
if (nLocked == 2)//分支锁定,改主管
{
if ( ( dTDN - pParam->m_dDN ) > 1.e-2)
{
acutPrintf(_T("\n三通分支管径大于主管径!修改管径失败!"));
return false;
}
//主接口可修改.分支锁定
//原来的主接口
AecInterface inf2;
pFitting->GetInterface(2,inf2);
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eTee,nConnectType,pParam->m_dDN,dFD,dFL, sODNo,sProject,sLevel);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
if ( nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH,dThk);
pXDataMap->SetAt(PIPE_WN,dN);
}
}
double dL = 0.0,dS = 0.0;
if ( TDbPipeSupport::QueryTeeData(m_pADOServer,pParam->m_dDN,dTDN,dL,dS, sODNo, sProject, sLevel) )
{
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)//法兰管
{
dL += dInterfaceL;
dS += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
dL -= dInterfaceL;
dS -= dInterfaceL;
//颈法兰焊接方式
if (sODNo.CompareNoCase( _T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dL += dThk;
dS += dThk;
}
}
}
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL * 2);
pXDataMap->SetAt(KEY_T,dS);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
//记录更改调整,后面调整管线或阀门
AecInterface inf22;
pFitting->GetInterface(2,inf22);
AecInterfaceFrTo infFrTo;
infFrTo.infFr = inf2;
infFrTo.infTo = inf22;
m_arFrTo.append(infFrTo);
}
else //主管锁定,改分支
{
if ( ( pParam->m_dDN - dDN) > 1.e-2)
{
acutPrintf(_T("\n三通分支管径大于主管径!修改管径失败!"));
return false;
}
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eTee,nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
if ( nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH2,dThk);
pXDataMap->SetAt(PIPE_WN2,dN);
}
}
double dL = 0.0,dS = 0.0;
if ( TDbPipeSupport::QueryTeeData(m_pADOServer,dDN,pParam->m_dDN,dL,dS, sODNo, sProject, sLevel) )
{
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)//法兰管
{
dL += dInterfaceL;
dS += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
dL -= dInterfaceL;
dS -= dInterfaceL;
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dL += dThk;
dS += dThk;
}
}
}
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL * 2);
pXDataMap->SetAt(KEY_T,dS);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
}
bSuccesed = true;
}
else//全改,统一DN
{
double dDN = 0.0,dTDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
pXDataMap->GetAt(PIPE_TDN,dTDN);
if ( fabs(dTDN - dDN) > 1.e-2)
{
goto TeeStop;
break;
}
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eTee,nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
if ( nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH2,dThk);
pXDataMap->SetAt(PIPE_WN2,dN);
pXDataMap->SetAt(PIPE_WH,dThk);
pXDataMap->SetAt(PIPE_WN,dN);
}
}
double dL = 0.0,dS = 0.0;
if ( TDbPipeSupport::QueryTeeData(m_pADOServer,pParam->m_dDN,pParam->m_dDN,dL,dS, sODNo, sProject, sLevel) )
{
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)//法兰管
{
dL += dInterfaceL;
dS += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
dL -= dInterfaceL;
dS -= dInterfaceL;
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dL += dThk;
dS += dThk;
}
}
}
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL * 2);
pXDataMap->SetAt(KEY_T,dS);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
}
break;
}
case eCross:
{
if (m_bCrossStop)//四通分支管径不改尺寸
{
CrossStop:
nLocked = -1;
for(int k = 0;k < 4;k++)
{
sKey.Format(_T("LK_%d"),k);
if ( pXDataMap->GetAt(sKey,nLocked) )
{
if (nLocked > -1)
{
break;
}
}
}
if (nLocked > 1)//分支锁定,改主管
{
double dTDN = 0.0;
pXDataMap->GetAt(PIPE_TDN,dTDN);
double dDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eCross,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
if (nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH,dThk);
pXDataMap->SetAt(PIPE_WN,dN);
}
}
double dL = 0.0,dB = 0.0;
if ( TDbPipeSupport::QueryCrossData(m_pADOServer,pParam->m_dDN,pParam->m_dDN,dL,dB, sODNo, sProject, sLevel) )
{
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)//法兰管
{
dL += dInterfaceL;
dB += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
dL -= dInterfaceL;
dB -= dInterfaceL;
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dL += dThk;
dB += dThk;
}
}
}
//记录分支前
AecInterface inf2,inf3;
pFitting->GetInterface(2,inf2);
pFitting->GetInterface(3,inf3);
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL * 2);
pXDataMap->SetAt(KEY_T,dB * 2);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
//记录分支后
AecInterface inf22,inf33;
pFitting->GetInterface(2,inf22);
pFitting->GetInterface(3,inf33);
AecInterfaceFrTo infFt;
infFt.infFr = inf2;
infFt.infTo = inf22;
m_arFrTo.append(infFt);
infFt.infFr = inf3;
infFt.infTo = inf33;
m_arFrTo.append(infFt);
}
else//主管锁定,改分支
{
double dTDN = 0.0;
pXDataMap->GetAt(PIPE_TDN,dTDN);
double dDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eCross,pParam->m_nConnectType,dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
if (nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH2,dThk);
pXDataMap->SetAt(PIPE_WN2,dN);
}
}
double dL = 0.0,dB = 0.0;
if ( TDbPipeSupport::QueryCrossData(m_pADOServer,dDN,pParam->m_dDN,dL,dB, sODNo, sProject, sLevel) )
{
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)//法兰管
{
dL += dInterfaceL;
dB += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
dL -= dInterfaceL;
dB -= dInterfaceL;
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dL += dThk;
dB += dThk;
}
}
}
//记录主管前
AecInterface inf0,inf1;
pFitting->GetInterface(0,inf0);
pFitting->GetInterface(1,inf1);
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL * 2);
pXDataMap->SetAt(KEY_T,dB * 2);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
//记录主管后
AecInterface inf00,inf11;
pFitting->GetInterface(0,inf00);
pFitting->GetInterface(1,inf11);
AecInterfaceFrTo infFt;
infFt.infFr = inf0;
infFt.infTo = inf00;
m_arFrTo.append(infFt);
infFt.infFr = inf1;
infFt.infTo = inf11;
m_arFrTo.append(infFt);
}
bSuccesed = true;
}
else//全改,统一DN
{
double dDN = 0.0,dTDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
pXDataMap->GetAt(PIPE_TDN,dTDN);
if ( fabs(dTDN - dDN) > 1.e-2)
{
goto CrossStop;
break;
}
if (nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eCross,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
if (nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH,dThk);
pXDataMap->SetAt(PIPE_WN,dN);
pXDataMap->SetAt(PIPE_WH2,dThk);
pXDataMap->SetAt(PIPE_WN2,dN);
}
}
double dL = 0.0,dB = 0.0;
if ( TDbPipeSupport::QueryCrossData(m_pADOServer,pParam->m_dDN,pParam->m_dDN,dL,dB, sODNo, sProject, sLevel) )
{
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)//法兰管
{
dL += dInterfaceL;
dB += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
dL -= dInterfaceL;
dB -= dInterfaceL;
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dL += dThk;
dB += dThk;
}
}
}
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL * 2);
pXDataMap->SetAt(KEY_T,dB * 2);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
}
break;
}
case eWye://对于 Wye 的三个接口尺寸一样
{
double dDN = 0.0,dTDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
pXDataMap->GetAt(PIPE_TDN,dTDN);
if ( nConnectType > 0)
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eWye, nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
if ( nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH2,dThk);
pXDataMap->SetAt(PIPE_WN2,dN);
pXDataMap->SetAt(PIPE_WH,dThk);
pXDataMap->SetAt(PIPE_WN,dN);
}
}
int nType = 0;
double dM = 0.0, dB = 0.0, dInsL = 0.0, dInfD = 0.0;
TDbPipeSupport::QueryWYeData(m_pADOServer, (int)(pParam->m_dDN + 0.5), dM, dB, dInsL, dInfD, 0, sProject, sLevel);
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if (dInterfaceL > 1.e-3)
{
dM += dInterfaceL;
dB += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer, (int)(pParam->m_dDN + 0.5),1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dB += (dThk - dWh);
dM += (dThk - dWh);
}
}
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(PIPE_M,dM);
pXDataMap->SetAt(PIPE_B,dB);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
break;
}
case eLateral: //对于Lateral ,三个接口全改
{
if ( nConnectType > 0)
{
double dDN = 0.0,dTDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
pXDataMap->GetAt(PIPE_TDN,dTDN);
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eLateral, nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
if ( nConnectType == 3)
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
pXDataMap->SetAt(PIPE_WH2,dThk);
pXDataMap->SetAt(PIPE_WN2,dN);
pXDataMap->SetAt(PIPE_WH,dThk);
pXDataMap->SetAt(PIPE_WN,dN);
}
}
double dE = 0.0, dM = 0.0, dB = 0.0, dInsL = 0.0, dInfD = 0.0;
TDbPipeSupport::QueryLateralData(m_pADOServer, (int)(pParam->m_dDN+0.5), dE, dM, dB, dInsL, dInfD, 0, sProject, sLevel);
double dInterfaceL = 0.0;
pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
if ( dInterfaceL > 1.e-3)
{
dE += dInterfaceL;
dM += dInterfaceL;
dB += dInterfaceL;
}
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,(int)(pParam->m_dDN+0.5),1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
dE += (dThk - dWh);
dB += (dThk - dWh);
dM += (dThk - dWh);
}
}
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(PIPE_E,dE);
pXDataMap->SetAt(PIPE_M,dM);
pXDataMap->SetAt(PIPE_B,dB);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
break;
}
case eReduce:
{
double dL = 0.0;
pXDataMap->GetAt(KEY_Length,dL);
double dD = 0.0;
pXDataMap->GetAt(PIPE_D,dD);
double dDN = 0.0;
pXDataMap->GetAt(PIPE_DN,dDN);
double dTDN = 0.0;
pXDataMap->GetAt(PIPE_EDN,dTDN);
//判断修改端
if ( fabs(m_paramOld.m_dDN - dDN) < 1.e-2)//
{
if ( fabs( pParam->m_dDN - dDN ) < 1.e-2)
{
acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
return false;
}
//改主管,分支不变
if ( nConnectType > 0)//
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eReduce, nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
}
//长度单独设置
if (!TDbPipeSupport::QueryReduceData(m_pADOServer, nConnectType,(int)pParam->m_dDN, (int)dTDN, dL,pXDataMap,sODNo))
{
acutPrintf(_T("\n没有查到%d到%d的变径长度!变径变更失败!"), (int)pParam->m_dDN, (int)dTDN);
return false;
}
pParam->m_dInterfaceL3 = dL;
//记录修改前
AecInterface inf1;
pFitting->GetInterface(1,inf1);
pXDataMap->SetAt(KEY_Length,dL);
pXDataMap->SetAt(PIPE_INTERFACEL3,dL);
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_D,pParam->m_dDN);
AcGeVector3d vtDir;
pXDataMap->GetAt(KEY_MAJBR,vtDir);
AcGePoint3d ptSta;
pXDataMap->GetAt(KEY_START,ptSta);
vtDir.normalize();
AcGePoint3d ptEnd = ptSta + pParam->m_dInterfaceL3 * vtDir;
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN);
double dWD2 = 0.0,dWh2 = 0.0,dThk2 = 0.0,dN2 = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,dTDN,1.0,dWD2,dWh2,dThk2,dN2);
//颈法兰焊接方式
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
ptEnd += (dThk2 + dThk) * vtDir;
}
pXDataMap->SetAt(PIPE_WN2,dN);
pXDataMap->SetAt(PIPE_WH2,dThk);
}
//是否偏移
double dOffset = (pParam->m_dDN - dTDN) / 2.0;
AcGeVector3d vtOffset;
pXDataMap->GetAt(KEY_OFFSET,vtOffset);
vtOffset.normalize();
vtOffset *= dOffset;
ptEnd += vtOffset;
pXDataMap->SetAt(KEY_END,ptEnd);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
//记录修改后
AecInterface inf11;
pFitting->GetInterface(1,inf11);
AecInterfaceFrTo infFt;
infFt.infFr = inf1;
infFt.infTo = inf11;
m_arFrTo.append(infFt);
}
else//主管不改，改分支
{
if ( fabs( pParam->m_dDN - dTDN ) < 1.e-2)
{
acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
return false;
}
if ( nConnectType > 0)//
{
double dFD = 0.0,dFL = 0.0;
TDbPipeSupport::QueryInfFDFL(m_pADOServer,eReduce, nConnectType,pParam->m_dDN,dFD,dFL, sProject, sLevel);
pXDataMap->SetAt(PIPE_INTERFACED,dFD);
pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
}
//长度单独设置
if (!TDbPipeSupport::QueryReduceData(m_pADOServer, nConnectType, dDN, (int)pParam->m_dDN, dL, pXDataMap,sODNo))
{
acutPrintf(_T("\n没有查到%d到%d的变径长度!变径变更失败!"), (int)pParam->m_dDN, (int)dTDN);
return false;
}
double dLx = 0, dSx = 0;
pXDataMap->GetAt(_T("H2"), dLx);
pXDataMap->GetAt(_T("H1"), dSx);
pParam->m_dInterfaceL3 = dL;
pXDataMap->SetAt(KEY_Length,dL);
pXDataMap->SetAt(PIPE_EDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_EOD,pParam->m_dOD);
AcGeVector3d vtDir;
pXDataMap->GetAt(KEY_MAJBR,vtDir);
AcGePoint3d ptSta;
pXDataMap->GetAt(KEY_START,ptSta);
vtDir.normalize();
AcGePoint3d ptEnd = ptSta + (pParam->m_dInterfaceL3 + dLx + dSx) * vtDir;
if ( nConnectType == 3)//法兰连接
{
//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
double dWD2 = 0.0,dWh2 = 0.0,dThk2 = 0.0,dN2 = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD2,dWh2,dThk2,dN2, sProject, sLevel,sODNo);
//颈法兰焊接方式
//ptSta += dWh * vtDir;
if (sODNo.CompareNoCase(_T("S")) != 0 &&
sODNo.CompareNoCase(_T("GSF")) != 0)
{
ptEnd += (dThk2 + dThk) * vtDir;
}
pXDataMap->SetAt(PIPE_WN,dN2);
pXDataMap->SetAt(PIPE_WH,dThk2);
}
//是否偏移
double dOffset = (dDN - pParam->m_dDN) / 2.0;
AcGeVector3d vtOffset;
pXDataMap->GetAt(KEY_OFFSET,vtOffset);
vtOffset.normalize();
vtOffset *= dOffset;
ptEnd += vtOffset;
pXDataMap->SetAt(KEY_END,ptEnd);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
}
bSuccesed = true;
break;
}
case eWcap:
{
//全改
double dL = 0.0;
TDbPipeSupport::QueryCapData(m_pADOServer, pParam->m_dDN, dL,sODNo);
pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
pXDataMap->SetAt(KEY_L,dL);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
break;
}
case eFlxJoin:
{
TDbPipeSupport::QueryFlxJoinData(m_pADOServer, pParam->m_dDN, dPre, pXDataMap);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
break;
}
case eThrough://直通 PVC
case eUJoin://活接 PVC
case eRJoin://缩接 PVC 伸缩节
case eOJoin://外螺纹接头
case eIJoin://内螺纹接头
{
//全改
TDbPipeSupport::QueryPVCSpecFit(m_pADOServer, pParam->m_dDN, sODNo, eType, pXDataMap);
pXDataMap->SetAt(PIPE_DN, pParam->m_dDN);
pXDataMap->SetAt(PIPE_OD, pParam->m_dOD);
pXDataMap->SetAt(PIPE_TDN, pParam->m_dDN);
pXDataMap->SetAt(PIPE_TOD, pParam->m_dOD);
pXDataMap->SetAt(PIPE_THICK, pParam->m_dThick);
pFitting->ReCreateDraw2d();
pFitting->ReCreateDraw3d();
bSuccesed = true;
break;
}
default:
break;
}
return bSuccesed;
}
AecDbEwFitting* AecPipeLineModify::CreateNewFlang(AecDbEwFitting* pFitFr,const WPipe::PipeParam& paramNew)
{
AecDbEwFitting* pFlange = new AecDbEwFitting;
AecDbObjXDataMap* pXDataMapF = pFlange->GetSpecialtyData();
pFlange->copyFrom(pFitFr);
double dPre = 1.0;
WPipe::PipeParam* pParam = (WPipe::PipeParam*)&paramNew;
CString sODNo = _T("A");
bool bIsPvc = TDbPipeLine::IsPlasticsMat(pParam, sODNo);
CString sPre;
pFitFr->GetSpecialtyData()->GetAt(PIPE_PRESSURE,sPre);
dPre = _ttof(sPre);
CString sProject;
pFitFr->GetSpecialtyData()->GetAt(DOC_PROJECT, sProject);
CString sLevel;
pFitFr->GetSpecialtyData()->GetAt(PIPE_LEVEL, sLevel);
//[法兰外径],[法兰厚度],[法兰高度]
double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
TDbPipeSupport::QueryFlangData(m_pADOServer,paramNew.m_dDN,dPre,dWD,dWh,dThk,dN, sProject, sLevel, sODNo);
pXDataMapF->SetAt(PIPE_DN,paramNew.m_dDN);
pXDataMapF->SetAt(PIPE_N,dN);
pXDataMapF->SetAt(PIPE_OD,paramNew.m_dOD);
pXDataMapF->SetAt(PIPE_WD,dWD); //发兰盘外径
pXDataMapF->SetAt(PIPE_WTHICK,dWh); //大盘面厚度
//pXDataMapF->SetAt(PIPE_THICK,dThk);//总厚
pXDataMapF->SetAt(PIPE_THICK, dWh); // 管线上的法兰不画法兰颈
return pFlange;
}
bool AecPipeLineModify::ModifyByInfAssoc(const AcArray<AecInterface>& arFitEquOldInfs,AecMInterfaces* pFitEquMInfNew,const WPipe::PipeParam& paramNew)
{
//从 m_arNetIds 找
//移除一个,去除一个
//一直到inf锁定为止
//arFitEquOldInfs 和 pFitEquMInfNew 一一对应
AcArray<AecInterface> arNewInfs;
pFitEquMInfNew->GetInterface(arNewInfs);
AcDbEntity* pEnt = NULL;
AecMInterfaces* pMInfMeetWith = NULL;
for (int i = 0;i < m_arNetIds.length();i++)
{
pMInfMeetWith = NULL;
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,m_arNetIds.at(i),AcDb::kForRead))
{
AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
if (pPipe != NULL)
{
pMInfMeetWith = static_cast<AecMInterfaces*>(pPipe);
}
if (pMInfMeetWith != NULL)
{
AcGeVector3d vtDir,vtDir2;
AcGePoint3d ptS,ptE,ptNew;
AecInterface infOn,infNew;
for (int j = 0;j < arFitEquOldInfs.length();j++)
{
const AecInterface& inf = arFitEquOldInfs.at(j);
if (pMInfMeetWith->GetInterface(inf.ptPos,infOn))
{
//碰上此接口
if (pPipe != NULL)
{
pPipe->upgradeOpen();
//改管子的长度
ptS = pPipe->StartPoint();
ptE = pPipe->EndPoint();
vtDir = ptE - ptS;
if (ptS.distanceTo(infOn.ptPos) < 1.e-2)//误差0.01
{
pFitEquMInfNew->GetInterface(j,infNew);
vtDir2 = ptE - infNew.ptPos;
if (!vtDir2.isCodirectionalTo(vtDir))
{
pEnt->close();
acutPrintf(_T("管线尺寸变更幅度过大!产生管线错位!变更失败!"));
return false;
}
pPipe->SetStartPoint( infNew.ptPos );
}
if (ptE.distanceTo(infOn.ptPos) < 1.e-2)
{
pFitEquMInfNew->GetInterface(j,infNew);
vtDir2 = infNew.ptPos - ptS;
if ( !vtDir2.isCodirectionalTo(vtDir) )
{
pEnt->close();
acutPrintf(_T("管线尺寸变更幅度过大!产生管线错位!变更失败!"));
return false;
}
pPipe->SetEndPoint( infNew.ptPos );
}
pPipe->downgradeOpen();
}
//对fit 无效，导致回溯
/*AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
if (pFit != NULL)
{
}*/
break;
}
}
}
pEnt->close();
}
}
return true;
}
extern AecDbEwEquipment *startForPipeValve(LPCTSTR type
, LPCTSTR title
, const double &dn
, const double &pn
, bool &bHasFlange
, const int &idx = 0
, const AecDbObjXDataMap *pSrcData = NULL);
AecDbEwEquipment* AecPipeLineModify::getEquiment( AecDbEwEquipment *pOldEqu
, const WPipe::PipeParam &paramNew
, bool &bHasFangle
, AecEqui::ValveType val
, LPCTSTR psz/* = NULL*/
, LPCTSTR pszFolder/* = NULL*/)
{
if (!pOldEqu) return NULL;
int bParaValve(false);
pOldEqu->GetAt(_T("_parameter_equ_"), bParaValve);
AecDbEwEquipment *pEqu(NULL);
if (!bParaValve)
{
if (!psz || !pszFolder) return NULL;
bool b2DFlagCheck(false);
pEqu = CEquipmentLibraryDlg::selectCustomValve(
psz
, paramNew.m_dDN
, bHasFangle
, true
, bHasFangle
, b2DFlagCheck);
if (!pEqu) return NULL;
pEqu->SetAt(PIPE_VALVE, val);
pEqu->SetAt(KEY_SUBRUNTIME, eValve);
pEqu->SetAt(KEY_VLV2D, TRUE);
pEqu->SetAt(PIPE_LEVEL, paramNew.szLevel);
}
else // 参数化
{
pEqu = startForPipeValve(psz
, CString(_T("插入")) + psz
, paramNew.m_dDN
, paramNew.m_dPress
, bHasFangle
, 0
, pOldEqu->GetSpecialtyData());
if (pEqu)
{
pEqu->SetAt(PIPE_VALVE, val);
pEqu->SetAt(KEY_SUBRUNTIME, eValve);
pEqu->SetAt(KEY_VLV2D, TRUE);
}
}
return pEqu;
}
extern int g_nVlvLen;
extern AecEqui::VlvType g_vlvType[];
typedef AcArray<AcGeMatrix3d> AcGeMatrix3dArray;
AecDbEwEquipment* AecPipeLineModify::CreateNewValve(AecDbEwEquipment* pEqu,const WPipe::PipeParam& paramNew)
{
if (pEqu != NULL)
{
AcGePoint3d ptIns;
AcGeVector3d vtDir;
AecInterface infOld,infNew,infNew1;
pEqu->GetInsert(ptIns,vtDir);
pEqu->GetInterface(0,infOld);
AcGeMatrix3dArray arMatrix;
pEqu->GetAllAddTransforms(arMatrix);
pEqu->SetDashLayer(PipelineTools::AecInitLayerEx(LAY_FITN_DASH, 8, _T("DASH"), NULL));
pEqu->SetCenterLayer(PipelineTools::AecInitLayerEx(LAY_FITN_CENTER, 4, _T("Center2"), NULL));
CString sName;
int nVal = 0;
pEqu->GetSpecialtyData()->GetAt(PIPE_VALVE, nVal);
AecEqui::ValveType eVlvType = (AecEqui::ValveType)nVal;
for (int i = 0; i < g_nVlvLen; i++)
{
if ( (int)g_vlvType[i].eType == nVal)
{
sName = g_vlvType[i].szNameCn;
break;
}
}
//通过sName,dNewDN查新的阀门
if (m_pADOServer != NULL)
{
int bParaValve(false);
pEqu->GetAt(_T("_parameter_equ_"), bParaValve);
bool bHasFangle = false;
AecDbEwEquipment* pEquNew = getEquiment(pEqu
, paramNew
, bHasFangle
, eVlvType
, sName
, VALVE_FOLDER);
if (pEquNew != NULL)
{
//立管是否转动方向
pEquNew->SetVert(pEqu->IsVert());
pEquNew->SetInsert(ptIns,vtDir);
for (int i = 0;i < arMatrix.length();i++)
{
pEquNew->AddTransform(arMatrix.at(i));
}
pEquNew->GetInterface(0,infNew);
//接口中心校正,并且必须是第一接口情况
if (infOld.vtDir.isParallelTo(infNew.vtDir))
{
if (!infOld.vtDir.isCodirectionalTo(infNew.vtDir))
{
pEquNew->GetInterface(1,infNew);
}
}
// 此处不需要调整，在外部调用已经调整 2025-4-3
// AcGeVector3d vt = infOld.ptPos - infNew.ptPos;
// if (!vt.isZeroLength())
// {
// //平移等标高
// AcGeMatrix3d xform;
// xform.setToTranslation(vt);
// pEquNew->AddTransform(vt);
// }
//验证测试
pEquNew->GetInterface(0,infNew);
pEquNew->GetInterface(1,infNew1);
pEquNew->setLayer(pEqu->layerId());
pEquNew->setLinetype(pEqu->linetypeId());
AcDbObjectId idDsh;
pEqu->GetDashLayer(idDsh);
pEquNew->SetDashLayer(idDsh);
AcDbObjectId idCen;
pEqu->GetCenterLayer(idCen);
pEquNew->SetCenterLayer(idCen);
return pEquNew;
}
}
}
return NULL;
}
bool AecPipeLineModify::ModifyPipeOnParam(const AcDbObjectIdArray& arPipeIds,const WPipe::PipeParam& paramNew)
{
AcDbEntity* pEnt = NULL;
for(int i = 0;i < arPipeIds.length();i++)
{
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arPipeIds.at(i),AcDb::kForWrite))
{
AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
if (pPipe != NULL)
{
//公称 外径 壁厚 压了等级,曲率半径
WPipe::PipeParam* pParam = pPipe->GetPipeParam();
//覆盖为新的参数
pParam->m_dDN = paramNew.m_dDN;
pParam->m_dOD = paramNew.m_dOD;
_tcscpy(pParam->szODSn, paramNew.szODSn);
_tcscpy(pParam->szStdNo, paramNew.szStdNo);
switch (pParam->m_eD)
{
case WPipe::eOD:
{
pParam->m_dD = paramNew.m_dOD;
break;
}
case WPipe::eDN:
{
pParam->m_dD = paramNew.m_dDN;
break;
}
case WPipe::eID:
{
pParam->m_dD = paramNew.m_dOD - 2.0 * paramNew.m_dThick;
break;
}
default:
break;
}
pParam->m_dThick = paramNew.m_dThick;
_tcscpy(pParam->szLevel,paramNew.szLevel);
pParam->m_dRRatio = paramNew.m_dRRatio;
if (_tcslen(paramNew.szMertial) > 0)
_tcscpy(pParam->szMertial, paramNew.szMertial);
if (pParam->m_nConnectType == 3)
{
pParam->m_dInterfaceL = paramNew.m_dInterfaceL;
pParam->m_dInterfaceD = paramNew.m_dInterfaceD;
}
if (m_bUpdateMat)
{
_tcscpy(pParam->szMertial,paramNew.szMertial);
_tcscpy(pParam->szMertialFit,paramNew.szMertialFit);
_tcscpy(pParam->szSys, paramNew.szSys);
pPipe->GetSpecialtyData()->SetAt(PIPE_COLOR, paramNew.m_nPipeColor);
//设置图层
TDbPipeLine::SetPipeLayer(pPipe, paramNew.szSys);
}
pPipe->SetPipeParam(pParam);
delete pParam;
}
pEnt->close();
}
}
return true;
}
bool AecPipeLineModify::AddjustTInfAssoc()
{
//主要是管子
if (!m_arFrTo.isEmpty())
{
//选择管线,管件
struct resbuf* pRb = acutBuildList(RTDXF0, DXF_PIPE_ONLY, 0);
ads_name ss,ent;
acedSSGet(_T("A"),NULL,NULL,pRb,ss);
Adesk::Int32 nLen = 0;
acedSSLength(ss,&nLen);
AcGePoint3d ptS,ptE;
AcDbObjectId id;
AcDbEntity* pEnt = NULL;
for (int i = 0;i < nLen;i++)
{
if (m_arFrTo.isEmpty())
{
break;
}
acedSSName(ss,i,ent);
acdbGetObjectId(id,ent);
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
{
AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
if (pPipe != NULL)
{
ptS = pPipe->StartPoint();
ptE = pPipe->EndPoint();
for (int k = 0;k < m_arFrTo.length();k++)
{
AecInterfaceFrTo& infFrTo = m_arFrTo.at(k);
if (infFrTo.infFr.ptPos.distanceTo(ptS) < 1.e-3 )
{
pPipe->upgradeOpen();
pPipe->SetStartPoint(infFrTo.infTo.ptPos);
pPipe->downgradeOpen();
m_arFrTo.removeAt(k);
k -= 1;
break;
}
if (infFrTo.infFr.ptPos.distanceTo(ptE) < 1.e-3)
{
pPipe->upgradeOpen();
pPipe->SetEndPoint(infFrTo.infTo.ptPos);
pPipe->downgradeOpen();
m_arFrTo.removeAt(k);
k -= 1;
break;
}
}
}
pEnt->close();
}
}
acedSSFree(ss);
acutRelRb(pRb);
}
return true;
}
Reference in new issue View Git Blame Copy Permalink