1941 lines
46 KiB
C++
1941 lines
46 KiB
C++
#include "stdafx.h"
|
|
#include "StdArx.h"
|
|
#include "AecMInterfaces.h"
|
|
#include "AecDbHvacFitting.h"
|
|
#include "AecDbEwEquipment.h"
|
|
#include "AecPipeLineModify.h"
|
|
#include "AecDbDuctLine.h"
|
|
#include "coretools.h"
|
|
|
|
#ifndef DXF_PIPE_ONLY
|
|
#define DXF_PIPE_ONLY _T("AEC_DBDUCT")
|
|
#endif
|
|
|
|
#ifndef VALVE_FOLDER
|
|
#define VALVE_FOLDER _T("阀")
|
|
#endif
|
|
|
|
extern double GetElbowLx(AecHvac::DuctParam *pParam);
|
|
extern double GetElbowL(AecHvac::DuctParam *pParam);
|
|
|
|
AecPipeLineModify::AecPipeLineModify(void)
|
|
{
|
|
m_bTeeStop = FALSE;
|
|
m_bUpdateMat = FALSE;
|
|
m_bCrossStop = FALSE;
|
|
m_bElLock = false;
|
|
memset(&m_paramOld,0,sizeof(AecHvac::DuctParam));
|
|
}
|
|
|
|
AecPipeLineModify::~AecPipeLineModify(void)
|
|
{
|
|
|
|
}
|
|
|
|
void AecPipeLineModify::SetPipeParamOld(const AecHvac::DuctParam * pPipeParam)
|
|
{
|
|
if (pPipeParam != NULL)
|
|
{
|
|
memcpy(&m_paramOld,pPipeParam,sizeof(AecHvac::DuctParam));
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool AecPipeLineModify::ModifyPipeLineParam(AcDbObjectIdArray& arPipeIds,AcDbObjectIdArray& arFitIds,AcDbObjectIdArray& arEquIds, AecHvac::DuctParam& paramNew,BOOL bUpdateMat)
|
|
{
|
|
m_bUpdateMat = bUpdateMat;
|
|
|
|
//1.先优先统一改管子的尺寸
|
|
ModifyPipeOnParam(arPipeIds,paramNew);
|
|
m_arPipeIds.append(arPipeIds);
|
|
|
|
AcArray<AcDbObjectIdInf> arAssFlgs,arAssEquIds;
|
|
|
|
//2.先修改定位管件,定位管件的位置为绝对位置
|
|
//弯头,三通,四通,乙字弯
|
|
//修改后导致接口位置改变,影响连接件
|
|
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))
|
|
{
|
|
AecDbHvacFitting * pFit = AecDbHvacFitting::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 eReduce:
|
|
case eCross:
|
|
case eOffset:
|
|
{
|
|
//按阀门接口找出接口接的阀门
|
|
CPoint ptnPos1 = PickAssocEqu(arInfs,arEquIds,arAssEquIds);
|
|
|
|
//改完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;
|
|
}
|
|
}
|
|
|
|
//按照接口路线修改
|
|
//一直到管子停止;
|
|
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;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
if ( fabs(m_paramOld.dSize[0] - paramNew.dSize[0]) > 1.e-1 ||
|
|
fabs(m_paramOld.dSize[1] - paramNew.dSize[1]) > 1.e-1 ||
|
|
fabs(m_paramOld.m_dRatio - paramNew.m_dRatio) > 1.e-1 )
|
|
{
|
|
//从某一个设备开始 建立方向串
|
|
if (!arAssEquIds.isEmpty())
|
|
{
|
|
MakeEquListStartByEqus(arAssEquIds,arEquIds);
|
|
}
|
|
|
|
//4.arEquIds 余下孤立的阀门建立方向串
|
|
AcArray<AcDbObjectIdInf> arIdInf;
|
|
AcDbObjectIdArray arFlangIds;
|
|
MakeEquListTheRest(arEquIds,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);
|
|
CoreTools::AddToModelSpace(pCir,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);
|
|
CoreTools::AddToModelSpace(pLn,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))
|
|
{
|
|
AecDbHvacDuct * pPipe = AecDbHvacDuct::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 AecHvac::DuctParam & 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;
|
|
}
|
|
}
|
|
|
|
pEnt->close();
|
|
}
|
|
|
|
pLast = pNext;
|
|
pNext = pNext->pNext;
|
|
}
|
|
|
|
|
|
//可能更改两侧的管子
|
|
if (pLast != NULL)
|
|
{
|
|
ModifyPipeOnNewInf(infOld,infTo);
|
|
}
|
|
}
|
|
|
|
//沿着list修改阀门
|
|
void AecPipeLineModify::ModifyEquAlongList(AcArray<AcDbObjectIdInf>& arAssEquIds,const AecHvac::DuctParam & paramNew)
|
|
{
|
|
//链的开头记录要整体移动
|
|
AcDbEntity* pEnt = NULL;
|
|
AcGeMatrix3d xMove;
|
|
AcGeVector3d vtDir,vtTmp;
|
|
AcGePoint3d ptS;
|
|
AecInterface infPipe,infTo,infPipeOther,infPipeOtherTo;
|
|
|
|
for (int i = 0;i < arAssEquIds.length();i++)
|
|
{
|
|
AcDbObjectIdInf& idInf = arAssEquIds.at(i);
|
|
xMove.setToTranslation(idInf.vtMove);
|
|
|
|
if ( Acad::eOk == 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;
|
|
}
|
|
}
|
|
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
//弯头等fit直接接设备，法兰管线才有
|
|
void AecPipeLineModify::MakeEquListStartByEqus(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::MakeEquListStartByFlgs(AcArray<AcDbObjectIdInf>& arAssFlgs,AcDbObjectIdArray& arEquIds)
|
|
{
|
|
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();
|
|
}
|
|
}
|
|
|
|
if (!bFindEqu )
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
AecDbHvacFitting * pFit = AecDbHvacFitting::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,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);
|
|
MakeEquListStartByFlgs(arIdInf0,arEquIds);
|
|
|
|
//向右
|
|
AcDbObjectIdInf idInf1;
|
|
idInf1.pNext = NULL;
|
|
idInf1.id = id;
|
|
idInf1.infFr = inf1;
|
|
idInf0.vtMove.set(0,0,0);
|
|
|
|
AcArray<AcDbObjectIdInf> arIdInf1;
|
|
arIdInf1.append(idInf1);
|
|
MakeEquListStartByFlgs(arIdInf1,arEquIds);
|
|
|
|
//左右合成生成一条链
|
|
AcDbObjectIdInf* pTail = ReverIdInf(arIdInf0.first());
|
|
if (pTail != NULL)
|
|
{
|
|
//arIdInf0取右侧接口
|
|
AcDbObjectIdInf* pNext = &arIdInf0.first();
|
|
ReverIdInfInf(pNext);
|
|
|
|
pTail->pNext = arIdInf1.first().pNext;
|
|
}
|
|
|
|
//添加一条链
|
|
arIdInf.append(arIdInf0.first());
|
|
}
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool AecPipeLineModify::ModifyFitting(AecDbHvacFitting* pFitting,const AecHvac::DuctParam & paramNew)
|
|
{
|
|
bool bSuccesed = false;
|
|
AecHvac::DuctParam* pParam = (AecHvac::DuctParam *)¶mNew;
|
|
|
|
AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
|
|
|
|
if (m_bUpdateMat)
|
|
{
|
|
pXDataMap->SetAt(PIPE_MATERIAL,pParam->szMat);
|
|
pXDataMap->SetAt(PIPE_SYS, pParam->szSys);
|
|
|
|
//设置图层
|
|
AecDbDuctLine::SetFittingLayer(pFitting, pParam->szSys);
|
|
}
|
|
|
|
int nType = 0,nLocked = -1;
|
|
pXDataMap->GetAt(KEY_RUNTIME,nType);
|
|
EFittingType eType = (EFittingType)nType;
|
|
|
|
//如果DN不变,仅仅改外径和壁厚
|
|
AecHvac::DuctParam paramOld;
|
|
pFitting->GetDuctParam(paramOld);
|
|
|
|
if ( fabs(paramOld.dSize[0] - pParam->dSize[0]) < 1.e-2 &&
|
|
fabs(paramOld.dSize[1] - pParam->dSize[1]) > 1.e-2)
|
|
{
|
|
pXDataMap->SetAt(PIPE_THICK,pParam->dSize[2]);
|
|
|
|
//如果曲率半径改变
|
|
double dOldRatio = paramOld.m_dRatio;
|
|
if ( fabs(dOldRatio - pParam->m_dRatio) > 1.e-2)
|
|
{
|
|
if (eType != eElbow)//不是弯头
|
|
{
|
|
pXDataMap->SetAt(PIPE_RATIO,pParam->m_dRatio);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//进行到弯头修改
|
|
}
|
|
}
|
|
else//曲率半径不变
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
double dLx = GetElbowLx(pParam);
|
|
double dL = GetElbowL(pParam);
|
|
|
|
AcGeVector3d vtMaj;
|
|
AcGeVector3d vtMin;
|
|
AcGePoint3d ptStart, ptMid, ptEnd;
|
|
CString sKey;
|
|
//弯头,三通,四通,变径
|
|
switch( eType )
|
|
{
|
|
case eElbow:
|
|
{
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
|
|
pXDataMap->GetAt(HELB_StartPoint, ptStart);
|
|
pXDataMap->GetAt(HELB_CornerPoint, ptMid);
|
|
pXDataMap->GetAt(HELB_EndPoint, ptEnd);
|
|
|
|
vtMaj = ptStart - ptMid; vtMaj.normalize();
|
|
vtMin = ptEnd - ptMid; vtMin.normalize();
|
|
|
|
ptStart = ptMid + vtMaj * dL;
|
|
ptEnd = ptMid + vtMin * dL;
|
|
|
|
pXDataMap->SetAt(HELB_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HELB_EndThick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HELB_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HELB_EndWidth, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
|
|
pXDataMap->SetAt(HELB_Diameter, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HELB_EndDiameter, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HELB_StartPoint, ptStart);
|
|
pXDataMap->SetAt(HELB_EndPoint, ptEnd);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录修改后
|
|
AecInterface inf11, inf00;
|
|
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;
|
|
break;
|
|
}
|
|
case eTee:
|
|
{
|
|
if (m_bTeeStop) //三通分支管径不改尺寸; 主接口可修改.分支锁定
|
|
{
|
|
TeeStop:
|
|
nLocked = -1;
|
|
for(int k = 0;k < 3;k++)
|
|
{
|
|
sKey.Format(_T("LK_%d"),k);
|
|
if ( pXDataMap->GetAt(sKey,nLocked) )
|
|
{
|
|
if (nLocked > -1)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
double dTDN = 0.0;
|
|
pXDataMap->GetAt(HTEE_BranchWidth,dTDN);
|
|
|
|
double dDN = 0.0;
|
|
pXDataMap->GetAt(HTEE_StartWidth,dDN);
|
|
|
|
if (nLocked == 2)//分支锁定,改主管
|
|
{
|
|
if ( ( dTDN - pParam->dSize[0] ) > 1.e-2)
|
|
{
|
|
acutPrintf(_T("\n三通分支管径大于主管径!修改管径失败!"));
|
|
return false;
|
|
}
|
|
|
|
//主接口可修改.分支锁定
|
|
//原来的主接口
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
AecInterface inf2;
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
pFitting->GetInterface(2, inf2);
|
|
|
|
pXDataMap->GetAt(HTEE_EndDir, vtMaj);
|
|
pXDataMap->GetAt(HTEE_BranchDir, vtMin);
|
|
vtMaj.normalize(); vtMin.normalize();
|
|
|
|
int nSectType = 0;
|
|
ESection eType;
|
|
pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
|
|
eType = (ESection)nSectType;
|
|
|
|
//如果是矩形 立放置
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtMaj.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
if (eType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[1]);
|
|
//pXDataMap->SetAt(HTEE_BranchWidth, m_pPipeParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HTEE_Thick, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[0]);
|
|
//pXDataMap->SetAt(HTEE_BranchThick, m_pPipeParam->dSize[0]);
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);
|
|
//pXDataMap->SetAt(HTEE_BranchWidth, m_pPipeParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);
|
|
//pXDataMap->SetAt(HTEE_BranchThick, m_pPipeParam->dSize[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);
|
|
//pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
|
|
pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);
|
|
//pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
|
|
}
|
|
|
|
pXDataMap->GetAt(HTEE_StartPoint, ptStart);
|
|
pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
|
|
Midpoint(ptStart, ptEnd, ptMid);
|
|
|
|
ptStart = ptMid - vtMaj * dL;
|
|
ptEnd = ptMid + vtMaj * dL;
|
|
|
|
pXDataMap->SetAt(HTEE_StartPoint, ptStart);
|
|
pXDataMap->SetAt(HTEE_EndPoint, ptEnd);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录修改后
|
|
AecInterface inf11, inf00, inf22;
|
|
pFitting->GetInterface(0, inf00);
|
|
pFitting->GetInterface(1, inf11);
|
|
pFitting->GetInterface(2, inf22);
|
|
|
|
AecInterfaceFrTo infFt;
|
|
|
|
infFt.infFr = inf0;
|
|
infFt.infTo = inf00;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf1;
|
|
infFt.infTo = inf11;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf2;
|
|
infFt.infTo = inf22;
|
|
m_arFrTo.append(infFt);
|
|
}
|
|
else //主管锁定,改分支
|
|
{
|
|
if ( ( pParam->dSize[0] - dDN) > 1.e-2)
|
|
{
|
|
acutPrintf(_T("\n三通分支管径大于主管径!修改管径失败!"));
|
|
return false;
|
|
}
|
|
|
|
AecInterface inf11, inf00;
|
|
pFitting->GetInterface(2, inf00);
|
|
|
|
int nSectType = 0;
|
|
ESection eType;
|
|
pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
|
|
eType = (ESection)nSectType;
|
|
|
|
//如果是矩形 立放置
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtMaj.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
if (eType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[0]);
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
|
|
}
|
|
|
|
pXDataMap->GetAt(HTEE_StartPoint, ptStart);
|
|
pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
|
|
|
|
Midpoint(ptStart, ptEnd, ptMid);
|
|
|
|
ptStart = ptMid - vtMaj * dL;
|
|
ptEnd = ptMid + vtMaj * dL;
|
|
|
|
pXDataMap->SetAt(HTEE_StartPoint, ptStart);
|
|
pXDataMap->SetAt(HTEE_EndPoint, ptEnd);
|
|
|
|
////记录修改后
|
|
pFitting->GetInterface(2, inf11);
|
|
|
|
AecInterfaceFrTo infFt;
|
|
|
|
infFt.infFr = inf00;
|
|
infFt.infTo = inf11;
|
|
m_arFrTo.append(infFt);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
}
|
|
bSuccesed = true;
|
|
}
|
|
else//全改,统一DN
|
|
{
|
|
double dDN = 0.0,dTDN = 0.0;
|
|
pXDataMap->GetAt(HTEE_StartWidth,dDN);
|
|
pXDataMap->GetAt(HTEE_BranchWidth,dTDN);
|
|
|
|
if ( fabs(dTDN - dDN) > 1.e-2)
|
|
{
|
|
goto TeeStop;
|
|
break;
|
|
}
|
|
|
|
int nSectType = 0;
|
|
ESection eType;
|
|
pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
|
|
eType = (ESection)nSectType;
|
|
|
|
//原来的主接口
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
AecInterface inf2;
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
pFitting->GetInterface(2, inf2);
|
|
|
|
pFitting->SetDuctParam(paramNew);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
pXDataMap->GetAt(HTEE_EndDir, vtMaj);
|
|
pXDataMap->GetAt(HTEE_BranchDir, vtMin);
|
|
vtMaj.normalize(); vtMin.normalize();
|
|
|
|
//如果是矩形 立放置
|
|
if (vtMin.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtMaj.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
if (eType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[1]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[0]); //w
|
|
|
|
pXDataMap->SetAt(HTEE_Thick, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[0]);
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
|
|
pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
|
|
pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
|
|
}
|
|
|
|
pXDataMap->GetAt(HTEE_StartPoint, ptStart);
|
|
pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
|
|
Midpoint(ptStart, ptEnd, ptMid);
|
|
|
|
ptStart = ptMid - vtMaj * dL;
|
|
ptEnd = ptMid + vtMaj * dL;
|
|
|
|
pXDataMap->SetAt(HTEE_StartPoint, ptStart);
|
|
pXDataMap->SetAt(HTEE_EndPoint, ptEnd);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录修改后
|
|
AecInterface inf11, inf00, inf22;
|
|
pFitting->GetInterface(0, inf00);
|
|
pFitting->GetInterface(1, inf11);
|
|
pFitting->GetInterface(2, inf22);
|
|
|
|
AecInterfaceFrTo infFt;
|
|
|
|
infFt.infFr = inf0;
|
|
infFt.infTo = inf00;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf1;
|
|
infFt.infTo = inf11;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf2;
|
|
infFt.infTo = inf22;
|
|
m_arFrTo.append(infFt);
|
|
|
|
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(HCRS_EndWidth,dTDN);
|
|
|
|
double dDN = 0.0;
|
|
pXDataMap->GetAt(HCRS_StartWidth,dDN);
|
|
|
|
//记录分支前
|
|
//原来的主接口
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
AecInterface inf2;
|
|
AecInterface inf3;
|
|
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
pFitting->GetInterface(2, inf2);
|
|
pFitting->GetInterface(3, inf3);
|
|
|
|
pXDataMap->GetAt(HCRS_StartDir, vtMaj);
|
|
pXDataMap->GetAt(HCRS_BranchDir1, vtMin);
|
|
|
|
vtMaj.normalize(); vtMin.normalize();
|
|
|
|
int nSectType = 0;
|
|
ESection eType;
|
|
pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
|
|
eType = (ESection)nSectType;
|
|
|
|
if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtMin.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
//如果是矩形
|
|
if (pParam->eType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_Thick, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
}
|
|
|
|
ptStart = ptMid + vtMaj * dL;
|
|
ptEnd = ptMid + vtMin * dL;
|
|
|
|
pXDataMap->SetAt(HCRS_StartPoint, ptStart);
|
|
pXDataMap->SetAt(HCRS_EndPoint, ptEnd);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录主管后
|
|
AecInterface inf00, inf11, inf22, inf33;
|
|
pFitting->GetInterface(0, inf00);
|
|
pFitting->GetInterface(1, inf11);
|
|
pFitting->GetInterface(2, inf22);
|
|
pFitting->GetInterface(3, inf33);
|
|
|
|
AecInterfaceFrTo infFt;
|
|
infFt.infFr = inf0;
|
|
infFt.infTo = inf00;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf1;
|
|
infFt.infTo = inf11;
|
|
m_arFrTo.append(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(HCRS_Branch1Width,dTDN);
|
|
|
|
double dDN = 0.0;
|
|
pXDataMap->GetAt(HCRS_StartWidth,dDN);
|
|
|
|
AcGePoint3d ptMid;
|
|
pXDataMap->GetAt(KEY_MID, ptMid);
|
|
|
|
double dL = GetElbowL(pParam);
|
|
|
|
int nSectType = 0;
|
|
ESection eType;
|
|
pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
|
|
eType = (ESection)nSectType;
|
|
|
|
//记录分支前
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
AecInterface inf2;
|
|
AecInterface inf3;
|
|
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
pFitting->GetInterface(2, inf2);
|
|
pFitting->GetInterface(3, inf3);
|
|
|
|
|
|
AcGeVector3d vtBra1, vtBr2, vtMaj;
|
|
pXDataMap->GetAt(HCRS_BranchDir1, vtBra1);
|
|
pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
|
pXDataMap->GetAt(HCRS_StartDir, vtMaj);
|
|
|
|
vtBra1.normalize(); vtBr2.normalize();
|
|
|
|
if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtBra1.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
if (pParam->eType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[0]);
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
|
|
}
|
|
|
|
AcGePoint3d ptBra1 = ptMid + vtBra1 * dL;
|
|
AcGePoint3d ptBra2 = ptMid + vtBr2 * dL;
|
|
|
|
pXDataMap->SetAt(HCRS_BranchPoint1, ptBra1);
|
|
pXDataMap->SetAt(HCRS_BranchPoint2, ptBra2);
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录主管后
|
|
AecInterface inf00, inf11, inf22, inf33;
|
|
pFitting->GetInterface(0, inf00);
|
|
pFitting->GetInterface(1, inf11);
|
|
pFitting->GetInterface(2, inf22);
|
|
pFitting->GetInterface(3, inf33);
|
|
|
|
AecInterfaceFrTo infFt;
|
|
infFt.infFr = inf0;
|
|
infFt.infTo = inf00;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf1;
|
|
infFt.infTo = inf11;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf2;
|
|
infFt.infTo = inf22;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf3;
|
|
infFt.infTo = inf33;
|
|
m_arFrTo.append(infFt);
|
|
}
|
|
bSuccesed = true;
|
|
}
|
|
else//全改,统一DN
|
|
{
|
|
double dDN = 0.0,dTDN = 0.0;
|
|
pXDataMap->GetAt(HCRS_StartWidth,dDN);
|
|
pXDataMap->GetAt(HCRS_Branch1Width,dTDN);
|
|
|
|
if ( fabs(dTDN - dDN) > 1.e-2)
|
|
{
|
|
goto CrossStop;
|
|
break;
|
|
}
|
|
|
|
//记录分支前
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
AecInterface inf2;
|
|
AecInterface inf3;
|
|
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
pFitting->GetInterface(2, inf2);
|
|
pFitting->GetInterface(3, inf3);
|
|
|
|
AcGePoint3d ptMid;
|
|
pXDataMap->GetAt(KEY_MID, ptMid);
|
|
double dL = GetElbowL(pParam);
|
|
|
|
AcGeVector3d vtStart, vtEnd;
|
|
pXDataMap->GetAt(HCRS_StartDir, vtStart);
|
|
pXDataMap->GetAt(HCRS_EndDir, vtEnd);
|
|
vtStart.normalize(); vtEnd.normalize();
|
|
|
|
int nSectType = 0;
|
|
ESection eType;
|
|
pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
|
|
eType = (ESection)nSectType;
|
|
|
|
ptStart = ptMid + vtStart * dL;
|
|
ptEnd = ptMid + vtEnd * dL;
|
|
|
|
AcGeVector3d vtBra1, vtBr2;
|
|
pXDataMap->GetAt(HCRS_BranchDir1, vtBra1);
|
|
pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
|
|
vtBra1.normalize(); vtBr2.normalize();
|
|
|
|
AcGePoint3d ptBra1 = ptMid + vtBra1 * dL;
|
|
AcGePoint3d ptBra2 = ptMid + vtBr2 * dL;
|
|
|
|
pXDataMap->SetAt(HCRS_StartPoint, ptStart);
|
|
pXDataMap->SetAt(HCRS_EndPoint, ptEnd);
|
|
pXDataMap->SetAt(HCRS_BranchPoint1, ptBra1);
|
|
pXDataMap->SetAt(HCRS_BranchPoint2, ptBra2);
|
|
|
|
|
|
if (vtBra1.isParallelTo(AcGeVector3d::kZAxis) ||
|
|
vtStart.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
//如果是矩形
|
|
if (pParam->eType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_Thick, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[0]);
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
|
|
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
}
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录主管后
|
|
AecInterface inf00, inf11, inf22, inf33;
|
|
pFitting->GetInterface(0, inf00);
|
|
pFitting->GetInterface(1, inf11);
|
|
pFitting->GetInterface(2, inf22);
|
|
pFitting->GetInterface(3, inf33);
|
|
|
|
AecInterfaceFrTo infFt;
|
|
infFt.infFr = inf0;
|
|
infFt.infTo = inf00;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf1;
|
|
infFt.infTo = inf11;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf2;
|
|
infFt.infTo = inf22;
|
|
m_arFrTo.append(infFt);
|
|
|
|
infFt.infFr = inf3;
|
|
infFt.infTo = inf33;
|
|
m_arFrTo.append(infFt);
|
|
|
|
bSuccesed = true;
|
|
}
|
|
break;
|
|
}
|
|
case eReduce:
|
|
{
|
|
double dDN = 0.0;
|
|
pXDataMap->GetAt(HRED_StartWidth,dDN);
|
|
|
|
double dTDN = 0.0;
|
|
pXDataMap->GetAt(HRED_EndWidth,dTDN);
|
|
|
|
//主管改，不改分支
|
|
if ( fabs(m_paramOld.dSize[0] - dDN) < 1.e-2)//
|
|
{
|
|
if ( fabs( pParam->dSize[0] - dDN ) < 1.e-2)
|
|
{
|
|
acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
|
|
return false;
|
|
}
|
|
|
|
//记录修改前
|
|
AecInterface inf0, inf1;
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
|
|
ESection eStartSectType = eRect;
|
|
pXDataMap->GetAt(HRED_StartSectType, (int &)eStartSectType);
|
|
|
|
if (eStartSectType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HRED_StartWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HRED_StartThick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HRED_StartWidth, pParam->dSize[0]);
|
|
//pXDataMap->SetAt(HRED_StartThick, pParam->dSize[1]);
|
|
pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
|
|
pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //0
|
|
}
|
|
|
|
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);
|
|
}
|
|
else//主管不改，改分支
|
|
{
|
|
if ( fabs( pParam->dSize[0] - dTDN ) < 1.e-2)
|
|
{
|
|
acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
|
|
return false;
|
|
}
|
|
|
|
|
|
ESection eEndSectType = eRect;
|
|
pXDataMap->GetAt(HRED_EndSectType, (int &)eEndSectType);
|
|
|
|
//记录修改前
|
|
AecInterface inf0, inf1;
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
|
|
if (eEndSectType == eRect)
|
|
{
|
|
pXDataMap->SetAt(HRED_EndWidth, pParam->dSize[0]);
|
|
pXDataMap->SetAt(HRED_EndThick, pParam->dSize[1]);
|
|
}
|
|
else
|
|
{
|
|
pXDataMap->SetAt(HRED_EndWidth, pParam->dSize[0]);
|
|
//pXDataMap->SetAt(HRED_EndThick, pParam->dSize[1]);
|
|
}
|
|
|
|
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;
|
|
|
|
break;
|
|
}
|
|
case eOffset:
|
|
{
|
|
//eArcuateLink = 1, // 双弧
|
|
//eLinearLink = 2, // 角接
|
|
//eObliqueLink = 3, // 斜接
|
|
//共同数据
|
|
|
|
AecInterface inf0;
|
|
AecInterface inf1;
|
|
pFitting->GetInterface(0, inf0);
|
|
pFitting->GetInterface(1, inf1);
|
|
|
|
AecHvac::HvacOffsetType eOffsetType = AecHvac::eArcuateLink;
|
|
pXDataMap->GetAt(HOFF_Type, (int&)eOffsetType);
|
|
|
|
if (eOffsetType == 1 || eOffsetType == 2)
|
|
{
|
|
pXDataMap->SetAt(HOFF_Thick, paramNew.dSize[0]);
|
|
pXDataMap->SetAt(HOFF_StartWidth, paramNew.dSize[1]);
|
|
pXDataMap->SetAt(HOFF_EndWidth, paramNew.dSize[1]);
|
|
}
|
|
else
|
|
{
|
|
//其他走弯头+直管组合
|
|
}
|
|
|
|
pFitting->ReCreateDraw2d();
|
|
pFitting->ReCreateDraw3d();
|
|
|
|
//记录修改后
|
|
AecInterface inf11, inf00;
|
|
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;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return bSuccesed;
|
|
}
|
|
|
|
bool AecPipeLineModify::ModifyByInfAssoc(const AcArray<AecInterface>& arFitEquOldInfs,AecMInterfaces* pFitEquMInfNew,const AecHvac::DuctParam & 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))
|
|
{
|
|
AecDbHvacDuct * pPipe = AecDbHvacDuct::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 无效，导致回溯
|
|
/*AecDbHvacFitting* pFit = AecDbHvacFitting::cast(pEnt);
|
|
if (pFit != NULL)
|
|
{
|
|
}*/
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
AecDbEwEquipment* AecPipeLineModify::getEquiment(bool bByDB
|
|
, const double &dDN
|
|
, LPCTSTR pszPN
|
|
, bool &bHasFangle
|
|
, AecEqui::ValveType val
|
|
, LPCTSTR psz/* = NULL*/
|
|
, LPCTSTR pszFolder/* = NULL*/)
|
|
{
|
|
if (bByDB)
|
|
{
|
|
if (!psz || !pszFolder) return NULL;
|
|
|
|
/*AecDbEwEquipment *pEqu = CEquipmentLibraryDlg::getEquipment(CString(pszFolder) + _T("\\") + psz, dDN);
|
|
if (pEqu)
|
|
{
|
|
AecDbObjXDataMap *pXMap = pEqu->GetSpecialtyData(AcDb::kForWrite);
|
|
if (pXMap)
|
|
{
|
|
pXMap->SetAt(PIPE_VALVE, val);
|
|
pXMap->SetAt(KEY_SUBRUNTIME, eValve);
|
|
pXMap->SetAt(KEY_VLV2D, TRUE);
|
|
}
|
|
return pEqu;
|
|
}*/
|
|
return NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
typedef AcArray<AcGeMatrix3d> AcGeMatrix3dArray;
|
|
AecDbEwEquipment* AecPipeLineModify::CreateNewValve(AecDbEwEquipment* pEqu,const AecHvac::DuctParam & paramNew)
|
|
{
|
|
if (pEqu != NULL)
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool AecPipeLineModify::ModifyPipeOnParam(const AcDbObjectIdArray& arPipeIds,const AecHvac::DuctParam & paramNew)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
for(int i = 0;i < arPipeIds.length();i++)
|
|
{
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arPipeIds.at(i),AcDb::kForWrite))
|
|
{
|
|
AecDbHvacDuct * pPipe = AecDbHvacDuct::cast(pEnt);
|
|
if (pPipe != NULL)
|
|
{
|
|
//公称 外径 壁厚 压了等级,曲率半径
|
|
AecHvac::DuctParam param;
|
|
pPipe->GetDuctParam(param);
|
|
|
|
//覆盖为新的参数
|
|
AecHvac::DuctParam *pParam = ¶m;
|
|
double dElOld = param.m_dEl;
|
|
|
|
memcpy(pParam, ¶mNew, sizeof(AecHvac::DuctParam));
|
|
if (m_bElLock)
|
|
{
|
|
pParam->m_dEl = dElOld;
|
|
}
|
|
|
|
if (m_bUpdateMat)
|
|
{
|
|
_tcscpy(pParam->szMat,paramNew.szMat);
|
|
_tcscpy(pParam->szSys, paramNew.szSys);
|
|
|
|
//设置图层
|
|
AecDbDuctLine::SetPipeLayer(pPipe, paramNew.szSys);
|
|
}
|
|
|
|
pPipe->SetDuctParam(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))
|
|
{
|
|
AecDbHvacDuct* pPipe = AecDbHvacDuct::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;
|
|
} |