1514 lines
38 KiB
C++
1514 lines
38 KiB
C++
#include "StdAfx.h"
|
|
#include "StdArx.h"
|
|
#include "resource.h"
|
|
#include "KTPIDPipeParamDlg.h"
|
|
#include "KTPIDPipeOper.h"
|
|
#include "DLGArribtEdit.h"
|
|
#include "KTPIDInstLineDlg.h"
|
|
#include "LineNumDlg.h"
|
|
#include "coretools.h"
|
|
#include <sstream>
|
|
|
|
#define LAYER_MAJOR1 _T("LAY_MAJOR1")
|
|
#define LAYER_MAJOR2 _T("LAY_MAJOR2")
|
|
#define LAYER_MINOR1 _T("LAY_MINOR1")
|
|
#define LAYER_MINOR2 _T("LAY_MINOR2")
|
|
#define LAYER_INST_1 _T("LAY_INSTRUMENT")
|
|
#define LAYER_INSULA _T("LAY_INSULATION")
|
|
#define LAYER_JACKET _T("LAY_JACKET")
|
|
|
|
#define PID_LINETYPE_DEF _T("AcadIso.lin")
|
|
#define PID_LINETYPE_FILE _T("KTPID.lin")
|
|
|
|
#define DEBUG_INFO(format, ...) acutPrintf(_T("\nFile:%s, Line:%d, Function:%s, %s"),\
|
|
CString(__FILE__), __LINE__ , CString(__FUNCTION__), ##__VA_ARGS__);
|
|
|
|
|
|
namespace
|
|
{
|
|
void drawCircle(const AcGePoint3d &pt, const double &r = 10, const int &clr = 2)
|
|
{
|
|
AcDbCircle *pC = new AcDbCircle(pt, AcGeVector3d::kZAxis, r);
|
|
pC->setColorIndex(clr);
|
|
CKTCadUtility::AddToCurrentSpace(pC);
|
|
pC->close();
|
|
}
|
|
|
|
void ResetXDataMap(AecDbObjXDataMap &xDataMap)
|
|
{
|
|
xDataMap.SetAt(DOC_PIDTRADE, WPipe::ePetro); //应用行业，石油
|
|
xDataMap.SetAt(DOC_PIDSCRIPTT, _T("{0}{-}{1}{-}{2}{-}{3}"));//上标脚本
|
|
xDataMap.SetAt(DOC_PIDSCRIPTB, _T("{4}{-}{5}"));//下标脚本
|
|
|
|
xDataMap.SetAt(DOC_PIDBSPACE, 3.0); //交叉断线间距
|
|
xDataMap.SetAt(DOC_PIDEWITHDIM, TRUE); //设备插入标注
|
|
xDataMap.SetAt(DOC_PIDVWITHDIM, TRUE); //阀门插入标注
|
|
|
|
xDataMap.SetAt(DOC_PIDINSRDN, 12); //仪表泡直径
|
|
|
|
xDataMap.SetAt(DOC_CONSIGN, 30.0); //续接符号
|
|
xDataMap.SetAt(DOC_PIDBARROW, 6.0); //大箭头
|
|
xDataMap.SetAt(DOC_PIDEQPTXTH, 3.5); //设备标注文字高度
|
|
xDataMap.SetAt(DOC_PIDEQPTXTF, 1.0); //设备文字宽度系数
|
|
xDataMap.SetAt(DOC_PIDMARROW, 3.0); //中箭头
|
|
xDataMap.SetAt(DOC_PIDSARROW, 1.5); //小箭头
|
|
xDataMap.SetAt(DOC_PIDVALVTXTH, 3.5); //阀门文字高度
|
|
xDataMap.SetAt(DOC_PIDVALVTXTF, 1.0); //阀门文字宽度系数
|
|
xDataMap.SetAt(DOC_PIDDIMTXTH, 3.5); //标注文字高度
|
|
xDataMap.SetAt(DOC_PIDDIMTXTF, 1.0); //标注文字宽度系数
|
|
xDataMap.SetAt(DOC_EQUSCALE, 6.0); //设备比例
|
|
xDataMap.SetAt(DOC_LINEARSCALE, 10.0); //线性比例
|
|
xDataMap.SetAt(DOC_PIDMPIPE1W, 1.0); //主管道线宽1
|
|
xDataMap.SetAt(DOC_PIDMPIPE2W, 0.5); //主管道线宽2
|
|
xDataMap.SetAt(DOC_NODESCALE, 6.0); //管嘴比例
|
|
xDataMap.SetAt(DOC_PIDSPIPE1W, 0.25); //次管道线宽1
|
|
xDataMap.SetAt(DOC_PIDSPIPE2W, 0.125); //次管道线宽2
|
|
xDataMap.SetAt(DOC_VALVESCALE, 100.0); //阀门比例
|
|
xDataMap.SetAt(DOC_PIDUNIT, 0); //单位
|
|
xDataMap.SetAt(DOC_PIDDIMTERM, 0); //标注端符
|
|
}
|
|
|
|
void DefaultPIDParam(PID::PIDPipeParam * pPidparam)
|
|
{
|
|
if (pPidparam != NULL)
|
|
{
|
|
pPidparam->m_dDN = 100.0;
|
|
_tcscpy(pPidparam->m_pszInchDN, _T("4\""));
|
|
_tcscpy(pPidparam->m_pszZone, _T("1"));
|
|
_tcscpy(pPidparam->m_pszNo, _T("1000"));
|
|
_tcscpy(pPidparam->m_pszDesc, _T("工艺空气"));
|
|
_tcscpy(pPidparam->m_pszMedia, _T("PA"));
|
|
_tcscpy(pPidparam->m_pszLevel, _T("1.6A1"));
|
|
_tcscpy(pPidparam->m_pszLineNo, _T("PA-1000"));
|
|
_tcscpy(pPidparam->m_pszInsTag, _T("ST1"));
|
|
_tcscpy(pPidparam->m_pszInsTagDim, _T("S"));
|
|
pPidparam->m_nTraType = 0;
|
|
pPidparam->m_dCoverSpace = 0.0;
|
|
pPidparam->m_dHeatThick = 0.0;
|
|
}
|
|
}
|
|
|
|
void GetLastPIDParam(PID::PIDPipeParam * pPidparam)
|
|
{
|
|
if (pPidparam != NULL)
|
|
{
|
|
KTPIDPipeOper::ReadPIDParamFromModel(pPidparam);
|
|
}
|
|
}
|
|
|
|
int BreakParamCompare(const void *pParam1, const void *pParam2)
|
|
{
|
|
return ((((PID::CBreakParam*)pParam1)->dParam < ((PID::CBreakParam*)pParam2)->dParam) ? -1 : ((((PID::CBreakParam*)pParam2)->dParam < ((PID::CBreakParam*)pParam1)->dParam) ? 1 : 0));
|
|
}
|
|
|
|
int ConnectParamCompare(const void *pParam1, const void *pParam2)
|
|
{
|
|
return ((((PID::CConnectData*)pParam1)->dParam < ((PID::CConnectData*)pParam2)->dParam) ? -1 : 1);
|
|
}
|
|
|
|
BOOL FindPipePlines(const AcDbObjectId& idPline
|
|
, AcDbObjectIdArray& arid
|
|
, double& dLeftWidth
|
|
, double& dRightWidth)
|
|
{
|
|
arid.append(idPline);
|
|
dLeftWidth = dRightWidth = 0.0;
|
|
|
|
AcDbPolyline* pPline = NULL;
|
|
acdbOpenObject(pPline, idPline, AcDb::kForRead);
|
|
if (NULL == pPline)
|
|
return FALSE;
|
|
|
|
if (2 > pPline->numVerts())
|
|
{
|
|
pPline->close();
|
|
return FALSE;
|
|
}
|
|
|
|
AcGePoint3d pt1, pt2;
|
|
pPline->getPointAt(0, pt1);
|
|
pPline->getPointAt(1, pt2);
|
|
AcGeLine3d line(pt1, pt2);
|
|
AcGeVector3d vt1(pt2 - pt1);
|
|
AcGeVector3d vt2 = pPline->normal();
|
|
pPline->close();
|
|
|
|
AcDbObjectIdArray aridGroup;
|
|
if (0 < CKTCadUtility::GetItemGroups(idPline, aridGroup))
|
|
CKTCadUtility::GetGroupItems(aridGroup[0], arid);
|
|
|
|
double dAngle, dDist;
|
|
AcGePoint3d pt3, pt4;
|
|
int iPos = arid.length();
|
|
while ((--iPos) >= 1)
|
|
{
|
|
if (arid[iPos] == idPline)
|
|
{
|
|
arid.removeAt(iPos);
|
|
continue;
|
|
}
|
|
|
|
if (Acad::eOk != acdbOpenObject(pPline, arid[iPos], AcDb::kForRead))
|
|
{
|
|
arid.removeAt(iPos);
|
|
continue;
|
|
}
|
|
|
|
pPline->getPointAt(0, pt3);
|
|
pPline->close();
|
|
pt4 = line.closestPointTo(pt3);
|
|
|
|
dAngle = vt1.angleTo(pt3 - pt4, vt2);
|
|
|
|
if (dAngle < PI)
|
|
{
|
|
dDist = pt3.distanceTo(pt4);
|
|
if (dLeftWidth < dDist)
|
|
dLeftWidth = dDist;
|
|
}
|
|
else
|
|
{
|
|
dDist = -pt3.distanceTo(pt4);
|
|
if (dRightWidth > dDist)
|
|
dRightWidth = dDist;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CreatePolyline(AcDbObjectIdArray& arid
|
|
, LPCTSTR pszLayer
|
|
, LPCTSTR pszLType = NULL
|
|
, int iColor = PID::kColorByLayer
|
|
, double dWidth = 0
|
|
, PID::CPlineDataArray* parPlineData = NULL)
|
|
{
|
|
ads_point ptAdsBase;
|
|
int iRet = acedGetPoint(NULL, _T("\n请选择起点："), ptAdsBase);
|
|
if (RTNORM != iRet)
|
|
return FALSE;
|
|
|
|
AcGePoint3d ptBase;
|
|
acdbUcs2Wcs(ptAdsBase, asDblArray(ptBase), false);
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(pszLayer);
|
|
|
|
AcGeVector3d vtNormal(UcsZAxis);
|
|
AcGePlane plane(AcGePoint3d::kOrigin, vtNormal);
|
|
|
|
AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
|
|
ASSERT(NULL != pDb);
|
|
|
|
// 主管
|
|
AcDbPolyline* pPline = new AcDbPolyline;
|
|
ASSERT(NULL != pPline);
|
|
|
|
double dElev = plane.distanceTo(UcsOrigin);
|
|
pPline->setNormal(vtNormal);
|
|
pPline->setElevation(dElev);
|
|
pPline->setConstantWidth(dWidth);
|
|
pPline->setLayer(idLayer);
|
|
pPline->setColorIndex(iColor);
|
|
if (NULL != pszLType)
|
|
{
|
|
// 分解"线型路径及文件\线型"格式
|
|
TCHAR szPathName[MAX_PATH];
|
|
LPCTSTR pszType = _tcsrchr(pszLType, _T('\\'));
|
|
if (NULL == pszType)
|
|
{
|
|
_tcscpy(szPathName, PID_LINETYPE_DEF);
|
|
pszType = pszLType;
|
|
}
|
|
else
|
|
{
|
|
iRet = pszType - pszLType;
|
|
_tcsncpy(szPathName, pszLType, iRet); szPathName[iRet] = 0;
|
|
pszType++;
|
|
}
|
|
|
|
CString strLinFile(FilePath::GetSysDir() + _T("\\"));
|
|
strLinFile += szPathName;
|
|
pDb->loadLineTypeFile(pszType, strLinFile);
|
|
|
|
pPline->setLinetype(pszType);
|
|
}
|
|
|
|
AcGePoint2d pt2d(ptBase.convert2d(plane));
|
|
pPline->addVertexAt(0, pt2d);
|
|
|
|
AcDbObjectId idPline;
|
|
if (Acad::eOk != CKTCadUtility::AddToCurrentSpace(pPline, idPline))
|
|
{
|
|
delete pPline;
|
|
return FALSE;
|
|
}
|
|
|
|
pPline->close();
|
|
pPline = NULL;
|
|
|
|
// 伴管
|
|
int iPos;
|
|
PID::CPLineData* pData;
|
|
if (NULL != parPlineData)
|
|
{
|
|
iPos = parPlineData->length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pData = &((PID::CPLineData&)parPlineData->operator [](iPos));
|
|
ASSERT(NULL != pData);
|
|
|
|
ASSERT(NULL == pData->pPline);
|
|
pData->pPline = new AcDbPolyline;
|
|
ASSERT(NULL != pData->pPline);
|
|
|
|
pData->pPline->setNormal(vtNormal);
|
|
pData->pPline->setElevation(dElev);
|
|
pData->pPline->setConstantWidth(pData->dWidth);
|
|
pData->pPline->setLayer(KTSetting::InitLayer(pData->pszLayer));
|
|
pData->pPline->setColorIndex(pData->iColor);
|
|
if (NULL != pData->pszLType)
|
|
{
|
|
// 分解"线型路径及文件\线型"格式
|
|
TCHAR szPathName[MAX_PATH];
|
|
LPCTSTR pszType = _tcsrchr(pData->pszLType, _T('\\'));
|
|
if (NULL == pszType)
|
|
{
|
|
_tcscpy(szPathName, PID_LINETYPE_DEF);
|
|
pszType = pData->pszLType;
|
|
}
|
|
else
|
|
{
|
|
iRet = pszType - pData->pszLType;
|
|
_tcsncpy(szPathName, pData->pszLType, iRet); szPathName[iRet] = 0;
|
|
pszType++;
|
|
}
|
|
|
|
CString strLinFile(FilePath::GetSysDir() + _T("\\"));
|
|
strLinFile += szPathName;
|
|
pDb->loadLineTypeFile(pszType, szPathName);
|
|
pData->pPline->setLinetype(pszType);
|
|
}
|
|
|
|
pData->pPline->addVertexAt(0, pt2d);
|
|
|
|
if (Acad::eOk != CKTCadUtility::AddToCurrentSpace(pData->pPline, pData->id))
|
|
{
|
|
delete pData->pPline;
|
|
parPlineData->removeAt(iPos);
|
|
}
|
|
else
|
|
{
|
|
pData->pPline->close();
|
|
pData->pPline = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGeVector3d vtOff1, vtOff2;
|
|
AcGeLine3d line1, line2;
|
|
AcGePoint3d pt1, pt2, ptPrev, ptFar;
|
|
|
|
int iIndex;
|
|
BOOL bExtend;
|
|
ads_point ptAdsNext;
|
|
while (TRUE)
|
|
{
|
|
acedInitGet(0, _T("Undo"));
|
|
iRet = acedGetPoint(ptAdsBase, _T("\n请选择下一点或 [放弃(U)]："), ptAdsNext);
|
|
|
|
if (Acad::eOk != acdbOpenObject(pPline, idPline, AcDb::kForWrite))
|
|
break;
|
|
|
|
iIndex = pPline->numVerts();
|
|
|
|
if (RTNONE == iRet)
|
|
{
|
|
if (iIndex >= 2)
|
|
{
|
|
pPline->close();
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pPline->erase();
|
|
pPline->close();
|
|
|
|
if (NULL != parPlineData)
|
|
{
|
|
iPos = parPlineData->length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pData = &((PID::CPLineData&)parPlineData->operator [](iPos));
|
|
ASSERT(NULL != pData);
|
|
|
|
if (Acad::eOk != acdbOpenObject(pData->pPline, pData->id, AcDb::kForWrite))
|
|
continue;
|
|
|
|
pData->pPline->erase();
|
|
pData->pPline->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (RTKWORD == iRet)
|
|
{
|
|
iIndex--;
|
|
if (iIndex > 0)
|
|
{
|
|
pPline->removeVertexAt(iIndex);
|
|
pPline->getPointAt(iIndex - 1, ptBase);
|
|
acdbWcs2Ucs(asDblArray(ptBase), ptAdsBase, false);
|
|
pPline->getPointAt(iIndex - 2, ptPrev);
|
|
vtOff1 = vtNormal.crossProduct(ptBase - ptPrev);
|
|
vtOff1.normalize();
|
|
pPline->close();
|
|
|
|
if (NULL != parPlineData)
|
|
{
|
|
iPos = parPlineData->length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pData = &((PID::CPLineData&)parPlineData->operator [](iPos));
|
|
ASSERT(NULL != pData);
|
|
|
|
if (Acad::eOk != acdbOpenObject(pData->pPline, pData->id, AcDb::kForWrite))
|
|
continue;
|
|
|
|
pData->pPline->removeVertexAt(iIndex);
|
|
|
|
if (iIndex > 0)
|
|
{
|
|
pt1 = ptBase + vtOff1 * pData->dOffset;
|
|
pData->pPline->setPointAt(iIndex - 1, pt1.convert2d(plane));
|
|
}
|
|
|
|
pData->pPline->close();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPline->close();
|
|
acutPrintf(_T("\n已经撤销了所有线段。"));
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (RTNORM != iRet)
|
|
{
|
|
pPline->erase();
|
|
pPline->close();
|
|
|
|
if (NULL != parPlineData)
|
|
{
|
|
iPos = parPlineData->length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pData = &((PID::CPLineData&)parPlineData->operator [](iPos));
|
|
ASSERT(NULL != pData);
|
|
|
|
if (Acad::eOk != acdbOpenObject(pData->pPline, pData->id, AcDb::kForWrite))
|
|
continue;
|
|
|
|
pData->pPline->erase();
|
|
pData->pPline->close();
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
acdbUcs2Wcs(ptAdsNext, asDblArray(ptBase), false);
|
|
pPline->getPointAt(iIndex - 1, ptPrev);
|
|
vtOff1 = vtNormal.crossProduct(ptBase - ptPrev);
|
|
vtOff1.normalize();
|
|
if (iIndex == 1)
|
|
{
|
|
pPline->addVertexAt(iIndex, ptBase.convert2d(plane));
|
|
}
|
|
else
|
|
{
|
|
pPline->getPointAt(iIndex - 2, ptFar);
|
|
bExtend = (ptBase - ptPrev).isParallelTo(ptBase - ptFar);
|
|
if (bExtend)
|
|
{
|
|
pPline->setPointAt(iIndex - 1, ptBase.convert2d(plane));
|
|
}
|
|
else
|
|
{
|
|
vtOff2 = vtNormal.crossProduct(ptPrev - ptFar);
|
|
vtOff2.normalize();
|
|
pPline->addVertexAt(iIndex, ptBase.convert2d(plane));
|
|
}
|
|
}
|
|
pPline->close();
|
|
|
|
if (NULL != parPlineData)
|
|
{
|
|
iPos = parPlineData->length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pData = &((PID::CPLineData&)parPlineData->operator [](iPos));
|
|
ASSERT(NULL != pData);
|
|
|
|
if (Acad::eOk != acdbOpenObject(pData->pPline, pData->id, AcDb::kForWrite))
|
|
continue;
|
|
|
|
if (iIndex == 1)
|
|
{
|
|
pt2 = ptBase + vtOff1 * pData->dOffset;
|
|
pData->pPline->addVertexAt(iIndex, pt2.convert2d(plane));
|
|
pt1 = ptPrev + vtOff1 * pData->dOffset;
|
|
pData->pPline->setPointAt(iIndex - 1, pt1.convert2d(plane));
|
|
}
|
|
else
|
|
{
|
|
if (bExtend)
|
|
{
|
|
pt1 = ptBase + vtOff1 * pData->dOffset;
|
|
pData->pPline->setPointAt(iIndex - 1, pt1.convert2d(plane));
|
|
}
|
|
else
|
|
{
|
|
pt2 = ptBase + vtOff1 * pData->dOffset;
|
|
pData->pPline->addVertexAt(iIndex, pt2.convert2d(plane));
|
|
line1.set(pt2, ptPrev + vtOff1 * pData->dOffset);
|
|
line2.set(ptPrev + vtOff2 * pData->dOffset, ptFar + vtOff2 * pData->dOffset);
|
|
line1.intersectWith(line2, pt1);
|
|
pData->pPline->setPointAt(iIndex - 1, pt1.convert2d(plane));
|
|
}
|
|
}
|
|
|
|
pData->pPline->close();
|
|
}
|
|
}
|
|
|
|
ptAdsBase[X] = ptAdsNext[X];
|
|
ptAdsBase[Y] = ptAdsNext[Y];
|
|
ptAdsBase[Z] = ptAdsNext[Z];
|
|
}
|
|
|
|
arid.append(idPline);
|
|
|
|
if (NULL != parPlineData)
|
|
{
|
|
iPos = parPlineData->length();
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pData = &((PID::CPLineData&)parPlineData->operator [](iPos));
|
|
ASSERT(NULL != pData);
|
|
|
|
pData->pPline = NULL;
|
|
arid.append(pData->id);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL OnBreakPline(AcDbPolyline* pPline
|
|
, const AcDbObjectIdArray& aridPline
|
|
, double dLeftWidth
|
|
, double dRightWidth
|
|
, double dBreakSpace
|
|
, PID::AcBreakParamArray& arParam
|
|
, const int &brkStyle)
|
|
{
|
|
ASSERT(NULL != pPline && 0 < arParam.length() && 1 < pPline->numVerts());
|
|
|
|
// 将arParam在曲线上按参数值从小到大排序
|
|
int iPos = arParam.length();
|
|
if (2 > pPline->numVerts() || Acad::eOk != pPline->upgradeOpen())
|
|
return FALSE;
|
|
|
|
|
|
|
|
qsort(arParam.asArrayPtr(), iPos, sizeof(PID::CBreakParam), BreakParamCompare);
|
|
|
|
// 打开所有的裁减实体
|
|
AcArray<AcDbPolyline*> arpPline;
|
|
arpPline.append(pPline);
|
|
AcDbPolyline* pPoly;
|
|
int iIndex = aridPline.length();
|
|
|
|
while ((--iIndex) >= 1) // 第0个即为pPline
|
|
{
|
|
if (Acad::eOk != acdbOpenObject(pPoly, aridPline[iIndex], AcDb::kForWrite))
|
|
continue;
|
|
arpPline.append(pPoly);
|
|
}
|
|
|
|
// 取得参数
|
|
AcGeVector3d vtNormal = pPline->normal();
|
|
AcGePlane plane(AcGePoint3d::kOrigin, vtNormal);
|
|
|
|
// 从曲线的末尾开始裁减，末尾裁减出来的曲线为新曲线，前面的修改保留曲线继续裁减
|
|
AcGeVector3d vt;
|
|
int iParam, iVert;
|
|
PID::CBreakParam* pItem;
|
|
AcDbPolyline* pNew;
|
|
struct resbuf* pRb;
|
|
AcDbObjectId idEnt;
|
|
AcDbObjectIdArray arid;
|
|
double dAngle, dWidth;
|
|
AcGePoint3d pt1, pt2, pt3;
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pItem = &arParam[iPos];
|
|
ASSERT(NULL != pItem);
|
|
|
|
// 判断在该点处曲线是否可以裁减(看是否裁超过拐点, 包括多线时)
|
|
iParam = int(pItem->dParam);
|
|
pPline->getPointAtParam(iParam, pt1);
|
|
pPline->getPointAtParam(iParam + 1, pt2);
|
|
|
|
vt = (pt2 - pt1).normal();
|
|
// 去除多线拐弯宽度
|
|
if (Acad::eOk == pPline->getPointAtParam(iParam - 1, pt3))
|
|
{
|
|
dAngle = vt.angleTo(pt1 - pt3, vtNormal);
|
|
pt1 += vt * fabs(dAngle > PI ? fabs(dLeftWidth) : fabs(dRightWidth));
|
|
}
|
|
// 去除多线拐弯宽度
|
|
if (Acad::eOk == pPline->getPointAtParam(iParam + 2, pt3))
|
|
{
|
|
dAngle = vt.angleTo(pt3 - pt2, vtNormal);
|
|
pt2 -= vt * fabs(dAngle < PI ? fabs(dLeftWidth) : fabs(dRightWidth));
|
|
}
|
|
// 判断是否够裁减, 并将pt1, pt2定位到断开位置
|
|
dAngle = vt.angleTo(pItem->vt, vtNormal);
|
|
if (dAngle < PI)
|
|
{
|
|
if (pt1.distanceTo(pItem->pt) < max(fabs(pItem->dLeft), pItem->dWidth) + dBreakSpace
|
|
|| pt2.distanceTo(pItem->pt) < max(fabs(pItem->dRight), pItem->dWidth) + dBreakSpace)
|
|
continue;
|
|
pt1 = pItem->pt - vt * (max(fabs(pItem->dLeft), pItem->dWidth) + dBreakSpace);
|
|
pt2 = pItem->pt + vt * (max(fabs(pItem->dRight), pItem->dWidth) + dBreakSpace);
|
|
}
|
|
else
|
|
{
|
|
if (pt1.distanceTo(pItem->pt) < max(fabs(pItem->dRight), pItem->dWidth) + dBreakSpace
|
|
|| pt2.distanceTo(pItem->pt) < max(fabs(pItem->dLeft), pItem->dWidth) + dBreakSpace)
|
|
continue;
|
|
pt1 = pItem->pt - vt * (max(fabs(pItem->dRight), pItem->dWidth) + dBreakSpace);
|
|
pt2 = pItem->pt + vt * (max(fabs(pItem->dLeft), pItem->dWidth) + dBreakSpace);
|
|
}
|
|
|
|
// 裁减出曲线, 修改保留旧曲线
|
|
arid.setLogicalLength(0);
|
|
iIndex = arpPline.length();
|
|
while ((--iIndex) >= 0)
|
|
{
|
|
pPoly = arpPline[iIndex];
|
|
ASSERT(NULL != pPoly);
|
|
|
|
pPoly->getConstantWidth(dWidth);
|
|
pRb = pPoly->xData();
|
|
if (brkStyle == 1)
|
|
{
|
|
AcDbPolyline *pArc = new AcDbPolyline;
|
|
pArc->setNormal(pPoly->normal());
|
|
pArc->setElevation(pPoly->elevation());
|
|
pArc->setPropertiesFrom(pPoly);
|
|
pArc->setConstantWidth(dWidth);
|
|
if (pRb)
|
|
pArc->setXData(pRb);
|
|
pArc->addVertexAt(0, pt1.convert2d(plane), 1);
|
|
pArc->addVertexAt(1, pt2.convert2d(plane));
|
|
CKTCadUtility::AddToCurrentSpace(pArc);
|
|
pArc->close();
|
|
}
|
|
|
|
pNew = new AcDbPolyline;
|
|
ASSERT(NULL != pPoly);
|
|
pNew->setNormal(pPoly->normal());
|
|
pNew->setElevation(pPoly->elevation());
|
|
pNew->setConstantWidth(dWidth);
|
|
// 复制属新和扩展数据
|
|
pNew->setPropertiesFrom(pPoly);
|
|
if (NULL != pRb)
|
|
{
|
|
pNew->setXData(pRb);
|
|
CKTCadUtility::FreeRbList(pRb);
|
|
}
|
|
//
|
|
iVert = 0;
|
|
pPoly->getClosestPointTo(pt2, pt3);
|
|
pNew->addVertexAt(iVert, pt3.convert2d(plane));
|
|
++iVert;
|
|
//
|
|
pPoly->getPointAt(iParam + 1, pt3);
|
|
pNew->addVertexAt(iVert, pt3.convert2d(plane));
|
|
++iVert;
|
|
pPoly->getClosestPointTo(pt1, pt3);
|
|
pPoly->setPointAt(iParam + 1, pt3.convert2d(plane));
|
|
//
|
|
while (Acad::eOk == pPoly->getPointAt(iParam + 2, pt3))
|
|
{
|
|
pNew->addVertexAt(iVert, pt3.convert2d(plane));
|
|
++iVert;
|
|
pPoly->removeVertexAt(iParam + 2);
|
|
}
|
|
|
|
// 加入数据库
|
|
CKTCadUtility::AddToCurrentSpace(pNew, idEnt);
|
|
pNew->close();
|
|
// 保存id
|
|
arid.append(idEnt);
|
|
}
|
|
|
|
// 创建组
|
|
if (arid.length() > 1)
|
|
CKTCadUtility::CreateAcDbGroup(arid);
|
|
}
|
|
|
|
VERIFY(Acad::eOk == pPline->downgradeOpen());
|
|
iIndex = aridPline.length();
|
|
while ((--iIndex) >= 1) // 第0个即为pPline
|
|
{
|
|
pPoly = arpPline[iIndex];
|
|
ASSERT(NULL != pPoly);
|
|
pPoly->close();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL OnBreakPline(const AcDbObjectIdArray& aridPline
|
|
, double dLeftWidth
|
|
, double dRightWidth
|
|
, double dBreakSpace
|
|
, LPCTSTR pszMeBrkLayer
|
|
, LPCTSTR pszVerBrkLayer
|
|
, LPCTSTR pszAllBrkLayer
|
|
, const int &brkStyle )
|
|
{
|
|
AcDbPolylinePtr pPline(aridPline[0], AcDb::kForRead);
|
|
if (NULL == pPline)
|
|
return FALSE;
|
|
|
|
// 关闭组选
|
|
KTCADSysVar<int> tempPickStyle(_T("PICKSTYLE"), 0);
|
|
|
|
struct resbuf rbTemp = { NULL, RT3DPOINT, 0 };
|
|
struct resbuf rbFence = { &rbTemp, RT3DPOINT, 0 };
|
|
|
|
struct resbuf rbMeBrk = { NULL, 8, 0 };
|
|
rbMeBrk.resval.rstring = (LPTSTR)pszMeBrkLayer;
|
|
|
|
struct resbuf rbVerBrk = { NULL, 8, 0 };
|
|
rbVerBrk.resval.rstring = (LPTSTR)pszVerBrkLayer;
|
|
|
|
struct resbuf rbAllBrk = { NULL, 8, 0 };
|
|
rbAllBrk.resval.rstring = (LPTSTR)pszAllBrkLayer;
|
|
|
|
CKTAdsPickSet ssMeBrk, ssVerBrk, ssAllBrk;
|
|
AcDbObjectIdArray arid;
|
|
|
|
AcGeTol tol;
|
|
tol.setEqualVector(0.7654);
|
|
AcGeVector3d vtXDir = UcsXAxis;
|
|
|
|
BOOL bHorz;
|
|
PID::CBreakParam cVert;
|
|
PID::AcBreakParamArray arThisParam, arOtherParam;
|
|
|
|
int iIdx;
|
|
AcGeVector3d vt;
|
|
double dLeft, dRight;
|
|
AcGePoint3d pt1, pt2;
|
|
AcGePoint3dArray arpt;
|
|
|
|
AcDbLine dbLine;
|
|
AcDbPolyline* pPoly;
|
|
int iPos = pPline->numVerts() - 1;
|
|
while ((--iPos) >= 0)
|
|
{
|
|
pPline->getPointAt(iPos, pt1);
|
|
pPline->getPointAt(iPos + 1, pt2);
|
|
|
|
dbLine.setStartPoint(pt1);
|
|
dbLine.setEndPoint(pt2);
|
|
|
|
vt = pt2 - pt1;
|
|
bHorz = vt.isParallelTo(vtXDir, tol);
|
|
|
|
acdbWcs2Ucs(asDblArray(pt1), rbFence.resval.rpoint, false);
|
|
acdbWcs2Ucs(asDblArray(pt2), rbTemp.resval.rpoint, false);
|
|
arThisParam.setLogicalLength(0);
|
|
|
|
// 我断他不断
|
|
if (NULL != pszMeBrkLayer && 0 < _tcslen(pszMeBrkLayer))
|
|
{
|
|
acedSSGet(_T("F"), &rbFence, NULL, &rbMeBrk, ssMeBrk);
|
|
ssMeBrk -= aridPline;
|
|
//
|
|
while (!ssMeBrk.IsEmpty())
|
|
{
|
|
arid.setLogicalLength(0);
|
|
FindPipePlines(ssMeBrk[0], arid, dLeft, dRight);
|
|
ssMeBrk -= arid[0];
|
|
|
|
if (Acad::eOk != acdbOpenObject(pPoly, arid[0], AcDb::kForRead))
|
|
continue;
|
|
|
|
arpt.setLogicalLength(0);
|
|
dbLine.intersectWith(pPoly, AcDb::kOnBothOperands, arpt);
|
|
|
|
iIdx = arpt.length();
|
|
while ((--iIdx) >= 0)
|
|
{
|
|
cVert.pt = arpt[iIdx];
|
|
pPoly->getFirstDeriv(cVert.pt, cVert.vt);
|
|
pPoly->getConstantWidth(cVert.dWidth);
|
|
cVert.dWidth /= 2;
|
|
cVert.dLeft = dLeft;
|
|
cVert.dRight = dRight;
|
|
pPline->getParamAtPoint(cVert.pt, cVert.dParam);
|
|
arThisParam.append(cVert);
|
|
}
|
|
|
|
pPoly->close();
|
|
}
|
|
acedSSFree(ssMeBrk);
|
|
}
|
|
|
|
// 竖断横不断
|
|
acedSSGet(_T("F"), &rbFence, NULL, &rbVerBrk, ssVerBrk);
|
|
ssVerBrk -= aridPline;
|
|
//
|
|
while (!ssVerBrk.IsEmpty())
|
|
{
|
|
arid.setLogicalLength(0);
|
|
FindPipePlines(ssVerBrk[0], arid, dLeft, dRight);
|
|
ssVerBrk -= arid[0];
|
|
|
|
if (Acad::eOk != acdbOpenObject(pPoly, arid[0], AcDb::kForRead))
|
|
continue;
|
|
|
|
arpt.setLogicalLength(0);
|
|
dbLine.intersectWith(pPoly, AcDb::kOnBothOperands, arpt);
|
|
|
|
arOtherParam.setLogicalLength(0);
|
|
iIdx = arpt.length();
|
|
while ((--iIdx) >= 0)
|
|
{
|
|
if (bHorz)
|
|
{
|
|
cVert.pt = arpt[iIdx];
|
|
cVert.vt = vt;
|
|
pPline->getConstantWidth(cVert.dWidth);
|
|
cVert.dWidth /= 2;
|
|
cVert.dLeft = dLeftWidth;
|
|
cVert.dRight = dRightWidth;
|
|
pPoly->getParamAtPoint(cVert.pt, cVert.dParam);
|
|
arOtherParam.append(cVert);
|
|
}
|
|
else
|
|
{
|
|
cVert.pt = arpt[iIdx];
|
|
pPoly->getFirstDeriv(cVert.pt, cVert.vt);
|
|
pPoly->getConstantWidth(cVert.dWidth);
|
|
cVert.dWidth /= 2;
|
|
cVert.dLeft = dLeft;
|
|
cVert.dRight = dRight;
|
|
pPline->getParamAtPoint(cVert.pt, cVert.dParam);
|
|
arThisParam.append(cVert);
|
|
}
|
|
}
|
|
|
|
acedSSFree(ssVerBrk);
|
|
// 断相交的线
|
|
if (0 < arOtherParam.length())
|
|
OnBreakPline(pPoly, arid, dLeft, dRight, dBreakSpace, arOtherParam, brkStyle);
|
|
|
|
pPoly->close();
|
|
}
|
|
|
|
// 断自己
|
|
if (0 < arThisParam.length())
|
|
OnBreakPline(pPline, aridPline, dLeftWidth, dRightWidth, dBreakSpace, arThisParam, brkStyle);
|
|
|
|
// 横竖都要断
|
|
if (NULL != pszAllBrkLayer && 0 < _tcslen(pszAllBrkLayer))
|
|
{
|
|
acedSSGet(_T("F"), &rbFence, NULL, &rbAllBrk, ssAllBrk);
|
|
ssAllBrk -= aridPline;
|
|
//
|
|
while (!ssAllBrk.IsEmpty())
|
|
{
|
|
arid.setLogicalLength(0);
|
|
FindPipePlines(ssAllBrk[0], arid, dLeft, dRight);
|
|
ssAllBrk -= arid[0];
|
|
|
|
if (Acad::eOk != acdbOpenObject(pPoly, arid[0], AcDb::kForRead))
|
|
continue;
|
|
|
|
arpt.setLogicalLength(0);
|
|
dbLine.intersectWith(pPoly, AcDb::kOnBothOperands, arpt);
|
|
|
|
arOtherParam.setLogicalLength(0);
|
|
iIdx = arpt.length();
|
|
while ((--iIdx) >= 0)
|
|
{
|
|
cVert.pt = arpt[iIdx];
|
|
cVert.vt = vt;
|
|
pPline->getConstantWidth(cVert.dWidth);
|
|
cVert.dWidth /= 2;
|
|
cVert.dLeft = dLeftWidth;
|
|
cVert.dRight = dRightWidth;
|
|
pPoly->getParamAtPoint(cVert.pt, cVert.dParam);
|
|
arOtherParam.append(cVert);
|
|
}
|
|
acedSSFree(ssAllBrk);
|
|
// 段相交的线
|
|
if (0 < arOtherParam.length())
|
|
OnBreakPline(pPoly, arid, dLeft, dRight, dBreakSpace, arOtherParam, brkStyle);
|
|
|
|
pPoly->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL OnPIDPipe(LPCTSTR pszLayer, double dPipeWidth, double dBreakSpace, const int &clr)
|
|
{
|
|
CAcModuleResourceOverride resOverride;
|
|
if (NULL == pszLayer || _tcslen(pszLayer) <= 0)
|
|
return FALSE;
|
|
|
|
KTSetting::InitLayer(pszLayer);
|
|
|
|
KTCADSysVar<int> varTemp(_T("ORTHOMODE"), 1);
|
|
|
|
//获取初始化数据
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
if (!KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap))
|
|
{
|
|
acedAlert(_T("\n系统没有初始化!"));
|
|
return FALSE;
|
|
}
|
|
|
|
PID::PIDPipeParam pidparam;
|
|
memset(&pidparam, 0, sizeof(PID::PIDPipeParam));
|
|
pidparam.m_nPipeColor = PID::kColorByLayer;
|
|
|
|
DefaultPIDParam(&pidparam);
|
|
GetLastPIDParam(&pidparam);
|
|
|
|
CString dbPath = FilePath::GetSysDir();
|
|
dbPath += _T("\\Plumbing.db");
|
|
CUIISQLiteServer sqlDb;
|
|
if (!sqlDb.InitADOServer(dbPath))
|
|
{
|
|
AfxMessageBox(IDS_LOADADOSERVERFAILED);
|
|
return FALSE;
|
|
}
|
|
|
|
KTPIDPipeParamDlg paramDlg;
|
|
pidparam.m_nPipeColor = clr;
|
|
paramDlg.SetPIDParam(&pidparam);
|
|
int nRes = paramDlg.DoModal();
|
|
if (nRes == IDOK)
|
|
{
|
|
//
|
|
KTPIDPipeOper::WritePIDParam2Model(&pidparam);
|
|
|
|
CString sProj;
|
|
xDataMap.GetAt(DOC_PIDPROJECT, sProj);
|
|
int nBrkStyle(1);
|
|
xDataMap.GetAt(DOC_PIDBRKSTYLE, nBrkStyle);
|
|
|
|
CString sSQL;
|
|
sSQL.Format(_T("select * from [AecSpecPipe] where [项目名称]='%s' and ")
|
|
_T("[等级名称]='%s' and [公称直径]=%d"), sProj, pidparam.m_pszLevel, (int)pidparam.m_dDN);
|
|
|
|
CString sInfo;
|
|
CStringArray arValues;
|
|
|
|
sqlDb.GetSelData(sSQL, arValues);
|
|
|
|
std::stringstream ss;
|
|
ss << arValues.GetSize();
|
|
|
|
if (arValues.GetSize() >= 13)
|
|
{
|
|
for (int i = 1; i <= 11; i++)//最后一个为描述
|
|
{
|
|
if (i == 1)
|
|
{
|
|
sInfo = arValues.GetAt(i);
|
|
}
|
|
else
|
|
{
|
|
sInfo += _T("^") + arValues.GetAt(i);
|
|
}
|
|
}
|
|
pidparam.m_dOD = _ttof(arValues.GetAt(9)); //外径
|
|
_tcscpy(pidparam.m_pszDesc, arValues.GetAt(12));
|
|
_tcscpy(pidparam.m_pszMtoInfo, sInfo);
|
|
|
|
|
|
double dLeft = 0.0;
|
|
double dRight = 0.0;
|
|
PID::CPlineDataArray arData;
|
|
if (pidparam.m_nTraType > 0)
|
|
{
|
|
PID::CPLineData data;
|
|
// 伴热
|
|
if (pidparam.m_nTraType & 1)
|
|
{
|
|
data.pszLayer = LAYER_INSULA;
|
|
data.pszLType = NULL;
|
|
data.iColor = PID::kColorByLayer;
|
|
data.dWidth = 0;
|
|
data.pPline = NULL;
|
|
data.dOffset = -pidparam.m_dHeatThick;
|
|
arData.append(data);
|
|
if (pidparam.m_dHeatThick < 0)
|
|
{
|
|
if (dLeft < -pidparam.m_dHeatThick)
|
|
dLeft = -pidparam.m_dHeatThick;
|
|
}
|
|
else
|
|
{
|
|
if (dRight > -pidparam.m_dHeatThick)
|
|
dRight = -pidparam.m_dHeatThick;
|
|
}
|
|
}
|
|
// 加套管
|
|
if (pidparam.m_nTraType & 2)
|
|
{
|
|
data.pszLayer = LAYER_JACKET;
|
|
data.pszLType = NULL;
|
|
data.iColor = PID::kColorByLayer;
|
|
data.dWidth = 0;
|
|
data.pPline = NULL;
|
|
data.dOffset = pidparam.m_dCoverSpace;
|
|
arData.append(data);
|
|
data.dOffset = -pidparam.m_dCoverSpace;
|
|
arData.append(data);
|
|
if (dLeft < fabs(pidparam.m_dCoverSpace))
|
|
dLeft = fabs(pidparam.m_dCoverSpace);
|
|
if (dRight > -fabs(pidparam.m_dCoverSpace))
|
|
dRight = -fabs(pidparam.m_dCoverSpace);
|
|
}
|
|
}
|
|
AcDbObjectIdArray arid;
|
|
if (!CreatePolyline(arid, pszLayer, NULL, pidparam.m_nPipeColor, dPipeWidth, &arData))
|
|
return FALSE;
|
|
|
|
if (arid.length() > 1)
|
|
CKTCadUtility::CreateAcDbGroup(arid);
|
|
|
|
KTPIDPipeOper::WriteXData(arid[0], &pidparam);
|
|
|
|
CString sMeBrkLayers, sLayer, sAllBrkLayers;
|
|
LPCTSTR pszLayers[] = { LAYER_MAJOR1, LAYER_MAJOR2, LAYER_MINOR1, LAYER_MINOR2, LAYER_INST_1 };
|
|
for (i = 0; i < sizeof(pszLayers) / sizeof(pszLayers[0]) && (0 != _tcsicmp(pszLayers[i], pszLayer)); i++)
|
|
{
|
|
if (KTSetting::GetLayerName(pszLayers[i], sLayer))
|
|
{
|
|
sMeBrkLayers += _T(",");
|
|
sMeBrkLayers += sLayer;
|
|
}
|
|
}
|
|
sMeBrkLayers.Delete(0);
|
|
for (i++; i < sizeof(pszLayers) / sizeof(pszLayers[0]); i++)
|
|
{
|
|
if (KTSetting::GetLayerName(pszLayers[i], sLayer))
|
|
{
|
|
sAllBrkLayers += _T(",");
|
|
sAllBrkLayers += sLayer;
|
|
}
|
|
}
|
|
sAllBrkLayers.Delete(0);
|
|
|
|
KTSetting::GetLayerName(pszLayer, sLayer);
|
|
OnBreakPline(arid, dLeft, dRight, dBreakSpace, sMeBrkLayers, sLayer, sAllBrkLayers, nBrkStyle);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
AcDbObjectId GetGroupId(AcDbObjectId objId)
|
|
{
|
|
AcDbObjectId persObjId;
|
|
AcDbObject *pEnt;
|
|
if (Acad::eOk != acdbOpenObject(pEnt, objId, AcDb::kForRead))
|
|
{
|
|
acutPrintf(_T("\nCannot open entity."));
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
|
|
AcDbDictionary *pGroup;
|
|
const AcDbVoidPtrArray *pReactors;
|
|
pReactors = pEnt->reactors();
|
|
if (pReactors == NULL)
|
|
{
|
|
acutPrintf(_T("\nEntity does not belong to a group."));
|
|
pEnt->close();
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
pEnt->close();
|
|
int length = pReactors->length();
|
|
void *pSomething;
|
|
for (int i = 0; i < length; ++i)
|
|
{
|
|
pSomething = (AcDbObject*)pReactors->at(i);
|
|
if (acdbIsPersistentReactor(pSomething)) {
|
|
// Every group reactor is a persistent reactor.
|
|
// Is this a reactor from a group?
|
|
persObjId = acdbPersistentReactorObjectId(pSomething);
|
|
AcDbObject *pReactor;
|
|
if (Acad::eOk != acdbOpenObject(pReactor, persObjId, AcDb::kForRead))
|
|
{
|
|
acutPrintf(_T("\nCannot get reactor."));
|
|
continue;
|
|
}
|
|
if (pReactor->isKindOf(AcDbGroup::desc())) {
|
|
// This is a group reactor. Get the group name.
|
|
AcDbObjectId groupId = pReactor->ownerId();
|
|
if (Acad::eOk != acdbOpenObject(pGroup, groupId, AcDb::kForRead))
|
|
{
|
|
acutPrintf(_T("\nCannot open group."));
|
|
pReactor->close();
|
|
continue;
|
|
}
|
|
LPTSTR groupName;
|
|
if (Acad::eOk != (pGroup->nameAt(persObjId, groupName)))
|
|
{
|
|
acutPrintf(_T("\nCannot get group name."));
|
|
pReactor->close();
|
|
pGroup->close();
|
|
continue;
|
|
}
|
|
pGroup->close();
|
|
}
|
|
pReactor->close();
|
|
}
|
|
}
|
|
return persObjId;
|
|
}
|
|
|
|
BOOL OnConnectPolyline(AcDbPolyline* pPline1, BOOL bStart1, AcDbPolyline* pPline2, BOOL bStart2)
|
|
{
|
|
AcGePoint2d pt;
|
|
int iPos = (bStart2 ? 1 : pPline2->numVerts() - 2);
|
|
if (Acad::eOk != pPline2->getPointAt(iPos, pt))
|
|
return FALSE;
|
|
(bStart2 ? ++iPos : --iPos);
|
|
pPline1->setPointAt((bStart1 ? 0 : pPline1->numVerts() - 1), pt);
|
|
|
|
while (Acad::eOk == pPline2->getPointAt(iPos, pt))
|
|
{
|
|
(bStart2 ? ++iPos : --iPos);
|
|
|
|
pPline1->addVertexAt((bStart1 ? 0 : pPline1->numVerts()), pt);
|
|
}
|
|
|
|
pPline2->erase();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL OnConnectPolylines(const AcDbObjectId& idEnt1, const AcDbObjectId& idEnt2, const AcGePoint3d ptNear)
|
|
{
|
|
double dLeft1, dRight1;
|
|
AcDbObjectIdArray arid1;
|
|
FindPipePlines(idEnt1, arid1, dLeft1, dRight1);
|
|
|
|
double dLeft2, dRight2;
|
|
AcDbObjectIdArray arid2;
|
|
FindPipePlines(idEnt2, arid2, dLeft2, dRight2);
|
|
|
|
int iLen1 = arid1.length();
|
|
int iLen2 = arid2.length();
|
|
// 没有找到曲线或数目不同，返回
|
|
if (iLen1 <= 0 || iLen1 != iLen2)
|
|
return FALSE;
|
|
|
|
// 取得排序方向
|
|
PID::CConnectData data;
|
|
AcGePoint3d pt1, pt2;
|
|
if (Acad::eOk != acdbOpenObject(data.pPline, arid1[0], AcDb::kForRead))
|
|
return FALSE;
|
|
data.pPline->getStartPoint(pt1);
|
|
data.pPline->getEndPoint(pt2);
|
|
if (ptNear.distanceTo(pt1) < ptNear.distanceTo(pt2))
|
|
data.pPline->getPointAt(1, pt2);
|
|
else
|
|
data.pPline->getPointAt(data.pPline->numVerts() - 2, pt1);
|
|
AcGeVector3d vtDir((pt2 - pt1).normal());
|
|
vtDir.rotateBy(PI / 2.0, data.pPline->normal());
|
|
data.pPline->close();
|
|
|
|
AcDbXline cXLine;
|
|
cXLine.setBasePoint(ptNear);
|
|
cXLine.setUnitDir(vtDir);
|
|
|
|
int iPos = iLen1;
|
|
PID::CConnectDataArray arData1, arData2;
|
|
while ((--iPos) >= 0)
|
|
{
|
|
if (Acad::eOk != acdbOpenObject(data.pPline, arid1[iPos], AcDb::kForWrite))
|
|
break;
|
|
data.pPline->getStartPoint(pt1);
|
|
data.pPline->getEndPoint(pt2);
|
|
pt1 = ((data.bStart = (ptNear.distanceTo(pt1) < ptNear.distanceTo(pt2))) ? pt1 : pt2);
|
|
cXLine.getClosestPointTo(pt1, pt2);
|
|
cXLine.getParamAtPoint(pt2, data.dParam);
|
|
arData1.append(data);
|
|
|
|
if (Acad::eOk != acdbOpenObject(data.pPline, arid2[iPos], AcDb::kForWrite))
|
|
break;
|
|
data.pPline->getStartPoint(pt1);
|
|
data.pPline->getEndPoint(pt2);
|
|
pt1 = ((data.bStart = (ptNear.distanceTo(pt1) < ptNear.distanceTo(pt2))) ? pt1 : pt2);
|
|
cXLine.getClosestPointTo(pt1, pt2);
|
|
cXLine.getParamAtPoint(pt2, data.dParam);
|
|
arData2.append(data);
|
|
}
|
|
|
|
BOOL bCanLink = TRUE;
|
|
iLen1 = arData1.length();
|
|
iLen2 = arData2.length();
|
|
if (iLen1 > 0 && iLen1 == iLen2)
|
|
{
|
|
// 在同一方向上排序
|
|
iPos = iLen1;
|
|
qsort(arData1.asArrayPtr(), iPos, sizeof(PID::CConnectData), ConnectParamCompare);
|
|
qsort(arData2.asArrayPtr(), iPos, sizeof(PID::CConnectData), ConnectParamCompare);
|
|
|
|
// 判断图层线型是否一致
|
|
while ((--iPos) >= 0 && bCanLink)
|
|
{
|
|
bCanLink = (arData1[iPos].pPline->layerId() == arData2[iPos].pPline->layerId()
|
|
&& arData1[iPos].pPline->linetypeId() == arData2[iPos].pPline->linetypeId());
|
|
}
|
|
|
|
// 连接曲线
|
|
iPos = iLen1;
|
|
while ((--iPos) >= 0 && bCanLink)
|
|
{
|
|
OnConnectPolyline(arData1[iPos].pPline, arData1[iPos].bStart, arData2[iPos].pPline, arData2[iPos].bStart);
|
|
}
|
|
}
|
|
|
|
while ((--iLen1) >= 0)
|
|
arData1[iLen1].pPline->close();
|
|
while ((--iLen2) >= 0)
|
|
arData2[iLen2].pPline->close();
|
|
|
|
return bCanLink;
|
|
}
|
|
}
|
|
|
|
// pid-pipe
|
|
void PL_KTPIDMajor1()
|
|
{
|
|
if (!CoreTools::hasCSSZ(true)) return;
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap);
|
|
|
|
double dWidth = 0.0;
|
|
xDataMap.GetAt(DOC_PIDMPIPE1W, dWidth);
|
|
double dBreak = 0.0;
|
|
xDataMap.GetAt(DOC_PIDBSPACE, dBreak);
|
|
|
|
OnPIDPipe(LAYER_MAJOR1, dWidth, dBreak, 1);
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTPIDMajor2()
|
|
{
|
|
if (!CoreTools::hasCSSZ(true)) return;
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap);
|
|
|
|
double dWidth = 0.0;
|
|
xDataMap.GetAt(DOC_PIDMPIPE2W, dWidth);
|
|
double dBreak = 0.0;
|
|
xDataMap.GetAt(DOC_PIDBSPACE, dBreak);
|
|
|
|
OnPIDPipe(LAYER_MAJOR2, dWidth, dBreak, 1);
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTPIDMinor1()
|
|
{
|
|
if (!CoreTools::hasCSSZ(true)) return;
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap);
|
|
|
|
double dWidth = 0.0;
|
|
xDataMap.GetAt(DOC_PIDSPIPE1W, dWidth);
|
|
double dBreak = 0.0;
|
|
xDataMap.GetAt(DOC_PIDBSPACE, dBreak);
|
|
|
|
OnPIDPipe(LAYER_MINOR1, dWidth, dBreak, 4);
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTPIDMinor2()
|
|
{
|
|
if (!CoreTools::hasCSSZ(true)) return;
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap);
|
|
|
|
double dWidth = 0.0;
|
|
xDataMap.GetAt(DOC_PIDSPIPE2W, dWidth);
|
|
double dBreak = 0.0;
|
|
xDataMap.GetAt(DOC_PIDBSPACE, dBreak);
|
|
|
|
OnPIDPipe(LAYER_MINOR2, dWidth, dBreak, 4);
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTPIDINSTLINE()
|
|
{
|
|
if (!CoreTools::hasCSSZ(true)) return;
|
|
CAcModuleResourceOverride resOverride;
|
|
|
|
KTPIDInstLineDlg dlg;
|
|
if (IDOK != dlg.DoModal())
|
|
return;
|
|
|
|
CString sLType;
|
|
sLType.Format(_T("%s\\%s"), PID_LINETYPE_FILE, dlg.GetLineType());
|
|
|
|
KTCADSysVar<int> varTemp(_T("ORTHOMODE"), 1);
|
|
|
|
AcDbObjectIdArray arid;
|
|
if (!CreatePolyline(arid, LAYER_INST_1, sLType))
|
|
return;
|
|
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap);
|
|
|
|
double dBreak = 0.0;
|
|
xDataMap.GetAt(DOC_PIDBSPACE, dBreak);
|
|
int nBrkStyle(1);
|
|
xDataMap.GetAt(DOC_PIDBRKSTYLE, nBrkStyle);
|
|
|
|
CString sMeBrkLayers, sLayer;
|
|
LPCTSTR pszLayers[] = { LAYER_MAJOR1, LAYER_MAJOR2, LAYER_MINOR1, LAYER_MINOR2 };
|
|
for (int i = 0; i < sizeof(pszLayers) / sizeof(pszLayers[0]); i++)
|
|
{
|
|
if (KTSetting::GetLayerName(pszLayers[i], sLayer))
|
|
{
|
|
sMeBrkLayers += _T(",");
|
|
sMeBrkLayers += sLayer;
|
|
}
|
|
}
|
|
sMeBrkLayers.Delete(0);
|
|
|
|
KTSetting::GetLayerName(LAYER_INST_1, sLayer);
|
|
|
|
OnBreakPline(arid, 0, 0, dBreak, sMeBrkLayers, sLayer, NULL, nBrkStyle);
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTAttribEdit()
|
|
{
|
|
ads_point pt;
|
|
ads_name ent;
|
|
int iRet = acedEntSel(_T("\n选择图形元件:"), ent, pt);
|
|
if (RTNORM != iRet)
|
|
return;
|
|
|
|
AcDbObjectId idEnt;
|
|
acdbGetObjectId(idEnt, ent);
|
|
if (idEnt.isNull())
|
|
return;
|
|
|
|
int nKind = -1;
|
|
CString sAppName(PIDPIPE_APP);
|
|
AecDbObjXDataMap objXData;
|
|
BOOL bFind = objXData.Read(idEnt, sAppName);
|
|
if (!bFind)
|
|
{
|
|
AcDbObjectId idGroup = GetGroupId(idEnt);
|
|
AcDbGroup* pGroup = NULL;
|
|
acdbOpenObject(pGroup, idGroup, AcDb::kForRead);
|
|
if (NULL == pGroup)
|
|
return;
|
|
|
|
CString sValue;
|
|
sAppName = _T("KTParamPart");
|
|
AcDbGroupIterator* pIT = pGroup->newIterator();
|
|
if (NULL != pIT)
|
|
{
|
|
for (; !pIT->done(); pIT->next())
|
|
{
|
|
idEnt = pIT->objectId();
|
|
if (objXData.Read(idEnt, sAppName)
|
|
&& objXData.GetAt(_T("点类型"), sValue) && 0 == sValue.CompareNoCase(_T("材料点")))
|
|
{
|
|
bFind = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete pIT;
|
|
|
|
pGroup->close();
|
|
}
|
|
|
|
if (!bFind)
|
|
return;
|
|
|
|
CAcModuleResourceOverride theResources;
|
|
CDLGArribtEdit dlg(&objXData);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
objXData.Write(idEnt, sAppName, FALSE);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTPIPEWMO()
|
|
{
|
|
ads_name ss;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE"), NULL);
|
|
int nRes = acedSSGet(NULL, NULL, NULL, pRb, ss);
|
|
if (RTNORM != nRes)
|
|
return;
|
|
|
|
Adesk::Int32 lLen = 0;
|
|
acedSSLength(ss, &lLen);
|
|
|
|
ads_name ent;
|
|
AcDbObjectIdArray arid;
|
|
while ((--lLen) >= 0)
|
|
{
|
|
acedSSName(ss, lLen, ent);
|
|
AcDbPolylinePtr pPLine(ent, AcDb::kForRead);
|
|
if (NULL == pPLine)
|
|
continue;
|
|
|
|
struct resbuf* pRbXdata = pPLine->xData(PIDPIPE_APP);
|
|
if (NULL == pRbXdata)
|
|
continue;
|
|
|
|
arid.append(pPLine->objectId());
|
|
|
|
acutRelRb(pRbXdata);
|
|
}
|
|
|
|
acedSSFree(ss);
|
|
|
|
int iPos = arid.length();
|
|
if (0 >= iPos)
|
|
return;
|
|
|
|
double dWidth = 0.0;
|
|
while (TRUE)
|
|
{
|
|
nRes = acedGetReal(_T("\n请输入新的管线打印线宽:"), &dWidth);
|
|
if (RTNORM != nRes)
|
|
return;
|
|
if (_IsZero_(dWidth))
|
|
{
|
|
acutPrintf(_T("\n打印线宽必须大于0!请重新输入!"));
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
while ((--iPos) >= 0)
|
|
{
|
|
AcDbPolylinePtr pPline(arid[iPos], AcDb::kForWrite);
|
|
if (NULL == pPline)
|
|
continue;
|
|
|
|
pPline->setConstantWidth(dWidth);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void PL_KTPIPECONNECT()
|
|
{
|
|
struct resbuf rbFilter = { NULL, RTDXF0, 0 };
|
|
rbFilter.resval.rstring = _tcsdup(_T("LWPOLYLINE"));
|
|
|
|
ads_name ent1;
|
|
ads_point pt1;
|
|
int iRet = CKTCadUtility::SelectEntity(_T("\n请选择第一根管线"), ent1, &rbFilter, pt1);
|
|
if (RTNORM != iRet)
|
|
return;
|
|
|
|
ads_name ent2;
|
|
ads_point pt2;
|
|
iRet = CKTCadUtility::SelectEntity(_T("\n请选择第二根管线"), ent2, &rbFilter, pt2);
|
|
if (RTNORM != iRet)
|
|
return;
|
|
|
|
|
|
//如果平行,共线
|
|
|
|
AcDbObjectId idEnt1, idEnt2;
|
|
acdbGetObjectId(idEnt1, ent1);
|
|
acdbGetObjectId(idEnt2, ent2);
|
|
|
|
acdbUcs2Wcs(pt1, pt1, false);
|
|
acdbUcs2Wcs(pt2, pt2, false);
|
|
AcGePoint3d pt = CKTCadUtility::GetMiddlePoint(asPnt3d(pt1), asPnt3d(pt2));
|
|
|
|
OnConnectPolylines(idEnt1, idEnt2, pt);
|
|
|
|
return;
|
|
}
|
|
|
|
void PI_OnPIDReport()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CLineNumDlg Dlg;
|
|
|
|
//获取初始化数据
|
|
AecDbObjXDataMap xDataMap;
|
|
ResetXDataMap(xDataMap);
|
|
if (!KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap))
|
|
{
|
|
acedAlert(_T("\n系统没有初始化!"));
|
|
return;
|
|
}
|
|
|
|
CString dbPath = FilePath::GetSysDir();
|
|
dbPath += _T("\\Plumbing.db");
|
|
CUIISQLiteServer sqlDb;
|
|
if (!sqlDb.InitADOServer(dbPath))
|
|
{
|
|
AfxMessageBox(IDS_LOADADOSERVERFAILED);
|
|
return;
|
|
}
|
|
|
|
Dlg.SetADOServer(&sqlDb);
|
|
int nRet = Dlg.DoModal();
|
|
}
|