2817 lines
85 KiB
C++
2817 lines
85 KiB
C++
#include "StdAfx.h"
|
||
#include "pcf.h"
|
||
#include "uiiado.h"
|
||
#include "base64.h"
|
||
#include "coretools.h"
|
||
#include "aecdbewpipe.h"
|
||
#include "aecdbewfitting.h"
|
||
#include "aecdbewequipment.h"
|
||
#include "aecdbxequipment.h"
|
||
#include "aecdbpipehanger.h"
|
||
#include <ostream>
|
||
#include <string>
|
||
#include <iomanip>
|
||
#include <set>
|
||
|
||
using namespace std;
|
||
|
||
namespace
|
||
{
|
||
typedef const wchar_t *STR_PTR;
|
||
typedef pair<wstring, wstring> STR_PAIR;
|
||
typedef map<wstring, wstring> STR_MAP;
|
||
|
||
// 定义属性字符串，避免直接输入造成笔误，用到那个，定义哪个
|
||
// ==========================================
|
||
// 1. 基础单位 (Units)
|
||
// ==========================================
|
||
STR_PTR PCF_UNITS_MM = L"MM";
|
||
STR_PTR PCF_UNITS_METER = L"METER";
|
||
STR_PTR PCF_UNITS_INCH = L"INCH";
|
||
STR_PTR PCF_UNITS_FEET = L"FEET";
|
||
STR_PTR PCF_UNITS_INCH_SIXTEENTH = L"INCH-SIXTEENTH";
|
||
STR_PTR PCF_UNITS_MM_HUNDREDTHS = L"MM-HUNDREDTHS";
|
||
STR_PTR PCF_UNITS_DEGREES = L"DEGREES";
|
||
STR_PTR PCF_UNITS_RADIANS = L"RADIANS";
|
||
STR_PTR PCF_UNITS_KGS = L"KGS";
|
||
STR_PTR PCF_UNITS_LBS = L"LBS";
|
||
STR_PTR PCF_UNITS_NM = L"NM";
|
||
STR_PTR PCF_UNITS_LBFT = L"LBFT";
|
||
|
||
// ==========================================
|
||
// 2. 全局头部属性 (Header Attributes)
|
||
// ==========================================
|
||
STR_PTR PCF_HEAD_ISOGEN_FILES = L"ISOGEN-FILES";
|
||
STR_PTR PCF_HEAD_UNITS_BORE = L"UNITS-BORE";
|
||
STR_PTR PCF_HEAD_UNITS_CO_ORDS = L"UNITS-CO-ORDS";
|
||
STR_PTR PCF_HEAD_UNITS_BOLT_DIA = L"UNITS-BOLT-DIA";
|
||
STR_PTR PCF_HEAD_UNITS_BOLT_LENGTH = L"UNITS-BOLT-LENGTH";
|
||
STR_PTR PCF_HEAD_UNITS_WEIGHT = L"UNITS-WEIGHT";
|
||
STR_PTR PCF_HEAD_PIPELINE_REFERENCE = L"PIPELINE-REFERENCE";
|
||
STR_PTR PCF_HEAD_PIPING_SPEC = L"PIPING-SPEC";
|
||
STR_PTR PCF_HEAD_REVISION = L"REVISION";
|
||
STR_PTR PCF_HEAD_PROJECT_IDENTIFIER = L"PROJECT-IDENTIFIER";
|
||
STR_PTR PCF_HEAD_SYSTEM_IDENTIFIER = L"SYSTEM-IDENTIFIER";
|
||
|
||
// ==========================================
|
||
// 3. 组件主类型 (Component Types) - 增加前缀 COMP_ 以防命名冲突
|
||
// ==========================================
|
||
STR_PTR PCF_COMP_PIPE = L"PIPE";
|
||
STR_PTR PCF_COMP_ELBOW = L"ELBOW";
|
||
STR_PTR PCF_COMP_TEE = L"TEE";
|
||
STR_PTR PCF_COMP_CROSS = L"CROSS";
|
||
STR_PTR PCF_COMP_REDUCER = L"REDUCER";
|
||
STR_PTR PCF_COMP_VALVE = L"VALVE";
|
||
STR_PTR PCF_COMP_FLANGE = L"FLANGE";
|
||
STR_PTR PCF_COMP_GASKET = L"GASKET";
|
||
STR_PTR PCF_COMP_BOLT = L"BOLT";
|
||
STR_PTR PCF_COMP_WELD = L"WELD";
|
||
STR_PTR PCF_COMP_CAP = L"CAP";
|
||
STR_PTR PCF_COMP_BLIND_FLANGE = L"FLANGE-BLIND";
|
||
STR_PTR PCF_COMP_REDUCER_CONC = L"REDUCER-CONCENTRIC";
|
||
STR_PTR PCF_COMP_REDUCER_ECC = L"REDUCER-ECCENTRIC";
|
||
STR_PTR PCF_COMP_INSTRUMENT = L"INSTRUMENT";
|
||
STR_PTR PCF_COMP_SUPPORT = L"SUPPORT";
|
||
STR_PTR PCF_COMP_EQUIPMENT = L"EQUIPMENT";
|
||
STR_PTR PCF_COMP_COUPLING = L"COUPLING";
|
||
STR_PTR PCF_COMP_OLET = L"OLET";
|
||
STR_PTR PCF_COMP_BEND = L"BEND";
|
||
|
||
// 设备(EQUIPMENT)块关键字
|
||
STR_PTR PCF_KW_REFERENCE = L"REFERENCE";
|
||
STR_PTR PCF_KW_LOCATION = L"LOCATION";
|
||
STR_PTR PCF_KW_ORIENTATION = L"ORIENTATION";
|
||
STR_PTR PCF_KW_NOZZLE = L"NOZZLE";
|
||
STR_PTR PCF_KW_DIRECTION = L"DIRECTION";
|
||
STR_PTR PCF_KW_SHAPE = L"SHAPE";
|
||
STR_PTR PCF_KW_CATEGORY = L"CATEGORY";
|
||
|
||
// 支吊架(SUPPORT)块关键字 / 取值
|
||
STR_PTR PCF_ATTR_NAME = L"NAME";
|
||
STR_PTR PCF_SKEY_SUPPORT_DEFAULT = L"01HG";
|
||
STR_PTR PCF_CAT_ERECTION = L"ERECTION";
|
||
STR_PTR PCF_ATTR_COMPONENT_ATTRIBUTE0 = L"COMPONENT-ATTRIBUTE0";
|
||
STR_PTR PCF_KEY_SUPPORT_DN = L"DN"; // 支吊架专业数据键(取自图集表的列名)
|
||
STR_PTR PCF_KEY_SUPPORT_MODE = L"MODE"; // 支吊架类型 0~4
|
||
|
||
// 焊口(WELD)块关键字 / 取值
|
||
STR_PTR PCF_ATTR_SKEY_WELD = L"WW"; // Isogen 焊接符号键
|
||
STR_PTR PCF_CAT_FABRICATION = L"FABRICATION";
|
||
|
||
// ==========================================
|
||
// 4. 坐标与节点类型 (Point Types)
|
||
// ==========================================
|
||
STR_PTR PCF_PT_END_POINT = L"END-POINT";
|
||
STR_PTR PCF_PT_CENTRE_POINT = L"CENTRE-POINT";
|
||
STR_PTR PCF_PT_BRANCH1_POINT = L"BRANCH1-POINT";
|
||
STR_PTR PCF_PT_BRANCH2_POINT = L"BRANCH2-POINT";
|
||
STR_PTR PCF_PT_CO_ORDS = L"CO-ORDS";
|
||
|
||
// ==========================================
|
||
// 5. 组件明细与业务属性 (Component Attributes)
|
||
// ==========================================
|
||
STR_PTR PCF_ATTR_SKEY = L"SKEY";
|
||
STR_PTR PCF_ATTR_ITEM_CODE = L"ITEM-CODE";
|
||
STR_PTR PCF_ATTR_ITEM_DESCRIPTION = L"ITEM-DESCRIPTION";
|
||
STR_PTR PCF_ATTR_MATERIAL_IDENTIFIER = L"MATERIAL-IDENTIFIER";
|
||
STR_PTR PCF_ATTR_WEIGHT = L"WEIGHT";
|
||
STR_PTR PCF_ATTR_WALL_THICKNESS = L"WALL-THICKNESS";
|
||
STR_PTR PCF_ATTR_RATING = L"RATING";
|
||
STR_PTR PCF_ATTR_FABRICATION_ITEM = L"FABRICATION-ITEM";
|
||
STR_PTR PCF_ATTR_ERECTION_ITEM = L"ERECTION-ITEM";
|
||
STR_PTR PCF_ATTR_SPINDLE_DIRECTION = L"SPINDLE-DIRECTION";
|
||
STR_PTR PCF_ATTR_MESSAGE_TEXT = L"MESSAGE-TEXT";
|
||
|
||
class PcfRow
|
||
{
|
||
public:
|
||
private:
|
||
ostream &m_out; // 统一使用窄字符流基类！
|
||
bool m_isFirstItem;
|
||
|
||
public:
|
||
PcfRow(ostream &outStream, int numOfSpace)
|
||
: m_out(outStream), m_isFirstItem(true)
|
||
{
|
||
for (int i = 0; i < numOfSpace; ++i) m_out << " ";
|
||
}
|
||
|
||
~PcfRow() { m_out << "\n"; }
|
||
|
||
// 1. 基础类型模板 (如 int, double, AcGePoint3d)
|
||
template <typename T>
|
||
PcfRow &operator<<(const T &value)
|
||
{
|
||
if (!m_isFirstItem) m_out << " ";
|
||
m_out << fixed << setprecision(4) << value;
|
||
m_isFirstItem = false;
|
||
return *this;
|
||
}
|
||
|
||
// 3. 核心升级：拦截 AutoCAD 宽字符 (处理带中文的描述信息)
|
||
PcfRow &operator<<(STR_PTR wValue)
|
||
{
|
||
if (!m_isFirstItem) m_out << " ";
|
||
|
||
// 自动转为 UTF-8 并推入底层字节流
|
||
m_out << Base64::unicode2Ansii(wValue, CP_UTF8);
|
||
|
||
m_isFirstItem = false;
|
||
return *this;
|
||
}
|
||
|
||
// 写一个属性
|
||
PcfRow &write_Attribute(STR_PTR attri, STR_PTR svalue)
|
||
{
|
||
if ((attri && svalue)
|
||
&& (wcslen(attri) > 0 && wcslen(svalue) > 0))
|
||
{
|
||
*this<< attri << svalue;
|
||
}
|
||
return *this;
|
||
}
|
||
};
|
||
|
||
PcfRow &operator<<(PcfRow &row, const AcGePoint3d &pt)
|
||
{
|
||
// 自动拆解并保持间距
|
||
row << pt.x << pt.y << pt.z;
|
||
return row;
|
||
}
|
||
|
||
void writePcfAttribute(ostream &out, int indent, STR_PTR attri, STR_PTR svalue)
|
||
{
|
||
// 只有当属性名和属性值都切实有效时，才实例化 PcfRow
|
||
if (attri && svalue && wcslen(attri) > 0 && wcslen(svalue) > 0)
|
||
PcfRow(out, indent) << attri << svalue;
|
||
}
|
||
|
||
STR_PAIR makePair(STR_PTR field, STR_PTR v)
|
||
{
|
||
return make_pair(field, v);
|
||
}
|
||
|
||
template <typename T>
|
||
STR_PAIR makePair(STR_PTR field, T &v, const int &prec = 0)
|
||
{
|
||
std::wstringstream wss;
|
||
wss << fixed << setprecision(prec) << v;
|
||
// 显式构造 std::pair，避免再匹配到本模板造成无限递归(C4717)
|
||
return std::make_pair(std::wstring(field), wss.str());
|
||
}
|
||
|
||
wstring getValue(STR_MAP mm, STR_PTR key)
|
||
{
|
||
STR_MAP::const_iterator it(mm.find(key));
|
||
if (it != mm.end())
|
||
return it->second;
|
||
return L"";
|
||
}
|
||
|
||
// ============================ 规格库(物料码)查询 ============================
|
||
|
||
// 合法等级名集合(取自 AecSpecname)，用于在实体专业数据里反查"等级"。
|
||
// 进程内只加载一次。
|
||
const std::set<CString> &validLevels(CUIISQLiteServer *pDb)
|
||
{
|
||
static std::set<CString> s_levels;
|
||
static bool s_bLoaded = false;
|
||
|
||
if (!s_bLoaded && pDb)
|
||
{
|
||
CStringArray ar;
|
||
if (pDb->GetSelData(_T("SELECT DISTINCT 等级名称 FROM AecSpecname"), ar) > 0)
|
||
{
|
||
for (int i = 0; i < ar.GetSize(); ++i)
|
||
{
|
||
CString s(ar[i]);
|
||
s.Trim();
|
||
if (!s.IsEmpty()) s_levels.insert(s);
|
||
}
|
||
}
|
||
// 加载失败(库没打开等)时下次再试
|
||
s_bLoaded = !s_levels.empty();
|
||
}
|
||
return s_levels;
|
||
}
|
||
|
||
/*
|
||
解析组件的"等级"。
|
||
先读 PIPE_LEVEL("Level")；为空时扫描专业数据里的全部字符串值，
|
||
命中 AecSpecname 里的合法等级名即采用。
|
||
|
||
实测图纸里 PIPE_LEVEL 经常为空(例如插入阀门时 command.cpp:18836 会把它清空)，
|
||
但规格库里的等级是有效的，所以必须做这层兜底，否则 ITEM-CODE 永远查不出来。
|
||
*/
|
||
CString resolveLevel(AecDbObjXDataMap *pMap, CUIISQLiteServer *pDb)
|
||
{
|
||
if (!pMap) return _T("");
|
||
|
||
CString sLevel;
|
||
if (pMap->GetAt(PIPE_LEVEL, sLevel) && !sLevel.IsEmpty())
|
||
{
|
||
sLevel.Trim();
|
||
return sLevel;
|
||
}
|
||
|
||
const std::set<CString> &levels = validLevels(pDb);
|
||
if (levels.empty()) return _T("");
|
||
|
||
// 需要非 const 迭代器才能遍历专业数据
|
||
for (AecDbObjXDataMap::It it = pMap->Begin(); it != pMap->End(); ++it)
|
||
{
|
||
const AecXData &xd = it->second;
|
||
if (xd.nVt == VT_BSTR && xd.pszVal)
|
||
{
|
||
CString s(xd.pszVal);
|
||
s.Trim();
|
||
if (levels.find(s) != levels.end())
|
||
return s;
|
||
}
|
||
}
|
||
return _T("");
|
||
}
|
||
|
||
// 拼规格查询 SQL：按 等级 + 若干等值过滤列
|
||
void buildSpecSql(CString &sql, LPCTSTR pszTable, const CString &sLevel
|
||
, const std::vector<std::pair<CString, CString> > &filters)
|
||
{
|
||
sql.Format(_T("SELECT * FROM %s t")
|
||
_T(" INNER JOIN AecSpecname a")
|
||
_T(" ON t.[项目名称] = a.[项目名称] AND t.[等级名称] = a.[等级名称]")
|
||
_T(" WHERE a.[等级名称] = '%s'"), pszTable, (LPCTSTR)sLevel);
|
||
|
||
for (size_t k = 0; k < filters.size(); ++k)
|
||
{
|
||
sql += _T(" AND t.[");
|
||
sql += filters[k].first;
|
||
sql += _T("] = '");
|
||
sql += filters[k].second;
|
||
sql += _T("'");
|
||
}
|
||
}
|
||
|
||
// 按 等级 + 若干等值过滤列 查规格库，返回所有匹配行(列名 -> 值)
|
||
bool querySpecRows(CUIISQLiteServer *pDb, LPCTSTR pszTable, const CString &sLevel
|
||
, const std::vector<std::pair<CString, CString> > &filters
|
||
, std::vector<std::map<CString, CString> > &rows)
|
||
{
|
||
rows.clear();
|
||
if (!pDb || !pszTable || sLevel.IsEmpty()) return false;
|
||
|
||
CString sql;
|
||
buildSpecSql(sql, pszTable, sLevel, filters);
|
||
return pDb->GetSelDataEx(sql, rows) > 0 && !rows.empty();
|
||
}
|
||
|
||
// 按 等级 + 若干等值过滤列 查规格库，返回第一行。查不到返回 false。
|
||
bool querySpecRow(CUIISQLiteServer *pDb, LPCTSTR pszTable, const CString &sLevel
|
||
, const std::vector<std::pair<CString, CString> > &filters
|
||
, std::map<CString, CString> &row)
|
||
{
|
||
std::vector<std::map<CString, CString> > rows;
|
||
if (!querySpecRows(pDb, pszTable, sLevel, filters, rows) || rows.empty()) return false;
|
||
|
||
row = rows[0];
|
||
return true;
|
||
}
|
||
|
||
// 从规格行里取一列(大小写与前后空格不敏感)
|
||
CString specField(const std::map<CString, CString> &row, LPCTSTR pszCol)
|
||
{
|
||
CString sWant(pszCol ? pszCol : _T(""));
|
||
sWant.Trim();
|
||
|
||
for (std::map<CString, CString>::const_iterator it = row.begin(); it != row.end(); ++it)
|
||
{
|
||
CString sKey(it->first);
|
||
sKey.Trim();
|
||
if (sKey.CompareNoCase(sWant) == 0)
|
||
{
|
||
CString sVal(it->second);
|
||
sVal.Trim();
|
||
return sVal;
|
||
}
|
||
}
|
||
return _T("");
|
||
}
|
||
|
||
// 用规格行填充 PCF 的 ITEM-CODE / ITEM-DESCRIPTION / PIPING-SPEC。
|
||
// pszDescOverride 非空时用它替换规格库里的"描述"(阀门用型号名比"BB"这类类型码更可读)。
|
||
bool writeSpecAttributes(std::ostream &out, const std::map<CString, CString> &row
|
||
, LPCTSTR pszDescOverride = NULL)
|
||
{
|
||
const CString sCode = specField(row, _T("元件代码"));
|
||
CString sDesc = specField(row, _T("描述"));
|
||
if (pszDescOverride && *pszDescOverride) sDesc = pszDescOverride;
|
||
const CString sSpec = specField(row, _T("等级名称"));
|
||
if (sCode.IsEmpty() && sDesc.IsEmpty()) return false;
|
||
|
||
writePcfAttribute(out, 4, PCF_ATTR_ITEM_CODE, (LPCTSTR)sCode);
|
||
writePcfAttribute(out, 4, PCF_ATTR_ITEM_DESCRIPTION, (LPCTSTR)sDesc);
|
||
writePcfAttribute(out, 4, PCF_HEAD_PIPING_SPEC, (LPCTSTR)sSpec);
|
||
return true;
|
||
}
|
||
|
||
// 数值 -> 规格库里的"公称直径"文本(库中以整数字符串存储，如 "50")
|
||
CString dnText(const double &dn)
|
||
{
|
||
CString s;
|
||
s.Format(_T("%d"), (int)(dn + 0.5));
|
||
return s;
|
||
}
|
||
|
||
/*
|
||
pcf 文件头(仅单位部分)。PIPELINE-REFERENCE 见 pcf_pipeline_reference()，
|
||
因为设备(EQUIPMENT)定义块必须写在 PIPELINE-REFERENCE 之前。
|
||
*/
|
||
bool pcf_begin(std::ostream &out
|
||
, STR_PTR isogen_files = L"ISOGEN.FLS"
|
||
, STR_PTR bore = PCF_UNITS_MM
|
||
, STR_PTR co_ords = PCF_UNITS_MM
|
||
, STR_PTR bolt_length = PCF_UNITS_MM
|
||
, STR_PTR bolt_dia = PCF_UNITS_MM
|
||
, STR_PTR weight = PCF_UNITS_KGS
|
||
)
|
||
{
|
||
if (!out.good()) return false;
|
||
PcfRow(out, 0) << PCF_HEAD_ISOGEN_FILES << isogen_files;
|
||
PcfRow(out, 0) << PCF_HEAD_UNITS_BORE << bore;
|
||
PcfRow(out, 0) << PCF_HEAD_UNITS_CO_ORDS << co_ords;
|
||
PcfRow(out, 0) << PCF_HEAD_UNITS_BOLT_LENGTH << bolt_length;
|
||
PcfRow(out, 0) << PCF_HEAD_UNITS_BOLT_DIA << bolt_dia;
|
||
PcfRow(out, 0) << PCF_HEAD_UNITS_WEIGHT << weight;
|
||
return true;
|
||
}
|
||
|
||
// 管线引用(放在设备定义之后)
|
||
bool pcf_pipeline_reference(std::ostream &out, STR_PTR pipeline_reference)
|
||
{
|
||
if (!out.good()) return false;
|
||
PcfRow(out, 0) << PCF_HEAD_PIPELINE_REFERENCE << pipeline_reference;
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
遍历模型空间，收集所有 管道/管件/设备 的 ObjectId 及其管道系统(PIPE_SYS)。
|
||
管道系统存放在实体专业数据里，键为 PIPE_SYS。
|
||
*/
|
||
void collectComponents(std::vector<AcDbObjectId> &ids, std::vector<CString> &systems)
|
||
{
|
||
ids.clear();
|
||
systems.clear();
|
||
|
||
AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
|
||
if (!pDb) return;
|
||
|
||
AcDbBlockTable *pTbl = NULL;
|
||
if (Acad::eOk != pDb->getBlockTable(pTbl, AcDb::kForRead)) return;
|
||
|
||
AcDbBlockTableRecord *pBTR = NULL;
|
||
if (Acad::eOk != pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForRead))
|
||
{
|
||
pTbl->close();
|
||
return;
|
||
}
|
||
pTbl->close();
|
||
|
||
AcDbBlockTableRecordIterator *pIter = NULL;
|
||
if (Acad::eOk != pBTR->newIterator(pIter))
|
||
{
|
||
pBTR->close();
|
||
return;
|
||
}
|
||
|
||
AcDbEntity *pEnt = NULL;
|
||
for (pIter->start(); !pIter->done(); pIter->step())
|
||
{
|
||
if (Acad::eOk != pIter->getEntity(pEnt, AcDb::kForRead) || !pEnt)
|
||
continue;
|
||
|
||
// 注意：AecDbEwPipe / AecDbXEquipment 派生自 AecDbCurveBase(→AcDbCurve)，
|
||
// 与 AecDbEntityBase(→AcDbEntity) 是“兄弟”类，并非其派生类。
|
||
// 因此不能用 AecDbEntityBase::cast 去读管道的专业数据(会返回 NULL)，
|
||
// 必须按具体类型分别调用 GetAt，否则管道取不到 PIPE_SYS 而被漏掉。
|
||
CString sSys;
|
||
bool bIsComponent = false;
|
||
|
||
if (AecDbEwPipe *pPipe = AecDbEwPipe::cast(pEnt))
|
||
{
|
||
pPipe->GetAt(PIPE_SYS, sSys);
|
||
bIsComponent = true;
|
||
}
|
||
else if (AecDbEwFitting *pFit = AecDbEwFitting::cast(pEnt))
|
||
{
|
||
pFit->GetAt(PIPE_SYS, sSys);
|
||
bIsComponent = true;
|
||
}
|
||
else if (AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pEnt))
|
||
{
|
||
pEqu->GetAt(PIPE_SYS, sSys);
|
||
bIsComponent = true;
|
||
}
|
||
else if (AecDbXEquipment *pXEqu = AecDbXEquipment::cast(pEnt))
|
||
{
|
||
pXEqu->GetAt(PIPE_SYS, sSys);
|
||
bIsComponent = true;
|
||
}
|
||
|
||
if (bIsComponent)
|
||
{
|
||
ids.push_back(pEnt->objectId());
|
||
systems.push_back(sSys);
|
||
}
|
||
pEnt->close();
|
||
}
|
||
|
||
DELETE_PTR(pIter);
|
||
pBTR->close();
|
||
}
|
||
|
||
// 收集图纸中出现过的所有管道系统(去重，忽略空值)
|
||
void collectSystems(std::vector<CString> &out)
|
||
{
|
||
out.clear();
|
||
|
||
std::vector<AcDbObjectId> ids;
|
||
std::vector<CString> systems;
|
||
collectComponents(ids, systems);
|
||
|
||
for (size_t k = 0; k < systems.size(); ++k)
|
||
{
|
||
if (systems[k].IsEmpty()) continue;
|
||
|
||
bool bFound = false;
|
||
for (size_t m = 0; m < out.size(); ++m)
|
||
{
|
||
if (out[m] == systems[k]) { bFound = true; break; }
|
||
}
|
||
if (!bFound) out.push_back(systems[k]);
|
||
}
|
||
}
|
||
|
||
// 按管道系统(PIPE_SYS)收集 管道/管件/设备
|
||
bool getComponentBySystem(LPCTSTR pszSys, AcDbObjectIdArray &ids)
|
||
{
|
||
if (!pszSys || _tcslen(pszSys) == 0) return false;
|
||
|
||
std::vector<AcDbObjectId> allIds;
|
||
std::vector<CString> systems;
|
||
collectComponents(allIds, systems);
|
||
|
||
for (size_t k = 0; k < allIds.size(); ++k)
|
||
{
|
||
if (systems[k] == pszSys)
|
||
ids.append(allIds[k]);
|
||
}
|
||
|
||
return !ids.isEmpty();
|
||
}
|
||
|
||
/*
|
||
* =================================================================================
|
||
* [PCF 降级说明：无 ITEM-CODE 时的保底策略]
|
||
* 适用组件：PIPE (直管)
|
||
* =================================================================================
|
||
* 如果当前管道没有物料码 (ITEM-CODE)，你至少需要以下字段才能描述一段管道：
|
||
* * 1. 语法绝对必填字段（仅画几何骨架）：
|
||
* - END-POINT (起点): 定义管道空间的起点三维坐标 (X, Y, Z) 及 该端的公称直径。
|
||
* - END-POINT (终点): 定义管道空间的终点三维坐标 (X, Y, Z) 及 该端的公称直径。
|
||
* *意义：有了这两个端点，引擎就能在两点之间画出一条中心线。这是底线。*
|
||
* * 2. 工程强烈建议补充的字段（为了让下游软件不报错，且 BOM 表不为空）：
|
||
* - ITEM-DESCRIPTION : 极其重要！物料的文本描述（如 L"非标工艺直管"），下游软件的 BOM 会直接打印这句话。
|
||
* - WALL-THICKNESS : 壁厚数值。部分查看器（如 Navisworks）依赖“管径+壁厚”来推算真实的管道外径，不传可能会画出极细的线。
|
||
* - MATERIAL-IDENTIFIER : 材质（如 L"CS" 或 L"碳钢"），辅助下游进行管道应力分析。
|
||
* - FABRICATION-ITEM (或 ERECTION-ITEM) : 预制/现场安装标识。不带值（直接写属性名），表示这是一根工厂预制管。
|
||
* =================================================================================
|
||
*/
|
||
// 处理普通管道，非法兰管道
|
||
|
||
// 直管规格查询：按 等级 + 公称直径 在 AecSpecPipe 中查物料码/描述/等级
|
||
bool getPipeSpecRow(CUIISQLiteServer *pDb, const CString &sLevel, const double &dn
|
||
, std::map<CString, CString> &row)
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(dn)));
|
||
return querySpecRow(pDb, _T("AecSpecPipe"), sLevel, filters, row);
|
||
}
|
||
|
||
// 读取数值型专业数据，兼容存为 double / 字符串 / 整数 三种情况。
|
||
// 实测部分图纸把 PIPE_DN / PIPE_THICK 存成字符串(如 "450")，
|
||
// 若只用 double 读取会失败，导致直管被静默跳过。
|
||
template <typename T>
|
||
bool getNumericValue(T *pEnt, LPCTSTR pszKey, double &dVal)
|
||
{
|
||
if (!pEnt) return false;
|
||
|
||
if (pEnt->GetAt(pszKey, dVal)) return true;
|
||
|
||
CString s;
|
||
if (pEnt->GetAt(pszKey, s) && !s.IsEmpty())
|
||
{
|
||
dVal = _ttof(s);
|
||
return true;
|
||
}
|
||
|
||
int n(0);
|
||
if (pEnt->GetAt(pszKey, n))
|
||
{
|
||
dVal = (double)n;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// pStart/pEnd 用于"长直管中点切断"：把一根管按参数段拆成多根虚拟管输出，
|
||
// 传 NULL 时按管子自身的起止点输出。
|
||
bool pcf_pipe_normal(CUIISQLiteServer *pDb, AecDbEwPipe *pPipe, std::ostream &out
|
||
, const AcGePoint3d *pStart = NULL, const AcGePoint3d *pEnd = NULL)
|
||
{
|
||
if (!pPipe || !out.good())
|
||
return false;
|
||
|
||
AcGePoint3d ptStart = pStart ? *pStart : pPipe->StartPoint();
|
||
AcGePoint3d ptEnd = pEnd ? *pEnd : pPipe->EndPoint();
|
||
|
||
// 公称直径：先读专业数据(兼容字符串)，再退回 PipeParam
|
||
double bore(.0);
|
||
if (!getNumericValue(pPipe, PIPE_DN, bore) || bore <= 0.0)
|
||
{
|
||
WPipe::PipeParam *pParam = pPipe->GetPipeParam();
|
||
if (pParam) bore = pParam->m_dDN;
|
||
}
|
||
if (bore <= 0.0) return false;
|
||
|
||
// 壁厚：可选，缺失不阻断导出
|
||
double thickness(.0);
|
||
if (!getNumericValue(pPipe, PIPE_THICK, thickness) || thickness <= 0.0)
|
||
{
|
||
WPipe::PipeParam *pParam = pPipe->GetPipeParam();
|
||
if (pParam) thickness = pParam->m_dThick;
|
||
}
|
||
|
||
// 等级：先读 PIPE_LEVEL，为空时在专业数据里反查合法等级名
|
||
AecDbObjXDataMap *pMap = pPipe->GetSpecialtyData(AcDb::kForRead);
|
||
const CString level = resolveLevel(pMap, pDb);
|
||
|
||
// 写入组件主类标 (顶格，无缩进)
|
||
PcfRow(out, 0) << PCF_COMP_PIPE;
|
||
|
||
// 写入起止坐标与管径 (必须紧跟在 PIPE 后面，缩进 4 格)
|
||
PcfRow(out, 4) << PCF_PT_END_POINT << ptStart << bore;
|
||
PcfRow(out, 4) << PCF_PT_END_POINT << ptEnd << bore;
|
||
|
||
// 写入壁厚，保证在没有item-code和piping-spec时能够正常显示
|
||
if (thickness > 0.0)
|
||
PcfRow(out, 4) << PCF_ATTR_WALL_THICKNESS << thickness;
|
||
|
||
// 等级 -> 规格库 -> 物料码 / 描述 / 等级
|
||
if (!level.IsEmpty())
|
||
{
|
||
std::map<CString, CString> row;
|
||
if (getPipeSpecRow(pDb, level, bore, row))
|
||
writeSpecAttributes(out, row);
|
||
}
|
||
|
||
// 预制管件
|
||
PcfRow(out, 4) << PCF_ATTR_FABRICATION_ITEM;
|
||
|
||
out << "\n";
|
||
|
||
return true;
|
||
}
|
||
|
||
// ============================ Phase 2: 管件导出 ============================
|
||
|
||
// 读取管件某接口的管径：优先接口自身 dSize1，缺失时退回管件参数
|
||
double fitInfBore(AecDbEwFitting *pFit, const AecInterface &inf, int nInf)
|
||
{
|
||
double d = inf.dSize1;
|
||
if (d <= 0.0 && pFit)
|
||
{
|
||
WPipe::PipeParam *pParam = pFit->GetPipeParam(nInf);
|
||
if (pParam) d = pParam->m_dDN;
|
||
}
|
||
return d;
|
||
}
|
||
|
||
// 管件壁厚：优先专业数据(兼容字符串)，再退回管件参数
|
||
double fitThickness(AecDbEwFitting *pFit)
|
||
{
|
||
double t(0.0);
|
||
if (!getNumericValue(pFit, PIPE_THICK, t) || t <= 0.0)
|
||
{
|
||
WPipe::PipeParam *pParam = pFit ? pFit->GetPipeParam(0) : NULL;
|
||
if (pParam) t = pParam->m_dThick;
|
||
}
|
||
return t;
|
||
}
|
||
|
||
// 变径类型：集中式/偏心式，用于选择 PCF 组件名
|
||
STR_PTR getReducerTypeName(AecDbEwFitting *pFit)
|
||
{
|
||
WPipe::PipeParam *pParam = pFit ? pFit->GetPipeParam(0) : NULL;
|
||
if (pParam && pParam->m_eRed != WPipe::eCen)
|
||
return PCF_COMP_REDUCER_ECC;
|
||
return PCF_COMP_REDUCER_CONC;
|
||
}
|
||
|
||
// 弯头实际夹角：两接口方向向量的夹角(0~180°)。
|
||
// 90° 弯头约为 90°；45° 弯头约为 135°(即转弯 45°)。取不到返回 -1。
|
||
double fitBendAngle(AecDbEwFitting *pFit)
|
||
{
|
||
if (!pFit) return -1.0;
|
||
AcArray<AecInterface> arInfs;
|
||
if (!pFit->GetInterface(arInfs) || arInfs.length() < 2) return -1.0;
|
||
|
||
AcGeVector3d u = arInfs.at(0).vtDir;
|
||
AcGeVector3d v = arInfs.at(1).vtDir;
|
||
if (u.length() < 1e-9 || v.length() < 1e-9) return -1.0;
|
||
u.normalize();
|
||
v.normalize();
|
||
|
||
double c = u.dotProduct(v);
|
||
if (c > 1.0) c = 1.0;
|
||
if (c < -1.0) c = -1.0;
|
||
return acos(c) * 180.0 / 3.14159265358979323846;
|
||
}
|
||
|
||
/*
|
||
管件在规格库里的"类型"候选名(按优先级)。
|
||
实测 AecSpecFit.类型 只有:
|
||
弯头 / 三通 / 半管接头 / 补强圈 / 变径 / 管帽 / 斜三通 / 90度弯头 / 45度弯头 / 同心变径 / 偏心变径
|
||
而 AecSpecFlange.类型 只有 PL。
|
||
*/
|
||
void fitTypeCandidates(int nType, AecDbEwFitting *pFit, std::vector<CString> &names)
|
||
{
|
||
names.clear();
|
||
switch (nType)
|
||
{
|
||
case eElbow:
|
||
case eReduceElbow:
|
||
// 弯头的 90/45 度在 getFitSpecRow 里按实测夹角单独挑行，这里只列候选名。
|
||
names.push_back(_T("弯头"));
|
||
names.push_back(_T("90度弯头"));
|
||
names.push_back(_T("45度弯头"));
|
||
break;
|
||
case eReduce:
|
||
if (pFit && wcscmp(getReducerTypeName(pFit), PCF_COMP_REDUCER_ECC) == 0)
|
||
names.push_back(_T("偏心变径"));
|
||
else
|
||
names.push_back(_T("同心变径"));
|
||
names.push_back(_T("变径"));
|
||
break;
|
||
case eTee:
|
||
names.push_back(_T("三通"));
|
||
break;
|
||
case eCross:
|
||
names.push_back(_T("四通"));
|
||
names.push_back(_T("三通"));
|
||
break;
|
||
case eLateral:
|
||
case eWye:
|
||
names.push_back(_T("斜三通"));
|
||
names.push_back(_T("三通"));
|
||
break;
|
||
case eWcap:
|
||
names.push_back(_T("管帽"));
|
||
break;
|
||
case eRP:
|
||
names.push_back(_T("补强圈"));
|
||
break;
|
||
case eHP:
|
||
names.push_back(_T("半管接头"));
|
||
break;
|
||
case eFlange:
|
||
names.push_back(_T("PL"));
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 管件规格查询：法兰走 AecSpecFlange，其余走 AecSpecFit。
|
||
// 普通管件按类型候选名逐个试，最后退化为"只按管径"。
|
||
// 弯头特殊处理：90/45 度有时写在"类型"列、有时只在"描述"里区分，
|
||
// 需取回全部候选行后按实测夹角挑选。
|
||
bool getFitSpecRow(CUIISQLiteServer *pDb, AecDbEwFitting *pFit
|
||
, const CString &sLevel, const double &dn, std::map<CString, CString> &row)
|
||
{
|
||
if (!pFit || sLevel.IsEmpty() || dn <= 0.0) return false;
|
||
|
||
const int nType = pFit->GetFittingType();
|
||
const bool bFlange = (nType == eFlange);
|
||
LPCTSTR pszTable = bFlange ? _T("AecSpecFlange") : _T("AecSpecFit");
|
||
|
||
// ---- 弯头：按实测夹角在 90度/45度 行里挑 ----
|
||
if (nType == eElbow || nType == eReduceElbow)
|
||
{
|
||
std::vector<std::map<CString, CString> > rows;
|
||
const LPCTSTR aNames[3] = { _T("弯头"), _T("90度弯头"), _T("45度弯头") };
|
||
for (int i = 0; i < 3; ++i)
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(dn)));
|
||
filters.push_back(std::make_pair(CString(_T("类型")), CString(aNames[i])));
|
||
std::vector<std::map<CString, CString> > part;
|
||
if (querySpecRows(pDb, pszTable, sLevel, filters, part))
|
||
rows.insert(rows.end(), part.begin(), part.end());
|
||
}
|
||
if (rows.empty())
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(dn)));
|
||
querySpecRows(pDb, pszTable, sLevel, filters, rows);
|
||
}
|
||
if (rows.empty()) return false;
|
||
|
||
const double ang = fitBendAngle(pFit);
|
||
const bool bWant45 = (ang >= 112.5); // 夹角约 135° -> 45 度弯头
|
||
|
||
int nBest = -1;
|
||
for (size_t i = 0; i < rows.size(); ++i)
|
||
{
|
||
CString sAll = specField(rows[i], _T("类型")) + specField(rows[i], _T("描述"));
|
||
const bool bIs45 = (sAll.Find(_T("45度")) >= 0);
|
||
const bool bIs90 = (sAll.Find(_T("90度")) >= 0);
|
||
if (bWant45 && bIs45) { nBest = (int)i; break; }
|
||
if (!bWant45 && bIs90) { nBest = (int)i; break; }
|
||
}
|
||
if (nBest < 0) nBest = 0;
|
||
row = rows[nBest];
|
||
return true;
|
||
}
|
||
|
||
// ---- 其余管件：按类型候选名逐个试 ----
|
||
std::vector<CString> names;
|
||
fitTypeCandidates(nType, pFit, names);
|
||
|
||
for (size_t k = 0; k < names.size(); ++k)
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(dn)));
|
||
filters.push_back(std::make_pair(CString(_T("类型")), names[k]));
|
||
if (querySpecRow(pDb, pszTable, sLevel, filters, row))
|
||
return true;
|
||
}
|
||
|
||
// 再退化为只按管径(类型名对不上时的兜底)
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(dn)));
|
||
if (querySpecRow(pDb, pszTable, sLevel, filters, row))
|
||
return true;
|
||
}
|
||
|
||
// 法兰表查不到时，退回管件表再试一次
|
||
if (bFlange)
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(dn)));
|
||
if (querySpecRow(pDb, _T("AecSpecFit"), sLevel, filters, row))
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 写出管件公共属性：壁厚 / 规格库(物料码,描述,等级) / 预制标记
|
||
void writeFittingCommon(CUIISQLiteServer *pDb, AecDbEwFitting *pFit
|
||
, const double &bore, std::ostream &out)
|
||
{
|
||
double thickness = fitThickness(pFit);
|
||
if (thickness > 0.0)
|
||
PcfRow(out, 4) << PCF_ATTR_WALL_THICKNESS << thickness;
|
||
|
||
AecDbObjXDataMap *pMap = pFit->GetSpecialtyData(AcDb::kForRead);
|
||
const CString level = resolveLevel(pMap, pDb);
|
||
if (!level.IsEmpty() && pDb && bore > 0.0)
|
||
{
|
||
std::map<CString, CString> row;
|
||
if (getFitSpecRow(pDb, pFit, level, bore, row))
|
||
writeSpecAttributes(out, row);
|
||
}
|
||
|
||
// 预制管件
|
||
PcfRow(out, 4) << PCF_ATTR_FABRICATION_ITEM;
|
||
}
|
||
|
||
// 求两条射线(点+方向)在空间中的交点。
|
||
// 弯头两端方向一般相交(如 90° 弯头)，相交时返回角点；接近平行时退化为两端点中点。
|
||
AcGePoint3d intersectRays(const AcGePoint3d &p0, const AcGeVector3d &d0
|
||
, const AcGePoint3d &p1, const AcGeVector3d &d1)
|
||
{
|
||
AcGeVector3d u(d0), v(d1);
|
||
u.normalize();
|
||
v.normalize();
|
||
AcGeVector3d w(p0 - p1);
|
||
|
||
const double a = u.dotProduct(u);
|
||
const double b = u.dotProduct(v);
|
||
const double c = v.dotProduct(v);
|
||
const double d = u.dotProduct(w);
|
||
const double e = v.dotProduct(w);
|
||
const double denom = a * c - b * b;
|
||
|
||
if (fabs(denom) < 1e-9)
|
||
return AcGePoint3d((p0.x + p1.x) * 0.5, (p0.y + p1.y) * 0.5, (p0.z + p1.z) * 0.5);
|
||
|
||
const double sc = (b * e - c * d) / denom;
|
||
return p0 + u * sc;
|
||
}
|
||
|
||
// 方向向量 -> PCF 方位(NORTH/SOUTH/EAST/WEST/UP/DOWN)
|
||
STR_PTR dirToOrientation(const AcGeVector3d &v)
|
||
{
|
||
const double ax = fabs(v.x), ay = fabs(v.y), az = fabs(v.z);
|
||
if (az >= ax && az >= ay) return (v.z >= 0.0) ? L"UP" : L"DOWN";
|
||
if (ax >= ay) return (v.x >= 0.0) ? L"EAST" : L"WEST";
|
||
return (v.y >= 0.0) ? L"NORTH" : L"SOUTH";
|
||
}
|
||
|
||
/*
|
||
* 通用：写出组件头与点位(不含属性)。
|
||
* 参考 PCF Reference Guide 的点位要求：
|
||
* 1 个接口 -> END-POINT
|
||
* 2 个接口 -> END-POINT x2
|
||
* 2 个接口 + bCentre -> END-POINT x2 + CENTRE-POINT
|
||
* 3 个接口 -> END-POINT x2 + BRANCH1-POINT
|
||
* 4+ 个接口 -> END-POINT x2 + BRANCH1/2-POINT
|
||
* 接口按 nLevel 排序：0/1=主管两端，>=2=支管。bores 与 arInfs 一一对应。
|
||
*/
|
||
bool writeComponentPoints(std::ostream &out, AcArray<AecInterface> &arInfs
|
||
, const std::vector<double> &bores, STR_PTR compType, bool bCentre, double &dBore)
|
||
{
|
||
if (!out.good() || arInfs.isEmpty()) return false;
|
||
|
||
// 按 nLevel 升序排序(插入排序，接口数很少)
|
||
std::vector<int> arOrder;
|
||
for (int i = 0; i < arInfs.length(); ++i)
|
||
{
|
||
int lv = arInfs.at(i).nLevel;
|
||
size_t nPos = arOrder.size();
|
||
for (size_t k = 0; k < arOrder.size(); ++k)
|
||
{
|
||
if (lv < arInfs.at(arOrder[k]).nLevel) { nPos = k; break; }
|
||
}
|
||
arOrder.insert(arOrder.begin() + nPos, i);
|
||
}
|
||
|
||
const int nCount = (int)arOrder.size();
|
||
const int nMain = nCount >= 2 ? 2 : 1;
|
||
|
||
PcfRow(out, 0) << compType;
|
||
|
||
dBore = 0.0;
|
||
for (int i = 0; i < nMain; ++i)
|
||
{
|
||
const int idx = arOrder[i];
|
||
double d = (idx < (int)bores.size()) ? bores[idx] : arInfs.at(idx).dSize1;
|
||
if (dBore <= 0.0) dBore = d;
|
||
PcfRow(out, 4) << PCF_PT_END_POINT << arInfs.at(idx).ptPos << d;
|
||
}
|
||
|
||
if (bCentre && nCount >= 2)
|
||
{
|
||
const AecInterface &i0 = arInfs.at(arOrder[0]);
|
||
const AecInterface &i1 = arInfs.at(arOrder[1]);
|
||
PcfRow(out, 4) << PCF_PT_CENTRE_POINT
|
||
<< intersectRays(i0.ptPos, i0.vtDir, i1.ptPos, i1.vtDir);
|
||
}
|
||
|
||
for (int i = 2; i < nCount; ++i)
|
||
{
|
||
const int idx = arOrder[i];
|
||
double d = (idx < (int)bores.size()) ? bores[idx] : arInfs.at(idx).dSize1;
|
||
STR_PTR ptType = (i == 2) ? PCF_PT_BRANCH1_POINT : PCF_PT_BRANCH2_POINT;
|
||
PcfRow(out, 4) << ptType << arInfs.at(idx).ptPos << d;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 管件：接口管径已解析后写入点位，再补管件属性
|
||
bool pcf_genericFitting(CUIISQLiteServer *pDb, AecDbEwFitting *pFit
|
||
, STR_PTR compType, std::ostream &out, bool bCentre)
|
||
{
|
||
if (!pFit || !out.good()) return false;
|
||
|
||
AcArray<AecInterface> arInfs;
|
||
if (!pFit->GetInterface(arInfs) || arInfs.isEmpty()) return false;
|
||
|
||
std::vector<double> bores;
|
||
for (int i = 0; i < arInfs.length(); ++i)
|
||
bores.push_back(fitInfBore(pFit, arInfs.at(i), i));
|
||
|
||
double dBore = 0.0;
|
||
if (!writeComponentPoints(out, arInfs, bores, compType, bCentre, dBore))
|
||
return false;
|
||
|
||
writeFittingCommon(pDb, pFit, dBore, out);
|
||
out << "\n";
|
||
return true;
|
||
}
|
||
|
||
// ============================ Phase 3: 设备导出 ============================
|
||
|
||
// 阀门类型枚举(AecEqui::ValveType, EarThwormDef.h:2267) -> 规格库 AecSpecValve.[类别] 名称。
|
||
// 名称须与 g_vlvType[] (PipelineCmd/command.cpp:158) 及 Plumbing.db 的 [类别] 值一致。
|
||
LPCTSTR valveCategoryName(int nType)
|
||
{
|
||
switch (nType)
|
||
{
|
||
case 1: return _T("闸阀");
|
||
case 2: return _T("截止阀");
|
||
case 3: return _T("球阀");
|
||
case 4: return _T("止回阀");
|
||
case 5: return _T("蝶阀");
|
||
case 6: return _T("角阀");
|
||
case 7: return _T("安全阀");
|
||
case 8: return _T("三通阀");
|
||
case 9: return _T("四通阀");
|
||
case 10: return _T("调节阀");
|
||
case 11: return _T("疏水阀");
|
||
case 12: return _T("旋塞阀");
|
||
case 13: return _T("隔膜阀");
|
||
case 14: return _T("减压阀");
|
||
case 15: return _T("电磁阀");
|
||
case 16: return _T("橡胶接头");
|
||
case 17: return _T("排气阀");
|
||
case 18: return _T("排泥阀");
|
||
case 19: return _T("浆液阀");
|
||
case 20: return _T("闸门");
|
||
case 21: return _T("孔板");
|
||
case 22: return _T("桶式过滤器");
|
||
case 23: return _T("临时过滤器");
|
||
case 24: return _T("T型过滤器");
|
||
case 25: return _T("T型过滤器");
|
||
case 26: return _T("视镜");
|
||
case 27: return _T("流量计");
|
||
case 28: return _T("阻火器");
|
||
case 31: return _T("伸缩接头");
|
||
case 32: return _T("传力接头");
|
||
default: return _T("");
|
||
}
|
||
}
|
||
|
||
// 写出阀门/管道附件类设备的公共属性：壁厚 / 名称 / 阀门规格库 / 预制标记
|
||
void writeEquipmentCommon(CUIISQLiteServer *pDb, AecDbEwEquipment *pEqu
|
||
, const double &bore, std::ostream &out)
|
||
{
|
||
double thickness(0.0);
|
||
if (getNumericValue(pEqu, PIPE_THICK, thickness) && thickness > 0.0)
|
||
PcfRow(out, 4) << PCF_ATTR_WALL_THICKNESS << thickness;
|
||
|
||
// 名称：阀门型号名(如 D373H法兰硬密封蝶阀DN450)，比规格库"描述"更具可读性，用作 ITEM-DESCRIPTION
|
||
CString sName;
|
||
pEqu->GetAt(KEY_NAME, sName);
|
||
|
||
// 阀门规格库：按 等级 + 类别(阀门类型) + 公称直径 在 AecSpecValve 中查物料码/描述/等级。
|
||
// 同一等级+管径下闸阀/止回阀/蝶阀等多行并存，必须再按"类别"过滤，否则会取错行。
|
||
bool bSpec = false;
|
||
AecDbObjXDataMap *pMap = pEqu->GetSpecialtyData(AcDb::kForRead);
|
||
const CString level = resolveLevel(pMap, pDb);
|
||
if (!level.IsEmpty() && pDb && bore > 0.0)
|
||
{
|
||
int nVlvType = -1;
|
||
if (pMap) pMap->GetAt(PIPE_VALVE, nVlvType);
|
||
const LPCTSTR pszCat = valveCategoryName(nVlvType);
|
||
|
||
// 必须按 类别 精确匹配：同一等级+管径下闸阀/止回阀/蝶阀等并存，
|
||
// 类别未知或库中无此类别时宁可不写物料码，也不能退化为按管径取到别的阀种。
|
||
std::map<CString, CString> row;
|
||
bool bFound = false;
|
||
if (pszCat && *pszCat)
|
||
{
|
||
std::vector<std::pair<CString, CString> > filters;
|
||
filters.push_back(std::make_pair(CString(_T("公称直径")), dnText(bore)));
|
||
filters.push_back(std::make_pair(CString(_T("类别")), CString(pszCat)));
|
||
bFound = querySpecRow(pDb, _T("AecSpecValve"), level, filters, row);
|
||
}
|
||
|
||
if (bFound)
|
||
bSpec = writeSpecAttributes(out, row, (LPCTSTR)sName);
|
||
}
|
||
|
||
if (!bSpec)
|
||
writePcfAttribute(out, 4, PCF_ATTR_ITEM_DESCRIPTION, (LPCTSTR)sName);
|
||
|
||
PcfRow(out, 4) << PCF_ATTR_FABRICATION_ITEM;
|
||
}
|
||
|
||
// 阀门/管道附件类设备(AecDbEwEquipment)：作为 VALVE 组件导出
|
||
bool pcf_ewEquipment(CUIISQLiteServer *pDb, AecDbEwEquipment *pEqu, std::ostream &out)
|
||
{
|
||
if (!pEqu || !out.good()) return false;
|
||
|
||
AcArray<AecInterface> arInfs;
|
||
if (!pEqu->GetInterface(arInfs) || arInfs.isEmpty()) return false;
|
||
|
||
std::vector<double> bores;
|
||
for (int i = 0; i < arInfs.length(); ++i)
|
||
bores.push_back(arInfs.at(i).dSize1);
|
||
|
||
double dBore = 0.0;
|
||
if (!writeComponentPoints(out, arInfs, bores, PCF_COMP_VALVE, true, dBore))
|
||
return false;
|
||
|
||
writeEquipmentCommon(pDb, pEqu, dBore, out);
|
||
out << "\n";
|
||
return true;
|
||
}
|
||
|
||
// 容器/设备类(AecDbXEquipment)：导出为 EQUIPMENT 定义块(含 NOZZLE)，需放在 PIPELINE-REFERENCE 之前
|
||
bool pcf_xEquipment(CUIISQLiteServer *pDb, AecDbXEquipment *pXEqu, std::ostream &out)
|
||
{
|
||
if (!pXEqu || !out.good()) return false;
|
||
|
||
AcGePoint3d ptIns;
|
||
AcGeVector3d vtDir;
|
||
pXEqu->GetInsert(ptIns, vtDir);
|
||
|
||
// 设备名：优先 NAME，其次唯一名，最后给个兜底
|
||
CString sName;
|
||
pXEqu->GetAt(KEY_NAME, sName);
|
||
if (sName.IsEmpty()) sName = pXEqu->getUniqueName();
|
||
if (sName.IsEmpty()) sName = _T("EQUIPMENT");
|
||
|
||
PcfRow(out, 0) << PCF_COMP_EQUIPMENT;
|
||
PcfRow(out, 4) << PCF_KW_REFERENCE << (LPCTSTR)sName;
|
||
PcfRow(out, 4) << PCF_KW_LOCATION << ptIns;
|
||
PcfRow(out, 4) << PCF_KW_ORIENTATION << dirToOrientation(vtDir);
|
||
|
||
// 管嘴
|
||
AcArray<AecInterface> arInfs;
|
||
if (pXEqu->GetInterface(arInfs))
|
||
{
|
||
for (int i = 0; i < arInfs.length(); ++i)
|
||
{
|
||
const AecInterface &inf = arInfs.at(i);
|
||
|
||
CString sNoz;
|
||
sNoz.Format(_T("%sN%d"), (LPCTSTR)sName, i + 1);
|
||
|
||
PcfRow(out, 4) << PCF_KW_NOZZLE;
|
||
PcfRow(out, 8) << PCF_KW_REFERENCE << (LPCTSTR)sNoz;
|
||
PcfRow(out, 8) << PCF_KW_DIRECTION << dirToOrientation(inf.vtDir);
|
||
PcfRow(out, 8) << PCF_PT_CO_ORDS << inf.ptPos << inf.dSize1;
|
||
}
|
||
}
|
||
|
||
out << "\n";
|
||
return true;
|
||
}
|
||
|
||
// 管件按 EFittingType 分发到通用导出
|
||
bool pcf_fitting(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)
|
||
{
|
||
if (!pFit) return false;
|
||
|
||
switch (pFit->GetFittingType())
|
||
{
|
||
case eElbow:
|
||
case eReduceElbow:
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_ELBOW, out, true);
|
||
|
||
case eReduce:
|
||
return pcf_genericFitting(pDb, pFit, getReducerTypeName(pFit), out, false);
|
||
|
||
case eTee:
|
||
case eWye:
|
||
case eLateral:
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_TEE, out, false);
|
||
|
||
case eCross:
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_CROSS, out, false);
|
||
|
||
case eFlange:
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_FLANGE, out, false);
|
||
|
||
case eWcap:
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_CAP, out, false);
|
||
|
||
case eSPB://八字盲板
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_BLIND_FLANGE, out, false);
|
||
|
||
case eGastket://垫片
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_GASKET, out, false);
|
||
|
||
case eFlxJoin://箍
|
||
case eThrough://直通
|
||
case eUJoin://活接
|
||
case eRJoin://缩接
|
||
case eOJoin://外螺纹接头
|
||
case eIJoin://内螺纹接头
|
||
return pcf_genericFitting(pDb, pFit, PCF_COMP_COUPLING, out, false);
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// ============================ Phase 4: 支吊架导出 ============================
|
||
|
||
// 点到线段的最短距离
|
||
double distPointSegment(const AcGePoint3d &p, const AcGePoint3d &a, const AcGePoint3d &b)
|
||
{
|
||
AcGeVector3d ab(b - a);
|
||
const double len2 = ab.lengthSqrd();
|
||
if (len2 < 1e-12) return p.distanceTo(a);
|
||
|
||
double t = AcGeVector3d(p - a).dotProduct(ab) / len2;
|
||
if (t < 0.0) t = 0.0;
|
||
else if (t > 1.0) t = 1.0;
|
||
return p.distanceTo(a + ab * t);
|
||
}
|
||
|
||
// 取组件主轴线段(两个 nLevel<2 的接口)；接口不足两个时退化为一个点
|
||
bool mainAxisSegment(AcArray<AecInterface> &arInfs, AcGePoint3d &a, AcGePoint3d &b)
|
||
{
|
||
if (arInfs.isEmpty()) return false;
|
||
|
||
std::vector<const AecInterface *> arMain;
|
||
for (int i = 0; i < arInfs.length(); ++i)
|
||
{
|
||
if (arInfs.at(i).nLevel < 2) arMain.push_back(&arInfs.at(i));
|
||
}
|
||
if (arMain.empty()) arMain.push_back(&arInfs.at(0));
|
||
|
||
a = arMain[0]->ptPos;
|
||
b = (arMain.size() >= 2) ? arMain[1]->ptPos : a;
|
||
return true;
|
||
}
|
||
|
||
// 支吊架既没有 PIPE_SYS，也没有宿主管道句柄，只能按空间位置就近归属到组件，
|
||
// 再取该组件的管道系统。这里把组件的中心线段连同系统名收集起来备用。
|
||
struct SupportTarget
|
||
{
|
||
CString sys;
|
||
AcGePoint3d a;
|
||
AcGePoint3d b;
|
||
};
|
||
|
||
void collectSupportTargets(std::vector<SupportTarget> &targets)
|
||
{
|
||
targets.clear();
|
||
|
||
AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
|
||
if (!pDb) return;
|
||
|
||
AcDbBlockTable *pTbl = NULL;
|
||
if (Acad::eOk != pDb->getBlockTable(pTbl, AcDb::kForRead)) return;
|
||
|
||
AcDbBlockTableRecord *pBTR = NULL;
|
||
if (Acad::eOk != pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForRead))
|
||
{
|
||
pTbl->close();
|
||
return;
|
||
}
|
||
pTbl->close();
|
||
|
||
AcDbBlockTableRecordIterator *pIter = NULL;
|
||
if (Acad::eOk != pBTR->newIterator(pIter))
|
||
{
|
||
pBTR->close();
|
||
return;
|
||
}
|
||
|
||
AcDbEntity *pEnt = NULL;
|
||
for (pIter->start(); !pIter->done(); pIter->step())
|
||
{
|
||
if (Acad::eOk != pIter->getEntity(pEnt, AcDb::kForRead) || !pEnt)
|
||
continue;
|
||
|
||
SupportTarget t;
|
||
bool bOk = false;
|
||
|
||
if (AecDbEwPipe *pPipe = AecDbEwPipe::cast(pEnt))
|
||
{
|
||
t.a = pPipe->StartPoint();
|
||
t.b = pPipe->EndPoint();
|
||
pPipe->GetAt(PIPE_SYS, t.sys);
|
||
bOk = true;
|
||
}
|
||
else if (AecDbEwFitting *pFit = AecDbEwFitting::cast(pEnt))
|
||
{
|
||
AcArray<AecInterface> arInfs;
|
||
if (pFit->GetInterface(arInfs) && mainAxisSegment(arInfs, t.a, t.b))
|
||
{
|
||
pFit->GetAt(PIPE_SYS, t.sys);
|
||
bOk = true;
|
||
}
|
||
}
|
||
else if (AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pEnt))
|
||
{
|
||
AcArray<AecInterface> arInfs;
|
||
if (pEqu->GetInterface(arInfs) && mainAxisSegment(arInfs, t.a, t.b))
|
||
{
|
||
pEqu->GetAt(PIPE_SYS, t.sys);
|
||
bOk = true;
|
||
}
|
||
}
|
||
else if (AecDbXEquipment *pXEqu = AecDbXEquipment::cast(pEnt))
|
||
{
|
||
AcArray<AecInterface> arInfs;
|
||
if (pXEqu->GetInterface(arInfs) && mainAxisSegment(arInfs, t.a, t.b))
|
||
{
|
||
pXEqu->GetAt(PIPE_SYS, t.sys);
|
||
bOk = true;
|
||
}
|
||
}
|
||
|
||
pEnt->close();
|
||
|
||
if (bOk && !t.sys.IsEmpty())
|
||
targets.push_back(t);
|
||
}
|
||
|
||
DELETE_PTR(pIter);
|
||
pBTR->close();
|
||
}
|
||
|
||
// 支吊架(插入点 pt)是否属于指定管道系统：取最近组件所属的系统
|
||
bool supportBelongsToSystem(const AcGePoint3d &pt, LPCTSTR pszSys
|
||
, const std::vector<SupportTarget> &targets)
|
||
{
|
||
double dMin = 0.0;
|
||
CString sBest;
|
||
for (size_t k = 0; k < targets.size(); ++k)
|
||
{
|
||
const double d = distPointSegment(pt, targets[k].a, targets[k].b);
|
||
if (sBest.IsEmpty() || d < dMin)
|
||
{
|
||
dMin = d;
|
||
sBest = targets[k].sys;
|
||
}
|
||
}
|
||
return (sBest == pszSys);
|
||
}
|
||
|
||
// 收集图纸中所有支吊架(AecDbPipeHanger, DXF 名 AEC_PIPEHNGR)
|
||
void collectPipeHangers(std::vector<AcDbObjectId> &ids)
|
||
{
|
||
ids.clear();
|
||
|
||
AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
|
||
if (!pDb) return;
|
||
|
||
AcDbBlockTable *pTbl = NULL;
|
||
if (Acad::eOk != pDb->getBlockTable(pTbl, AcDb::kForRead)) return;
|
||
|
||
AcDbBlockTableRecord *pBTR = NULL;
|
||
if (Acad::eOk != pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForRead))
|
||
{
|
||
pTbl->close();
|
||
return;
|
||
}
|
||
pTbl->close();
|
||
|
||
AcDbBlockTableRecordIterator *pIter = NULL;
|
||
if (Acad::eOk != pBTR->newIterator(pIter))
|
||
{
|
||
pBTR->close();
|
||
return;
|
||
}
|
||
|
||
AcDbEntity *pEnt = NULL;
|
||
for (pIter->start(); !pIter->done(); pIter->step())
|
||
{
|
||
if (Acad::eOk != pIter->getEntity(pEnt, AcDb::kForRead) || !pEnt)
|
||
continue;
|
||
if (AecDbPipeHanger::cast(pEnt))
|
||
ids.push_back(pEnt->objectId());
|
||
pEnt->close();
|
||
}
|
||
|
||
DELETE_PTR(pIter);
|
||
pBTR->close();
|
||
}
|
||
|
||
/*
|
||
支吊架 -> SUPPORT 组件块(单坐标)。
|
||
参考 PCF Reference Guide：
|
||
SUPPORT 必填 CO-ORDS(含公称尺寸) + SKEY；默认 SKEY 为 01HG(双平行线支架符号)；
|
||
CATEGORY 取 ERECTION(现场安装)；名称走 NAME / ITEM-DESCRIPTION。
|
||
支架类型(0~4)不是 PCF 标准属性，借 COMPONENT-ATTRIBUTE0 带出，方便下游重映射符号。
|
||
*/
|
||
bool pcf_support(AecDbPipeHanger *pHanger, std::ostream &out)
|
||
{
|
||
if (!pHanger || !out.good()) return false;
|
||
|
||
const AcGePoint3d pt = pHanger->position();
|
||
|
||
double dn(0.0);
|
||
getNumericValue(pHanger, PCF_KEY_SUPPORT_DN, dn);
|
||
|
||
PcfRow(out, 0) << PCF_COMP_SUPPORT;
|
||
if (dn > 0.0)
|
||
PcfRow(out, 4) << PCF_PT_CO_ORDS << pt << dn;
|
||
else
|
||
PcfRow(out, 4) << PCF_PT_CO_ORDS << pt;
|
||
|
||
PcfRow(out, 4) << PCF_ATTR_SKEY << PCF_SKEY_SUPPORT_DEFAULT;
|
||
|
||
CString sName;
|
||
pHanger->GetAt(KEY_NAME, sName);
|
||
writePcfAttribute(out, 4, PCF_ATTR_NAME, (LPCTSTR)sName);
|
||
writePcfAttribute(out, 4, PCF_ATTR_ITEM_DESCRIPTION, (LPCTSTR)sName);
|
||
|
||
int nMode(-1);
|
||
if (pHanger->GetAt(PCF_KEY_SUPPORT_MODE, nMode))
|
||
{
|
||
CString sMode;
|
||
sMode.Format(_T("%d"), nMode);
|
||
writePcfAttribute(out, 4, PCF_ATTR_COMPONENT_ATTRIBUTE0, (LPCTSTR)sMode);
|
||
}
|
||
|
||
PcfRow(out, 4) << PCF_KW_CATEGORY << PCF_CAT_ERECTION;
|
||
out << "\n";
|
||
return true;
|
||
}
|
||
|
||
// ============================ Phase 5: 自动分图 ============================
|
||
|
||
// 接图标识的 PCF 属性名。写在下游组件属性之后，随该组件一起被识别。
|
||
STR_PTR PCF_ATTR_CONTINUATION = L"MESSAGE-TEXT";
|
||
|
||
// ---- 5.1 组件通用读取 ----
|
||
|
||
// 候选"管号"键，按优先级排列。
|
||
// 注意：工程里"管号"存在 PIPE_NO("No")，但"改管"路径
|
||
// (PipelineCmd\AecPipeLine.cpp:3647) 会用"顺序号"把 PIPE_NO 覆盖掉，
|
||
// 所以不能硬编码，由 probeGroupKey() 实测后挑一个可用的键。
|
||
LPCTSTR g_pszNoKeys[] =
|
||
{
|
||
PIPE_NO, // "No" 管号(可能已被顺序号覆盖)
|
||
PIPE_LINENO, // "LineNo" 管线号(PID 用，现场常为空)
|
||
PIPE_SPEC, // "Spec" 管子上标
|
||
KEY_NO, // "No." 顺序号
|
||
PIPE_UNITNO, // "UnitNo" 单元号
|
||
PIPE_ZONE, // "Zone" 区号
|
||
};
|
||
|
||
template <typename T>
|
||
bool readKeyString(T *pEnt, LPCTSTR pszKey, CString &s)
|
||
{
|
||
s.Empty();
|
||
if (!pEnt || !pszKey) return false;
|
||
if (pEnt->GetAt(pszKey, s) && !s.IsEmpty()) return true;
|
||
s.Empty();
|
||
return false;
|
||
}
|
||
|
||
// 管道/管件/设备是"兄弟"类，必须分别 cast 才能读到专业数据
|
||
bool readComponentKey(AcDbObject *pObj, LPCTSTR pszKey, CString &s)
|
||
{
|
||
s.Empty();
|
||
if (!pObj) return false;
|
||
|
||
if (AecDbEwPipe *pPipe = AecDbEwPipe::cast(pObj))
|
||
return readKeyString(pPipe, pszKey, s);
|
||
if (AecDbEwFitting *pFit = AecDbEwFitting::cast(pObj))
|
||
return readKeyString(pFit, pszKey, s);
|
||
if (AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pObj))
|
||
return readKeyString(pEqu, pszKey, s);
|
||
if (AecDbXEquipment *pXEqu = AecDbXEquipment::cast(pObj))
|
||
return readKeyString(pXEqu, pszKey, s);
|
||
return false;
|
||
}
|
||
|
||
// 组件的 EFittingType；非本插件组件返回 -1
|
||
int getCompType(AcDbObject *pObj)
|
||
{
|
||
if (!pObj) return -1;
|
||
if (AecDbEwPipe::cast(pObj)) return ePipe;
|
||
if (AecDbEwFitting *pFit = AecDbEwFitting::cast(pObj)) return pFit->GetFittingType();
|
||
if (AecDbEwEquipment::cast(pObj)) return eEquipment;
|
||
if (AecDbXEquipment::cast(pObj)) return eEquipment;
|
||
return -1;
|
||
}
|
||
|
||
// ---- 5.3 网络图与切点 ----
|
||
|
||
// 网络里的一个组件节点(长直管被切断时，同一实体可对应多个节点)
|
||
struct NetNode
|
||
{
|
||
AcDbObjectId id;
|
||
int nType; // EFITTINGTYPE
|
||
AcGePoint3d a, b; // 该节点占据的主轴线段
|
||
AcArray<AecInterface> infs;
|
||
int nSplitIdx; // 对应的 PipeSplit 下标(用于把切段精确落到图上)
|
||
|
||
NetNode() : nType(-1), nSplitIdx(-1) {}
|
||
};
|
||
|
||
// 一个可用于连接的接口点
|
||
struct ConnPt
|
||
{
|
||
AcGePoint3d pt;
|
||
int nConn; // AecInterface::nConnectType: 0焊接 1承插 2螺纹 3法兰 4卡箍
|
||
double bore; // 接口管径
|
||
ConnPt() : nConn(-1), bore(0.0) {}
|
||
};
|
||
|
||
// 两个组件之间的连接 —— 潜在切点 / 焊缝
|
||
struct NetJoint
|
||
{
|
||
int nA, nB; // NetNode 下标
|
||
AcGePoint3d pt; // 接口位置
|
||
bool bFlange; // 至少一端是法兰 -> 法兰面
|
||
bool bWeld; // 焊接接口 -> 需要输出 WELD 记录
|
||
int nConnA, nConnB; // 两侧接口的连接类型
|
||
double dBore; // 接口管径
|
||
|
||
NetJoint() : nA(-1), nB(-1), bFlange(false), bWeld(false)
|
||
, nConnA(-1), nConnB(-1), dBore(0.0) {}
|
||
};
|
||
|
||
// 切点优先级：法兰面(2) > 现场焊缝(1) > 普通接口(0)
|
||
int jointPriority(const NetJoint &j)
|
||
{
|
||
if (j.bFlange) return 2;
|
||
if (j.bWeld) return 1;
|
||
return 0;
|
||
}
|
||
|
||
// 直管某端(起点/终点)的接口连接类型；接口数据不足时返回 -1
|
||
int pipeEndConnect(const NetNode &nd, const AcGePoint3d &pt)
|
||
{
|
||
int nBest = -1;
|
||
double dMin = 1e18;
|
||
for (int i = 0; i < nd.infs.length(); ++i)
|
||
{
|
||
const double d = nd.infs.at(i).ptPos.distanceTo(pt);
|
||
if (d < dMin) { dMin = d; nBest = nd.infs.at(i).nConnectType; }
|
||
}
|
||
return nBest;
|
||
}
|
||
|
||
// 直管某端的接口管径
|
||
double pipeEndBore(const NetNode &nd, const AcGePoint3d &pt)
|
||
{
|
||
double dBore = 0.0;
|
||
double dMin = 1e18;
|
||
for (int i = 0; i < nd.infs.length(); ++i)
|
||
{
|
||
const double d = nd.infs.at(i).ptPos.distanceTo(pt);
|
||
if (d < dMin) { dMin = d; dBore = nd.infs.at(i).dSize1; }
|
||
}
|
||
return dBore;
|
||
}
|
||
|
||
// 节点上所有可用于连接的接口(带连接类型与管径)
|
||
void nodeConnPoints(const NetNode &nd, std::vector<ConnPt> &pts)
|
||
{
|
||
pts.clear();
|
||
|
||
if (nd.nType == ePipe)
|
||
{
|
||
ConnPt c0, c1;
|
||
c0.pt = nd.a; c0.nConn = pipeEndConnect(nd, nd.a); c0.bore = pipeEndBore(nd, nd.a);
|
||
c1.pt = nd.b; c1.nConn = pipeEndConnect(nd, nd.b); c1.bore = pipeEndBore(nd, nd.b);
|
||
pts.push_back(c0);
|
||
pts.push_back(c1);
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < nd.infs.length(); ++i)
|
||
{
|
||
ConnPt c;
|
||
c.pt = nd.infs.at(i).ptPos;
|
||
c.nConn = nd.infs.at(i).nConnectType;
|
||
c.bore = nd.infs.at(i).dSize1;
|
||
pts.push_back(c);
|
||
}
|
||
|
||
if (pts.empty())
|
||
{
|
||
ConnPt c0, c1;
|
||
c0.pt = nd.a;
|
||
pts.push_back(c0);
|
||
if (nd.a.distanceTo(nd.b) > 1e-9) { c1.pt = nd.b; pts.push_back(c1); }
|
||
}
|
||
}
|
||
|
||
// 接口重合判定的容差(图纸单位)。本图纸里相邻组件的接口位置是严格重合的，
|
||
// 取 0.01 足够；不再借用底层按垫片尺寸(dGasket)放大的容差。
|
||
double netTolerance()
|
||
{
|
||
double dUnit = 1.0;
|
||
struct resbuf rb;
|
||
if (acedGetVar(_T("INSUNITS"), &rb) == RTNORM && rb.resval.rint == AcDb::kUnitsMeters)
|
||
dUnit = 0.001;
|
||
return __max(0.01 * dUnit, 0.01);
|
||
}
|
||
|
||
// 读一个实体的接口与主轴线段(接口不足两个时退化为点)
|
||
bool readAxisSegment(AcDbObject *pObj, AcArray<AecInterface> &infs
|
||
, AcGePoint3d &a, AcGePoint3d &b)
|
||
{
|
||
if (AecDbEwPipe *pPipe = AecDbEwPipe::cast(pObj))
|
||
{
|
||
a = pPipe->StartPoint();
|
||
b = pPipe->EndPoint();
|
||
pPipe->GetInterface(infs);
|
||
return true;
|
||
}
|
||
|
||
if (AecDbEwFitting *pFit = AecDbEwFitting::cast(pObj))
|
||
{
|
||
pFit->GetInterface(infs);
|
||
}
|
||
else if (AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pObj))
|
||
{
|
||
pEqu->GetInterface(infs);
|
||
}
|
||
else if (AecDbXEquipment *pXEqu = AecDbXEquipment::cast(pObj))
|
||
{
|
||
pXEqu->GetInterface(infs);
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!mainAxisSegment(infs, a, b))
|
||
{
|
||
a = b = AcGePoint3d::kOrigin;
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
组装网络图。
|
||
dSplitLen > 0 时，长度超过 dSplitLen 的直管会被拆成多段"虚拟节点"
|
||
(按 dSplitLen 等分)，这样后续既可以在节点数上控制图幅，也能在长直管
|
||
的中点处自然形成切点(符合"长直管段中心点切断"的要求)。
|
||
pipeSplits 回传每个被拆直管的切段参数，供写 PCF 时输出多根虚拟管。
|
||
*/
|
||
struct PipeSplit
|
||
{
|
||
AcDbObjectId id;
|
||
double t0, t1; // 沿管子起点->终点方向的归一化参数
|
||
};
|
||
|
||
void buildNetwork(const AcDbObjectIdArray &ids, double dSplitLen
|
||
, std::vector<NetNode> &nodes, std::vector<NetJoint> &joints
|
||
, std::vector<PipeSplit> &pipeSplits)
|
||
{
|
||
nodes.clear();
|
||
joints.clear();
|
||
pipeSplits.clear();
|
||
|
||
for (int i = 0; i < ids.length(); ++i)
|
||
{
|
||
AcDbObjectPointer<AcDbObject> pObj(ids[i], AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) continue;
|
||
|
||
const int nType = getCompType(pObj.object());
|
||
if (nType < 0) continue;
|
||
|
||
AcGePoint3d a, b;
|
||
AcArray<AecInterface> infs;
|
||
if (!readAxisSegment(pObj.object(), infs, a, b)) continue;
|
||
|
||
// 长直管：按 dSplitLen 等分，逐段建节点
|
||
const double dLen = a.distanceTo(b);
|
||
if (dSplitLen > 0.0 && nType == ePipe && dLen > dSplitLen * 1.5)
|
||
{
|
||
const int nSeg = (int)(dLen / dSplitLen) + 1;
|
||
const AcGeVector3d vt(b - a);
|
||
|
||
for (int k = 0; k < nSeg; ++k)
|
||
{
|
||
const double t0 = (double)k / nSeg;
|
||
const double t1 = (double)(k + 1) / nSeg;
|
||
|
||
NetNode nd;
|
||
nd.id = ids[i];
|
||
nd.nType = ePipe;
|
||
nd.a = a + vt * t0;
|
||
nd.b = a + vt * t1;
|
||
nd.infs = infs; // 保留接口，供判断端部连接类型(焊接/法兰)
|
||
nd.nSplitIdx = (int)pipeSplits.size();
|
||
nodes.push_back(nd);
|
||
|
||
PipeSplit sp;
|
||
sp.id = ids[i];
|
||
sp.t0 = t0;
|
||
sp.t1 = t1;
|
||
pipeSplits.push_back(sp);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
NetNode nd;
|
||
nd.id = ids[i];
|
||
nd.nType = nType;
|
||
nd.a = a;
|
||
nd.b = b;
|
||
nd.infs = infs;
|
||
nd.nSplitIdx = (int)pipeSplits.size();
|
||
nodes.push_back(nd);
|
||
|
||
PipeSplit sp;
|
||
sp.id = ids[i];
|
||
sp.t0 = 0.0;
|
||
sp.t1 = 1.0;
|
||
pipeSplits.push_back(sp);
|
||
}
|
||
|
||
// 连接关系：接口位置重合即视为相接
|
||
const double dTol = netTolerance();
|
||
|
||
for (size_t i = 0; i < nodes.size(); ++i)
|
||
{
|
||
std::vector<ConnPt> ptI;
|
||
nodeConnPoints(nodes[i], ptI);
|
||
|
||
for (size_t k = i + 1; k < nodes.size(); ++k)
|
||
{
|
||
std::vector<ConnPt> ptK;
|
||
nodeConnPoints(nodes[k], ptK);
|
||
|
||
int nHitX = -1, nHitY = -1;
|
||
for (size_t x = 0; x < ptI.size() && nHitX < 0; ++x)
|
||
{
|
||
for (size_t y = 0; y < ptK.size() && nHitX < 0; ++y)
|
||
{
|
||
if (ptI[x].pt.distanceTo(ptK[y].pt) <= dTol)
|
||
{
|
||
nHitX = (int)x;
|
||
nHitY = (int)y;
|
||
}
|
||
}
|
||
}
|
||
if (nHitX < 0) continue;
|
||
|
||
NetJoint jt;
|
||
jt.nA = (int)i;
|
||
jt.nB = (int)k;
|
||
jt.pt = ptI[nHitX].pt;
|
||
jt.nConnA = ptI[nHitX].nConn;
|
||
jt.nConnB = ptK[nHitY].nConn;
|
||
jt.dBore = (ptI[nHitX].bore > 0.0) ? ptI[nHitX].bore : ptK[nHitY].bore;
|
||
|
||
// 法兰面：一端是法兰管件，或某一侧接口本身就是法兰连接(3)
|
||
jt.bFlange = (nodes[i].nType == eFlange) || (nodes[k].nType == eFlange)
|
||
|| (jt.nConnA == 3) || (jt.nConnB == 3);
|
||
|
||
/*
|
||
螺栓连接的法兰面不算焊口：
|
||
- 任一接口的连接类型是"法兰(3)"；或
|
||
- 一端是法兰管件，另一端是阀门/设备(均以 eEquipment 表示)或另一片法兰。
|
||
注意：法兰的另一端(焊颈)与直管/管件相接仍是焊口，故不能"凡法兰即不算焊"。
|
||
*/
|
||
bool bBoltedFace = (jt.nConnA == 3) || (jt.nConnB == 3);
|
||
if (!bBoltedFace && (nodes[i].nType == eFlange || nodes[k].nType == eFlange))
|
||
{
|
||
const int nOther = (nodes[i].nType == eFlange) ? nodes[k].nType : nodes[i].nType;
|
||
if (nOther == eEquipment || nOther == eFlange)
|
||
bBoltedFace = true;
|
||
}
|
||
|
||
// 焊接接头：两侧接口的连接类型都是"焊接(0)"，且不是螺栓法兰面。
|
||
// 连接类型取不到(-1，接口数据缺失)时，退回"非螺栓面且至少一端是直管"的旧判据。
|
||
if (bBoltedFace)
|
||
jt.bWeld = false;
|
||
else if (jt.nConnA == 0 && jt.nConnB == 0)
|
||
jt.bWeld = true;
|
||
else if (jt.nConnA < 0 && jt.nConnB < 0)
|
||
jt.bWeld = (nodes[i].nType == ePipe || nodes[k].nType == ePipe);
|
||
|
||
joints.push_back(jt);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---- 5.3b 连通子网剥离 ----
|
||
|
||
/*
|
||
把一组组件按"接口相接"的连通性拆成若干连通子网。
|
||
连通性完全以本文件的接口重合判定为准(即 buildNetwork 建的图)，这样
|
||
"拆子网"、"选切点"、"跨图续接标注"三处用的是同一套几何规则，结果自洽。
|
||
|
||
不用底层 GetPipeNetNodes：它的容差取的是目标接口的垫片尺寸(dGasket)，
|
||
在本图纸上会把接口位置完全重合(距离 0)的法兰与阀门判成不连通，导致
|
||
一个系统被切成上百个碎片。
|
||
*/
|
||
void splitNetByConnectivity(const AcDbObjectIdArray &ids, std::vector<AcDbObjectIdArray> &nets)
|
||
{
|
||
nets.clear();
|
||
if (ids.isEmpty()) return;
|
||
|
||
std::vector<NetNode> nodes;
|
||
std::vector<NetJoint> joints;
|
||
std::vector<PipeSplit> splits;
|
||
buildNetwork(ids, 0.0, nodes, joints, splits);
|
||
|
||
const int n = (int)nodes.size();
|
||
if (n <= 0) return;
|
||
|
||
// 并查集：接口重合即视为同一子网
|
||
std::vector<int> par(n);
|
||
for (int i = 0; i < n; ++i) par[i] = i;
|
||
|
||
for (size_t j = 0; j < joints.size(); ++j)
|
||
{
|
||
int a = joints[j].nA, b = joints[j].nB;
|
||
while (par[a] != a) { par[a] = par[par[a]]; a = par[a]; }
|
||
while (par[b] != b) { par[b] = par[par[b]]; b = par[b]; }
|
||
if (a != b) par[a] = b;
|
||
}
|
||
|
||
// 按根聚拢；节点顺序沿用系统内的组件顺序，保证导出顺序稳定
|
||
std::map<int, int> rootToNet;
|
||
for (int i = 0; i < n; ++i)
|
||
{
|
||
int r = i;
|
||
while (par[r] != r) { par[r] = par[par[r]]; r = par[r]; }
|
||
|
||
std::map<int, int>::iterator it = rootToNet.find(r);
|
||
int idx;
|
||
if (it == rootToNet.end())
|
||
{
|
||
idx = (int)nets.size();
|
||
rootToNet.insert(std::make_pair(r, idx));
|
||
nets.push_back(AcDbObjectIdArray());
|
||
}
|
||
else
|
||
{
|
||
idx = it->second;
|
||
}
|
||
|
||
if (nets[idx].find(nodes[i].id) == -1)
|
||
nets[idx].append(nodes[i].id);
|
||
}
|
||
|
||
acutPrintf(_T("\n连通子网 %d 个。"), (int)nets.size());
|
||
}
|
||
|
||
// 管号里常见的占位值(空、全分隔符)视为"没填"
|
||
bool isBlankKey(const CString &s)
|
||
{
|
||
if (s.IsEmpty()) return true;
|
||
for (int i = 0; i < s.GetLength(); ++i)
|
||
{
|
||
const TCHAR c = s[i];
|
||
if (c != _T('-') && c != _T('_') && c != _T('.') && c != _T(' ') && c != _T('/'))
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
取一个连通子网的"管号"：子网内出现次数最多的非空管号。
|
||
阀门/附件这类不带管号的组件因此会跟着它所在的那条管线走，
|
||
而不是被单独分出去。取不到时退回系统名。
|
||
*/
|
||
CString dominantKey(const AcDbObjectIdArray &ids, LPCTSTR pszKey, LPCTSTR pszDefault)
|
||
{
|
||
CString sDefault(pszDefault ? pszDefault : _T(""));
|
||
if (!pszKey || _tcslen(pszKey) == 0) return sDefault;
|
||
|
||
std::map<CString, int> hist;
|
||
for (int i = 0; i < ids.length(); ++i)
|
||
{
|
||
AcDbObjectPointer<AcDbObject> pObj(ids[i], AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) continue;
|
||
|
||
CString s;
|
||
if (!readComponentKey(pObj.object(), pszKey, s) || isBlankKey(s)) continue;
|
||
hist[s]++;
|
||
}
|
||
|
||
CString sBest;
|
||
int nBest = 0;
|
||
for (std::map<CString, int>::const_iterator it = hist.begin(); it != hist.end(); ++it)
|
||
{
|
||
if (it->second > nBest) { nBest = it->second; sBest = it->first; }
|
||
}
|
||
|
||
return sBest.IsEmpty() ? sDefault : sBest;
|
||
}
|
||
|
||
// ---- 5.4 尺寸/密度二次切分 ----
|
||
|
||
/*
|
||
一张图放不下时，沿管线走向从一端开始累加组件；一旦再加就会超过
|
||
nMaxNodes 个组件或 dMaxSpan 的跨度，就回退到"最近的优先切点"再切。
|
||
因为只在组件之间的接口处切，所以绝不会切在弯头/三通内部。
|
||
*/
|
||
void splitBySize(const std::vector<NetNode> &nodes, const std::vector<NetJoint> &joints
|
||
, int nMaxNodes, double dMaxSpan, std::vector<std::vector<int> > &sheets)
|
||
{
|
||
sheets.clear();
|
||
|
||
const int n = (int)nodes.size();
|
||
if (n <= 0) return;
|
||
|
||
// 邻接表：node -> (邻居, joint 下标)
|
||
std::vector<std::vector<std::pair<int, int> > > adj(n);
|
||
for (int j = 0; j < (int)joints.size(); ++j)
|
||
{
|
||
adj[joints[j].nA].push_back(std::make_pair(joints[j].nB, j));
|
||
adj[joints[j].nB].push_back(std::make_pair(joints[j].nA, j));
|
||
}
|
||
|
||
std::vector<char> used(n, 0);
|
||
|
||
for (int s = 0; s < n; ++s)
|
||
{
|
||
if (used[s]) continue;
|
||
|
||
// 优先从"端点"(度为 1)起步，符合管线走向
|
||
int start = s;
|
||
for (int k = 0; k < n; ++k)
|
||
{
|
||
if (!used[k] && adj[k].size() <= 1) { start = k; break; }
|
||
}
|
||
|
||
std::vector<int> order; // 遍历顺序
|
||
std::vector<int> entry; // 进入 order[k] 所用的 joint；order[0] = -1
|
||
std::vector<int> stack;
|
||
|
||
order.push_back(start);
|
||
entry.push_back(-1);
|
||
used[start] = 1;
|
||
stack.push_back(start);
|
||
|
||
AcGePoint3d ptMin, ptMax;
|
||
bool bBox = false;
|
||
|
||
while (!stack.empty())
|
||
{
|
||
const int u = stack.back();
|
||
|
||
int v = -1, je = -1;
|
||
for (size_t t = 0; t < adj[u].size(); ++t)
|
||
{
|
||
const int w = adj[u][t].first;
|
||
if (used[w]) continue;
|
||
v = w;
|
||
je = adj[u][t].second;
|
||
break;
|
||
}
|
||
if (v < 0) { stack.pop_back(); continue; }
|
||
|
||
// 组件数上限
|
||
if (nMaxNodes > 0 && (int)order.size() >= nMaxNodes)
|
||
break;
|
||
|
||
// 空间跨度上限
|
||
if (dMaxSpan > 0.0)
|
||
{
|
||
AcGePoint3d mn = nodes[v].a, mx = nodes[v].b;
|
||
if (mn.x > mx.x) { const double t = mn.x; mn.x = mx.x; mx.x = t; }
|
||
if (mn.y > mx.y) { const double t = mn.y; mn.y = mx.y; mx.y = t; }
|
||
if (mn.z > mx.z) { const double t = mn.z; mn.z = mx.z; mx.z = t; }
|
||
|
||
AcGePoint3d tmn = mn, tmx = mx;
|
||
if (bBox)
|
||
{
|
||
if (ptMin.x < tmn.x) tmn.x = ptMin.x;
|
||
if (ptMin.y < tmn.y) tmn.y = ptMin.y;
|
||
if (ptMin.z < tmn.z) tmn.z = ptMin.z;
|
||
if (ptMax.x > tmx.x) tmx.x = ptMax.x;
|
||
if (ptMax.y > tmx.y) tmx.y = ptMax.y;
|
||
if (ptMax.z > tmx.z) tmx.z = ptMax.z;
|
||
}
|
||
|
||
const double dx = tmx.x - tmn.x;
|
||
const double dy = tmx.y - tmn.y;
|
||
const double dz = tmx.z - tmn.z;
|
||
if (__max(dx, __max(dy, dz)) > dMaxSpan)
|
||
break;
|
||
|
||
ptMin = tmn;
|
||
ptMax = tmx;
|
||
bBox = true;
|
||
}
|
||
|
||
order.push_back(v);
|
||
entry.push_back(je);
|
||
used[v] = 1;
|
||
stack.push_back(v);
|
||
}
|
||
|
||
int nKeep = (int)order.size();
|
||
|
||
// 是否"因超限被截断"(最后一个节点还有没用到的邻居)
|
||
bool bTruncated = false;
|
||
{
|
||
const int last = order.back();
|
||
for (size_t t = 0; t < adj[last].size(); ++t)
|
||
{
|
||
if (!used[adj[last][t].first]) { bTruncated = true; break; }
|
||
}
|
||
}
|
||
|
||
// 回退到最近的优先切点(法兰面/现场焊缝)，让切点落在该落的地方
|
||
if (bTruncated)
|
||
{
|
||
for (int k = nKeep - 1; k >= 1; --k)
|
||
{
|
||
if (jointPriority(joints[entry[k]]) >= 1)
|
||
{
|
||
// order[k..] 交还给下一轮
|
||
for (int t = k; t < nKeep; ++t) used[order[t]] = 0;
|
||
nKeep = k;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
sheets.push_back(std::vector<int>(order.begin(), order.begin() + nKeep));
|
||
}
|
||
}
|
||
|
||
// ---- 5.5 分图导出 ----
|
||
|
||
// 文件名非法字符替换
|
||
CString sanitizeFileName(LPCTSTR psz)
|
||
{
|
||
CString s(psz ? psz : _T(""));
|
||
LPCTSTR pszBad = _T("\\/:*?\"<>|");
|
||
for (int i = 0; i < (int)_tcslen(pszBad); ++i)
|
||
s.Replace(pszBad[i], _T('_'));
|
||
s.Trim();
|
||
if (s.IsEmpty()) s = _T("PCF");
|
||
return s;
|
||
}
|
||
|
||
// 一个焊口：位置 + 管径 + 两侧组件(用于把焊口挂到组件所在的那张图上)
|
||
struct WeldRec
|
||
{
|
||
AcGePoint3d pt;
|
||
double bore;
|
||
AcDbObjectId idA, idB;
|
||
|
||
WeldRec() : bore(0.0) {}
|
||
};
|
||
|
||
/*
|
||
焊口(WELD)。PCF 参考手册里 WELD 的标准写法：
|
||
WELD
|
||
END-POINT x y z <size>
|
||
END-POINT x y z <size>
|
||
SKEY WW
|
||
CATEGORY FABRICATION
|
||
(两个 END-POINT 分别代表焊缝两侧；本模型里两侧位置重合，故坐标相同。)
|
||
*/
|
||
bool pcf_weld(const WeldRec &w, std::ostream &out)
|
||
{
|
||
if (!out.good()) return false;
|
||
|
||
PcfRow(out, 0) << PCF_COMP_WELD;
|
||
if (w.bore > 0.0)
|
||
{
|
||
PcfRow(out, 4) << PCF_PT_END_POINT << w.pt << w.bore;
|
||
PcfRow(out, 4) << PCF_PT_END_POINT << w.pt << w.bore;
|
||
}
|
||
else
|
||
{
|
||
PcfRow(out, 4) << PCF_PT_CO_ORDS << w.pt;
|
||
}
|
||
PcfRow(out, 4) << PCF_ATTR_SKEY << PCF_ATTR_SKEY_WELD;
|
||
PcfRow(out, 4) << PCF_KW_CATEGORY << PCF_CAT_FABRICATION;
|
||
out << "\n";
|
||
return true;
|
||
}
|
||
|
||
// 设备(EQUIPMENT)定义块：必须写在 PIPELINE-REFERENCE 之前
|
||
void writePcfEquipmentDefs(std::ostream &out, CUIISQLiteServer *pDb
|
||
, const AcDbObjectIdArray &ids, int &nDef, int &nDefOk)
|
||
{
|
||
nDef = nDefOk = 0;
|
||
for (int i(0); i < ids.length(); ++i)
|
||
{
|
||
AcDbObjectPointer<AcDbObject> pObj(ids[i], AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) continue;
|
||
if (pObj->isA() != AecDbXEquipment::desc()) continue;
|
||
|
||
++nDef;
|
||
AecDbXEquipment *pXEqu = AecDbXEquipment::cast(pObj.object());
|
||
if (pcf_xEquipment(pDb, pXEqu, out)) ++nDefOk;
|
||
}
|
||
}
|
||
|
||
// 管道 / 管件 / 阀门(设备) / 焊口
|
||
void writePcfComponents(std::ostream &out, CUIISQLiteServer *pDb
|
||
, const AcDbObjectIdArray &ids
|
||
, const std::vector<PipeSplit> *pSplits
|
||
, const std::vector<std::pair<AcDbObjectId, CString> > *pMsgs
|
||
, const std::vector<WeldRec> *pWelds
|
||
, int &nPipe, int &nPipeOk, int &nFit, int &nFitOk, int &nEqu, int &nEquOk
|
||
, int &nWeld, int &nWeldOk)
|
||
{
|
||
nPipe = nPipeOk = nFit = nFitOk = nEqu = nEquOk = 0;
|
||
nWeld = nWeldOk = 0;
|
||
|
||
// 同一实体被拆成多段时，先按实体归拢切段参数
|
||
std::vector<size_t> hit;
|
||
|
||
for (int i(0); i < ids.length(); ++i)
|
||
{
|
||
const AcDbObjectId &id(ids[i]);
|
||
|
||
AcDbObjectPointer<AcDbObject> pObj(id, AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) continue;
|
||
|
||
bool bOk = false;
|
||
|
||
if (pObj->isA() == AecDbEwPipe::desc())
|
||
{
|
||
AecDbEwPipe *pPipe = AecDbEwPipe::cast(pObj.object());
|
||
|
||
// 收集本实体对应的切段(通常只有一段)
|
||
hit.clear();
|
||
if (pSplits)
|
||
{
|
||
for (size_t k = 0; k < pSplits->size(); ++k)
|
||
if ((*pSplits)[k].id == id) hit.push_back(k);
|
||
}
|
||
|
||
if (!hit.empty())
|
||
{
|
||
// 长直管被切断：本图只输出落在本图上的那几段虚拟管
|
||
const AcGePoint3d ptA = pPipe->StartPoint();
|
||
const AcGeVector3d vt(pPipe->EndPoint() - ptA);
|
||
|
||
nPipe += (int)hit.size();
|
||
for (size_t k = 0; k < hit.size(); ++k)
|
||
{
|
||
const PipeSplit &sp = (*pSplits)[hit[k]];
|
||
const AcGePoint3d ptS = ptA + vt * sp.t0;
|
||
const AcGePoint3d ptE = ptA + vt * sp.t1;
|
||
if (pcf_pipe_normal(pDb, pPipe, out, &ptS, &ptE)) ++nPipeOk;
|
||
}
|
||
bOk = true;
|
||
}
|
||
else
|
||
{
|
||
++nPipe;
|
||
if (pcf_pipe_normal(pDb, pPipe, out)) { ++nPipeOk; bOk = true; }
|
||
}
|
||
}
|
||
else if (pObj->isA() == AecDbEwFitting::desc())
|
||
{
|
||
++nFit;
|
||
AecDbEwFitting *pFit = AecDbEwFitting::cast(pObj.object());
|
||
if (pcf_fitting(pDb, pFit, out)) { ++nFitOk; bOk = true; }
|
||
}
|
||
else if (pObj->isA() == AecDbEwEquipment::desc())
|
||
{
|
||
++nEqu;
|
||
AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pObj.object());
|
||
if (pcf_ewEquipment(pDb, pEqu, out)) { ++nEquOk; bOk = true; }
|
||
}
|
||
|
||
// 接图标识：紧跟在本组件属性之后写，随该组件一起被下游识别。
|
||
// 同一个组件可能是两个切缝的端点(例如三通的两条支管各去了不同的图)，
|
||
// 所以这里要把该组件的所有接图标识都写出来，不能 break。
|
||
if (bOk && pMsgs)
|
||
{
|
||
for (size_t k = 0; k < pMsgs->size(); ++k)
|
||
{
|
||
if ((*pMsgs)[k].first == id)
|
||
writePcfAttribute(out, 4, PCF_ATTR_CONTINUATION, (LPCTSTR)(*pMsgs)[k].second);
|
||
}
|
||
}
|
||
|
||
// 焊口：挂在焊缝 A 端组件之后，保持与相邻组件的前后关系
|
||
if (bOk && pWelds)
|
||
{
|
||
for (size_t k = 0; k < pWelds->size(); ++k)
|
||
{
|
||
if ((*pWelds)[k].idA != id) continue;
|
||
++nWeld;
|
||
if (pcf_weld((*pWelds)[k], out)) ++nWeldOk;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 支吊架：本身不带 PIPE_SYS，也没有宿主管道句柄，按空间就近归属到本管道系统
|
||
void writePcfSupports(std::ostream &out, LPCTSTR pszSys
|
||
, const std::vector<AcDbObjectId> &hangers
|
||
, const std::vector<SupportTarget> &targets, int &nSup, int &nSupOk)
|
||
{
|
||
nSup = nSupOk = 0;
|
||
|
||
for (size_t k(0); k < hangers.size(); ++k)
|
||
{
|
||
AcDbObjectPointer<AcDbObject> pObj(hangers[k], AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) continue;
|
||
|
||
AecDbPipeHanger *pHanger = AecDbPipeHanger::cast(pObj.object());
|
||
if (!pHanger) continue;
|
||
|
||
if (!supportBelongsToSystem(pHanger->position(), pszSys, targets)) continue;
|
||
|
||
++nSup;
|
||
if (pcf_support(pHanger, out)) ++nSupOk;
|
||
}
|
||
}
|
||
|
||
// 一张图(一个 PCF 文件)的统计
|
||
struct PcfSheetCounts
|
||
{
|
||
int nPipe, nPipeOk, nFit, nFitOk, nEqu, nEquOk, nEquDef, nEquDefOk, nSup, nSupOk, nWeld, nWeldOk;
|
||
PcfSheetCounts()
|
||
: nPipe(0), nPipeOk(0), nFit(0), nFitOk(0), nEqu(0), nEquOk(0)
|
||
, nEquDef(0), nEquDefOk(0), nSup(0), nSupOk(0), nWeld(0), nWeldOk(0) {}
|
||
};
|
||
|
||
/*
|
||
写一张图的完整 PCF 内容(文件流的打开/关闭由调用方负责)。
|
||
pszPipelineRef : PIPELINE-REFERENCE 取值(管号，取不到时用系统名)
|
||
pSplits : 长直管切段(可空)
|
||
pMsgs : 接图标识(可空)
|
||
*/
|
||
void writePcfSheet(std::ostream &out, CUIISQLiteServer *pDb, LPCTSTR pszPipelineRef
|
||
, const AcDbObjectIdArray &ids
|
||
, const std::vector<SupportTarget> &targets
|
||
, const std::vector<AcDbObjectId> &hangers
|
||
, LPCTSTR pszSupportSys
|
||
, const std::vector<PipeSplit> *pSplits
|
||
, const std::vector<std::pair<AcDbObjectId, CString> > *pMsgs
|
||
, const std::vector<WeldRec> *pWelds
|
||
, PcfSheetCounts &c)
|
||
{
|
||
pcf_begin(out);
|
||
|
||
writePcfEquipmentDefs(out, pDb, ids, c.nEquDef, c.nEquDefOk);
|
||
|
||
pcf_pipeline_reference(out, pszPipelineRef);
|
||
|
||
writePcfComponents(out, pDb, ids, pSplits, pMsgs, pWelds
|
||
, c.nPipe, c.nPipeOk, c.nFit, c.nFitOk, c.nEqu, c.nEquOk, c.nWeld, c.nWeldOk);
|
||
|
||
writePcfSupports(out, pszSupportSys, hangers, targets, c.nSup, c.nSupOk);
|
||
}
|
||
|
||
// 一次遍历同时统计所有候选键的取值分布(避免按 6 个键反复打开实体)
|
||
void probeGroupKeys(const AcDbObjectIdArray &ids, std::vector<std::map<CString, int> > &hists)
|
||
{
|
||
const int nKeys = (int)(sizeof(g_pszNoKeys) / sizeof(g_pszNoKeys[0]));
|
||
hists.assign(nKeys, std::map<CString, int>());
|
||
|
||
for (int i = 0; i < ids.length(); ++i)
|
||
{
|
||
AcDbObjectPointer<AcDbObject> pObj(ids[i], AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) continue;
|
||
|
||
for (int k = 0; k < nKeys; ++k)
|
||
{
|
||
CString s;
|
||
if (readComponentKey(pObj.object(), g_pszNoKeys[k], s) && !s.IsEmpty())
|
||
hists[k][s]++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 跨图连接判定用：一个连接点及其所属组件
|
||
struct SheetPoint
|
||
{
|
||
AcGePoint3d pt;
|
||
AcDbObjectId id;
|
||
};
|
||
|
||
// 取一个实体的节点信息(接口 + 主轴)，定义见下方
|
||
bool readNode(AcDbObjectId id, NetNode &nd);
|
||
|
||
// 预计算一张图的全部连接点，避免跨图两两比较时反复打开实体
|
||
void collectSheetPoints(const AcDbObjectIdArray &ids, std::vector<SheetPoint> &pts)
|
||
{
|
||
pts.clear();
|
||
|
||
for (int i = 0; i < ids.length(); ++i)
|
||
{
|
||
NetNode nd;
|
||
if (!readNode(ids[i], nd)) continue;
|
||
|
||
std::vector<ConnPt> ar;
|
||
nodeConnPoints(nd, ar);
|
||
|
||
for (size_t k = 0; k < ar.size(); ++k)
|
||
{
|
||
SheetPoint sp;
|
||
sp.pt = ar[k].pt;
|
||
sp.id = ids[i];
|
||
pts.push_back(sp);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 取一个实体的节点信息(接口 + 主轴)，供跨图连接判定使用
|
||
bool readNode(AcDbObjectId id, NetNode &nd)
|
||
{
|
||
AcDbObjectPointer<AcDbObject> pObj(id, AcDb::kForRead);
|
||
if (pObj.openStatus() != Acad::eOk) return false;
|
||
|
||
const int nType = getCompType(pObj.object());
|
||
if (nType < 0) return false;
|
||
|
||
AcGePoint3d a, b;
|
||
AcArray<AecInterface> infs;
|
||
if (!readAxisSegment(pObj.object(), infs, a, b)) return false;
|
||
|
||
nd.id = id;
|
||
nd.nType = nType;
|
||
nd.a = a;
|
||
nd.b = b;
|
||
nd.infs = infs;
|
||
return true;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
// 默认输出路径(实现在文件末尾)
|
||
static CString makeDefaultPcfPath(LPCTSTR pszSystem);
|
||
|
||
// 对外只暴露这一个接口
|
||
// 按管道系统(pszSystem)得到该系统下的所有 管道/管件/设备，并输出到 pcf 文件
|
||
bool PCF::makePCF(LPCTSTR pszFile, LPCTSTR pszSystem)
|
||
{
|
||
if (!pszFile || _tcslen(pszFile) == 0)
|
||
return false;
|
||
|
||
// 未指定管道系统时，遍历图纸中出现的所有管道系统，取第一个
|
||
CString sSystem;
|
||
if (pszSystem && _tcslen(pszSystem) > 0)
|
||
{
|
||
sSystem = pszSystem;
|
||
}
|
||
else
|
||
{
|
||
std::vector<CString> systems;
|
||
collectSystems(systems);
|
||
if (systems.empty())
|
||
{
|
||
acutPrintf(_T("\n图纸中未找到任何管道系统(PIPE_PSYSTEM)!"));
|
||
return false;
|
||
}
|
||
sSystem = systems[0];
|
||
}
|
||
|
||
AcDbObjectIdArray ids;
|
||
if (!getComponentBySystem(sSystem, ids))
|
||
{
|
||
acutPrintf(_T("\n管道系统 [%s] 下没有 管道/管件/设备。"), (LPCTSTR)sSystem);
|
||
return false;
|
||
}
|
||
|
||
// 规格库(物料码/描述/等级)用于填充 PCF 的 ITEM-CODE 等属性；
|
||
// 打不开时降级为只输出几何骨架，不阻断导出。
|
||
CUIISQLiteServer *pDb = new CUIISQLiteServer;
|
||
if (!pDb->InitADOServer(FilePath::GetSysDir() + _T("\\Plumbing.db")))
|
||
{
|
||
AfxMessageBox(_T("数据库驱动加载数据库Plumbing.db失败!将只导出几何骨架。"));
|
||
DELETE_PTR(pDb);
|
||
pDb = NULL;
|
||
}
|
||
|
||
std::ofstream out(pszFile, std::ios::binary);
|
||
if (!out.good())
|
||
{
|
||
DELETE_PTR(pDb);
|
||
return false;
|
||
}
|
||
|
||
// 支吊架按空间就近归属，先备好归属用的组件主轴表
|
||
std::vector<SupportTarget> targets;
|
||
collectSupportTargets(targets);
|
||
|
||
std::vector<AcDbObjectId> hangers;
|
||
collectPipeHangers(hangers);
|
||
|
||
// 焊口：整系统建一次网络，取出所有焊接接头(两侧接口连接类型都是"焊接")
|
||
std::vector<WeldRec> welds;
|
||
{
|
||
std::vector<NetNode> nodes;
|
||
std::vector<NetJoint> joints;
|
||
std::vector<PipeSplit> splits;
|
||
buildNetwork(ids, 0.0, nodes, joints, splits);
|
||
|
||
for (size_t j = 0; j < joints.size(); ++j)
|
||
{
|
||
if (!joints[j].bWeld) continue;
|
||
|
||
WeldRec w;
|
||
w.pt = joints[j].pt;
|
||
w.bore = joints[j].dBore;
|
||
w.idA = nodes[joints[j].nA].id;
|
||
w.idB = nodes[joints[j].nB].id;
|
||
welds.push_back(w);
|
||
}
|
||
}
|
||
|
||
// 头部(单位) + 设备定义 + 管线引用 + 组件 + 焊口 + 支吊架
|
||
PcfSheetCounts c;
|
||
writePcfSheet(out, pDb, (LPCTSTR)sSystem, ids, targets, hangers, (LPCTSTR)sSystem
|
||
, NULL, NULL, &welds, c);
|
||
|
||
out.close();
|
||
DELETE_PTR(pDb);
|
||
|
||
acutPrintf(_T("\n管道系统 [%s]: 直管 %d/%d, 管件 %d/%d, 阀门/附件 %d/%d, 设备定义 %d/%d, 焊口 %d/%d, 支吊架 %d/%d。")
|
||
, (LPCTSTR)sSystem, c.nPipeOk, c.nPipe, c.nFitOk, c.nFit, c.nEquOk, c.nEqu
|
||
, c.nEquDefOk, c.nEquDef, c.nWeldOk, c.nWeld, c.nSupOk, c.nSup);
|
||
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
自动分图：把一个管道系统拆成多张 ISO 图，每张图导出一个 PCF 文件。
|
||
见 pcf.h 里的规则说明。
|
||
*/
|
||
bool PCF::makePCFSplit(LPCTSTR pszDir, LPCTSTR pszSystem, int nMaxNodes, double dMaxSpan)
|
||
{
|
||
// 1. 选系统
|
||
CString sSystem;
|
||
if (pszSystem && _tcslen(pszSystem) > 0)
|
||
{
|
||
sSystem = pszSystem;
|
||
}
|
||
else
|
||
{
|
||
std::vector<CString> systems;
|
||
collectSystems(systems);
|
||
if (systems.empty())
|
||
{
|
||
acutPrintf(_T("\n图纸中未找到任何管道系统(PIPE_PSYSTEM)!"));
|
||
return false;
|
||
}
|
||
sSystem = systems[0];
|
||
}
|
||
|
||
// 2. 取该系统的全部组件
|
||
AcDbObjectIdArray ids;
|
||
if (!getComponentBySystem(sSystem, ids))
|
||
{
|
||
acutPrintf(_T("\n管道系统 [%s] 下没有 管道/管件/设备。"), (LPCTSTR)sSystem);
|
||
return false;
|
||
}
|
||
|
||
// 3. 探测可用的"管号"键
|
||
acutPrintf(_T("\n---- 自动分图: 管道系统 [%s]，共 %d 个组件 ----")
|
||
, (LPCTSTR)sSystem, ids.length());
|
||
acutPrintf(_T("\n候选管号键的填充情况:"));
|
||
|
||
std::vector<std::map<CString, int> > hists;
|
||
probeGroupKeys(ids, hists);
|
||
|
||
LPCTSTR pszUseKey = NULL;
|
||
const int nKeys = (int)(sizeof(g_pszNoKeys) / sizeof(g_pszNoKeys[0]));
|
||
for (int k = 0; k < nKeys; ++k)
|
||
{
|
||
int nFilled = 0;
|
||
for (std::map<CString, int>::const_iterator it = hists[k].begin(); it != hists[k].end(); ++it)
|
||
nFilled += it->second;
|
||
|
||
acutPrintf(_T("\n %-10s 有值 %d/%d，取值 %d 种")
|
||
, g_pszNoKeys[k], nFilled, ids.length(), (int)hists[k].size());
|
||
|
||
// 可用的分组键：多数组件有值，且取值数明显少于组件数(否则等于按每根管分组)
|
||
if (!pszUseKey && nFilled * 2 >= ids.length() && !hists[k].empty()
|
||
&& (int)hists[k].size() * 2 <= ids.length())
|
||
pszUseKey = g_pszNoKeys[k];
|
||
}
|
||
|
||
if (pszUseKey)
|
||
acutPrintf(_T("\n采用分组键: [%s]。"), pszUseKey);
|
||
else
|
||
acutPrintf(_T("\n未找到可用的管号键(取值过于分散或全为空)，改按连通子网分图。"));
|
||
|
||
// 4. 先按接口连通性把整个系统拆成连通子网，再按子网内的"多数管号"归并成管线组。
|
||
// 顺序很重要：阀门/附件这类不带管号的组件必须先靠连通性归到它所在的管线上，
|
||
// 否则会被单独分出去(实测 97 个阀门会各自成一张图)。
|
||
std::vector<AcDbObjectIdArray> nets;
|
||
splitNetByConnectivity(ids, nets);
|
||
|
||
std::map<CString, AcDbObjectIdArray> groups;
|
||
std::vector<CString> groupOrder;
|
||
for (size_t k = 0; k < nets.size(); ++k)
|
||
{
|
||
const CString sKey = dominantKey(nets[k], pszUseKey, (LPCTSTR)sSystem);
|
||
|
||
if (groups.find(sKey) == groups.end())
|
||
groupOrder.push_back(sKey);
|
||
|
||
for (int i = 0; i < nets[k].length(); ++i)
|
||
groups[sKey].append(nets[k][i]);
|
||
}
|
||
|
||
acutPrintf(_T("\n按管号归并为 %d 个管线组。"), (int)groupOrder.size());
|
||
|
||
// 5. 组内按图幅二次切分(同一管线组可能由多条互不相连的子网组成，各自成图)
|
||
struct SheetPlan
|
||
{
|
||
CString ref; // PIPELINE-REFERENCE(管号)
|
||
AcDbObjectIdArray ids;
|
||
std::vector<PipeSplit> splits;
|
||
std::vector<WeldRec> welds;
|
||
};
|
||
std::vector<SheetPlan> plans;
|
||
|
||
for (size_t gi = 0; gi < groupOrder.size(); ++gi)
|
||
{
|
||
const CString &sKey = groupOrder[gi];
|
||
const AcDbObjectIdArray &groupIds = groups[sKey];
|
||
|
||
std::vector<NetNode> nodes;
|
||
std::vector<NetJoint> joints;
|
||
std::vector<PipeSplit> splits;
|
||
|
||
// 长直管按 dMaxSpan 预切段，使"长直管中心点"也能成为切点
|
||
buildNetwork(groupIds, dMaxSpan, nodes, joints, splits);
|
||
|
||
// 单张图的限制按组件个数换算到节点个数
|
||
const int nLimit = (nMaxNodes > 0) ? nMaxNodes : 0;
|
||
|
||
std::vector<std::vector<int> > sheets;
|
||
splitBySize(nodes, joints, nLimit, dMaxSpan, sheets);
|
||
|
||
// 节点 -> 图号
|
||
std::vector<int> nodeSheet(nodes.size(), -1);
|
||
for (size_t s = 0; s < sheets.size(); ++s)
|
||
{
|
||
for (size_t t = 0; t < sheets[s].size(); ++t)
|
||
nodeSheet[sheets[s][t]] = (int)s;
|
||
}
|
||
|
||
// 焊口按 A 端所在图归属(两端分属不同图时归 A 端那张，保证全系统只出现一次)
|
||
std::vector<std::vector<WeldRec> > sheetWelds(sheets.size());
|
||
for (size_t j = 0; j < joints.size(); ++j)
|
||
{
|
||
if (!joints[j].bWeld) continue;
|
||
|
||
int s = -1;
|
||
if (joints[j].nA >= 0 && joints[j].nA < (int)nodeSheet.size())
|
||
s = nodeSheet[joints[j].nA];
|
||
if (s < 0 && joints[j].nB >= 0 && joints[j].nB < (int)nodeSheet.size())
|
||
s = nodeSheet[joints[j].nB];
|
||
if (s < 0) continue;
|
||
|
||
WeldRec w;
|
||
w.pt = joints[j].pt;
|
||
w.bore = joints[j].dBore;
|
||
w.idA = nodes[joints[j].nA].id;
|
||
w.idB = nodes[joints[j].nB].id;
|
||
sheetWelds[s].push_back(w);
|
||
}
|
||
|
||
for (size_t s = 0; s < sheets.size(); ++s)
|
||
{
|
||
SheetPlan plan;
|
||
plan.ref = sKey;
|
||
plan.welds = sheetWelds[s];
|
||
|
||
// 节点 -> 组件(去重，保持顺序)
|
||
for (size_t t = 0; t < sheets[s].size(); ++t)
|
||
{
|
||
const NetNode &nd = nodes[sheets[s][t]];
|
||
if (plan.ids.find(nd.id) == -1)
|
||
plan.ids.append(nd.id);
|
||
}
|
||
|
||
// 只保留本图用到的切段(按节点精确对应，避免把别张图的段带进来)
|
||
for (size_t t = 0; t < sheets[s].size(); ++t)
|
||
{
|
||
const int q = nodes[sheets[s][t]].nSplitIdx;
|
||
if (q < 0 || q >= (int)splits.size()) continue;
|
||
if (splits[q].t0 <= 0.0 && splits[q].t1 >= 1.0) continue; // 未切
|
||
plan.splits.push_back(splits[q]);
|
||
}
|
||
|
||
plans.push_back(plan);
|
||
}
|
||
}
|
||
|
||
if (plans.empty())
|
||
{
|
||
acutPrintf(_T("\n没有可导出的分图。"));
|
||
return false;
|
||
}
|
||
|
||
// 6. 生成图号并建立"接图纸"映射：
|
||
// 每个切点两侧各写一条"接图纸 <对方图号>"，方便施工拼图。
|
||
std::vector<CString> sheetCodes;
|
||
for (size_t s = 0; s < plans.size(); ++s)
|
||
{
|
||
CString sCode;
|
||
sCode.Format(_T("ISO-%03d"), (int)(s + 1));
|
||
sheetCodes.push_back(sCode);
|
||
}
|
||
|
||
// 图号 -> 该图包含的组件
|
||
std::vector<std::vector<AcDbObjectId> > sheetIds(plans.size());
|
||
for (size_t s = 0; s < plans.size(); ++s)
|
||
{
|
||
for (int i = 0; i < plans[s].ids.length(); ++i)
|
||
sheetIds[s].push_back(plans[s].ids[i]);
|
||
}
|
||
|
||
// 逐对检查两张图之间是否存在"跨图连接"：A 图某组件的接口位置与 B 图某组件的
|
||
// 接口位置重合即认为这两张图原本是接在一起的，两侧互相写"接图纸"标识。
|
||
// 先把各图的连接点算好，之后只是纯坐标比较，不再反复打开实体。
|
||
std::vector<std::vector<SheetPoint> > sheetPts(plans.size());
|
||
for (size_t s = 0; s < plans.size(); ++s)
|
||
collectSheetPoints(plans[s].ids, sheetPts[s]);
|
||
|
||
std::vector<std::pair<AcDbObjectId, CString> > msgs;
|
||
{
|
||
const double dTol = netTolerance();
|
||
|
||
for (size_t a = 0; a < plans.size(); ++a)
|
||
{
|
||
for (size_t b = 0; b < plans.size(); ++b)
|
||
{
|
||
if (a == b) continue;
|
||
|
||
CString sMsg;
|
||
sMsg.Format(_T("接图纸 %s"), (LPCTSTR)sheetCodes[b]);
|
||
|
||
// 一对图之间可能有好几处切缝，逐处都标，不能只标第一处
|
||
std::vector<AcDbObjectId> hits;
|
||
for (size_t x = 0; x < sheetPts[a].size(); ++x)
|
||
{
|
||
for (size_t y = 0; y < sheetPts[b].size(); ++y)
|
||
{
|
||
if (sheetPts[a][x].pt.distanceTo(sheetPts[b][y].pt) > dTol) continue;
|
||
|
||
const AcDbObjectId &idHit = sheetPts[a][x].id;
|
||
bool bDup = false;
|
||
for (size_t k = 0; k < hits.size(); ++k)
|
||
{
|
||
if (hits[k] == idHit) { bDup = true; break; }
|
||
}
|
||
if (!bDup) hits.push_back(idHit);
|
||
break; // 本连接点已配上，换下一个
|
||
}
|
||
}
|
||
|
||
for (size_t k = 0; k < hits.size(); ++k)
|
||
msgs.push_back(std::make_pair(hits[k], sMsg));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 7. 输出目录
|
||
CString sDir = (pszDir && _tcslen(pszDir) > 0) ? pszDir : _T("");
|
||
if (sDir.IsEmpty())
|
||
{
|
||
CString sPath = makeDefaultPcfPath((LPCTSTR)sSystem);
|
||
const int nPos = sPath.ReverseFind(_T('\\'));
|
||
sDir = (nPos >= 0) ? sPath.Left(nPos) : _T("");
|
||
}
|
||
if (!sDir.IsEmpty() && sDir[sDir.GetLength() - 1] != _T('\\'))
|
||
sDir += _T("\\");
|
||
|
||
// 8. 支吊架(全图收集一次，逐图按空间就近归属)
|
||
std::vector<SupportTarget> targets;
|
||
collectSupportTargets(targets);
|
||
|
||
std::vector<AcDbObjectId> hangers;
|
||
collectPipeHangers(hangers);
|
||
|
||
// 9. 逐图写文件
|
||
CUIISQLiteServer *pDb = new CUIISQLiteServer;
|
||
if (!pDb->InitADOServer(FilePath::GetSysDir() + _T("\\Plumbing.db")))
|
||
{
|
||
AfxMessageBox(_T("数据库驱动加载数据库Plumbing.db失败!将只导出几何骨架。"));
|
||
DELETE_PTR(pDb);
|
||
pDb = NULL;
|
||
}
|
||
|
||
int nOk = 0;
|
||
for (size_t s = 0; s < plans.size(); ++s)
|
||
{
|
||
CString sFile;
|
||
sFile.Format(_T("%s%s_%s.pcf")
|
||
, (LPCTSTR)sDir
|
||
, (LPCTSTR)sheetCodes[s]
|
||
, (LPCTSTR)sanitizeFileName(plans[s].ref));
|
||
|
||
std::ofstream out((LPCTSTR)sFile, std::ios::binary);
|
||
if (!out.good())
|
||
{
|
||
acutPrintf(_T("\n分图 %s 无法写入: %s"), (LPCTSTR)sheetCodes[s], (LPCTSTR)sFile);
|
||
continue;
|
||
}
|
||
|
||
// 本图相关的接图标识
|
||
std::vector<std::pair<AcDbObjectId, CString> > sheetMsgs;
|
||
for (size_t m = 0; m < msgs.size(); ++m)
|
||
{
|
||
for (size_t i = 0; i < sheetIds[s].size(); ++i)
|
||
{
|
||
if (msgs[m].first == sheetIds[s][i])
|
||
{
|
||
sheetMsgs.push_back(msgs[m]);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
PcfSheetCounts c;
|
||
writePcfSheet(out, pDb, (LPCTSTR)plans[s].ref, plans[s].ids, targets, hangers
|
||
, (LPCTSTR)sSystem, &plans[s].splits, &sheetMsgs, &plans[s].welds, c);
|
||
out.close();
|
||
|
||
++nOk;
|
||
acutPrintf(_T("\n %s -> %s (直管 %d, 管件 %d, 阀门/附件 %d, 设备定义 %d, 焊口 %d, 支吊架 %d)")
|
||
, (LPCTSTR)sheetCodes[s], (LPCTSTR)sFile
|
||
, c.nPipeOk, c.nFitOk, c.nEquOk, c.nEquDefOk, c.nWeldOk, c.nSupOk);
|
||
}
|
||
|
||
DELETE_PTR(pDb);
|
||
|
||
acutPrintf(_T("\n自动分图完成: 系统 [%s] 共输出 %d 张图，目录 %s")
|
||
, (LPCTSTR)sSystem, nOk, (LPCTSTR)sDir);
|
||
|
||
return nOk > 0;
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
// 默认输出路径：图纸所在目录\<系统名>.pcf；图纸未保存时退回系统目录
|
||
static CString makeDefaultPcfPath(LPCTSTR pszSystem)
|
||
{
|
||
CString sSys = (pszSystem && _tcslen(pszSystem) > 0) ? pszSystem : _T("PCF");
|
||
CString sPath;
|
||
|
||
const TCHAR *pszDwg = NULL;
|
||
acdbCurDwg()->getFilename(pszDwg);
|
||
if (pszDwg && _tcslen(pszDwg) > 0)
|
||
{
|
||
sPath = pszDwg;
|
||
int nPos = sPath.ReverseFind(_T('\\'));
|
||
if (nPos < 0) nPos = sPath.ReverseFind(_T('/'));
|
||
sPath = (nPos >= 0) ? sPath.Left(nPos + 1) : _T("");
|
||
}
|
||
|
||
if (sPath.IsEmpty())
|
||
sPath = FilePath::GetSysDir() + _T("\\");
|
||
|
||
sPath += sSys;
|
||
sPath += _T(".pcf");
|
||
return sPath;
|
||
}
|
||
|
||
// 命令：按管道系统导出 PCF 中间文件
|
||
// 交互用法：EW_PCF -> 列出系统 -> 输入系统(可空=自动取第一个) -> 输入输出路径(可空=采用默认路径)
|
||
// 非交互用法：EW_PCF + 两次回车，即自动选取第一个系统并导出到默认路径，不会挂起等待输入。
|
||
void EW_PCFCmdFnc()
|
||
{
|
||
// 1. 列出图纸中现有的管道系统，方便选择
|
||
std::vector<CString> systems;
|
||
collectSystems(systems);
|
||
if (!systems.empty())
|
||
{
|
||
acutPrintf(_T("\n图纸中的管道系统共 %d 个:"), (int)systems.size());
|
||
for (size_t k = 0; k < systems.size(); ++k)
|
||
acutPrintf(_T("\n [%d] %s"), (int)(k + 1), (LPCTSTR)systems[k]);
|
||
}
|
||
else
|
||
{
|
||
acutPrintf(_T("\n未找到管道系统(PIPE_PSYSTEM)，将无法导出。"));
|
||
}
|
||
|
||
// 2. 输入系统(可空=自动取第一个)
|
||
TCHAR szSys[256] = { 0 };
|
||
if (acedGetString(FALSE, _T("\n请输入管道系统<直接回车=自动选取第一个>: "), szSys) != RTNORM)
|
||
return;
|
||
CString sSystem = szSys;
|
||
|
||
// 留空时直接取第一个系统，便于默认文件名带上系统名
|
||
if (sSystem.IsEmpty() && !systems.empty())
|
||
sSystem = systems[0];
|
||
|
||
// 3. 输出路径：先算出默认值并显示，直接回车即采用默认，避免非交互调用时挂起等待
|
||
CString sDef = makeDefaultPcfPath(sSystem.IsEmpty() ? NULL : (LPCTSTR)sSystem);
|
||
CString sPrompt;
|
||
sPrompt.Format(_T("\n请输入输出的PCF文件完整路径<直接回车采用默认: %s>: "), (LPCTSTR)sDef);
|
||
|
||
TCHAR szFile[512] = { 0 };
|
||
if (acedGetString(FALSE, sPrompt, szFile) != RTNORM)
|
||
return;
|
||
CString sFile = szFile;
|
||
if (sFile.IsEmpty())
|
||
sFile = sDef;
|
||
|
||
// 4. 导出
|
||
LPCTSTR pszSys = sSystem.IsEmpty() ? NULL : (LPCTSTR)sSystem;
|
||
if (PCF::makePCF(sFile, pszSys))
|
||
acutPrintf(_T("\nPCF导出成功: %s"), (LPCTSTR)sFile);
|
||
else
|
||
acutPrintf(_T("\nPCF导出失败!请检查管道系统下是否存在 管道/管件/设备。"));
|
||
}
|
||
|
||
// 命令：自动分图 —— 把一个管道系统自动拆成多张 ISO 图(每张图一个 PCF 文件)
|
||
// 拆分规则见 PCF::makePCFSplit()。全部提示直接回车即采用默认值，便于非交互调用。
|
||
void EW_PCFSPLITCmdFnc()
|
||
{
|
||
// 1. 列出图纸中现有的管道系统
|
||
std::vector<CString> systems;
|
||
collectSystems(systems);
|
||
if (!systems.empty())
|
||
{
|
||
acutPrintf(_T("\n图纸中的管道系统共 %d 个:"), (int)systems.size());
|
||
for (size_t k = 0; k < systems.size(); ++k)
|
||
acutPrintf(_T("\n [%d] %s"), (int)(k + 1), (LPCTSTR)systems[k]);
|
||
}
|
||
else
|
||
{
|
||
acutPrintf(_T("\n未找到管道系统(PIPE_PSYSTEM)，将无法分图。"));
|
||
}
|
||
|
||
// 2. 管道系统
|
||
TCHAR szSys[256] = { 0 };
|
||
if (acedGetString(FALSE, _T("\n请输入要分图的管道系统<直接回车=自动选取第一个>: "), szSys) != RTNORM)
|
||
return;
|
||
CString sSystem = szSys;
|
||
if (sSystem.IsEmpty() && !systems.empty())
|
||
sSystem = systems[0];
|
||
|
||
// 3. 单张图最大组件数(超过则继续切分)
|
||
TCHAR szNum[64] = { 0 };
|
||
if (acedGetString(FALSE, _T("\n请输入单张图最大组件数<直接回车=60，0=不限制>: "), szNum) != RTNORM)
|
||
return;
|
||
int nMaxNodes = 60;
|
||
if (_tcslen(szNum) > 0) nMaxNodes = _ttoi(szNum);
|
||
|
||
// 4. 单张图最大空间跨度(超过则在长直管中点继续切分)
|
||
TCHAR szSpan[64] = { 0 };
|
||
if (acedGetString(FALSE, _T("\n请输入单张图最大空间跨度<直接回车=0，表示不限制>: "), szSpan) != RTNORM)
|
||
return;
|
||
double dMaxSpan = 0.0;
|
||
if (_tcslen(szSpan) > 0) dMaxSpan = _ttof(szSpan);
|
||
|
||
// 5. 输出目录：默认取图纸所在目录
|
||
CString sDefDir;
|
||
{
|
||
CString sDef = makeDefaultPcfPath(sSystem.IsEmpty() ? NULL : (LPCTSTR)sSystem);
|
||
const int nPos = sDef.ReverseFind(_T('\\'));
|
||
sDefDir = (nPos >= 0) ? sDef.Left(nPos) : _T("");
|
||
}
|
||
|
||
CString sPrompt;
|
||
sPrompt.Format(_T("\n请输入分图输出目录<直接回车=图纸所在目录: %s>: "), (LPCTSTR)sDefDir);
|
||
TCHAR szDir[512] = { 0 };
|
||
if (acedGetString(FALSE, sPrompt, szDir) != RTNORM)
|
||
return;
|
||
CString sDir = szDir;
|
||
if (sDir.IsEmpty()) sDir = sDefDir;
|
||
|
||
// 6. 分图导出
|
||
LPCTSTR pszSys = sSystem.IsEmpty() ? NULL : (LPCTSTR)sSystem;
|
||
if (PCF::makePCFSplit(sDir, pszSys, nMaxNodes, dMaxSpan))
|
||
acutPrintf(_T("\n自动分图完成。"));
|
||
else
|
||
acutPrintf(_T("\n自动分图失败!请检查管道系统下是否存在 管道/管件/设备。"));
|
||
}
|