872a68d5be
新增功能:
- 添加SaveResult结构体用于保存操作结果
- 实现CreoManager::SaveModel()方法，使用OTK pfcModel::Save() API
- 添加SaveModelHandler HTTP路由处理器
- 注册/api/model/save接口支持POST请求
技术特性:
- 简化设计：只保存当前模型到原位置，无复杂另存为逻辑
- 完善的OTK异常处理：支持BadInputs、GeneralError、InvalidName等
- 标准JSON API格式：返回文件大小、保存时间、软件信息等
- 与现有架构完全兼容：不影响任何现有功能
API使用:
POST /api/model/save
请求: {"software_type": "creo"}
响应: 包含file_size、save_time、software、original_file等信息
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
2183 lines
101 KiB
C++
2183 lines
101 KiB
C++
#include "pch.h"
|
||
#include "CreoManager.h"
|
||
#include <wfcAssembly.h>
|
||
#include <pfcBase.h>
|
||
#include <pfcGlobal.h>
|
||
#include <pfcExport.h>
|
||
#include <pfcModel.h>
|
||
#include <pfcAssembly.h>
|
||
#include <pfcFeature.h>
|
||
#include <pfcSolid.h>
|
||
#include <wfcSolid.h>
|
||
#include <wfcFeatureInstructions.h>
|
||
#include <stdcols.h>
|
||
#include <ctime>
|
||
#include <sstream>
|
||
#include <iomanip>
|
||
#include <fstream>
|
||
#include <windows.h>
|
||
#include <vector>
|
||
#include <map>
|
||
#include <string>
|
||
#include <set>
|
||
#include <cstdlib>
|
||
#include <algorithm>
|
||
#include <functional>
|
||
#include <cmath>
|
||
|
||
// 防止Windows宏冲突
|
||
#ifdef max
|
||
#undef max
|
||
#endif
|
||
#ifdef min
|
||
#undef min
|
||
#endif
|
||
|
||
|
||
// 构造函数：简化实现
|
||
CreoManager::CreoManager() {
|
||
// 配置设置可能需要通过config.pro文件或其他方式
|
||
// 暂时移除代码中的配置设置
|
||
}
|
||
|
||
CreoManager& CreoManager::Instance() {
|
||
static CreoManager instance;
|
||
return instance;
|
||
}
|
||
|
||
CreoStatus CreoManager::GetCreoStatus() {
|
||
CreoStatus status;
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
|
||
status.is_connected = sessionInfo.is_valid;
|
||
status.version = sessionInfo.version;
|
||
status.build = sessionInfo.build;
|
||
|
||
if (sessionInfo.is_valid) {
|
||
// 获取工作目录
|
||
try {
|
||
xstring workdir = sessionInfo.session->GetCurrentDirectory();
|
||
status.working_directory = XStringToString(workdir);
|
||
}
|
||
catch (...) {
|
||
status.working_directory = "Failed to get working directory";
|
||
}
|
||
status.session_id = 1;
|
||
} else {
|
||
status.working_directory = "Failed to connect to Creo";
|
||
status.session_id = 0;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
ModelStatus CreoManager::GetModelStatus() {
|
||
ModelStatus status;
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
|
||
if (!sessionInfo.is_valid) {
|
||
return status;
|
||
}
|
||
|
||
try {
|
||
pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
|
||
if (current_model) {
|
||
status.has_model = true;
|
||
|
||
// 获取模型名称和文件名
|
||
try {
|
||
xstring name_xstr = current_model->GetFileName();
|
||
status.name = XStringToString(name_xstr);
|
||
status.filename = status.name;
|
||
}
|
||
catch (...) {
|
||
status.name = "Failed to get model name";
|
||
status.filename = "Failed to get filename";
|
||
}
|
||
|
||
// 获取模型类型
|
||
try {
|
||
pfcModelType model_type = current_model->GetType();
|
||
switch (model_type) {
|
||
case pfcMDL_PART:
|
||
status.type = "Part";
|
||
status.is_assembly = false;
|
||
break;
|
||
case pfcMDL_ASSEMBLY:
|
||
status.type = "Assembly";
|
||
status.is_assembly = true;
|
||
break;
|
||
case pfcMDL_DRAWING:
|
||
status.type = "Drawing";
|
||
status.is_assembly = false;
|
||
break;
|
||
default:
|
||
status.type = "";
|
||
status.is_assembly = false;
|
||
break;
|
||
}
|
||
}
|
||
catch (...) {
|
||
status.type = "Failed to get model type";
|
||
status.is_assembly = false;
|
||
}
|
||
|
||
// 获取模型文件大小（装配体统计所有零件和子装配体的总大小）
|
||
try {
|
||
if (status.is_assembly) {
|
||
// 装配体：统计所有组件的文件大小
|
||
status.file_size = CalculateAssemblyTotalSize(current_model);
|
||
} else {
|
||
// 单个零件：直接获取文件大小
|
||
status.file_size = GetModelFileSize(current_model);
|
||
}
|
||
}
|
||
catch (...) {
|
||
status.file_size = "Exception getting file size";
|
||
}
|
||
|
||
// 获取真实的零件数量和装配体层级
|
||
if (status.is_assembly) {
|
||
try {
|
||
wfcWAssembly_ptr wAssembly = wfcWAssembly::cast(current_model);
|
||
if (wAssembly) {
|
||
// 获取所有显示的组件
|
||
wfcWComponentPaths_ptr components = wAssembly->ListDisplayedComponents();
|
||
if (components) {
|
||
status.total_parts = components->getarraysize();
|
||
} else {
|
||
status.total_parts = 0;
|
||
}
|
||
status.assembly_levels = SafeCalculateAssemblyLevels(wAssembly);
|
||
} else {
|
||
status.total_parts = 0;
|
||
status.assembly_levels = 0;
|
||
}
|
||
}
|
||
catch (...) {
|
||
status.total_parts = 0;
|
||
status.assembly_levels = 0;
|
||
}
|
||
} else {
|
||
// 非装配体（零件）的真实数据
|
||
status.total_parts = 1;
|
||
status.assembly_levels = 1;
|
||
}
|
||
|
||
// 解析软件信息
|
||
std::string full_version = sessionInfo.version;
|
||
size_t space_pos = full_version.find(" ");
|
||
if (space_pos != std::string::npos) {
|
||
status.software = full_version.substr(0, space_pos);
|
||
status.version = full_version.substr(space_pos + 1);
|
||
} else {
|
||
status.software = "Failed to parse software name";
|
||
status.version = "Failed to parse version";
|
||
}
|
||
|
||
// 设置其他信息
|
||
status.connection_time = GetCurrentTimeString();
|
||
status.open_time = status.connection_time;
|
||
status.connection_status = "Connected";
|
||
}
|
||
}
|
||
catch (...) {
|
||
status.has_model = false;
|
||
status.name = "Failed to access model";
|
||
status.filename = "Failed to access model";
|
||
status.type = "Failed to access model";
|
||
status.is_assembly = false;
|
||
status.total_parts = 0;
|
||
status.assembly_levels = 0;
|
||
status.software = "Failed to access model";
|
||
status.version = "Failed to access model";
|
||
status.connection_time = "Failed to get time";
|
||
status.open_time = "Failed to get time";
|
||
status.connection_status = "Failed to get status";
|
||
status.file_size = "Failed to access model";
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
bool CreoManager::ShowMessage(const std::string& message) {
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
|
||
if (!sessionInfo.is_valid) {
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
xstring msg_xstr = StringToXString(message);
|
||
sessionInfo.wSession->UIShowMessageDialog(msg_xstr, NULL);
|
||
return true;
|
||
}
|
||
catch (...) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
std::string CreoManager::XStringToString(const xstring& xstr) {
|
||
try {
|
||
std::wstring wstr(xstr);
|
||
if (wstr.empty()) {
|
||
return "";
|
||
}
|
||
|
||
// 使用WideCharToMultiByte进行正确的UTF-8编码转换
|
||
int size_needed = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.length(), NULL, 0, NULL, NULL);
|
||
if (size_needed <= 0) {
|
||
return "";
|
||
}
|
||
|
||
std::string result(size_needed, 0);
|
||
WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.length(), &result[0], size_needed, NULL, NULL);
|
||
return result;
|
||
}
|
||
catch (...) {
|
||
return "";
|
||
}
|
||
}
|
||
|
||
xstring CreoManager::StringToXString(const std::string& str) {
|
||
try {
|
||
if (str.empty()) {
|
||
return xstring();
|
||
}
|
||
|
||
// 使用MultiByteToWideChar进行正确的UTF-8解码转换
|
||
int size_needed = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), NULL, 0);
|
||
if (size_needed <= 0) {
|
||
return xstring();
|
||
}
|
||
|
||
std::wstring wstr(size_needed, 0);
|
||
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), &wstr[0], size_needed);
|
||
return xstring(wstr.c_str());
|
||
}
|
||
catch (...) {
|
||
return xstring();
|
||
}
|
||
}
|
||
|
||
std::string CreoManager::GetCurrentTimeString() {
|
||
std::time_t now = std::time(nullptr);
|
||
std::tm* local_tm = std::localtime(&now);
|
||
|
||
std::ostringstream oss;
|
||
oss << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S");
|
||
return oss.str();
|
||
}
|
||
|
||
std::string CreoManager::GetCurrentTimeStringISO() {
|
||
std::time_t now = std::time(nullptr);
|
||
std::tm* utc_tm = std::gmtime(&now);
|
||
|
||
std::ostringstream oss;
|
||
oss << std::put_time(utc_tm, "%Y-%m-%dT%H:%M:%S");
|
||
oss << ".000000Z"; // 添加微秒和UTC标识
|
||
return oss.str();
|
||
}
|
||
|
||
CreoManager::SessionInfo CreoManager::GetSessionInfo() {
|
||
SessionInfo info;
|
||
info.is_valid = false;
|
||
|
||
try {
|
||
info.session = pfcGetCurrentSessionWithCompatibility(pfcC4Compatible);
|
||
if (info.session) {
|
||
info.wSession = wfcWSession::cast(info.session);
|
||
if (info.wSession) {
|
||
// 获取版本信息
|
||
int version_num = info.wSession->GetReleaseNumericVersion();
|
||
xstring date_code = info.wSession->GetDisplayDateCode();
|
||
|
||
// 尝试获取真实的软件名称
|
||
std::string software_name = "Creo"; // 基础名称，如果无法获取更详细的名称
|
||
|
||
std::ostringstream version_str;
|
||
version_str << software_name << " " << version_num << ".0";
|
||
info.version = version_str.str();
|
||
info.build = XStringToString(date_code);
|
||
info.is_valid = true;
|
||
} else {
|
||
info.version = "Failed to get version";
|
||
info.build = "Failed to get build";
|
||
}
|
||
} else {
|
||
info.version = "Failed to connect to Creo";
|
||
info.build = "Failed to connect to Creo";
|
||
}
|
||
}
|
||
catch (...) {
|
||
info.version = "Failed to get version";
|
||
info.build = "Failed to get build";
|
||
}
|
||
|
||
return info;
|
||
}
|
||
|
||
std::string CreoManager::GetFileSize(const std::string& filepath) {
|
||
try {
|
||
if (filepath.empty()) {
|
||
return "Empty filepath";
|
||
}
|
||
|
||
// 复用现有的字符串转换逻辑
|
||
xstring xpath = StringToXString(filepath);
|
||
std::wstring wpath(xpath);
|
||
|
||
WIN32_FILE_ATTRIBUTE_DATA fileInfo;
|
||
if (GetFileAttributesExW(wpath.c_str(), GetFileExInfoStandard, &fileInfo)) {
|
||
LARGE_INTEGER size;
|
||
size.HighPart = fileInfo.nFileSizeHigh;
|
||
size.LowPart = fileInfo.nFileSizeLow;
|
||
|
||
double file_size_mb = static_cast<double>(size.QuadPart) / (1024.0 * 1024.0);
|
||
|
||
std::ostringstream oss;
|
||
oss << std::fixed << std::setprecision(1) << file_size_mb << "MB";
|
||
return oss.str();
|
||
} else {
|
||
DWORD error = GetLastError();
|
||
std::ostringstream oss;
|
||
oss << "File access failed (Error: " << error << ") Path: " << filepath;
|
||
return oss.str();
|
||
}
|
||
}
|
||
catch (...) {
|
||
return "Exception in GetFileSize";
|
||
}
|
||
}
|
||
|
||
int CreoManager::SafeCalculateAssemblyLevels(wfcWAssembly_ptr assembly) {
|
||
try {
|
||
if (!assembly) {
|
||
return 1;
|
||
}
|
||
|
||
// 使用ComponentPath分析装配体层级深度
|
||
wfcWComponentPaths_ptr components = assembly->ListDisplayedComponents();
|
||
if (!components) {
|
||
return 1;
|
||
}
|
||
|
||
int component_count = components->getarraysize();
|
||
if (component_count == 0) {
|
||
return 1;
|
||
}
|
||
|
||
int max_level = 1;
|
||
// 移除组件数量限制，检查所有组件
|
||
|
||
for (int i = 0; i < component_count; i++) {
|
||
try {
|
||
wfcWComponentPath_ptr comp_path = components->get(i);
|
||
if (comp_path) {
|
||
// 使用GetComponentIds获取组件路径
|
||
xintsequence_ptr ids = comp_path->GetComponentIds();
|
||
if (ids) {
|
||
// 路径深度就是装配体层级
|
||
int path_depth = ids->getarraysize();
|
||
if (path_depth > max_level) {
|
||
max_level = path_depth;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (...) {
|
||
// 跳过有问题的组件
|
||
continue;
|
||
}
|
||
}
|
||
|
||
return max_level;
|
||
|
||
}
|
||
catch (...) {
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
std::string CreoManager::GetModelFileSize(pfcModel_ptr model) {
|
||
try {
|
||
if (!model) {
|
||
return "0.0MB";
|
||
}
|
||
|
||
// 先检查模型是否可以安全调用GetDescr
|
||
try {
|
||
pfcModelDescriptor_ptr descr = model->GetDescr();
|
||
if (!descr) {
|
||
return "0.0MB";
|
||
}
|
||
} catch (...) {
|
||
// 如果GetDescr失败，可能是轻量级模型，尝试其他方法
|
||
try {
|
||
xstring origin = model->GetOrigin();
|
||
std::string origin_str = XStringToString(origin);
|
||
if (!origin_str.empty()) {
|
||
return GetFileSize(origin_str);
|
||
}
|
||
} catch (...) {
|
||
// 所有方法都失败，返回默认值
|
||
return "0.0MB";
|
||
}
|
||
return "0.0MB";
|
||
}
|
||
|
||
// 使用origin路径获取文件大小
|
||
try {
|
||
xstring origin = model->GetOrigin();
|
||
std::string origin_str = XStringToString(origin);
|
||
if (!origin_str.empty()) {
|
||
return GetFileSize(origin_str);
|
||
}
|
||
} catch (...) {
|
||
return "0.0MB";
|
||
}
|
||
|
||
return "0.0MB";
|
||
}
|
||
catch (...) {
|
||
return "0.0MB";
|
||
}
|
||
}
|
||
|
||
double CreoManager::ParseMBFromSizeString(const std::string& size_str) {
|
||
try {
|
||
if (size_str.find("MB") != std::string::npos) {
|
||
size_t mb_pos = size_str.find("MB");
|
||
std::string size_num = size_str.substr(0, mb_pos);
|
||
return std::stod(size_num);
|
||
}
|
||
return 0.0;
|
||
}
|
||
catch (...) {
|
||
return 0.0;
|
||
}
|
||
}
|
||
|
||
std::string CreoManager::CalculateAssemblyTotalSize(pfcModel_ptr model) {
|
||
try {
|
||
wfcWAssembly_ptr assembly = wfcWAssembly::cast(model);
|
||
if (!assembly) {
|
||
return "Not an assembly";
|
||
}
|
||
|
||
double total_size_bytes = 0;
|
||
int processed_count = 0;
|
||
|
||
// 首先添加主装配体文件大小
|
||
std::string main_size = GetModelFileSize(model);
|
||
double main_mb = ParseMBFromSizeString(main_size);
|
||
if (main_mb > 0) {
|
||
total_size_bytes += main_mb * 1024 * 1024;
|
||
processed_count++;
|
||
}
|
||
|
||
// 使用ListDisplayedComponents获取组件（保持原有逻辑）
|
||
wfcWComponentPaths_ptr components = assembly->ListDisplayedComponents();
|
||
if (components) {
|
||
int component_count = components->getarraysize();
|
||
|
||
for (int i = 0; i < component_count; i++) {
|
||
try {
|
||
wfcWComponentPath_ptr comp_path = components->get(i);
|
||
if (comp_path) {
|
||
pfcSolid_ptr leaf_solid = comp_path->GetLeaf();
|
||
if (leaf_solid) {
|
||
pfcModel_ptr comp_model = pfcModel::cast(leaf_solid);
|
||
if (comp_model) {
|
||
std::string comp_size = GetModelFileSize(comp_model);
|
||
double comp_mb = ParseMBFromSizeString(comp_size);
|
||
if (comp_mb > 0) {
|
||
total_size_bytes += comp_mb * 1024 * 1024;
|
||
processed_count++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (...) {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 转换为MB并返回
|
||
double total_mb = total_size_bytes / (1024.0 * 1024.0);
|
||
std::ostringstream oss;
|
||
oss << std::fixed << std::setprecision(1) << total_mb << "MB (from " << processed_count << " files)";
|
||
return oss.str();
|
||
|
||
}
|
||
catch (...) {
|
||
return "Exception in CalculateAssemblyTotalSize";
|
||
}
|
||
}
|
||
|
||
ExportResult CreoManager::ExportModelToSTEP(const std::string& export_path, const std::string& geom_flags) {
|
||
ExportResult result;
|
||
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
|
||
if (!sessionInfo.is_valid) {
|
||
result.error_message = "Creo session not available";
|
||
return result;
|
||
}
|
||
|
||
try {
|
||
pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
|
||
if (!current_model) {
|
||
result.error_message = "No current model loaded";
|
||
return result;
|
||
}
|
||
|
||
// 检查导出路径是否有效
|
||
if (export_path.empty()) {
|
||
result.error_message = "Invalid export path";
|
||
return result;
|
||
}
|
||
|
||
// 检查模型类型是否支持导出
|
||
pfcModelType model_type = current_model->GetType();
|
||
if (model_type != pfcMDL_PART && model_type != pfcMDL_ASSEMBLY) {
|
||
result.error_message = "Model type not supported for export";
|
||
return result;
|
||
}
|
||
|
||
// 创建几何导出标志
|
||
pfcGeomExportFlags_ptr geometryFlags = pfcGeomExportFlags::Create();
|
||
|
||
// 创建STEP导出指令
|
||
pfcSTEPExportInstructions_ptr exportInstructions =
|
||
pfcSTEPExportInstructions::Create(geometryFlags);
|
||
|
||
// 执行导出 - 使用xrstring类型
|
||
xrstring export_path_xrstr = export_path.c_str();
|
||
current_model->Export(export_path_xrstr, pfcExportInstructions::cast(exportInstructions));
|
||
|
||
// 检查导出文件是否存在（使用Windows API）
|
||
WIN32_FILE_ATTRIBUTE_DATA fileInfo;
|
||
if (GetFileAttributesExA(export_path.c_str(), GetFileExInfoStandard, &fileInfo)) {
|
||
result.success = true;
|
||
result.export_path = export_path;
|
||
result.file_size = GetFileSize(export_path);
|
||
result.format = "step";
|
||
result.export_time = GetCurrentTimeStringISO();
|
||
result.software = "Creo Parametric";
|
||
|
||
// 获取原始文件信息
|
||
try {
|
||
xstring name_xstr = current_model->GetFileName();
|
||
result.original_file = XStringToString(name_xstr);
|
||
} catch (...) {
|
||
result.original_file = "Unknown";
|
||
}
|
||
|
||
// 解析目录和文件名
|
||
size_t last_slash = export_path.find_last_of("\\/");
|
||
if (last_slash != std::string::npos) {
|
||
result.dirname = export_path.substr(0, last_slash);
|
||
result.filename = export_path.substr(last_slash + 1);
|
||
} else {
|
||
result.dirname = "";
|
||
result.filename = export_path;
|
||
}
|
||
|
||
} else {
|
||
result.error_message = "Export file not created";
|
||
}
|
||
|
||
}
|
||
catch (...) {
|
||
result.error_message = "Export operation failed";
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// 保存模型功能实现
|
||
SaveResult CreoManager::SaveModel() {
|
||
SaveResult result;
|
||
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
|
||
if (!sessionInfo.is_valid) {
|
||
result.error_message = "Creo session not available";
|
||
return result;
|
||
}
|
||
|
||
try {
|
||
pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
|
||
if (!current_model) {
|
||
result.error_message = "No current model loaded";
|
||
return result;
|
||
}
|
||
|
||
// 获取文件信息
|
||
xstring original_name = current_model->GetFileName();
|
||
result.original_file = XStringToString(original_name);
|
||
result.software = "Creo Parametric";
|
||
|
||
// 执行保存操作
|
||
current_model->Save();
|
||
|
||
// 设置成功结果
|
||
result.save_time = GetCurrentTimeStringISO();
|
||
result.file_size = GetModelFileSize(current_model);
|
||
result.success = true;
|
||
|
||
}
|
||
catch (const pfcXToolkitBadInputs&) {
|
||
result.error_message = "Bad input parameters";
|
||
}
|
||
catch (const pfcXToolkitGeneralError&) {
|
||
result.error_message = "Creo toolkit error";
|
||
}
|
||
catch (const pfcXToolkitInvalidName&) {
|
||
result.error_message = "Invalid file name";
|
||
}
|
||
catch (const pfcXToolkitCantWrite&) {
|
||
result.error_message = "Cannot write to file";
|
||
}
|
||
catch (const pfcXToolkitCantOpen&) {
|
||
result.error_message = "Cannot open file";
|
||
}
|
||
catch (const std::exception& e) {
|
||
result.error_message = "Standard error: " + std::string(e.what());
|
||
}
|
||
catch (...) {
|
||
result.error_message = "Unknown error during save operation";
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// 层级分析主方法
|
||
HierarchyAnalysisResult CreoManager::AnalyzeModelHierarchy(const HierarchyAnalysisRequest& request) {
|
||
HierarchyAnalysisResult result;
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
|
||
if (!sessionInfo.is_valid) {
|
||
result.error_message = "Creo session not available";
|
||
return result;
|
||
}
|
||
|
||
try {
|
||
pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
|
||
if (!current_model) {
|
||
result.error_message = "No current model loaded";
|
||
return result;
|
||
}
|
||
|
||
// 检查是否为装配体
|
||
if (current_model->GetType() != pfcMDL_ASSEMBLY) {
|
||
result.error_message = "Current model is not an assembly";
|
||
return result;
|
||
}
|
||
|
||
// 转换为装配体
|
||
wfcWAssembly_ptr assembly = wfcWAssembly::cast(current_model);
|
||
if (!assembly) {
|
||
result.error_message = "Failed to cast model to assembly";
|
||
return result;
|
||
}
|
||
|
||
// 初始化结果（SOTA算法）
|
||
result.project_name = request.project_name.empty() ?
|
||
XStringToString(current_model->GetFileName()) : request.project_name;
|
||
result.total_levels = 0;
|
||
result.total_components = 0;
|
||
result.hierarchy.clear();
|
||
|
||
// 创建根装配体组件信息
|
||
ComponentInfo root_component;
|
||
|
||
// 获取根装配体文件名
|
||
try {
|
||
xstring filename_xstr = current_model->GetFileName();
|
||
root_component.id = XStringToString(filename_xstr);
|
||
} catch (...) {
|
||
try {
|
||
xstring origin = current_model->GetOrigin();
|
||
std::string origin_str = XStringToString(origin);
|
||
size_t pos = origin_str.find_last_of("/\\");
|
||
if (pos != std::string::npos) {
|
||
root_component.id = origin_str.substr(pos + 1);
|
||
} else {
|
||
root_component.id = origin_str;
|
||
}
|
||
} catch (...) {
|
||
root_component.id = "root_assembly.asm";
|
||
}
|
||
}
|
||
|
||
// 设置根装配体属性
|
||
root_component.name = root_component.id;
|
||
root_component.type = "assembly";
|
||
root_component.level = 0;
|
||
root_component.path = root_component.id;
|
||
root_component.full_path = root_component.id;
|
||
root_component.file_size = GetModelFileSize(current_model);
|
||
root_component.deletion_safety = "forbidden";
|
||
root_component.is_visible = true;
|
||
root_component.model_type = "MDL_ASSEMBLY";
|
||
root_component.children_count = 0; // 将在递归后计算
|
||
|
||
// 初始化层级0并添加根装配体
|
||
result.hierarchy.push_back(std::vector<ComponentInfo>());
|
||
result.hierarchy[0].push_back(root_component);
|
||
|
||
// 使用新的SOTA递归算法分析子组件（从层级1开始）
|
||
AnalyzeAssemblyNode(assembly, 1, root_component.name, root_component.path, result);
|
||
|
||
// 计算根装配体的children_count
|
||
if (result.hierarchy.size() > 1) {
|
||
result.hierarchy[0][0].children_count = result.hierarchy[1].size();
|
||
}
|
||
|
||
// 计算最终统计
|
||
result.total_levels = result.hierarchy.size();
|
||
|
||
// 计算总组件数（从所有层级统计）
|
||
result.total_components = 0;
|
||
for (const auto& level : result.hierarchy) {
|
||
result.total_components += level.size();
|
||
}
|
||
|
||
// 设置成功状态
|
||
result.success = true;
|
||
result.message = "Hierarchy analysis completed";
|
||
|
||
return result;
|
||
|
||
} catch (const std::exception& e) {
|
||
result.error_message = "Exception during hierarchy analysis: " + std::string(e.what());
|
||
} catch (...) {
|
||
result.error_message = "Unknown exception during hierarchy analysis";
|
||
}
|
||
|
||
return result;
|
||
}
|
||
// 评估删除安全性
|
||
std::string CreoManager::EvaluateDeletionSafety(const ComponentInfo& component) {
|
||
if (component.level == 0) {
|
||
return "forbidden"; // 主装配体不能删除
|
||
}
|
||
|
||
if (component.type == "assembly") {
|
||
return "risky"; // 子装配体删除有风险
|
||
}
|
||
|
||
return "moderate"; // 零件删除相对安全
|
||
}
|
||
|
||
// 获取组件文件大小 (使用更安全的方法)
|
||
std::string CreoManager::GetComponentFileSize(wfcWComponentPath_ptr component_path) {
|
||
try {
|
||
pfcSolid_ptr leaf_model = component_path->GetLeaf();
|
||
if (leaf_model) {
|
||
// 使用更安全的转换方法
|
||
pfcModel_ptr model = pfcModel::cast(leaf_model);
|
||
if (model) {
|
||
return GetModelFileSize(model);
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 捕获所有异常，返回默认值
|
||
}
|
||
|
||
return "0.0MB";
|
||
}
|
||
|
||
// 获取模型类型字符串
|
||
std::string CreoManager::GetModelTypeString(pfcModelType model_type) {
|
||
switch (model_type) {
|
||
case pfcMDL_ASSEMBLY:
|
||
return "MDL_ASSEMBLY";
|
||
case pfcMDL_PART:
|
||
return "MDL_PART";
|
||
case pfcMDL_DRAWING:
|
||
return "MDL_DRAWING";
|
||
default:
|
||
return "MDL_UNKNOWN";
|
||
}
|
||
}
|
||
|
||
// 计算子组件数量
|
||
int CreoManager::CountChildComponents(wfcWComponentPath_ptr component_path) {
|
||
try {
|
||
pfcSolid_ptr leaf_model = component_path->GetLeaf();
|
||
if (leaf_model && leaf_model->GetType() == pfcMDL_ASSEMBLY) {
|
||
wfcWAssembly_ptr sub_assembly = wfcWAssembly::cast(leaf_model);
|
||
if (sub_assembly) {
|
||
wfcWComponentPaths_ptr sub_components = sub_assembly->ListDisplayedComponents();
|
||
if (sub_components) {
|
||
return sub_components->getarraysize();
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 忽略错误
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
// =============== SOTA层级分析算法 ===============
|
||
|
||
void CreoManager::AnalyzeAssemblyNode(wfcWAssembly_ptr assembly,
|
||
int level,
|
||
const std::string& parentName,
|
||
const std::string& currentPath,
|
||
HierarchyAnalysisResult& result) {
|
||
if (!assembly) return;
|
||
|
||
try {
|
||
// 更新最大层级深度
|
||
if (level + 1 > result.total_levels) {
|
||
result.total_levels = level + 1;
|
||
}
|
||
|
||
// 确保层级容器足够大
|
||
while (result.hierarchy.size() <= level) {
|
||
result.hierarchy.push_back(std::vector<ComponentInfo>());
|
||
}
|
||
|
||
// 使用ListFeaturesByType获取所有组件特征（包括隐藏的）
|
||
pfcFeatures_ptr features = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
|
||
if (!features) return;
|
||
|
||
int features_count = features->getarraysize();
|
||
if (features_count <= 0) return;
|
||
|
||
// 遍历所有组件特征
|
||
for (int i = 0; i < features_count; i++) {
|
||
try {
|
||
pfcFeature_ptr feature = features->get(i);
|
||
if (!feature) continue;
|
||
|
||
// 转换为组件特征
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (!compFeat) continue;
|
||
|
||
// 加载模型一次（避免重复调用）
|
||
pfcModel_ptr childModel = LoadComponentModel(compFeat);
|
||
|
||
// 创建组件信息，传递已加载的模型
|
||
ComponentInfo component = CreateComponentFromFeature(compFeat, level, parentName, currentPath, childModel);
|
||
|
||
// 添加到当前层级
|
||
result.hierarchy[level].push_back(component);
|
||
|
||
// 递归处理子装配体
|
||
if (component.type == "assembly" && childModel) {
|
||
try {
|
||
if (childModel->GetType() == pfcMDL_ASSEMBLY) {
|
||
wfcWAssembly_ptr childAssembly = wfcWAssembly::cast(childModel);
|
||
if (childAssembly) {
|
||
// 递归分析子装配体
|
||
AnalyzeAssemblyNode(childAssembly, level + 1,
|
||
component.name, component.path, result);
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 处理无法加载的子装配体
|
||
}
|
||
}
|
||
|
||
} catch (...) {
|
||
continue; // 忽略单个组件错误
|
||
}
|
||
}
|
||
|
||
// children_count在CreateComponentFromFeature中已经设置
|
||
|
||
} catch (...) {
|
||
// 处理整体错误
|
||
}
|
||
}
|
||
|
||
ComponentInfo CreoManager::CreateComponentFromFeature(pfcComponentFeat_ptr compFeat,
|
||
int level,
|
||
const std::string& parentName,
|
||
const std::string& currentPath,
|
||
pfcModel_ptr preloadedModel) {
|
||
ComponentInfo component;
|
||
component.level = level;
|
||
component.children_count = 0;
|
||
component.is_visible = true;
|
||
component.file_size = "0.0MB";
|
||
component.deletion_safety = "moderate";
|
||
|
||
try {
|
||
// 获取组件模型描述符
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
// 获取文件名作为ID
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
component.id = XStringToString(filename_xstr);
|
||
|
||
// 生成显示名称（去掉扩展名并格式化）
|
||
component.name = component.id;
|
||
size_t ext_pos = component.name.find_last_of(".");
|
||
if (ext_pos != std::string::npos) {
|
||
component.name = component.name.substr(0, ext_pos);
|
||
}
|
||
|
||
// 格式化显示名称
|
||
if (!component.name.empty()) {
|
||
component.name[0] = std::toupper(component.name[0]);
|
||
for (size_t i = 1; i < component.name.size(); i++) {
|
||
if (component.name[i-1] == '_' || component.name[i-1] == ' ') {
|
||
component.name[i] = std::toupper(component.name[i]);
|
||
} else {
|
||
component.name[i] = std::tolower(component.name[i]);
|
||
}
|
||
}
|
||
std::replace(component.name.begin(), component.name.end(), '_', ' ');
|
||
}
|
||
|
||
// 设置组件类型
|
||
if (modelDescr->GetType() == pfcMDL_ASSEMBLY) {
|
||
component.type = "assembly";
|
||
component.model_type = "MDL_ASSEMBLY";
|
||
} else {
|
||
component.type = "part";
|
||
component.model_type = "MDL_PART";
|
||
}
|
||
|
||
// 构建完整路径
|
||
if (currentPath.empty()) {
|
||
component.path = component.id;
|
||
} else {
|
||
component.path = currentPath + "/" + component.id;
|
||
}
|
||
component.full_path = component.path;
|
||
|
||
// 使用预加载的模型获取文件大小
|
||
try {
|
||
if (preloadedModel) {
|
||
component.file_size = GetModelFileSize(preloadedModel);
|
||
|
||
// 对于装配体，直接计算子组件数量（避免重复API调用）
|
||
if (component.type == "assembly" && preloadedModel->GetType() == pfcMDL_ASSEMBLY) {
|
||
wfcWAssembly_ptr assembly = wfcWAssembly::cast(preloadedModel);
|
||
if (assembly) {
|
||
try {
|
||
pfcFeatures_ptr childFeatures = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
|
||
if (childFeatures) {
|
||
component.children_count = childFeatures->getarraysize();
|
||
}
|
||
} catch (...) {
|
||
component.children_count = 0;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
component.file_size = "0.0MB";
|
||
}
|
||
} catch (...) {
|
||
component.file_size = "0.0MB";
|
||
}
|
||
}
|
||
|
||
} catch (...) {
|
||
// 使用默认值
|
||
component.id = "unknown_component_" + std::to_string(level);
|
||
component.name = "Unknown Component";
|
||
component.type = "part";
|
||
component.path = currentPath + "/" + component.id;
|
||
component.full_path = component.path;
|
||
}
|
||
|
||
return component;
|
||
}
|
||
|
||
pfcModel_ptr CreoManager::LoadComponentModel(pfcComponentFeat_ptr compFeat) {
|
||
try {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (!modelDescr) return nullptr;
|
||
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
if (!sessionInfo.is_valid) return nullptr;
|
||
|
||
// 尝试从会话中获取已加载的模型
|
||
try {
|
||
return sessionInfo.session->GetModelFromDescr(modelDescr);
|
||
} catch (pfcXToolkitError&) {
|
||
// 模型未加载，返回nullptr
|
||
return nullptr;
|
||
}
|
||
|
||
} catch (...) {
|
||
return nullptr;
|
||
}
|
||
}
|
||
|
||
// 层级删除功能实现
|
||
CreoManager::HierarchyDeleteResult CreoManager::DeleteHierarchyComponents(const std::string& project_name, int target_level) {
|
||
HierarchyDeleteResult result;
|
||
result.target_level = target_level;
|
||
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
if (!sessionInfo.is_valid) {
|
||
result.error_message = "Creo session not available";
|
||
return result;
|
||
}
|
||
|
||
try {
|
||
pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
|
||
if (!current_model) {
|
||
result.error_message = "No current model loaded";
|
||
return result;
|
||
}
|
||
|
||
// 检查是否为装配体
|
||
if (current_model->GetType() != pfcMDL_ASSEMBLY) {
|
||
result.error_message = "Current model is not an assembly";
|
||
return result;
|
||
}
|
||
|
||
// 转换为装配体
|
||
wfcWAssembly_ptr assembly = wfcWAssembly::cast(current_model);
|
||
if (!assembly) {
|
||
result.error_message = "Failed to cast model to assembly";
|
||
return result;
|
||
}
|
||
|
||
// target_level=2表示保留2层，删除第3层的组件
|
||
// 层级映射：target_level=2 -> 删除level_3 -> currentLevel=2
|
||
int deleteLevel = target_level - 1;
|
||
|
||
// 收集删除统计信息
|
||
std::map<int, std::vector<std::string>> componentsToDeleteByLevel;
|
||
int total_deleted = 0;
|
||
int successful_count = 0;
|
||
int failed_count = 0;
|
||
|
||
// 递归遍历到指定层级直接删除
|
||
std::function<void(wfcWAssembly_ptr, int)> deleteAtLevel = [&](wfcWAssembly_ptr currentAssembly, int currentLevel) {
|
||
if (!currentAssembly || currentLevel > deleteLevel) return;
|
||
|
||
try {
|
||
pfcFeatures_ptr features = currentAssembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
|
||
|
||
// 正常执行，无需调试输出
|
||
|
||
if (features) {
|
||
if (currentLevel == deleteLevel) {
|
||
// 在目标层级：获取所有组件并删除
|
||
xintsequence_ptr featIds = xintsequence::create();
|
||
std::vector<std::string> levelComponents;
|
||
for (int i = 0; i < features->getarraysize(); i++) {
|
||
pfcFeature_ptr feature = features->get(i);
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
// 记录组件信息用于响应
|
||
try {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
std::string filename = XStringToString(filename_xstr);
|
||
levelComponents.push_back(filename);
|
||
total_deleted++;
|
||
}
|
||
} catch (...) {
|
||
// 忽略获取文件名失败的组件
|
||
}
|
||
|
||
// 添加到删除列表
|
||
int featId = feature->GetId();
|
||
featIds->append(featId);
|
||
}
|
||
}
|
||
|
||
// 执行删除
|
||
if (featIds->getarraysize() > 0) {
|
||
try {
|
||
wfcWSolid_ptr wsolid = wfcWSolid::cast(currentAssembly);
|
||
if (wsolid) {
|
||
|
||
// 使用SuppressFeatures方法，更安全地"删除"组件
|
||
wfcFeatSuppressOrDeleteOptions_ptr options = wfcFeatSuppressOrDeleteOptions::create();
|
||
options->append(wfcFEAT_SUPP_OR_DEL_NO_OPTS);
|
||
|
||
// 创建重生成指令，允许失败
|
||
wfcWRegenInstructions_ptr regenInstr = wfcWRegenInstructions::Create();
|
||
|
||
// 执行抑制操作（更安全，不会破坏引用关系）
|
||
wsolid->SuppressFeatures(featIds, options, regenInstr);
|
||
|
||
// 手动重生成模型
|
||
try {
|
||
currentAssembly->Regenerate(nullptr);
|
||
} catch (...) {
|
||
// 重生成失败不影响抑制操作
|
||
}
|
||
|
||
successful_count += featIds->getarraysize();
|
||
|
||
// 记录成功抑制的组件 - 累积而不是覆盖
|
||
if (componentsToDeleteByLevel.find(deleteLevel + 1) == componentsToDeleteByLevel.end()) {
|
||
componentsToDeleteByLevel[deleteLevel + 1] = std::vector<std::string>();
|
||
}
|
||
componentsToDeleteByLevel[deleteLevel + 1].insert(
|
||
componentsToDeleteByLevel[deleteLevel + 1].end(),
|
||
levelComponents.begin(),
|
||
levelComponents.end()
|
||
);
|
||
} else {
|
||
failed_count += featIds->getarraysize();
|
||
}
|
||
} catch (...) {
|
||
failed_count += featIds->getarraysize();
|
||
}
|
||
}
|
||
} else if (currentLevel < deleteLevel) {
|
||
// 还没到目标层级：只对装配体组件继续递归
|
||
for (int i = 0; i < features->getarraysize(); i++) {
|
||
pfcFeature_ptr feature = features->get(i);
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr && modelDescr->GetType() == pfcMDL_ASSEMBLY) {
|
||
pfcModel_ptr childModel = LoadComponentModel(compFeat);
|
||
if (childModel && childModel->GetType() == pfcMDL_ASSEMBLY) {
|
||
wfcWAssembly_ptr childAssembly = wfcWAssembly::cast(childModel);
|
||
if (childAssembly) {
|
||
deleteAtLevel(childAssembly, currentLevel + 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 忽略单个装配体的错误
|
||
}
|
||
};
|
||
|
||
// 从根装配体开始删除（层级0）
|
||
deleteAtLevel(assembly, 0);
|
||
|
||
result.deleted_components = componentsToDeleteByLevel;
|
||
result.total_deleted = total_deleted;
|
||
result.original_levels = 0; // 临时设置，避免异常值
|
||
|
||
// 删除完成后重新生成模型
|
||
if (successful_count > 0) {
|
||
try {
|
||
assembly->Regenerate(nullptr);
|
||
} catch (...) {
|
||
// 重新生成失败不影响删除结果
|
||
}
|
||
}
|
||
|
||
result.successful = successful_count;
|
||
result.failed = failed_count;
|
||
result.final_levels = target_level + 1; // 删除后的层级数
|
||
|
||
if (failed_count == 0) {
|
||
result.success = true;
|
||
result.message = "All components suppressed successfully (safer than deletion)";
|
||
} else {
|
||
result.success = (successful_count > 0);
|
||
result.message = "Suppression completed with " + std::to_string(failed_count) + " failures";
|
||
}
|
||
|
||
} catch (const std::exception& e) {
|
||
result.error_message = "Exception during suppression: " + std::string(e.what());
|
||
} catch (...) {
|
||
result.error_message = "Unknown error during suppression";
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// 薄壳化分析实现
|
||
CreoManager::ShellAnalysisResult CreoManager::AnalyzeShellFeatures(const ShellAnalysisRequest& request) {
|
||
ShellAnalysisResult result;
|
||
|
||
try {
|
||
// 获取会话信息
|
||
SessionInfo sessionInfo = GetSessionInfo();
|
||
if (!sessionInfo.is_valid) {
|
||
result.error_message = "Cannot connect to CREOSON server";
|
||
return result;
|
||
}
|
||
|
||
// 获取当前模型
|
||
pfcModel_ptr currentModel = sessionInfo.session->GetCurrentModel();
|
||
if (!currentModel) {
|
||
result.error_message = "Cannot get shell analysis results, please ensure a model is open in Creo";
|
||
return result;
|
||
}
|
||
|
||
// === 第3步调试：添加基本特征分析逻辑 ===
|
||
|
||
// 基本模型信息
|
||
bool is_assembly = false;
|
||
try {
|
||
is_assembly = (currentModel->GetType() == pfcModelType::pfcMDL_ASSEMBLY);
|
||
} catch (...) {
|
||
is_assembly = false;
|
||
}
|
||
|
||
// 设置基本参数
|
||
result.analysis_parameters.preserve_external_surfaces = request.preserve_external_surfaces;
|
||
result.analysis_parameters.min_wall_thickness = request.min_wall_thickness;
|
||
result.analysis_parameters.confidence_threshold = request.confidence_threshold;
|
||
result.analysis_parameters.assembly_analysis = is_assembly;
|
||
|
||
// === 真正的薄壳化分析算法 ===
|
||
// 基于包络盒边界识别法 + 层次结构增强 + 特征安全性评估
|
||
|
||
int total_features = 0;
|
||
int deletable_features = 0;
|
||
int preserved_features = 0;
|
||
int shell_surfaces = 0;
|
||
int internal_surfaces = 0;
|
||
|
||
// 外壳特征白名单（基于算法原理）
|
||
std::set<std::string> shell_feature_whitelist;
|
||
|
||
try {
|
||
if (!is_assembly) {
|
||
// === 零件模型薄壳化分析 ===
|
||
pfcSolid_ptr solid = pfcSolid::cast(currentModel);
|
||
if (solid) {
|
||
pfcFeatures_ptr features = solid->ListFeaturesByType(NULL);
|
||
if (features) {
|
||
total_features = features->getarraysize();
|
||
|
||
// === 第1步：真实几何包络盒计算（基于OTK API）===
|
||
pfcOutline3D_ptr global_outline = nullptr;
|
||
double tolerance = 0.1; // 默认容差，后续根据模型大小调整
|
||
|
||
try {
|
||
// 使用OTK API获取零件的真实几何边界
|
||
global_outline = solid->EvalOutline(nullptr); // 使用默认坐标系
|
||
|
||
if (global_outline) {
|
||
pfcPoint3D_ptr minPoint = global_outline->get(0);
|
||
pfcPoint3D_ptr maxPoint = global_outline->get(1);
|
||
|
||
// 计算真实对角线长度
|
||
double dx = maxPoint->get(0) - minPoint->get(0);
|
||
double dy = maxPoint->get(1) - minPoint->get(1);
|
||
double dz = maxPoint->get(2) - minPoint->get(2);
|
||
double diagonal_length = sqrt(dx*dx + dy*dy + dz*dz);
|
||
|
||
// 基于真实模型大小设置容差
|
||
tolerance = diagonal_length * 0.001; // 0.1%容差
|
||
}
|
||
} catch (...) {
|
||
// 如果无法获取边界框，使用默认容差
|
||
tolerance = 1.0;
|
||
}
|
||
|
||
// 第2步：外壳识别算法 - 基于包络盒边界识别法
|
||
for (int i = 0; i < total_features; i++) {
|
||
try {
|
||
pfcFeature_ptr feature = features->get(i);
|
||
if (feature) {
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
std::string feat_name = "";
|
||
|
||
// 安全获取特征名称 - 生成标准格式名称
|
||
try {
|
||
xstring xstr_name = feature->GetName();
|
||
if (xstr_name != xstringnil && !xstr_name.IsEmpty()) {
|
||
feat_name = XStringToString(xstr_name);
|
||
} else {
|
||
// 使用特征类型+编号格式
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
std::string type_name = GetFeatureTypeName(feat_type);
|
||
feat_name = type_name + "_" + std::to_string(i + 1);
|
||
}
|
||
} catch (...) {
|
||
// 获取失败时，使用特征类型+编号格式
|
||
try {
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
std::string type_name = GetFeatureTypeName(feat_type);
|
||
feat_name = type_name + "_" + std::to_string(i + 1);
|
||
} catch (...) {
|
||
feat_name = "FEATURE_" + std::to_string(i + 1);
|
||
}
|
||
}
|
||
|
||
// === 基于真实几何的薄壳化分析 ===
|
||
double confidence = 0.5; // 基础置信度，基于几何分析调整
|
||
bool is_shell_feature = false;
|
||
bool is_internal_feature = false;
|
||
bool feature_touches_boundary = false;
|
||
|
||
try {
|
||
// === 真实几何分析：判断特征是否接触模型边界 ===
|
||
feature_touches_boundary = AnalyzeFeatureGeometry(feature, global_outline, tolerance);
|
||
|
||
// 基于几何位置的分类
|
||
if (feature_touches_boundary) {
|
||
// 特征接触模型边界 -> 可能是外壳特征
|
||
is_shell_feature = true;
|
||
shell_feature_whitelist.insert(feat_name);
|
||
confidence = 0.2; // 低置信度删除，倾向保留
|
||
shell_surfaces++;
|
||
|
||
// 进一步检查特征类型
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_PROTRUSION ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_SHELL ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_DOME ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_TORUS) {
|
||
// 构建外形的特征且接触边界 -> 强制保留
|
||
confidence = 0.05;
|
||
}
|
||
} else {
|
||
// 特征完全在内部 -> 内部特征
|
||
is_internal_feature = true;
|
||
confidence = 0.8; // 高置信度删除
|
||
internal_surfaces++;
|
||
|
||
// 内部特征的具体分类
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_HOLE ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_ROUND ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_CHAMFER) {
|
||
// 明确的内部加工特征 -> 激进删除
|
||
confidence = 0.95;
|
||
}
|
||
}
|
||
|
||
// 标准件识别（优先级最高）
|
||
if (IsStandardPart(feat_name)) {
|
||
confidence = 0.99; // 标准件强制删除
|
||
is_internal_feature = true;
|
||
is_shell_feature = false;
|
||
}
|
||
|
||
// 用户设置：保护外部表面
|
||
if (request.preserve_external_surfaces && is_shell_feature) {
|
||
confidence = std::min(confidence, 0.1); // 强制保留外部表面
|
||
}
|
||
|
||
} catch (...) {
|
||
// 几何分析失败，回退到基于特征类型的简单判断
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) {
|
||
confidence = 0.7; // 中等置信度删除
|
||
is_internal_feature = true;
|
||
} else {
|
||
confidence = 0.3; // 低置信度删除，倾向保留
|
||
}
|
||
}
|
||
|
||
// 置信度限制
|
||
confidence = std::min(1.0, std::max(0.0, confidence));
|
||
|
||
// 第4步：激进特征分类（降低删除阈值）
|
||
if (confidence > 0.8) {
|
||
// 安全删除：高置信度的内部特征
|
||
FeatureDeletion deletion;
|
||
deletion.id = i + 1;
|
||
deletion.name = feat_name;
|
||
deletion.type = GetFeatureTypeName(feat_type);
|
||
deletion.reason = IsStandardPart(feat_name) ?
|
||
"Internal feature, safe for removal" :
|
||
"Internal feature, safe for removal";
|
||
deletion.confidence = confidence;
|
||
deletion.volume_reduction =
|
||
(feat_type == pfcFeatureType::pfcFEATTYPE_CUT) ? 25 :
|
||
(feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) ? 20 : 15;
|
||
deletion.component_type = "FEATURE";
|
||
|
||
// 获取零件文件信息（零件模式）
|
||
if (currentModel) {
|
||
try {
|
||
xstring part_name = currentModel->GetFileName();
|
||
if (part_name != xstringnil && !part_name.IsEmpty()) {
|
||
deletion.part_file = XStringToString(part_name);
|
||
}
|
||
|
||
xstring full_path = currentModel->GetFullName();
|
||
if (full_path != xstringnil && !full_path.IsEmpty()) {
|
||
deletion.part_path = XStringToString(full_path);
|
||
}
|
||
} catch (...) {
|
||
// 文件信息获取失败，保持空值
|
||
}
|
||
}
|
||
|
||
result.safe_deletions.push_back(deletion);
|
||
deletable_features++;
|
||
|
||
} else if (confidence > 0.5 && !is_shell_feature) {
|
||
// 建议删除：中等置信度的非外壳特征
|
||
FeatureDeletion suggestion;
|
||
suggestion.id = i + 1;
|
||
suggestion.name = feat_name;
|
||
suggestion.type = GetFeatureTypeName(feat_type);
|
||
suggestion.reason = "Suggest deletion - review recommended";
|
||
suggestion.confidence = confidence;
|
||
suggestion.volume_reduction = 10;
|
||
suggestion.component_type = "FEATURE";
|
||
|
||
// 获取零件文件信息（零件模式）
|
||
if (currentModel) {
|
||
try {
|
||
xstring part_name = currentModel->GetFileName();
|
||
if (part_name != xstringnil && !part_name.IsEmpty()) {
|
||
suggestion.part_file = XStringToString(part_name);
|
||
}
|
||
|
||
xstring full_path = currentModel->GetFullName();
|
||
if (full_path != xstringnil && !full_path.IsEmpty()) {
|
||
suggestion.part_path = XStringToString(full_path);
|
||
}
|
||
} catch (...) {
|
||
// 文件信息获取失败，保持空值
|
||
}
|
||
}
|
||
|
||
result.suggested_deletions.push_back(suggestion);
|
||
|
||
} else {
|
||
// 保留：低置信度或外壳特征
|
||
FeatureDeletion preserve;
|
||
preserve.id = i + 1;
|
||
preserve.name = feat_name;
|
||
preserve.type = GetFeatureTypeName(feat_type);
|
||
preserve.reason = is_shell_feature ?
|
||
"Shell feature - preserve model appearance" :
|
||
"Structural feature - preserve";
|
||
preserve.confidence = confidence;
|
||
preserve.volume_reduction = 0;
|
||
preserve.component_type = "FEATURE";
|
||
|
||
// 获取零件文件信息（零件模式）
|
||
if (currentModel) {
|
||
try {
|
||
xstring part_name = currentModel->GetFileName();
|
||
if (part_name != xstringnil && !part_name.IsEmpty()) {
|
||
preserve.part_file = XStringToString(part_name);
|
||
}
|
||
|
||
xstring full_path = currentModel->GetFullName();
|
||
if (full_path != xstringnil && !full_path.IsEmpty()) {
|
||
preserve.part_path = XStringToString(full_path);
|
||
}
|
||
} catch (...) {
|
||
// 文件信息获取失败，保持空值
|
||
}
|
||
}
|
||
|
||
result.preserve_list.push_back(preserve);
|
||
preserved_features++;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// === 装配体薄壳化分析（标准算法实现）===
|
||
wfcWAssembly_ptr assembly = wfcWAssembly::cast(currentModel);
|
||
if (assembly) {
|
||
|
||
// === 第1步：数据获取 ===
|
||
pfcFeatures_ptr features = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
|
||
if (features) {
|
||
total_features = features->getarraysize();
|
||
|
||
// 递归收集所有层级组件
|
||
std::vector<std::pair<pfcFeature_ptr, std::string>> all_components;
|
||
|
||
// 获取根装配体名称作为路径起点（保留扩展名）
|
||
std::string root_assembly_name = "";
|
||
try {
|
||
xstring filename_xstr = currentModel->GetFileName();
|
||
if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
|
||
root_assembly_name = XStringToString(filename_xstr);
|
||
// 保留扩展名显示完整文件名
|
||
// 注意：这里显示的是Creo中当前打开的模型文件名
|
||
} else {
|
||
root_assembly_name = "ROOT_ASSEMBLY.asm";
|
||
}
|
||
} catch (...) {
|
||
root_assembly_name = "ROOT_ASSEMBLY.asm";
|
||
}
|
||
|
||
CollectAllComponentsForShellAnalysis(assembly, root_assembly_name, all_components);
|
||
total_features = (int)all_components.size();
|
||
|
||
// === 第2步：外壳识别算法 - 全局包络盒计算 ===
|
||
pfcOutline3D_ptr global_bbox = nullptr;
|
||
double tolerance = 0.1;
|
||
|
||
try {
|
||
pfcSolid_ptr assemblySolid = pfcSolid::cast(assembly);
|
||
if (assemblySolid) {
|
||
global_bbox = assemblySolid->EvalOutline(nullptr);
|
||
if (global_bbox) {
|
||
pfcPoint3D_ptr minPoint = global_bbox->get(0);
|
||
pfcPoint3D_ptr maxPoint = global_bbox->get(1);
|
||
|
||
// 计算对角线长度设置容差
|
||
double dx = maxPoint->get(0) - minPoint->get(0);
|
||
double dy = maxPoint->get(1) - minPoint->get(1);
|
||
double dz = maxPoint->get(2) - minPoint->get(2);
|
||
double diagonal_length = sqrt(dx*dx + dy*dy + dz*dz);
|
||
tolerance = diagonal_length * 0.001; // 标准容差：对角线长度 * 1e-3
|
||
}
|
||
}
|
||
} catch (...) {
|
||
tolerance = 1.0; // 默认容差
|
||
}
|
||
|
||
// === 第3步：外壳特征白名单构建 ===
|
||
std::set<std::string> shell_feature_whitelist;
|
||
|
||
// 对每个组件进行边界判定
|
||
for (int i = 0; i < total_features; i++) {
|
||
try {
|
||
pfcFeature_ptr feature = all_components[i].first;
|
||
if (feature) {
|
||
std::string comp_name = "";
|
||
try {
|
||
xstring xstr_name = feature->GetName();
|
||
if (xstr_name != xstringnil && !xstr_name.IsEmpty()) {
|
||
comp_name = XStringToString(xstr_name);
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} catch (...) {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
|
||
// === 边界判定算法 ===
|
||
bool is_on_boundary = false;
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat && global_bbox) {
|
||
pfcModelDescriptor_ptr modelDesc = compFeat->GetModelDescr();
|
||
if (modelDesc) {
|
||
pfcSession_ptr session = pfcGetCurrentSession();
|
||
pfcModel_ptr componentModel = nullptr;
|
||
try {
|
||
componentModel = session->GetModelFromDescr(modelDesc);
|
||
} catch (...) {
|
||
componentModel = nullptr;
|
||
}
|
||
|
||
if (componentModel) {
|
||
pfcSolid_ptr componentSolid = pfcSolid::cast(componentModel);
|
||
if (componentSolid) {
|
||
pfcOutline3D_ptr comp_bbox = componentSolid->EvalOutline(nullptr);
|
||
if (comp_bbox) {
|
||
pfcPoint3D_ptr comp_min = comp_bbox->get(0);
|
||
pfcPoint3D_ptr comp_max = comp_bbox->get(1);
|
||
pfcPoint3D_ptr global_min = global_bbox->get(0);
|
||
pfcPoint3D_ptr global_max = global_bbox->get(1);
|
||
|
||
// === 标准边界判定：if (S.min_extent ≈ global_min) OR (S.max_extent ≈ global_max) ===
|
||
if (abs(comp_min->get(0) - global_min->get(0)) < tolerance ||
|
||
abs(comp_min->get(1) - global_min->get(1)) < tolerance ||
|
||
abs(comp_min->get(2) - global_min->get(2)) < tolerance ||
|
||
abs(comp_max->get(0) - global_max->get(0)) < tolerance ||
|
||
abs(comp_max->get(1) - global_max->get(1)) < tolerance ||
|
||
abs(comp_max->get(2) - global_max->get(2)) < tolerance) {
|
||
is_on_boundary = true;
|
||
shell_feature_whitelist.insert(comp_name);
|
||
shell_surfaces++;
|
||
} else {
|
||
internal_surfaces++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 边界判定失败，默认为内部组件
|
||
internal_surfaces++;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// === 第4步：特征分类（标准置信度算法）===
|
||
for (int i = 0; i < total_features; i++) {
|
||
try {
|
||
pfcFeature_ptr feature = all_components[i].first;
|
||
std::string component_path = all_components[i].second;
|
||
if (feature) {
|
||
std::string comp_name = "";
|
||
|
||
// 安全获取组件文件名（与路径中的名称保持一致）
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
|
||
comp_name = XStringToString(filename_xstr);
|
||
// 保留扩展名，与路径中的名称保持一致
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} catch (...) {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
|
||
// === 标准置信度计算算法 ===
|
||
double confidence = 0.5; // 基础置信度
|
||
bool is_standard = IsStandardPart(comp_name);
|
||
bool is_internal = IsInternalPart(feature, currentModel);
|
||
bool is_in_shell_whitelist = (shell_feature_whitelist.find(comp_name) != shell_feature_whitelist.end());
|
||
std::string deletion_reason = "Standard shell analysis";
|
||
|
||
// === 标准置信度算法：按文档实现 ===
|
||
// confidence = calculate_deletion_confidence(feature, shell_whitelist, hierarchy)
|
||
|
||
// === 优先级判断：避免逻辑冲突 ===
|
||
// 规则1：标准件（最高优先级）
|
||
if (is_standard) {
|
||
confidence += 0.4; // 提高到0.9，确保进入safeDeletions
|
||
deletion_reason = "Standard part detected";
|
||
}
|
||
// 规则2：外壳特征判断（不能与内部组件冲突）
|
||
else if (is_in_shell_whitelist) {
|
||
confidence -= 0.4;
|
||
deletion_reason = "Shell feature - boundary component";
|
||
}
|
||
// 规则3：内部组件判断（与外壳特征互斥）
|
||
else if (is_internal) {
|
||
confidence += 0.35; // 提高到0.85，确保进入safeDeletions
|
||
deletion_reason = "Internal part by geometry";
|
||
}
|
||
|
||
// 规则4：层级深度分析（BOM层次结构增强）
|
||
int path_depth = std::count(component_path.begin(), component_path.end(), '/');
|
||
if (path_depth >= 3) {
|
||
confidence += 0.4; // 很深层级，强制删除
|
||
if (deletion_reason == "Standard shell analysis") {
|
||
deletion_reason = "Very deep hierarchy component";
|
||
}
|
||
} else if (path_depth >= 2) {
|
||
confidence += 0.2; // 深层级组件，提高删除置信度
|
||
if (deletion_reason == "Standard shell analysis") {
|
||
deletion_reason = "Deep hierarchy component";
|
||
}
|
||
}
|
||
|
||
// 限制置信度范围
|
||
confidence = std::min(1.0, std::max(0.0, confidence));
|
||
|
||
// === 特征安全性评估算法分类（按文档标准）===
|
||
|
||
if (confidence > 0.8) {
|
||
// Safe Deletions: 内部特征 + 非外壳表面 + confidence > 0.8
|
||
FeatureDeletion deletion;
|
||
deletion.id = i + 1;
|
||
deletion.name = comp_name;
|
||
deletion.type = "COMPONENT";
|
||
deletion.reason = deletion_reason;
|
||
deletion.confidence = confidence;
|
||
deletion.volume_reduction = 15; // 估算值
|
||
deletion.component_type = "COMPONENT";
|
||
|
||
// 获取组件文件信息（装配体模式）
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
|
||
deletion.part_file = XStringToString(filename_xstr);
|
||
}
|
||
deletion.part_path = component_path;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 组件信息获取失败，保持空值
|
||
}
|
||
|
||
result.safe_deletions.push_back(deletion);
|
||
deletable_features++;
|
||
|
||
} else if (confidence >= 0.5 && confidence <= 0.8) {
|
||
// Suggested Deletions: 部分内部特征 + confidence 0.5-0.8
|
||
FeatureDeletion suggestion;
|
||
suggestion.id = i + 1;
|
||
suggestion.name = comp_name;
|
||
suggestion.type = "COMPONENT";
|
||
suggestion.reason = deletion_reason;
|
||
suggestion.confidence = confidence;
|
||
suggestion.volume_reduction = 10; // 估算值
|
||
suggestion.component_type = "COMPONENT";
|
||
|
||
// 获取组件文件信息（装配体模式）
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
|
||
suggestion.part_file = XStringToString(filename_xstr);
|
||
}
|
||
suggestion.part_path = component_path;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 组件信息获取失败，保持空值
|
||
}
|
||
|
||
result.suggested_deletions.push_back(suggestion);
|
||
|
||
} else {
|
||
// Preserve: 外壳特征 + 基础结构特征 + confidence < 0.5
|
||
FeatureDeletion preserve;
|
||
preserve.id = i + 1;
|
||
preserve.name = comp_name;
|
||
preserve.type = "COMPONENT";
|
||
preserve.reason = deletion_reason;
|
||
preserve.confidence = confidence;
|
||
preserve.volume_reduction = 0;
|
||
preserve.component_type = "COMPONENT";
|
||
|
||
// 获取组件文件信息（装配体模式）
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
|
||
preserve.part_file = XStringToString(filename_xstr);
|
||
}
|
||
preserve.part_path = component_path;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 组件信息获取失败，保持空值
|
||
}
|
||
|
||
result.preserve_list.push_back(preserve);
|
||
preserved_features++;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
total_features = 0;
|
||
deletable_features = 0;
|
||
preserved_features = 0;
|
||
}
|
||
|
||
// 设置薄壳化分析统计信息
|
||
result.analysis_parameters.total_features = total_features;
|
||
result.analysis_parameters.deletable_features = deletable_features;
|
||
result.analysis_parameters.preserved_features = preserved_features;
|
||
result.analysis_parameters.surface_count = shell_surfaces + internal_surfaces;
|
||
result.analysis_parameters.shell_surfaces = shell_surfaces;
|
||
result.analysis_parameters.internal_surfaces = internal_surfaces;
|
||
result.analysis_parameters.shell_feature_whitelist = (int)shell_feature_whitelist.size();
|
||
|
||
// 计算预估效果（基于删除建议）
|
||
int total_volume_reduction = 0;
|
||
for (const auto& deletion : result.safe_deletions) {
|
||
total_volume_reduction += deletion.volume_reduction;
|
||
}
|
||
for (const auto& suggestion : result.suggested_deletions) {
|
||
total_volume_reduction += suggestion.volume_reduction;
|
||
}
|
||
|
||
if (total_volume_reduction > 0) {
|
||
result.estimated_reduction.volume_reduction = std::to_string(total_volume_reduction) + "%";
|
||
result.estimated_reduction.file_size_reduction = std::to_string(total_volume_reduction / 2) + "%";
|
||
result.estimated_reduction.performance_improvement = std::to_string(1.0 + total_volume_reduction / 100.0) + "x";
|
||
} else {
|
||
result.estimated_reduction.volume_reduction = "0%";
|
||
result.estimated_reduction.file_size_reduction = "0%";
|
||
result.estimated_reduction.performance_improvement = "1.0x";
|
||
}
|
||
|
||
// 装配体层次分析（如果是装配体）
|
||
if (is_assembly) {
|
||
result.analysis_parameters.hierarchy_analysis.enabled = true;
|
||
result.analysis_parameters.hierarchy_analysis.total_parts = 0;
|
||
result.analysis_parameters.hierarchy_analysis.outer_parts = 0;
|
||
result.analysis_parameters.hierarchy_analysis.internal_parts = 0;
|
||
result.analysis_parameters.hierarchy_analysis.containment_relationships = 0;
|
||
result.analysis_parameters.hierarchy_analysis.performance_stats["total_analysis_time"] = "Shell analysis complete - bbox boundary identification + hierarchy enhancement";
|
||
result.analysis_parameters.hierarchy_analysis.performance_stats["api_calls_made"] = "BBox + Surface + FeatureType + StandardPart + WallThickness + Confidence";
|
||
}
|
||
|
||
result.success = true;
|
||
|
||
} catch (const std::exception& e) {
|
||
result.error_message = "Server internal error: " + std::string(e.what());
|
||
} catch (...) {
|
||
result.error_message = "Server internal error: unknown exception";
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// 辅助方法：获取特征类型名称
|
||
std::string CreoManager::GetFeatureTypeName(pfcFeatureType feat_type) {
|
||
switch (feat_type) {
|
||
case pfcFeatureType::pfcFEATTYPE_PROTRUSION: return "EXTRUDE";
|
||
case pfcFeatureType::pfcFEATTYPE_CUT: return "CUT";
|
||
case pfcFeatureType::pfcFEATTYPE_SHELL: return "SHELL";
|
||
case pfcFeatureType::pfcFEATTYPE_HOLE: return "HOLE";
|
||
case pfcFeatureType::pfcFEATTYPE_ROUND: return "ROUND";
|
||
case pfcFeatureType::pfcFEATTYPE_CHAMFER: return "CHAMFER";
|
||
case pfcFeatureType::pfcFEATTYPE_DATUM_PLANE: return "DATUM_PLANE";
|
||
case pfcFeatureType::pfcFEATTYPE_DATUM_AXIS: return "DATUM_AXIS";
|
||
case pfcFeatureType::pfcFEATTYPE_COMPONENT: return "COMPONENT";
|
||
default: return "UNKNOWN";
|
||
}
|
||
}
|
||
|
||
// 辅助方法：判断是否为外部表面特征
|
||
bool CreoManager::IsExternalSurface(pfcFeature_ptr feature, bool preserve_external) {
|
||
if (!preserve_external) return false;
|
||
|
||
// 基础判断逻辑（占位实现，后续可优化）
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
|
||
// 外壳特征通常是外部表面
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_SHELL) {
|
||
return true;
|
||
}
|
||
|
||
// 其他基础判断规则
|
||
// 这里可以加入更复杂的表面分析逻辑
|
||
return false;
|
||
}
|
||
|
||
// 辅助方法：检查壁厚
|
||
bool CreoManager::CheckWallThickness(pfcFeature_ptr feature, double min_thickness) {
|
||
// 基础壁厚检查逻辑（占位实现）
|
||
// 实际实现需要几何分析算法
|
||
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
|
||
// 简单规则：某些特征类型认为符合壁厚要求
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) {
|
||
return true; // 切削和孔特征通常可以删除
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// === 薄壳化算法核心实现 ===
|
||
|
||
// 删除了模拟包络盒计算 - 薄壳化分析直接基于特征类型
|
||
|
||
// 删除了模拟表面数据函数 - 薄壳化分析直接基于特征进行
|
||
|
||
// 删除了模拟表面识别算法 - 直接基于特征类型进行判断
|
||
|
||
// 5. 标准件识别算法
|
||
bool CreoManager::IsStandardPart(const std::string& part_name) {
|
||
// 标准件关键词列表
|
||
std::vector<std::string> standard_keywords = {
|
||
"SCREW", "BOLT", "NUT", "WASHER", "BEARING",
|
||
"GASKET", "SEAL", "O-RING", "SPRING", "PIN",
|
||
"螺钉", "螺栓", "螺母", "垫圈", "轴承", "弹簧",
|
||
"screw", "bolt", "nut", "washer", "bearing", "spring"
|
||
};
|
||
|
||
std::string upper_name = part_name;
|
||
std::transform(upper_name.begin(), upper_name.end(), upper_name.begin(), ::toupper);
|
||
|
||
for (const auto& keyword : standard_keywords) {
|
||
if (upper_name.find(keyword) != std::string::npos) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// 6. 内部零件判断（基于几何算法）
|
||
bool CreoManager::IsInternalPart(pfcFeature_ptr feature, pfcModel_ptr model) {
|
||
// 首先基于特征类型判断（明确的内部特征）
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) {
|
||
return true;
|
||
}
|
||
|
||
// === 基于几何算法的内部组件识别 ===
|
||
try {
|
||
// 对于组件特征，尝试获取其几何信息
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_COMPONENT) {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
// 获取组件模型
|
||
pfcModel_ptr componentModel = nullptr;
|
||
try {
|
||
pfcModelDescriptor_ptr modelDesc = compFeat->GetModelDescr();
|
||
if (modelDesc) {
|
||
pfcSession_ptr session = pfcGetCurrentSession();
|
||
try {
|
||
componentModel = session->GetModelFromDescr(modelDesc);
|
||
} catch (...) {
|
||
// 模型不在内存中，返回nullptr
|
||
componentModel = nullptr;
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 模型获取失败，使用几何分析
|
||
}
|
||
|
||
if (componentModel) {
|
||
// === 算法1：基于体积比例判断 ===
|
||
try {
|
||
pfcSolid_ptr componentSolid = pfcSolid::cast(componentModel);
|
||
pfcSolid_ptr parentSolid = pfcSolid::cast(model);
|
||
|
||
if (componentSolid && parentSolid) {
|
||
// 获取质量属性来计算体积
|
||
pfcMassProperty_ptr compMass = componentSolid->GetMassProperty(nullptr);
|
||
pfcMassProperty_ptr parentMass = parentSolid->GetMassProperty(nullptr);
|
||
|
||
if (compMass && parentMass) {
|
||
double compVolume = compMass->GetVolume();
|
||
double parentVolume = parentMass->GetVolume();
|
||
|
||
// 小体积组件（<5%总体积）更可能是内部组件
|
||
if (compVolume / parentVolume < 0.05) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 质量属性获取失败，继续其他算法
|
||
}
|
||
|
||
// === 算法2：基于包络盒分析 ===
|
||
try {
|
||
pfcSolid_ptr componentSolid = pfcSolid::cast(componentModel);
|
||
pfcSolid_ptr parentSolid = pfcSolid::cast(model);
|
||
|
||
if (componentSolid && parentSolid) {
|
||
pfcOutline3D_ptr compOutline = componentSolid->EvalOutline(nullptr);
|
||
pfcOutline3D_ptr parentOutline = parentSolid->EvalOutline(nullptr);
|
||
|
||
if (compOutline && parentOutline) {
|
||
// 计算组件包络盒
|
||
pfcPoint3D_ptr compMin = compOutline->get(0);
|
||
pfcPoint3D_ptr compMax = compOutline->get(1);
|
||
pfcPoint3D_ptr parentMin = parentOutline->get(0);
|
||
pfcPoint3D_ptr parentMax = parentOutline->get(1);
|
||
|
||
// 计算距离边界的最小距离
|
||
double minDistToEdge = std::min({
|
||
compMin->get(0) - parentMin->get(0), // X方向距离左边界
|
||
parentMax->get(0) - compMax->get(0), // X方向距离右边界
|
||
compMin->get(1) - parentMin->get(1), // Y方向距离
|
||
parentMax->get(1) - compMax->get(1),
|
||
compMin->get(2) - parentMin->get(2), // Z方向距离
|
||
parentMax->get(2) - compMax->get(2)
|
||
});
|
||
|
||
// 计算总尺寸作为参考
|
||
double parentDiagonal = sqrt(
|
||
pow(parentMax->get(0) - parentMin->get(0), 2) +
|
||
pow(parentMax->get(1) - parentMin->get(1), 2) +
|
||
pow(parentMax->get(2) - parentMin->get(2), 2)
|
||
);
|
||
|
||
// 如果组件距离边界较远（>5%对角线距离），认为是内部组件
|
||
if (minDistToEdge > parentDiagonal * 0.05) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 包络盒分析失败
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 几何分析失败，回退到特征类型判断
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// 薄壳化分析递归方法：收集所有层级的组件
|
||
void CreoManager::CollectAllComponentsForShellAnalysis(wfcWAssembly_ptr assembly,
|
||
const std::string& parentPath,
|
||
std::vector<std::pair<pfcFeature_ptr, std::string>>& allComponents) {
|
||
if (!assembly) return;
|
||
|
||
try {
|
||
// 获取当前装配体的所有组件（包括隐藏的）
|
||
pfcFeatures_ptr features = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
|
||
if (!features) return;
|
||
|
||
for (int i = 0; i < features->getarraysize(); i++) {
|
||
try {
|
||
pfcFeature_ptr feature = features->get(i);
|
||
if (!feature) continue;
|
||
|
||
// 获取组件文件名（参考层级分析的方法）
|
||
std::string comp_name = "";
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
auto modelDescr = compFeat->GetModelDescr();
|
||
if (modelDescr) {
|
||
xstring filename_xstr = modelDescr->GetFileName();
|
||
if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
|
||
comp_name = XStringToString(filename_xstr);
|
||
// 保留扩展名显示完整文件名
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} else {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
} catch (...) {
|
||
comp_name = "Component_" + std::to_string(i + 1);
|
||
}
|
||
|
||
// 构建完整路径（使用实际文件名）
|
||
std::string full_path = parentPath.empty() ? comp_name : parentPath + "/" + comp_name;
|
||
|
||
// 添加到组件列表
|
||
allComponents.push_back(std::make_pair(feature, full_path));
|
||
|
||
// 如果是子装配体，递归分析
|
||
try {
|
||
pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
|
||
if (compFeat) {
|
||
pfcModel_ptr childModel = LoadComponentModel(compFeat);
|
||
if (childModel) {
|
||
wfcWAssembly_ptr childAssembly = wfcWAssembly::cast(childModel);
|
||
if (childAssembly) {
|
||
// 递归收集子装配体的组件
|
||
CollectAllComponentsForShellAnalysis(childAssembly, full_path, allComponents);
|
||
}
|
||
}
|
||
}
|
||
} catch (...) {
|
||
// 处理无法加载的子装配体，继续处理下一个
|
||
continue;
|
||
}
|
||
|
||
} catch (...) {
|
||
continue; // 忽略单个组件错误
|
||
}
|
||
}
|
||
|
||
} catch (...) {
|
||
// 处理整体错误
|
||
}
|
||
}
|
||
|
||
// 真实几何分析：判断特征是否接触模型边界
|
||
bool CreoManager::AnalyzeFeatureGeometry(pfcFeature_ptr feature, pfcOutline3D_ptr globalOutline, double tolerance) {
|
||
if (!feature || !globalOutline) {
|
||
return false; // 无法分析，假设不接触边界
|
||
}
|
||
|
||
try {
|
||
// 获取全局边界框
|
||
pfcPoint3D_ptr globalMin = globalOutline->get(0);
|
||
pfcPoint3D_ptr globalMax = globalOutline->get(1);
|
||
|
||
// 目前OTK没有直接的"特征边界框"API，我们使用特征类型来推断
|
||
// 这是基于特征语义的几何分析，比完全的猜测更准确
|
||
|
||
pfcFeatureType feat_type = feature->GetFeatType();
|
||
|
||
// === 基于特征语义的边界分析 ===
|
||
|
||
// 1. 构建外形的特征通常接触边界
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_PROTRUSION ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_SHELL ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_DOME ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_TORUS) {
|
||
return true; // 这些特征定义模型外形，必定接触边界
|
||
}
|
||
|
||
// 2. 基础几何特征通常在边界上
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_FIRST) {
|
||
return true; // 基础特征在边界
|
||
}
|
||
|
||
// 3. 内部加工特征通常不接触边界
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_HOLE ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_ROUND ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_CHAMFER ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_RIB ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_DRAFT) {
|
||
|
||
// 对于加工特征，进一步分析
|
||
// 倒角和圆角可能在边界上（修饰外形）
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_ROUND ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_CHAMFER) {
|
||
return true; // 倒角圆角通常修饰外形，接触边界
|
||
}
|
||
|
||
// CUT和HOLE通常是内部特征
|
||
return false; // 不接触边界
|
||
}
|
||
|
||
// 4. 基准特征通常与边界无关
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_DATUM_PLANE ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_DATUM_AXIS ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_DATUM_POINT ||
|
||
feat_type == pfcFeatureType::pfcFEATTYPE_COORD_SYS) {
|
||
return false; // 基准特征不影响几何边界
|
||
}
|
||
|
||
// 5. 装配体特征
|
||
if (feat_type == pfcFeatureType::pfcFEATTYPE_COMPONENT) {
|
||
// 组件特征需要进一步分析，这里暂时假设接触边界
|
||
return true;
|
||
}
|
||
|
||
// 6. 其他特征类型的默认处理
|
||
// 对于不确定的特征类型，采用保守策略（假设接触边界）
|
||
return true;
|
||
|
||
} catch (...) {
|
||
// 分析失败，采用保守策略
|
||
return true; // 假设接触边界，避免错误删除重要特征
|
||
}
|
||
}
|