From 2b0c2055ff5a79cf794926fd5946f8f2a69d1a9b Mon Sep 17 00:00:00 2001 From: DESKTOP-8BA9KEAgjm Date: Sat, 3 Oct 2026 22:20:08 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E7=AE=A1=E9=81=93ISO?= =?UTF-8?q?=E5=9B=BEPCF=E5=AF=BC=E5=87=BA(EW=5FPCF/EW=5FPCFSPLIT)=EF=BC=8C?= =?UTF-8?q?=E5=AE=8C=E5=96=84ITEM-CODE=E4=B8=8EWELD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CoreCommand 新增管道 ISO 图 PCF 导出功能： - EW_PCF：整个管道系统导出为单个 PCF 文件。 - EW_PCFSPLIT：按管道系统/连通子网拆分为多张 PCF。 内容完善： - 组件齐全：直管、管件(弯头/三通/变径/管帽等)、法兰、阀门、设备、支吊架。 - ITEM-CODE：按 等级+管径(+类型/类别) 查规格库，写出 ITEM-CODE/ITEM-DESCRIPTION/PIPING-SPEC； 弯头按实测夹角区分 90°/45°，阀门按 VLVTYPE 映射类别过滤。 - WELD：两侧接口连接类型均为焊接(0) 时生成焊口；法兰螺栓面不计焊口。 构建：cmakelists.txt 加入 pcf.cpp；StdArx.h 声明 EW_PCF/EW_PCFSPLIT 命令。 --- CODEBUDDY.md | 150 + SourceCode/Code2026/CoreCommand/EarthWorm.cpp | 6 + SourceCode/Code2026/CoreCommand/StdArx.h | 2 + .../Code2026/CoreCommand/cmakelists.txt | 1 + SourceCode/Code2026/CoreCommand/pcf.cpp | 2800 +++++++++++++++-- SourceCode/Code2026/CoreCommand/pcf.h | 25 + iso需求讨论.txt | 6 + 7 files changed, 2734 insertions(+), 256 deletions(-) create mode 100644 CODEBUDDY.md create mode 100644 iso需求讨论.txt diff --git a/CODEBUDDY.md b/CODEBUDDY.md new file mode 100644 index 0000000..c0028fe --- /dev/null +++ b/CODEBUDDY.md @@ -0,0 +1,150 @@ +# CODEBUDDY.md + +This file provides guidance to CodeBuddy Code when working with code in this repository. + +> 另见 `ai.memory/`：随仓库提交的跨机器项目记忆（概览 / 构建 / 模块 / 工作日志 / 约定）。开始工作前建议先阅读。本文件与其保持一致，冲突时以 `ai.memory/` 与当前构建脚本为准。 + +## 项目概览 + +- **产品**：上海华软 **Envi3D 2026（环境设计）** —— CAD/BIM **机电(MEP)插件套件**。 +- **形态**：ObjectARX / ZRX 插件（DLL，后缀 `.arx` / `.zrx`），运行在 CAD 宿主内，含大量 MFC 界面与自定义图元实体。 +- **CMake 项目名**：`SHS_Code2026`（version 1.0.0）。 +- **主代码目录**：`SourceCode/Code2026/`（C++ 约 2888 `.cpp` + 3104 `.h`；另有天正 `tg_shs/` 系列库）。 +- **远端**：`origin` = `ssh://gjm@47.93.46.28:1216/srv/git/new-start.git`，主分支 `main`。提交信息用中文。 + +目标平台（由 preset 与编译宏区分）： + +| 平台 | SDK | 版本 | 对应 CAD | +| --- | --- | --- | --- | +| AutoCAD | ObjectARX | R18 ~ R26 | CAD 2010 ~ 2027 | +| 中望CAD | ZRX | Z2023 ~ Z2026 | ZWCAD 2023 ~ 2026 | + +## 构建 + +**统一使用 CMake，不再使用 Visual Studio 工程文件（`.vcxproj` / `.sln` 已全部删除）。唯一例外：`SourceCode/Code2026/StartApp/StartApp.sln`（C# 启动器，独立于 CMake）。** + +所有构建命令均在 `SourceCode/Code2026/` 目录下执行（preset 与 `cmakepresets.json` 同目录）： + +```bash +cd SourceCode/Code2026 + +# 配置 + 编译（示例：AutoCAD 2025-2026） +cmake --preset R250 +cmake --build --preset R250 + +# 只构建单个目标（例如某个模块） +cmake --build --preset R250 --target HvacCmd +``` + +- 要求 CMake ≥ 3.21；生成器固定 `Visual Studio 18 2026`，架构 `x64`。 +- 工具集（toolset）由 preset 指定，随 CAD 版本变化：`v143 / v142 / v141 / v140 / v110 / v100 / v90`。 +- C++ 标准自动切换：ARX 26 → C++20；ARX 20~25 与 ZRX → C++14；ARX 20 → C++03；更老 → C++98。 +- 输出目录：`bin/Code2026/{Debug|Release}-x64-<标签>` 与 `lib/Code2026/...`，标签形如 `R250` / `Z2026`。 +- Debug 构建会通过 post-build 调用 `copyarx.exe`，按 `sh_output_path.json`（ACAD）/ `zw_output_path.json`（中望）把产物部署到 `c:\ShangHuaSoft\Envi3D-2026-M`。 + +### 预设（`SourceCode/Code2026/cmakepresets.json`，共 13 套） + +| 分组 | preset | +| --- | --- | +| AutoCAD | `R180 R190 R200 R210 R220 R230 R240 R243 R250 R260` | +| 中望CAD | `Z2023 Z2024 Z2025 Z2026` | + +关键 cache 变量：`CAD_SDK_ROOT`（`arx/` 或 `zrx/`）、`DEP_LIB_ROOT`/`DEP_INC_ROOT`（`../dep_lib` / `../dep_inc`）、`PRODUCT=ENV_2025_V6_S0`、`TRIAL_YEAR=2026`、`GENERATE_BIN_DIR`/`GENERATE_LIB_DIR`。 + +### 顶层聚合目标 + +- `Build_TG` → `wfA wfB wfS wfAnotate wfoutdoor` +- `Build_SH_CORE` → `AecRxBase` + `CoreCommand_TRIAL_YEAR` + `CoreCommand_BAL_REMOTE` +- `Build_SH_GLOBAL` → `MFCCtrl sqliteserver AdsXRx ThunderProof` + +### 批量编译与打包（`autoCompile/WF2026/`） + +- `batch_build.bat` → 调用 `cmake_batch_build.py` 批量编译多个 preset。 +- 打包脚本：Inno Setup（`*.iss`）+ Python（`SHSCompile.py`）+ 多个 `.bat`，覆盖 ACAD/中望、1 年期/加密版，以及客户专版（中广核、国能集团等）。如 `环境设计-ACAD-加密自动打包.bat`、`环境设计-中望-1年期自动打包.bat`。 + +### CMake 构建体系（`cmake/`） + +- `cmake/functions.cmake`：核心封装 + - `add_custom_module(dir folder)`：注册子模块（自动 `add_subdirectory` + 设 FOLDER）；`add_custom_module_2(dir target folder)` 用于目录名≠目标名的情况。 + - `target_link_objectarx(target EXT)`：链接 CAD SDK、全局头 `ShsGlobalIncludes`、定义 `CMAKE` 与 `ARX=<版本>`。 + - `simple_link_cad_sdk`：按 `IsZWCAD()` 自动选择 `ThirdParty::ARX` / `ThirdParty::ZRX`。 + - `set_encryption_definitions_and_output_path(target MODE)`：**授权模式**，见下。 + - `set_debug_post_build`：调用 `copyarx.exe` 部署。 +- `cmake/ThirdPartyDeps.cmake`：定义 `ThirdParty::ARX` / `ZRX` / `SQLite3` / `cURL` / `TG` / `modernGlue` / `BitAnswer` 等接口目标；按 SDK 版本条件追加库（如 `acdrawbridge` 需 >19，`acpal`/`acgeoment` 需 >23）。 +- 顶层 `cmakelists.txt`：`add_custom_module` 注册全部模块并组织 `FOLDER`（`SH/Core`、`SH/Pipe` …）。 + +## 授权 / 加密 + +- `CoreCommand`、`CoreLibrary` 通过 `get_encryption_modes()` 由**同一套源码编译出两个目标**： + - `BAL_REMOTE`（网络锁 / 正式版） + - `TRIAL_YEAR`（1 年期试用版，定义 `TRIAL_YEAR=<年份>`） +- 依赖 **BitAnswer**（加密狗库）；加密表由 `utility/generateEncryptionTable` 生成。 + +## 架构 + +分三层： + +1. **实体层**：`CoreLibrary` 定义海量自定义图元 `AecDbXxx`（继承 `AcDbEntity`），是数据模型核心；同时含绘图/分解/布尔等基础能力。 +2. **命令层**：各 `*Cmd` 模块实现 MFC 对话框 + Jig 交互 + ARX 命令注册。 +3. **链接关系**：业务模块 → `AecRxBase` / `CoreCommand` / `sqliteserver` / `MFCCtrl`。 + +模块在顶层 `cmakelists.txt` 中按 FOLDER 分组： + +| FOLDER | 模块 | 职责 | +| --- | --- | --- | +| `SH/Global_Libraries` | `MFCCtrl`, `sqliteserver` | MFC 控件库；SQLite 数据服务 | +| `SH/ThunderProof` | `AdsXRx`, `ThunderProof` | 防雷接地设计 | +| `SH/Core` | `AecRxBase`, `CoreImplement`, `CoreLibrary`, `CoreCommand` | 核心基类、自定义实体、主命令 | +| `SH/Pipe` | `PipelineCmd`, `PipelineSpecCmd`, `PIDLineCmd`, `ISODraft`, `PipeHanger`, `PlumbingCmd`, `Pool3dCmd` | 管道/工艺/ISO 图/支吊架/给排水/水池 | +| `SH/Structures` | `ArchCmd`, `ElecCmd`, `HvacCmd`, `SPLDCmd` | 建筑/电气/暖通/道路 | +| `SH/Other` | `shsTK`, `Dimension`, `EarthWormMain`, `EarthWormCmd` | 通用工具、标注、主程序 | +| `TG/*` | `tg_shs/*` | 天正系列库 | + +关键模块： + +- **CoreLibrary**：数据模型核心（自定义实体 `AecDbXxx`）。 +- **AecRxBase**：ARX 基类库（`AecDbEntityBase`、`AecDbCurveBase`、Grip、双击编辑等）。 +- **CoreCommand**：主命令集 + MFC 主界面/面板（BIM 面板、AI 助手面板等）；**生成两种加密版本**。 +- **CoreImplement**：仅在 Debug 下有效（自定义实体的实现层）。 +- **StartApp**：C# (.NET WinForms) 启动器，不走 CMake，保留独立 `StartApp.sln`。 +- **tg_shs/**：天正系列（`shs_kernal`/wfK、`shs_twtkernal`/wfKernal、`shs_GeLib`、`shs_annotate`/wfA、`shs_twtanotate`/wfAnnotate、`shs_blklib`/wfB、`shs_siteplan`/wfS、`shs_pipewire`/wfpipew、`shs_outdoor`/wfoutdoor、`shs_ximage/*` 图像库、`shs_dbf`、`shs_sqlite` 等）。 + +## 目录结构 + +``` +envi-code/ +├── Arx/ # AutoCAD ObjectARX SDK（R19.0~R26.0，gitignore） +├── ZRX/ # 中望 ZRX SDK（Z2023~Z2026，gitignore） +├── SourceCode/ +│ ├── dep_inc/ # 第三方头：modernGlue、rapidjson、curl +│ ├── dep_lib/ # 第三方库：modernGlue、pub(含 sqlite3/BitAnswer) +│ └── Code2026/ # ★ 主代码 + cmakelists.txt + cmakepresets.json + cmake/ +├── bin/, lib/ # 编译产物（按 SDK 版本分子目录，gitignore） +├── cmake_output/ # CMake 生成目录（gitignore） +├── autoCompile/ # 打包/加密/发布脚本（.bat/.py/.iss） +├── utility/ # generateEncryptionTable（授权加密表生成） +└── ai.memory/ # 跨机器项目记忆 +``` + +## 新增模块约定 + +在模块目录放 `CMakeLists.txt`，并在顶层 `SourceCode/Code2026/cmakelists.txt` 用 `add_custom_module(<相对目录> )` 注册。模块 `CMakeLists.txt` 参考 `HvacCmd/CMakeLists.txt`： + +```cmake +add_library( SHARED ${SOURCES}) +add_def_file_name(SOURCES "") +target_set_name_and_suffix( "" ".arx") +target_link_objectarx( ) +set_debug_post_build( "" ".arx") +``` + +需要授权双版本时，参考 `CoreCommand/cmakelists.txt` 的 `get_encryption_modes` + `foreach(MODE ...)` + `set_encryption_definitions_and_output_path` 写法。 + +## 平台差异与注意事项 + +- 用 `IsZWCAD()` 判断目标平台；ZRX 产物后缀自动变 `.zrx`，链接 `ThirdParty::ZRX`；ARX 链接 `ThirdParty::ARX`。 +- 编译宏：`ARX=<版本号>` 或 `ZWCAD`。 +- **源码编码为 GBK/ANSI（无 BOM）**：新增或修改的 `.cpp/.h` 必须保存为 GBK。若存成 UTF-8，MSVC 会按 GBK 误读其中的中文，导致 `C2001: newline in constant`（中文全角标点如 `。` 紧跟字符串结尾引号时尤其容易触发）。提交前可用 `python -c "open('f.cpp','rb').read().decode('gbk')"` 校验。 +- 部分库仅在特定 SDK 版本可用（如 `acdrawbridge` 需 >19，`acpal`/`acgeoment` 需 >23），已在 `ThirdPartyDeps.cmake` 处理。 +- **禁止**新增或依赖 `.vcxproj` / `.sln`（`StartApp` 除外）。`cmake_output/` 下 CMake 生成的临时 `*.vcxproj` 是构建产物、已被 gitignore，**不要**误提交。 +- `.gitignore` 忽略：`Arx/`、`cmake_output/`、`bin/`、`lib/`，以及 `*.obj/*.pdb/*.user/.vs/` 等 VS 中间产物。 diff --git a/SourceCode/Code2026/CoreCommand/EarthWorm.cpp b/SourceCode/Code2026/CoreCommand/EarthWorm.cpp index 7849045..e156c99 100644 --- a/SourceCode/Code2026/CoreCommand/EarthWorm.cpp +++ b/SourceCode/Code2026/CoreCommand/EarthWorm.cpp @@ -722,6 +722,12 @@ void InitApplication() ADD_CMD(EW_DWGO, EW_PDWGOUTCmdFnc); ADD_CMD(EW_IGSO, EW_IGSOUTCmdFnc); + //ISOͼ: ߺŵ PCF мļ + ADD_CMD(EW_PCF, EW_PCFCmdFnc); + + //ISOͼ: Զͼ(ܺ/ͨ/ͼһܵϵͳɶ PCF) + ADD_CMD(EW_PCFSPLIT, EW_PCFSPLITCmdFnc); + // ADD_CMD(EW_GLMY, EW_GLMYCmdFnc); diff --git a/SourceCode/Code2026/CoreCommand/StdArx.h b/SourceCode/Code2026/CoreCommand/StdArx.h index d32e80b..9cddae7 100644 --- a/SourceCode/Code2026/CoreCommand/StdArx.h +++ b/SourceCode/Code2026/CoreCommand/StdArx.h @@ -128,6 +128,8 @@ void EW_STLOUTCmdFnc(); void EW_SALOUTCmdFnc(); void EW_PDWGOUTCmdFnc(); void EW_IGSOUTCmdFnc(); +void EW_PCFCmdFnc(); +void EW_PCFSPLITCmdFnc(); void EW_GLMYCmdFnc(); void EW_ENODECmdFnc(); void EW_CTRLVIEWCmdFnc(); diff --git a/SourceCode/Code2026/CoreCommand/cmakelists.txt b/SourceCode/Code2026/CoreCommand/cmakelists.txt index 90630b0..26941ed 100644 --- a/SourceCode/Code2026/CoreCommand/cmakelists.txt +++ b/SourceCode/Code2026/CoreCommand/cmakelists.txt @@ -99,6 +99,7 @@ set(SOURCES "aecuicontextmenu.cpp" "sortedmenuitemdlg.cpp" "collisiondetection.cpp" + "pcf.cpp" "EarthWorm.rc" # CoreCommand.def ) diff --git a/SourceCode/Code2026/CoreCommand/pcf.cpp b/SourceCode/Code2026/CoreCommand/pcf.cpp index 68d22f6..2bb9d46 100644 --- a/SourceCode/Code2026/CoreCommand/pcf.cpp +++ b/SourceCode/Code2026/CoreCommand/pcf.cpp @@ -7,9 +7,11 @@ #include "aecdbewfitting.h" #include "aecdbewequipment.h" #include "aecdbxequipment.h" +#include "aecdbpipehanger.h" #include #include #include +#include using namespace std; @@ -19,9 +21,9 @@ namespace typedef pair STR_PAIR; typedef map STR_MAP; - // 定义属性字符串，避免直接输入造成笔误，用到那个，定义哪个 + // ֱַɱõǸĸ // ========================================== - // 1. 基础单位 (Units) + // 1. λ (Units) // ========================================== STR_PTR PCF_UNITS_MM = L"MM"; STR_PTR PCF_UNITS_METER = L"METER"; @@ -37,7 +39,7 @@ namespace STR_PTR PCF_UNITS_LBFT = L"LBFT"; // ========================================== - // 2. 全局头部属性 (Header Attributes) + // 2. ȫͷ (Header Attributes) // ========================================== STR_PTR PCF_HEAD_ISOGEN_FILES = L"ISOGEN-FILES"; STR_PTR PCF_HEAD_UNITS_BORE = L"UNITS-BORE"; @@ -52,7 +54,7 @@ namespace STR_PTR PCF_HEAD_SYSTEM_IDENTIFIER = L"SYSTEM-IDENTIFIER"; // ========================================== - // 3. 组件主类型 (Component Types) - 增加前缀 COMP_ 以防命名冲突 + // 3. (Component Types) - ǰ׺ COMP_ Էͻ // ========================================== STR_PTR PCF_COMP_PIPE = L"PIPE"; STR_PTR PCF_COMP_ELBOW = L"ELBOW"; @@ -65,13 +67,39 @@ namespace 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"BLIND-FLANGE"; + 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) + // 4. ڵ (Point Types) // ========================================== STR_PTR PCF_PT_END_POINT = L"END-POINT"; STR_PTR PCF_PT_CENTRE_POINT = L"CENTRE-POINT"; @@ -80,7 +108,7 @@ namespace STR_PTR PCF_PT_CO_ORDS = L"CO-ORDS"; // ========================================== - // 5. 组件明细与业务属性 (Component Attributes) + // 5. ϸҵ (Component Attributes) // ========================================== STR_PTR PCF_ATTR_SKEY = L"SKEY"; STR_PTR PCF_ATTR_ITEM_CODE = L"ITEM-CODE"; @@ -98,7 +126,7 @@ namespace { public: private: - ostream &m_out; // 统一使用窄字符流基类！ + ostream &m_out; // ͳһʹխַ࣡ bool m_isFirstItem; public: @@ -110,7 +138,7 @@ namespace ~PcfRow() { m_out << "\n"; } - // 1. 基础类型模板 (如 int, double, AcGePoint3d) + // 1. ģ ( int, double, AcGePoint3d) template PcfRow &operator<<(const T &value) { @@ -120,19 +148,19 @@ namespace return *this; } - // 3. 核心升级：拦截 AutoCAD 宽字符 (处理带中文的描述信息) + // 3. AutoCAD ַ (ĵϢ) PcfRow &operator<<(STR_PTR wValue) { if (!m_isFirstItem) m_out << " "; - // 自动转为 UTF-8 并推入底层字节流 + // ԶתΪ 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) @@ -146,15 +174,15 @@ namespace 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 + if (attri && svalue && wcslen(attri) > 0 && wcslen(svalue) > 0) PcfRow(out, indent) << attri << svalue; } @@ -168,7 +196,8 @@ namespace { std::wstringstream wss; wss << fixed << setprecision(prec) << v; - return makePair(field, wss.str()); + // ʽ std::pairƥ䵽ģ޵ݹ(C4717) + return std::make_pair(std::wstring(field), wss.str()); } wstring getValue(STR_MAP mm, STR_PTR key) @@ -179,53 +208,169 @@ namespace return L""; } - // level 等级 - // 通过 level在 AecSpecname 里面查询 行业 - // 通过 等级、行业在table内查询 fileds - bool getSpecFieldByLevel(CUIISQLiteServer *pDb - , STR_PTR table - , STR_PTR level - , const STR_MAP &filter - , STR_MAP &results) + // ============================ ()ѯ ============================ + + // Ϸȼ(ȡ AecSpecname)ʵרҵﷴ"ȼ" + // ֻһΡ + const std::set &validLevels(CUIISQLiteServer *pDb) { - if (!pDb || !level || !table || !filter.empty()) return false; + static std::set s_levels; + static bool s_bLoaded = false; - std::wstringstream wss; - wss << L"SELECT *" - << L" FROM "<< table << L" t" - << L" INNER JOIN AecSpecname a" - << L" ON t.[项目名称] = a.[项目名称]" - << L" AND t.[等级名称] = a.[等级名称]" - << L" WHERE a.[等级名称] = '" << level << L"'"; - - STR_MAP::const_iterator itF(filter.begin()); - for (; itF != filter.end(); ++itF) + if (!s_bLoaded && pDb) { - wss << L" AND t.["<< itF->first << L"] = '" << itF->second << L"'"; + 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(); } - - map res; - pDb->GetSelData(wss.str().c_str(), res); - - map::const_iterator itR(res.begin()); - for (; itR != res.end(); ++itR) - { - results.insert(make_pair(itR->first, itR->second)); - } - - return !results.empty(); + return s_levels; } /* - pcf 文件头 + "ȼ" + ȶ PIPE_LEVEL("Level")Ϊʱɨרҵȫֵַ + AecSpecname ĺϷȼá + + ʵͼֽ PIPE_LEVEL Ϊ(뷧ʱ command.cpp:18836 ) + ĵȼЧģԱ㶵ף ITEM-CODE Զ鲻 */ - bool pcf_begin(std::ostream &out, STR_PTR pipeline_reference - , STR_PTR spec + 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 &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 > &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 > &filters + , std::vector > &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 > &filters + , std::map &row) + { + std::vector > rows; + if (!querySpecRows(pDb, pszTable, sLevel, filters, rows) || rows.empty()) return false; + + row = rows[0]; + return true; + } + + // ӹȡһ(Сдǰո) + CString specField(const std::map &row, LPCTSTR pszCol) + { + CString sWant(pszCol ? pszCol : _T("")); + sWant.Trim(); + + for (std::map::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 &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 bolt_dia = PCF_UNITS_MM , STR_PTR weight = PCF_UNITS_KGS ) { @@ -236,216 +381,765 @@ namespace 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; - PcfRow(out, 4) << PCF_HEAD_PIPING_SPEC << spec; return true; } + /* + ģͿռ䣬ռ ܵ/ܼ/豸 ObjectId ܵϵͳ(PIPE_SYS) + ܵϵͳʵרҵΪ PIPE_SYS + */ + void collectComponents(std::vector &ids, std::vector &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 &out) + { + out.clear(); + + std::vector ids; + std::vector 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 allIds; + std::vector 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 (直管) + * [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) : 预制/现场安装标识。不带值（直接写属性名），表示这是一根工厂预制管。 + * ǰܵû (ITEM-CODE)Ҫֶβһιܵ + * * 1. ﷨ԱֶΣιǼܣ + * - END-POINT (): ܵռά (X, Y, Z) ö˵Ĺֱ + * - END-POINT (յ): ܵռյά (X, Y, Z) ö˵Ĺֱ + * *壺˵㣬֮仭һߡǵߡ* + * * 2. ǿҽ鲹ֶΣΪ BOM Ϊգ + * - ITEM-DESCRIPTION : Ҫϵı L"DZ깤ֱ" BOM ֱӴӡ仰 + * - WALL-THICKNESS : ںֲֵ鿴 Navisworksܾ+ںʵĹܵ⾶ܻửϸߡ + * - MATERIAL-IDENTIFIER : ʣ L"CS" L"̼"νйܵӦ + * - FABRICATION-ITEM ( ERECTION-ITEM) : Ԥ/ֳװʶֱֵдʾһԤƹܡ * ================================================================================= */ - // 处理普通管道，非法兰管道 + // ͨܵǷܵ - wstring getItemCode(AecDbEwPipe *pPipe) + // ֱܹѯ ȼ + ֱ AecSpecPipe в//ȼ + bool getPipeSpecRow(CUIISQLiteServer *pDb, const CString &sLevel, const double &dn + , std::map &row) { - return L""; + std::vector > filters; + filters.push_back(std::make_pair(CString(_T("ֱ")), dnText(dn))); + return querySpecRow(pDb, _T("AecSpecPipe"), sLevel, filters, row); } - wstring getDescription(AecDbEwPipe *pPipe) + // ȡֵרҵݣݴΪ double / ַ / + // ʵⲿͼֽ PIPE_DN / PIPE_THICK ַ( "450") + // ֻ double ȡʧܣֱܱĬ + template + bool getNumericValue(T *pEnt, LPCTSTR pszKey, double &dVal) { - return L""; + 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; } - bool getPipeSpecInfo( CUIISQLiteServer *pDb - , STR_PTR level - , const double &dn - , STR_MAP &results) - { - map mm; - mm.insert(makePair(_T("公称直径"), dn)); - return getSpecFieldByLevel(pDb, L"aecspecpipe", level, mm, results); - } - - bool pcf_pipe_normal(CUIISQLiteServer *pDb, AecDbEwPipe *pPipe, std::ostream &out) + // 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 = pPipe->StartPoint(); - AcGePoint3d ptEnd = pPipe->EndPoint(); + AcGePoint3d ptStart = pStart ? *pStart : pPipe->StartPoint(); + AcGePoint3d ptEnd = pEnd ? *pEnd : pPipe->EndPoint(); + // ֱȶרҵ(ַ)˻ PipeParam double bore(.0); - if (!pPipe->GetAt(PIPE_DN, bore)) return false; + 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 (!pPipe->GetAt(PIPE_THICK, thickness)) return false; + if (!getNumericValue(pPipe, PIPE_THICK, thickness) || thickness <= 0.0) + { + WPipe::PipeParam *pParam = pPipe->GetPipeParam(); + if (pParam) thickness = pParam->m_dThick; + } - CString level(_T("")); - pPipe->GetAt(PIPE_LEVEL, level); + // ȼȶ PIPE_LEVELΪʱרҵﷴϷȼ + AecDbObjXDataMap *pMap = pPipe->GetSpecialtyData(AcDb::kForRead); + const CString level = resolveLevel(pMap, pDb); - // 写入组件主类标 (顶格，无缩进) + // д () PcfRow(out, 0) << PCF_COMP_PIPE; - // 写入起止坐标与管径 (必须紧跟在 PIPE 后面，缩进 4 格) + // дֹܾ ( PIPE 棬 4 ) PcfRow(out, 4) << PCF_PT_END_POINT << ptStart << bore; PcfRow(out, 4) << PCF_PT_END_POINT << ptEnd << bore; - // 写入壁厚，保证在没有item-code和piping-spec时能够正常显示 - PcfRow(out, 4) << PCF_ATTR_WALL_THICKNESS << thickness; + // дں񣬱֤ûitem-codepiping-specʱܹʾ + if (thickness > 0.0) + PcfRow(out, 4) << PCF_ATTR_WALL_THICKNESS << thickness; - // 等级管线 + // ȼ -> -> / / ȼ if (!level.IsEmpty()) { - STR_MAP mm; - getPipeSpecInfo(pDb, level, bore, mm); - - // 物料码 - writePcfAttribute(out, 4, PCF_ATTR_ITEM_CODE, getValue(mm, L"元件代码").c_str()); - - // 物料描述 - writePcfAttribute(out, 4, PCF_ATTR_ITEM_DESCRIPTION, getValue(mm, L"描述").c_str()); - - // 等级信息 - writePcfAttribute(out, 4, PCF_HEAD_PIPING_SPEC, getValue(mm, L"等级名称").c_str()); - } - else - { - + std::map row; + if (getPipeSpecRow(pDb, level, bore, row)) + writeSpecAttributes(out, row); } - // 预制管件 + // Ԥƹܼ PcfRow(out, 4) << PCF_ATTR_FABRICATION_ITEM; - out << L"\n"; + out << "\n"; return true; } - bool pcf_ewEquipment(CUIISQLiteServer *pDb, AecDbEwEquipment *pEqu, std::ostream &out) - { return false; } + // ============================ Phase 2: ܼ ============================ - bool pcf_xEquipment(CUIISQLiteServer *pDb, AecDbXEquipment *pXEqu, std::ostream &out) - { return false; } - - bool pcf_Elbow(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_ReduceElbow(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Tee(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Cross(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Wye(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Reduce(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Lateral(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Flange(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Wcap(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_FlxJoin(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_Through(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)//直通 - {return false;} - - bool pcf_UJoin(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)//活接 - {return false;} - - bool pcf_RJoin(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)//缩接 - {return false;} - - bool pcf_OJoin(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) //外螺纹接头 - {return false;} - - bool pcf_IJoin(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) //内螺纹接头 - {return false;} - - bool pcf_RP(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)//补强圈 - {return false;} - - bool pcf_HP(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)//半管接头 - {return false;} - - bool pcf_SPB(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out)//八字盲板 - {return false;} - - bool pcf_Gastket(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) - {return false;} - - bool pcf_fitting(CUIISQLiteServer *pDb, AecDbEwFitting *pFit, std::ostream &out) + // ȡܼijӿڵĹܾȽӿ dSize1ȱʧʱ˻عܼ + double fitInfBore(AecDbEwFitting *pFit, const AecInterface &inf, int nInf) { - if (!pFit || !pDb) return false; + double d = inf.dSize1; + if (d <= 0.0 && pFit) + { + WPipe::PipeParam *pParam = pFit->GetPipeParam(nInf); + if (pParam) d = pParam->m_dDN; + } + return d; + } - int nType(0); - if (!pFit->GetAt(KEY_RUNTIME, nType)) - return false; + // ܼںרҵ(ַ)˻عܼ + 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 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 &names) + { + names.clear(); switch (nType) { case eElbow: - return pcf_Elbow(pDb, pFit, out); case eReduceElbow: - return pcf_ReduceElbow(pDb, pFit, out); - case eTee: - return pcf_Tee(pDb, pFit, out); - case eCross: - return pcf_Cross(pDb, pFit, out); - case eWye: - return pcf_Wye(pDb, pFit, out); + // ͷ 90/45 getFitSpecRow ﰴʵнǵУֻкѡ + names.push_back(_T("ͷ")); + names.push_back(_T("90ͷ")); + names.push_back(_T("45ͷ")); + break; case eReduce: - return pcf_Reduce(pDb, pFit, out); + 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: - return pcf_Lateral(pDb, pFit, out); - case eFlange: - return pcf_Flange(pDb, pFit, out); + case eWye: + names.push_back(_T("бͨ")); + names.push_back(_T("ͨ")); + break; case eWcap: - return pcf_Wcap(pDb, pFit, out); - case eFlxJoin: - return pcf_FlxJoin(pDb, pFit, out); - case eThrough://直通 - return pcf_Through(pDb, pFit, out); - case eUJoin://活接 - return pcf_UJoin(pDb, pFit, out); - case eRJoin://缩接 - return pcf_RJoin(pDb, pFit, out); - case eOJoin: //外螺纹接头 - return pcf_OJoin(pDb, pFit, out); - case eIJoin: //内螺纹接头 - return pcf_IJoin(pDb, pFit, out); - case eRP://补强圈 - return pcf_RP(pDb, pFit, out); - case eHP://半管接头 - return pcf_HP(pDb, pFit, out); - case eSPB://八字盲板 - return pcf_SPB(pDb, pFit, out); - case eGastket: - return pcf_Gastket(pDb, pFit, out); + 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 &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 > rows; + const LPCTSTR aNames[3] = { _T("ͷ"), _T("90ͷ"), _T("45ͷ") }; + for (int i = 0; i < 3; ++i) + { + std::vector > filters; + filters.push_back(std::make_pair(CString(_T("ֱ")), dnText(dn))); + filters.push_back(std::make_pair(CString(_T("")), CString(aNames[i]))); + std::vector > part; + if (querySpecRows(pDb, pszTable, sLevel, filters, part)) + rows.insert(rows.end(), part.begin(), part.end()); + } + if (rows.empty()) + { + std::vector > 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 names; + fitTypeCandidates(nType, pFit, names); + + for (size_t k = 0; k < names.size(); ++k) + { + std::vector > 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 > filters; + filters.push_back(std::make_pair(CString(_T("ֱ")), dnText(dn))); + if (querySpecRow(pDb, pszTable, sLevel, filters, row)) + return true; + } + + // 鲻ʱ˻عܼһ + if (bFlange) + { + std::vector > 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 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 &arInfs + , const std::vector &bores, STR_PTR compType, bool bCentre, double &dBore) + { + if (!out.good() || arInfs.isEmpty()) return false; + + // nLevel (򣬽ӿ) + std::vector 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 arInfs; + if (!pFit->GetInterface(arInfs) || arInfs.isEmpty()) return false; + + std::vector 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 row; + bool bFound = false; + if (pszCat && *pszCat) + { + std::vector > 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 arInfs; + if (!pEqu->GetInterface(arInfs) || arInfs.isEmpty()) return false; + + std::vector 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 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; } @@ -453,76 +1147,1670 @@ namespace 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 &arInfs, AcGePoint3d &a, AcGePoint3d &b) + { + if (arInfs.isEmpty()) return false; + + std::vector 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 &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 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 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 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 &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 &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 + 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; + } + + // EFittingTypeDZ -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 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) {} + }; + + // ֮ DZе / + 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; + } + + // ֱij(/յ)Ľӿͣӿݲʱ -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; + } + + // ֱij˵Ľӿڹܾ + 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 &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 &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 &nodes, std::vector &joints + , std::vector &pipeSplits) + { + nodes.clear(); + joints.clear(); + pipeSplits.clear(); + + for (int i = 0; i < ids.length(); ++i) + { + AcDbObjectPointer 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 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 ptI; + nodeConnPoints(nodes[i], ptI); + + for (size_t k = i + 1; k < nodes.size(); ++k) + { + std::vector 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; + + // 棺һǷܼijһӿڱǷ(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 &nets) + { + nets.clear(); + if (ids.isEmpty()) return; + + std::vector nodes; + std::vector joints; + std::vector splits; + buildNetwork(ids, 0.0, nodes, joints, splits); + + const int n = (int)nodes.size(); + if (n <= 0) return; + + // 鼯ӿغϼΪͬһ + std::vector 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 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::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; + } + + /* + ȡһͨ"ܺ"ڳִķǿչܺš + /಻ܺŵ˻ڵߣ + DZֳȥȡʱ˻ϵͳ + */ + CString dominantKey(const AcDbObjectIdArray &ids, LPCTSTR pszKey, LPCTSTR pszDefault) + { + CString sDefault(pszDefault ? pszDefault : _T("")); + if (!pszKey || _tcslen(pszKey) == 0) return sDefault; + + std::map hist; + for (int i = 0; i < ids.length(); ++i) + { + AcDbObjectPointer 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::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 &nodes, const std::vector &joints + , int nMaxNodes, double dMaxSpan, std::vector > &sheets) + { + sheets.clear(); + + const int n = (int)nodes.size(); + if (n <= 0) return; + + // ڽӱnode -> (ھ, joint ±) + std::vector > > 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 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 order; // ˳ + std::vector entry; // order[k] õ jointorder[0] = -1 + std::vector 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(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 + END-POINT x y z + 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 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 *pSplits + , const std::vector > *pMsgs + , const std::vector *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 hit; + + for (int i(0); i < ids.length(); ++i) + { + const AcDbObjectId &id(ids[i]); + + AcDbObjectPointer 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 &hangers + , const std::vector &targets, int &nSup, int &nSupOk) + { + nSup = nSupOk = 0; + + for (size_t k(0); k < hangers.size(); ++k) + { + AcDbObjectPointer 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 &targets + , const std::vector &hangers + , LPCTSTR pszSupportSys + , const std::vector *pSplits + , const std::vector > *pMsgs + , const std::vector *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 > &hists) + { + const int nKeys = (int)(sizeof(g_pszNoKeys) / sizeof(g_pszNoKeys[0])); + hists.assign(nKeys, std::map()); + + for (int i = 0; i < ids.length(); ++i) + { + AcDbObjectPointer 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 &pts) + { + pts.clear(); + + for (int i = 0; i < ids.length(); ++i) + { + NetNode nd; + if (!readNode(ids[i], nd)) continue; + + std::vector 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 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 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; + } + } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// 对外只暴露这一个接口 -// pszSystem代表管道系统，可以通过这个参数得到此系统下的所有管道、管件、设备，并输出到pcf +// Ĭ·(ʵļĩβ) +static CString makeDefaultPcfPath(LPCTSTR pszSystem); + +// ֻ¶һӿ +// ܵϵͳ(pszSystem)õϵͳµ ܵ/ܼ/豸 pcf ļ bool PCF::makePCF(LPCTSTR pszFile, LPCTSTR pszSystem) { - CString dbPath(FilePath::GetSysDir() + _T("\\Plumbing.db")); + if (!pszFile || _tcslen(pszFile) == 0) + return false; + // δָܵϵͳʱͼֽгֵйܵϵͳȡһ + CString sSystem; + if (pszSystem && _tcslen(pszSystem) > 0) + { + sSystem = pszSystem; + } + else + { + std::vector 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(dbPath)) + 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()) { - AfxMessageBox(_T("数据库驱动加载数据库Plumbing.db失败!")); DELETE_PTR(pDb); return false; } - AcDbObjectIdArray ids; - // 得到 pszSystem 的所有管道、管件、设备 - // GetComponentBySystem(pszSystem, ids); + // ֧ܰռͽȱùõ + std::vector targets; + collectSupportTargets(targets); - if (ids.isEmpty()) return false; + std::vector hangers; + collectPipeHangers(hangers); -#ifdef NDEBUG - std::ofstream stream(pszFile, std::ios::binary); -#else - std::stringstream stream; -#endif - - pcf_begin(stream, L"P-1", L"sch40"); - - for (int i(0); i < ids.length(); ++i) + // ڣϵͳһ磬ȡкӽͷ(ӿͶ"") + std::vector welds; { - AcDbObjectId &id(ids[i]); + std::vector nodes; + std::vector joints; + std::vector splits; + buildNetwork(ids, 0.0, nodes, joints, splits); - AcDbObjectPointer pObj(id, AcDb::kForRead); - if (pObj.openStatus() != Acad::eOk) continue; + for (size_t j = 0; j < joints.size(); ++j) + { + if (!joints[j].bWeld) continue; - if (pObj->isA() == AecDbEwPipe::desc()) - { - AecDbEwPipe *pPipe = AecDbEwPipe::cast(pObj.object()); - pcf_pipe_normal(pDb, pPipe, stream); - } - else if (pObj->isA() == AecDbEwFitting::desc()) - { - AecDbEwFitting *pFit = AecDbEwFitting::cast(pObj.object()); - pcf_fitting(pDb, pFit, stream); - } - else if (pObj->isA() == AecDbEwEquipment::desc()) - { - AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pObj.object()); - pcf_ewEquipment(pDb, pEqu, stream); - } - else if (pObj->isA() == AecDbXEquipment::desc()) - { - AecDbXEquipment *pXEqu = AecDbXEquipment::cast(pObj.object()); - pcf_xEquipment(pDb, pXEqu, stream); + 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); } } -#ifndef NDEBUG - std::ofstream outFile(pszFile, std::ios::out | std::ios::binary); - if (outFile.is_open()) - { - outFile << stream.str(); - outFile.close(); - } -#endif + // ͷ(λ) + 豸 + + + + ֧ + 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 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 > 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::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 nets; + splitNetByConnectivity(ids, nets); + + std::map groups; + std::vector 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 splits; + std::vector welds; + }; + std::vector plans; + + for (size_t gi = 0; gi < groupOrder.size(); ++gi) + { + const CString &sKey = groupOrder[gi]; + const AcDbObjectIdArray &groupIds = groups[sKey]; + + std::vector nodes; + std::vector joints; + std::vector splits; + + // ֱܰ dMaxSpan ԤжΣʹ"ֱĵ"ҲܳΪе + buildNetwork(groupIds, dMaxSpan, nodes, joints, splits); + + // ͼư㵽ڵ + const int nLimit = (nMaxNodes > 0) ? nMaxNodes : 0; + + std::vector > sheets; + splitBySize(nodes, joints, nLimit, dMaxSpan, sheets); + + // ڵ -> ͼ + std::vector 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 > 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 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 > 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 ͼijĽӿλ B ͼij + // ӿλغϼΪͼԭǽһģ໥д"ͼֽ"ʶ + // ȰѸͼӵãֻ֮ǴȽϣٷʵ塣 + std::vector > sheetPts(plans.size()); + for (size_t s = 0; s < plans.size(); ++s) + collectSheetPoints(plans[s].ids, sheetPts[s]); + + std::vector > 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 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 targets; + collectSupportTargets(targets); + + std::vector 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 > 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 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("\nPCFļ·<ֱӻسĬ: %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 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뵥ͼ<ֱӻس=600=>: "), 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Զͼʧ!ܵϵͳǷ ܵ/ܼ/豸")); +} diff --git a/SourceCode/Code2026/CoreCommand/pcf.h b/SourceCode/Code2026/CoreCommand/pcf.h index da49198..7e0edef 100644 --- a/SourceCode/Code2026/CoreCommand/pcf.h +++ b/SourceCode/Code2026/CoreCommand/pcf.h @@ -1,6 +1,31 @@ #pragma once +// PCF (Piping Component File) +// ǰ׶Σܵϵͳռ ܵ/ܼ/豸 PCF мļ +// Isogen / isoAlgo / ISO ͼʹá class PCF { +public: + // ܵϵͳ(PIPE_PSYSTEM) PCF ļ + // pszFile : .pcf ļ· + // pszSystem : ܵϵͳӦʵרҵ PIPE_SYS + // (NULL մ)ʱԶѡȡͼֽеĵһܵϵͳ static bool makePCF(LPCTSTR pszFile, LPCTSTR pszSystem); + + // Զͼһܵϵͳɶ ISO ͼÿͼһ PCF ļ + // + // ֹ(רҵͼ) + // 1) Ȱ"ܺ"飬ͬһܺŹһ(ܺȡʱϵͳΪһ) + // 2) ڰܵͨ(ӿ)ٲͨ + // 3) Գ nMaxNodes ռȳ dMaxSpan + // عۼʱ˵"е"У + // е = (eFlange) > ֳ(ܼ) > ͨӿ + // ֻ֮ĽӿڴУ˾ͷ/ͨڲ + // 4) ÿе໥д"ͼֽ <Էͼ>"Ľʶʩƴͼ + // + // pszDir : Ŀ¼ʱͼֽĿ¼ + // pszSystem : ܵϵͳʱȡͼֽеһܵϵͳ + // nMaxNodes : ͼ<=0 ʾ + // dMaxSpan : ͼռ(ͼֽλ)<=0 ʾ + static bool makePCFSplit(LPCTSTR pszDir, LPCTSTR pszSystem, int nMaxNodes, double dMaxSpan); }; diff --git a/iso需求讨论.txt b/iso需求讨论.txt new file mode 100644 index 0000000..261c27d --- /dev/null +++ b/iso需求讨论.txt @@ -0,0 +1,6 @@ +现在需要在corecommand工程添加一个新功能:管道的ISO图,具体你可以参考网络上的isogen软件. +这个功能最主要的是实现isoAlgo (piping Isometric Algorithm) 算法. 现在国内的pipeCAD实现了一个 isoAlgo算法. +我现在有方案: +1.自己开发isoalgo算法,结合现有的管道系统,实现iso图功能 +2.把管道,管件,设备数据,保存为 pcf 文件,用 AutoCAD Plant 3D 内的 PNPIso.exe 来生成.据说这个exe可以免费用. +你的看法是什么? \ No newline at end of file