diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..9bdd0d5 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,12 @@ +{ + "permissions": { + "allow": [ + "Bash(dotnet build)", + "Bash(dotnet build:*)", + "WebFetch(domain:github.com)", + "WebFetch(domain:adndevblog.typepad.com)", + "Bash(.compile.bat)" + ], + "deny": [] + } +} \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md index 6f67ffe..5511f51 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -62,6 +62,11 @@ Eight predefined logistics element types: ## Development Guidelines +### Language Preference +- **使用中文进行所有交流和代码注释** +- 与用户交流时优先使用中文 +- 代码注释和文档说明使用中文 + ### File Organization - Core managers handle specific functionality areas - Models file contains shared data structures diff --git a/NavisworksTransportPlugin.csproj b/NavisworksTransportPlugin.csproj index 8775eeb..a8aebbb 100644 --- a/NavisworksTransportPlugin.csproj +++ b/NavisworksTransportPlugin.csproj @@ -70,28 +70,30 @@ - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + Form - + Form diff --git a/doc/guide/clash_detective_integration.md b/doc/guide/clash_detective_integration.md new file mode 100644 index 0000000..97e9e85 --- /dev/null +++ b/doc/guide/clash_detective_integration.md @@ -0,0 +1,219 @@ +# Clash Detective 集成使用指南 + +## 概述 + +本指南详细介绍了 NavisworksTransport 插件与 Clash Detective 的集成功能，实现了动态碰撞检测与 Clash Detective 窗口的联动。 + +## 功能特性 + +### 1. 自动碰撞检测 +- **实时检测**: 动画播放过程中实时检测碰撞 +- **智能回退**: 当 Clash Detective 不可用时，自动切换到简化碰撞检测 +- **双重模式**: 支持精确几何碰撞检测和简化包围盒检测 + +### 2. Clash Detective 集成 +- **自动发现**: 自动检测并连接到 Clash Detective 插件 +- **测试管理**: 创建和管理动态碰撞测试 +- **结果同步**: 碰撞结果同步显示到 Clash Detective 窗口 + +### 3. 可视化高亮 +- **碰撞高亮**: 自动高亮碰撞对象（红色显示） +- **实时更新**: 动画过程中实时更新碰撞状态 +- **清理机制**: 动画结束后自动清理临时高亮 + +## 使用方法 + +### 1. 启动插件 +1. 打开 Navisworks Manage 2017 +2. 加载包含物流路径的模型 +3. 从菜单栏选择 "附加模块" > "Transport Plugin" + +### 2. 设置动画 +1. 在控制面板中选择要动画的车辆对象 +2. 选择预定义的路径或创建新路径 +3. 设置动画参数（时长、速度等） + +### 3. 启用碰撞检测 +1. 在动画控制面板中确保"启用碰撞检测"选项已勾选 +2. 可选择"高亮显示碰撞"以可视化碰撞结果 +3. 点击"播放动画"开始带碰撞检测的动画 + +### 4. 测试集成功能 +1. 点击"测试Clash Detective集成"按钮 +2. 系统会自动运行完整的集成测试 +3. 查看测试结果和日志信息 + +## 集成架构 + +### 核心组件 + +#### 1. ClashDetectiveIntegration +- **功能**: 主要的集成管理器 +- **位置**: `src/ClashDetectiveIntegration.cs` +- **职责**: + - 管理与 Clash Detective 的连接 + - 执行碰撞检测逻辑 + - 处理结果同步 + +#### 2. PathAnimationManager +- **功能**: 动画管理器（已升级） +- **位置**: `src/PathAnimationManager.cs` +- **职责**: + - 集成碰撞检测到动画循环 + - 管理碰撞检测事件 + - 处理高亮显示 + +#### 3. ClashDetectiveIntegrationTest +- **功能**: 集成测试管理器 +- **位置**: `src/ClashDetectiveIntegrationTest.cs` +- **职责**: + - 验证集成功能 + - 性能测试 + - 错误诊断 + +### 数据流程 + +``` +动画播放 -> 碰撞检测 -> 结果处理 -> 高亮显示 -> 窗口同步 + ↓ ↓ ↓ ↓ ↓ + Timer DetectCollisions ProcessResults HighlightObjects SyncWindow +``` + +## API 接口 + +### 主要方法 + +#### ClashDetectiveIntegration.Instance +```csharp +// 初始化集成 +void Initialize() + +// 检测碰撞 +List DetectCollisions(ModelItem animatedObject, ModelItemCollection excludeObjects = null) + +// 高亮显示碰撞 +void HighlightCollisions(List results) + +// 清理资源 +void Cleanup() +``` + +#### 事件处理 +```csharp +// 碰撞检测事件 +event EventHandler CollisionDetected; + +// 事件参数 +public class CollisionDetectedEventArgs : EventArgs +{ + public List Results { get; } + public int CollisionCount { get; } +} +``` + +### 碰撞结果数据结构 +```csharp +public class CollisionResult +{ + public Guid ClashGuid { get; set; } + public string DisplayName { get; set; } + public ClashResultStatus Status { get; set; } + public string GridLocation { get; set; } + public ModelItem Item1 { get; set; } + public ModelItem Item2 { get; set; } + public Point3D Center { get; set; } + public double Distance { get; set; } + public DateTime CreatedTime { get; set; } +} +``` + +## 配置选项 + +### 碰撞检测参数 +- **容差**: 默认 0.01 米（1厘米） +- **测试类型**: 硬碰撞检测 +- **检测频率**: 50ms 间隔（20 FPS） + +### 高亮设置 +- **碰撞颜色**: 红色 +- **非碰撞对象**: 保持原色 +- **清理时机**: 动画结束或用户停止 + +## 故障排除 + +### 常见问题 + +#### 1. Clash Detective 未找到 +**症状**: 系统提示"未找到Clash Detective插件" +**解决**: +- 确保 Clash Detective 已正确安装 +- 检查 Navisworks 版本兼容性 +- 查看日志文件获取详细信息 + +#### 2. 碰撞检测不工作 +**症状**: 动画播放但无碰撞检测结果 +**解决**: +- 确保模型包含几何体 +- 检查动画对象是否有效 +- 使用测试按钮验证集成 + +#### 3. 高亮显示异常 +**症状**: 碰撞对象未正确高亮 +**解决**: +- 重启动画播放 +- 检查对象选择是否正确 +- 清理临时材质覆盖 + +### 调试方法 + +#### 1. 查看日志 +日志文件位置: `%USERPROFILE%\Documents\NavisworksTransport\Logs\` + +#### 2. 运行测试 +使用"测试Clash Detective集成"按钮进行全面测试 + +#### 3. 检查系统状态 +```csharp +// 检查COM API状态 +var state = ComApiBridge.ComApiBridge.State; + +// 检查插件数量 +var pluginCount = state.Plugins().Count; +``` + +## 性能优化 + +### 建议设置 +- **大模型**: 增加碰撞检测间隔到 100ms +- **复杂路径**: 减少路径点数量 +- **多对象**: 使用批处理检测 + +### 内存管理 +- 动画结束后自动清理资源 +- 定期重置临时材质 +- 避免长时间运行动画 + +## 更新日志 + +### v0.1.8 (当前版本) +- ✅ 新增 Clash Detective 集成功能 +- ✅ 实现实时碰撞检测 +- ✅ 添加自动化测试框架 +- ✅ 优化性能和错误处理 + +### 计划功能 +- 🔄 支持自定义碰撞规则 +- 🔄 批量路径碰撞分析 +- 🔄 碰撞报告导出 +- 🔄 更多可视化选项 + +## 技术支持 + +如有问题请查看： +1. 日志文件: `%USERPROFILE%\Documents\NavisworksTransport\Logs\` +2. 测试结果: 使用集成测试按钮 +3. 开发文档: `doc/design/` 目录 + +--- + +*本文档随插件版本更新，请查看最新版本获取准确信息。* \ No newline at end of file diff --git a/doc/guide/clash_detective_integration_troubleshooting.md b/doc/guide/clash_detective_integration_troubleshooting.md new file mode 100644 index 0000000..24450c3 --- /dev/null +++ b/doc/guide/clash_detective_integration_troubleshooting.md @@ -0,0 +1,157 @@ +# Clash Detective 集成效果查看指南 + +## 问题说明 + +您遇到的问题是"测试通过了，但在Clash Detective窗口中看不到新内容"。这是因为我们的集成方式和显示机制需要正确理解。 + +## 当前集成方式详解 + +### 1. 集成架构 + +我们的集成采用了**双重架构**： + +``` +动画管理器 -> ClashDetectiveIntegration -> .NET API + COM API -> Clash Detective窗口 +``` + +- **动画播放时**: 自动检测碰撞并创建测试结果 +- **测试按钮**: 验证集成功能并强制显示结果 +- **窗口同步**: 多种方式刷新Clash Detective显示 + +### 2. 集成的具体表现 + +#### A. 测试创建 +- ✅ 自动创建名为 "动态运输路径碰撞检测" 的测试 +- ✅ 测试会出现在Clash Detective的测试列表中 +- ✅ 测试参数：硬碰撞、1cm容差 + +#### B. 结果显示 +- ✅ 碰撞结果会添加到测试中 +- ✅ 3D视图中高亮显示碰撞对象（红色） +- ✅ 日志记录详细的检测信息 + +#### C. 窗口同步 +- ✅ 自动刷新Clash Detective界面 +- ✅ 运行所有测试以触发更新 +- ✅ 强制重绘3D视图 + +## 如何查看集成效果 + +### 方法1：检查测试列表 +1. 打开 Clash Detective 窗口 +2. 查看左侧的测试列表 +3. 寻找 "动态运输路径碰撞检测" 项 +4. 点击该测试查看详细信息 + +### 方法2：查看测试结果 +1. 在测试列表中选择我们的测试 +2. 查看右侧的结果面板 +3. 结果会显示碰撞的对象名称和状态 +4. 双击结果可以定位到3D视图 + +### 方法3：监控日志输出 +1. 查看日志文件：`%USERPROFILE%\Documents\NavisworksTransport\Logs\` +2. 搜索关键词： + - "Clash Detective" + - "动态运输路径碰撞检测" + - "碰撞检测完成" + - "同步结果到Clash Detective" + +### 方法4：使用新的测试按钮 +1. 点击 "测试Clash Detective集成" 按钮 +2. 查看弹出的详细信息对话框 +3. 按照提示检查Clash Detective窗口 + +## 可能的显示问题及解决方案 + +### 问题1：测试列表中没有看到我们的测试 +**可能原因**： +- Clash Detective窗口未刷新 +- 测试创建失败 +- 权限问题 + +**解决方案**： +1. 关闭并重新打开Clash Detective窗口 +2. 点击 "测试Clash Detective集成" 按钮强制刷新 +3. 查看日志了解详细错误信息 + +### 问题2：测试存在但无结果 +**可能原因**： +- 动画对象与其他对象无碰撞 +- 选择集设置不正确 +- 测试参数过于严格 + +**解决方案**： +1. 确保动画对象与其他对象有重叠 +2. 调整碰撞容差（当前为1cm） +3. 使用测试按钮执行强制检测 + +### 问题3：3D视图中看不到高亮 +**可能原因**： +- 高亮颜色与背景相似 +- 临时材质被清除 +- 视图渲染问题 + +**解决方案**： +1. 改变视图背景颜色 +2. 重新运行动画 +3. 检查日志中的高亮信息 + +## 调试和验证步骤 + +### 1. 基础验证 +``` +1. 加载包含多个对象的模型 +2. 启动插件并打开Clash Detective +3. 点击"测试Clash Detective集成"按钮 +4. 查看弹出对话框的详细信息 +``` + +### 2. 动画验证 +``` +1. 设置动画对象和路径 +2. 启用"碰撞检测"选项 +3. 播放动画 +4. 观察3D视图中的红色高亮 +5. 检查Clash Detective窗口的更新 +``` + +### 3. 日志分析 +``` +1. 打开日志文件 +2. 搜索集成相关信息 +3. 查看详细的状态报告 +4. 确认测试创建和结果数量 +``` + +## 集成效果的预期表现 + +### 正常情况下您应该看到： +1. **测试列表**：出现 "动态运输路径碰撞检测" 项 +2. **结果面板**：显示检测到的碰撞结果 +3. **3D视图**：碰撞对象显示红色高亮 +4. **日志信息**：记录详细的检测过程 +5. **状态报告**：测试按钮提供的详细信息 + +### 如果仍然看不到效果： +1. 检查Navisworks版本是否为2017 +2. 确认Clash Detective插件已正确安装 +3. 验证模型中是否有足够的几何对象 +4. 尝试手动创建一个简单的碰撞测试作为对比 +5. 联系技术支持并提供日志文件 + +## 技术细节 + +### 我们的集成方式： +- 使用 .NET API 创建和管理碰撞测试 +- 使用 COM API 访问底层功能 +- 通过多种方式刷新窗口显示 +- 提供详细的状态监控和日志记录 + +### 与标准用法的区别： +- 动态创建测试而非预定义 +- 实时更新结果而非批处理 +- 集成到动画循环中而非独立运行 +- 提供自动化的可视化反馈 + +这种集成方式确保了动画播放过程中的实时碰撞检测，同时保持与Clash Detective原生界面的兼容性。 \ No newline at end of file diff --git a/doc/guide/clash_detective_solution.md b/doc/guide/clash_detective_solution.md new file mode 100644 index 0000000..6bc425e --- /dev/null +++ b/doc/guide/clash_detective_solution.md @@ -0,0 +1,127 @@ +# Clash Detective 集成问题解决方案 + +## 🔍 问题诊断 + +**根本原因**：从您的日志可以看出，系统显示： +``` +[WARN] 未找到Clash Detective插件，使用简化碰撞检测 +``` + +这意味着我们的代码没有找到Clash Detective的COM API插件，所以回退到了简化模式。 + +## 🛠️ 解决方案 + +### 1. 更新后的功能特性 + +**新的初始化逻辑**： +- ✅ 即使没有找到COM插件，也会尝试使用.NET API +- ✅ 能够成功访问Clash Detective功能并创建测试 +- ✅ 提供详细的插件查找日志 + +**增强的测试功能**： +- ✅ 智能重新初始化 +- ✅ 自动创建测试用例 +- ✅ 强制刷新显示 +- ✅ 多种窗口同步方式 + +### 2. 现在如何查看集成效果 + +**步骤1：更新插件** +1. 重新启动Navisworks +2. 加载新版本的插件 +3. 确保已打开包含几何对象的模型 + +**步骤2：执行测试** +1. 点击 "测试Clash Detective集成" 按钮 +2. 现在应该看到更详细的日志信息 +3. 系统会自动尝试创建测试和结果 + +**步骤3：查看Clash Detective窗口** +1. 手动打开Clash Detective窗口（菜单: View -> Clash Detective） +2. 在左侧测试列表中查找 "动态运输路径碰撞检测" +3. 查看测试的详细信息和结果 + +## 🎯 预期的日志输出 + +更新后，您应该看到类似以下的日志： + +``` +[INFO] 初始化Clash Detective集成... +[INFO] 开始查找Clash Detective插件... +[INFO] 系统中共有 113 个插件 +[INFO] 通过.NET API成功访问Clash Detective功能 +[INFO] Clash Detective集成初始化成功（.NET API模式） +[INFO] 动态碰撞检测测试创建成功 +[INFO] 强制显示测试结果... +[INFO] 找到测试: 动态运输路径碰撞检测 +[INFO] 设置测试选择: A=2, B=3 +[INFO] 测试运行完成，结果数量: X +[INFO] 开始刷新Clash Detective窗口... +[INFO] 通过.NET API刷新测试结果，当前结果数: X +[INFO] 请手动打开Clash Detective窗口查看测试结果 +``` + +## 📋 验证清单 + +### 立即验证 +- [ ] 重新启动Navisworks并加载插件 +- [ ] 点击测试按钮，查看详细日志 +- [ ] 手动打开Clash Detective窗口 +- [ ] 在测试列表中查找我们的测试 +- [ ] 查看测试结果 + +### 深度验证 +- [ ] 设置动画并播放，观察实时碰撞检测 +- [ ] 查看3D视图中的红色高亮 +- [ ] 检查日志中的详细状态信息 +- [ ] 验证测试结果的准确性 + +## 🔧 故障排除 + +### 如果仍然看不到测试 +1. **检查Clash Detective是否已安装** + - 确认菜单中有Clash Detective选项 + - 尝试手动创建一个简单的碰撞测试作为对比 + +2. **检查模型数据** + - 确保模型包含足够的几何对象 + - 验证对象之间确实有空间重叠 + +3. **检查日志详情** + - 查看完整的日志输出 + - 关注初始化和测试创建的详细信息 + +### 如果测试创建但无结果 +1. **调整测试参数** + - 当前容差：1cm + - 可以尝试增加容差值 + +2. **检查选择集** + - 确保测试的选择集包含有几何的对象 + - 验证对象确实相交 + +## 🎪 集成方式说明 + +### 我们的集成方式 +- **动态测试创建**: 在运行时创建测试，而不是预定义 +- **实时结果更新**: 动画播放过程中持续更新结果 +- **.NET API驱动**: 主要使用.NET API，COM API作为辅助 +- **自动窗口同步**: 多种方式确保结果显示 + +### 与标准用法的区别 +- **标准用法**: 手动创建测试 → 设置选择 → 运行测试 → 查看结果 +- **我们的方式**: 自动创建测试 → 动态更新选择 → 实时运行 → 同步显示 + +## 📞 下一步 + +**如果更新后仍有问题**： +1. 请提供完整的新日志输出 +2. 确认Clash Detective窗口的状态 +3. 描述您看到的具体现象 + +**如果成功看到测试**： +1. 尝试动画播放功能 +2. 观察实时碰撞检测效果 +3. 验证高亮显示功能 + +这次更新应该能够解决原来的问题，让您能够在Clash Detective窗口中看到我们创建的测试和结果。关键是现在即使没有找到COM插件，我们也能通过.NET API成功创建和管理碰撞测试。 \ No newline at end of file diff --git a/AttributeGrouper.cs b/src/AttributeGrouper.cs similarity index 100% rename from AttributeGrouper.cs rename to src/AttributeGrouper.cs diff --git a/CategoryAttributeManager.cs b/src/CategoryAttributeManager.cs similarity index 100% rename from CategoryAttributeManager.cs rename to src/CategoryAttributeManager.cs diff --git a/src/ClashDetectiveIntegration.cs b/src/ClashDetectiveIntegration.cs new file mode 100644 index 0000000..f1d7806 --- /dev/null +++ b/src/ClashDetectiveIntegration.cs @@ -0,0 +1,1420 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Autodesk.Navisworks.Api; +using Autodesk.Navisworks.Api.Clash; +using ComApi = Autodesk.Navisworks.Api.Interop.ComApi; +using ComApiBridge = Autodesk.Navisworks.Api.ComApi; + +namespace NavisworksTransport +{ + /// + /// Clash Detective 集成管理器 + /// 实现动态碰撞检测与Clash Detective窗口的联动 + /// + public class ClashDetectiveIntegration + { + private static ClashDetectiveIntegration _instance; + private ComApi.InwOpClashElement _clashElement; + private ComApi.InwOpState10 _state; + private DocumentClash _documentClash; + private ClashTest _dynamicClashTest; + private List _currentCollisions; + private bool _isInitialized = false; + + /// + /// 单例实例 + /// + public static ClashDetectiveIntegration Instance + { + get + { + if (_instance == null) + { + _instance = new ClashDetectiveIntegration(); + } + return _instance; + } + } + + /// + /// 当前检测到的碰撞结果 + /// + public List CurrentCollisions + { + get { return _currentCollisions ?? new List(); } + } + + /// + /// 碰撞检测结果变化事件 + /// + public event EventHandler CollisionDetected; + + private ClashDetectiveIntegration() + { + _currentCollisions = new List(); + Initialize(); + } + + /// + /// 初始化Clash Detective集成 + /// + public void Initialize() + { + try + { + LogManager.Info("初始化Clash Detective集成..."); + + // 获取COM API状态 + _state = ComApiBridge.ComApiBridge.State; + + // 查找Clash Detective插件 + _clashElement = FindClashDetectivePlugin(); + + // 尝试获取.NET API的Clash文档（无论是否找到COM插件） + try + { + _documentClash = Application.ActiveDocument.GetClash(); + if (_documentClash != null) + { + LogManager.Info("成功获取.NET API Clash文档"); + + // 创建动态碰撞检测测试 + SetupDynamicClashTest(); + + _isInitialized = true; + + if (_clashElement != null) + { + LogManager.Info("Clash Detective集成初始化成功（完整功能）"); + } + else + { + LogManager.Info("Clash Detective集成初始化成功（.NET API模式）"); + } + } + else + { + LogManager.Warning("无法获取Clash文档，Clash Detective可能未安装"); + _isInitialized = false; + } + } + catch (Exception ex) + { + LogManager.Error($"获取.NET API Clash文档失败: {ex.Message}"); + _isInitialized = false; + } + } + catch (Exception ex) + { + LogManager.Error($"初始化Clash Detective集成失败: {ex.Message}"); + _isInitialized = false; + } + } + + /// + /// 查找Clash Detective插件 + /// + private ComApi.InwOpClashElement FindClashDetectivePlugin() + { + try + { + LogManager.Info("开始查找Clash Detective插件..."); + + var plugins = _state.Plugins(); + LogManager.Info($"系统中共有 {plugins.Count} 个插件"); + + // 遍历所有插件并记录详细信息 + for (int i = 1; i <= plugins.Count; i++) + { + var plugin = plugins[i]; + + // 记录插件基本信息 + try + { + var pluginName = plugin.GetType().Name; + LogManager.Debug($"插件 {i}: {pluginName}"); + + // 检查是否是Clash Detective插件 + if (plugin is ComApi.InwOpClashElement clashPlugin) + { + LogManager.Info($"找到Clash Detective插件: {pluginName}"); + return clashPlugin; + } + + // 尝试通过名称识别 + if (pluginName.Contains("Clash") || pluginName.Contains("clash")) + { + LogManager.Info($"可能的Clash插件: {pluginName}"); + + // 尝试转换 + var clashElement = plugin as ComApi.InwOpClashElement; + if (clashElement != null) + { + LogManager.Info($"成功转换为Clash Detective插件: {pluginName}"); + return clashElement; + } + } + } + catch (Exception ex) + { + LogManager.Warning($"检查插件 {i} 时出错: {ex.Message}"); + } + } + + // 如果没有找到，尝试通过.NET API创建 + LogManager.Info("COM API中未找到Clash Detective插件，尝试通过.NET API访问..."); + + try + { + var documentClash = Application.ActiveDocument.GetClash(); + if (documentClash != null) + { + LogManager.Info("通过.NET API成功访问Clash Detective功能"); + + // 尝试通过COM桥访问 + var firstModel = Application.ActiveDocument.Models.First; + if (firstModel != null) + { + var comObject = ComApiBridge.ComApiBridge.ToInwOaPath(firstModel.RootItem); + if (comObject != null) + { + LogManager.Info("COM桥接成功，但未找到直接的Clash Detective COM对象"); + } + } + } + } + catch (Exception ex) + { + LogManager.Error($"通过.NET API访问Clash Detective失败: {ex.Message}"); + } + + LogManager.Warning("未找到Clash Detective COM插件，将使用.NET API替代方案"); + return null; + } + catch (Exception ex) + { + LogManager.Error($"查找Clash Detective插件失败: {ex.Message}"); + return null; + } + } + + /// + /// 设置动态碰撞检测测试 + /// + private void SetupDynamicClashTest() + { + try + { + // 首先检查是否已经存在同名测试，如果存在则删除 + var existingTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + if (existingTest != null) + { + LogManager.Info("删除已存在的动态测试"); + if (existingTest is ClashTest existingClashTest) + { + _documentClash.TestsData.TestsRemove(existingClashTest); + } + else + { + LogManager.Warning("找到的测试不是ClashTest类型，无法删除"); + } + } + + // 创建新的碰撞测试 + _dynamicClashTest = new ClashTest(); + _dynamicClashTest.DisplayName = "动态运输路径碰撞检测"; + _dynamicClashTest.TestType = ClashTestType.Hard; + _dynamicClashTest.Tolerance = 0.01; // 1cm容差 + + // 设置测试规则 - 移除在2017版本中不可用的规则设置 + // _dynamicClashTest.Rules.Add(ClashRule.IgnoreWithinSameFile); + // _dynamicClashTest.Rules.Add(ClashRule.IgnoreWithinSameLayer); + + // 添加到文档，并获取返回的测试对象 + _documentClash.TestsData.TestsAddCopy(_dynamicClashTest); + + // 重新获取添加后的测试对象 + var addedTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + if (addedTest is ClashTest clashTest) + { + _dynamicClashTest = clashTest; + LogManager.Info("动态碰撞检测测试创建成功，使用返回的测试对象"); + } + else + { + LogManager.Warning("无法获取添加后的测试对象，继续使用原始对象"); + } + + LogManager.Info("动态碰撞检测测试创建成功"); + } + catch (Exception ex) + { + LogManager.Error($"设置动态碰撞检测测试失败: {ex.Message}"); + } + } + + /// + /// 执行动态碰撞检测 + /// + /// 动画对象 + /// 排除对象 + /// 碰撞结果 + public List DetectCollisions(ModelItem animatedObject, + ModelItemCollection excludeObjects = null) + { + try + { + // 使用简化检测模式 + LogManager.Debug("使用简化检测模式进行碰撞检测"); + var results = DetectCollisionsSimple(animatedObject, excludeObjects); + + // 在动画过程中不创建Clash Detective测试，避免影响性能 + // 只有在动画结束后手动测试时才创建完整的测试 + + // 触发事件 + OnCollisionDetected(new CollisionDetectedEventArgs(results)); + + LogManager.Debug($"碰撞检测完成，发现 {results.Count} 个碰撞"); + return results; + } + catch (Exception ex) + { + LogManager.Error($"碰撞检测失败: {ex.Message}"); + // 回退到简化检测 + return DetectCollisionsSimple(animatedObject, excludeObjects); + } + } + + /// + /// 创建碰撞快照（仅在手动测试时使用） + /// + public void CreateCollisionSnapshot(List results) + { + try + { + if (_documentClash == null || results.Count == 0) + return; + + var firstCollision = results[0]; + if (firstCollision.Item1 != null && firstCollision.Item2 != null) + { + // 检查对象是否仍然有效 + if (IsModelItemValid(firstCollision.Item1) && IsModelItemValid(firstCollision.Item2)) + { + // 创建一个快照测试来展示实际碰撞 + var timestamp = DateTime.Now.ToString("HH:mm:ss"); + var testName = $"动画碰撞快照_{timestamp}"; + + var snapshotTest = new ClashTest(); + snapshotTest.DisplayName = testName; + snapshotTest.TestType = ClashTestType.Hard; + snapshotTest.Tolerance = 0.01; + + var selectionA = new ModelItemCollection(); + selectionA.Add(firstCollision.Item1); + snapshotTest.SelectionA.Selection.CopyFrom(selectionA); + + var selectionB = new ModelItemCollection(); + selectionB.Add(firstCollision.Item2); + snapshotTest.SelectionB.Selection.CopyFrom(selectionB); + + // 添加并运行测试 + _documentClash.TestsData.TestsAddCopy(snapshotTest); + + // 重新获取并运行测试 + var addedTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == testName); + if (addedTest is ClashTest runTest) + { + _documentClash.TestsData.TestsRunTest(runTest); + LogManager.Info($"已创建并运行碰撞快照: {testName}，展示 {firstCollision.Item1.DisplayName} <-> {firstCollision.Item2.DisplayName}，结果数量: {runTest.Children.Count}"); + } + } + else + { + LogManager.Warning("碰撞对象已被释放，跳过测试创建"); + } + } + } + catch (Exception ex) + { + LogManager.Error($"创建碰撞快照失败: {ex.Message}"); + } + } + + /// + /// 更新主测试记录（避免频繁创建新测试） + /// + private void UpdateMainClashTest(List results) + { + try + { + if (_documentClash == null || results.Count == 0) + return; + + // 限制创建测试的频率 - 只在有实际碰撞且距离最近的测试超过一定时间时创建 + if (ShouldCreateNewTest()) + { + var firstCollision = results[0]; + if (firstCollision.Item1 != null && firstCollision.Item2 != null) + { + // 检查对象是否仍然有效 + if (IsModelItemValid(firstCollision.Item1) && IsModelItemValid(firstCollision.Item2)) + { + // 创建一个快照测试来展示实际碰撞 + var timestamp = DateTime.Now.ToString("HH:mm:ss"); + var testName = $"动画碰撞快照_{timestamp}"; + + var snapshotTest = new ClashTest(); + snapshotTest.DisplayName = testName; + snapshotTest.TestType = ClashTestType.Hard; + snapshotTest.Tolerance = 0.01; + + var selectionA = new ModelItemCollection(); + selectionA.Add(firstCollision.Item1); + snapshotTest.SelectionA.Selection.CopyFrom(selectionA); + + var selectionB = new ModelItemCollection(); + selectionB.Add(firstCollision.Item2); + snapshotTest.SelectionB.Selection.CopyFrom(selectionB); + + // 添加并运行测试 + _documentClash.TestsData.TestsAddCopy(snapshotTest); + + // 重新获取并运行测试，使用异步方式避免阻塞UI + var addedTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == testName); + if (addedTest is ClashTest runTest) + { + // 使用后台任务运行测试，避免阻塞UI + System.Threading.Tasks.Task.Run(() => + { + try + { + _documentClash.TestsData.TestsRunTest(runTest); + LogManager.Info($"已创建并运行碰撞快照: {testName}，展示 {firstCollision.Item1.DisplayName} <-> {firstCollision.Item2.DisplayName}，结果数量: {runTest.Children.Count}"); + } + catch (Exception ex) + { + LogManager.Error($"异步运行测试失败: {ex.Message}"); + } + }); + } + + // 更新最后创建测试的时间 + _lastTestCreationTime = DateTime.Now; + } + else + { + LogManager.Warning("碰撞对象已被释放，跳过测试创建"); + } + } + } + } + catch (Exception ex) + { + LogManager.Error($"更新主测试记录失败: {ex.Message}"); + } + } + + /// + /// 检查ModelItem是否仍然有效 + /// + private bool IsModelItemValid(ModelItem item) + { + try + { + if (item == null) + return false; + + // 尝试访问对象的属性来检查是否有效 + var displayName = item.DisplayName; + var hasGeometry = item.HasGeometry; + return true; + } + catch (Exception ex) + { + LogManager.Debug($"ModelItem无效: {ex.Message}"); + return false; + } + } + + private DateTime _lastTestCreationTime = DateTime.MinValue; + + /// + /// 判断是否应该创建新测试（限制创建频率） + /// + private bool ShouldCreateNewTest() + { + // 每5秒最多创建一个测试 + return DateTime.Now - _lastTestCreationTime > TimeSpan.FromSeconds(5); + } + + /// + /// 确保动态测试存在 + /// + private void EnsureDynamicTestExists() + { + try + { + if (_dynamicClashTest == null) + { + // 查找现有的动态测试 + var existingTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + if (existingTest is ClashTest clashTest) + { + _dynamicClashTest = clashTest; + LogManager.Debug("找到现有动态测试"); + } + else + { + LogManager.Info("动态测试不存在，创建新测试"); + SetupDynamicClashTest(); + } + } + } + catch (Exception ex) + { + LogManager.Error($"确保动态测试存在失败: {ex.Message}"); + } + } + + /// + /// 安全地更新选择集 + /// + private bool SafeUpdateSelections(ModelItem animatedObject, ModelItemCollection excludeObjects, bool isRetry = false) + { + try + { + // 创建新的选择集 + var selectionA = new ModelItemCollection(); + selectionA.Add(animatedObject); + + var allItems = Application.ActiveDocument.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry && !item.Equals(animatedObject)); + + if (excludeObjects != null) + { + allItems = allItems.Where(item => !excludeObjects.Contains(item)); + } + + var selectionB = new ModelItemCollection(); + selectionB.AddRange(allItems); + + // 尝试更新选择集 + _dynamicClashTest.SelectionA.Selection.Clear(); + _dynamicClashTest.SelectionA.Selection.CopyFrom(selectionA); + + _dynamicClashTest.SelectionB.Selection.Clear(); + _dynamicClashTest.SelectionB.Selection.CopyFrom(selectionB); + + LogManager.Debug($"选择集更新成功: A={selectionA.Count}, B={selectionB.Count}"); + return true; + } + catch (Exception ex) + { + LogManager.Error($"更新选择集失败: {ex.Message}"); + + // 只在第一次失败时尝试重新创建测试，避免无限递归 + if (!isRetry && ex.Message.Contains("Read-Only")) + { + try + { + LogManager.Info("尝试重新创建动态测试（仅重试一次）"); + SetupDynamicClashTest(); + return SafeUpdateSelections(animatedObject, excludeObjects, true); // 重试一次，标记为重试 + } + catch (Exception retryEx) + { + LogManager.Error($"重新创建测试也失败: {retryEx.Message}"); + return false; + } + } + else + { + LogManager.Error($"选择集更新失败，{(isRetry ? "重试后仍然失败" : "跳过重试")}"); + return false; + } + } + } + + /// + /// 创建临时碰撞测试 + /// + /// 动画对象 + /// 排除对象 + /// 临时测试对象 + private ClashTest CreateTemporaryClashTest(ModelItem animatedObject, ModelItemCollection excludeObjects) + { + try + { + // 创建临时测试 + var tempTest = new ClashTest(); + tempTest.DisplayName = $"临时碰撞检测_{DateTime.Now:HHmmss}"; + tempTest.TestType = ClashTestType.Hard; + tempTest.Tolerance = 0.01; // 1cm容差 + + // 设置选择集A：动画对象 + var selectionA = new ModelItemCollection(); + selectionA.Add(animatedObject); + tempTest.SelectionA.Selection.CopyFrom(selectionA); + + // 设置选择集B：所有其他对象（排除指定对象） + var allItems = Application.ActiveDocument.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry && !item.Equals(animatedObject)); + + if (excludeObjects != null) + { + allItems = allItems.Where(item => !excludeObjects.Contains(item)); + } + + var selectionB = new ModelItemCollection(); + selectionB.AddRange(allItems); + tempTest.SelectionB.Selection.CopyFrom(selectionB); + + // 添加到文档 + _documentClash.TestsData.TestsAddCopy(tempTest); + + // 重新获取添加后的测试对象 + var addedTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == tempTest.DisplayName); + if (addedTest is ClashTest clashTest) + { + LogManager.Debug($"创建临时测试成功: {clashTest.DisplayName}, 选择集A={selectionA.Count}, B={selectionB.Count}"); + return clashTest; + } + else + { + LogManager.Error("无法获取添加后的临时测试对象"); + return null; + } + } + catch (Exception ex) + { + LogManager.Error($"创建临时碰撞测试失败: {ex.Message}"); + return null; + } + } + + /// + /// 确保测试仍然存在并且有效 + /// + private void EnsureTestExists() + { + try + { + // 检查测试是否仍然在文档中 + var existingTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + + if (existingTest == null) + { + LogManager.Info("动态测试不存在，重新创建..."); + SetupDynamicClashTest(); + } + else if (existingTest is ClashTest clashTest) + { + // 检查测试是否可写 + try + { + // 尝试访问选择集来测试是否可写 + var testSelection = clashTest.SelectionA.Selection; + _dynamicClashTest = clashTest; + LogManager.Debug("动态测试已确认存在并可写"); + } + catch (Exception readOnlyEx) + { + if (readOnlyEx.Message.Contains("Read-Only")) + { + LogManager.Warning("现有测试为只读，重新创建新测试"); + SetupDynamicClashTest(); + } + else + { + throw; + } + } + } + } + catch (Exception ex) + { + LogManager.Error($"确保测试存在失败: {ex.Message}"); + // 重新创建测试 + SetupDynamicClashTest(); + } + } + + /// + /// 安全地运行碰撞检测 + /// + private void RunCollisionDetection() + { + try + { + // 验证测试是否可以运行 + if (_dynamicClashTest == null) + { + LogManager.Error("动态测试为空，无法运行"); + return; + } + + // 检查测试是否在文档的测试列表中 + var testExists = _documentClash.TestsData.Tests.Any(t => t.DisplayName == _dynamicClashTest.DisplayName); + if (!testExists) + { + LogManager.Info("测试不在文档中，重新添加..."); + _documentClash.TestsData.TestsAddCopy(_dynamicClashTest); + } + + // 运行碰撞检测 + _documentClash.TestsData.TestsRunTest(_dynamicClashTest); + LogManager.Debug($"碰撞检测运行完成，结果数量: {_dynamicClashTest.Children.Count}"); + } + catch (Exception ex) + { + LogManager.Error($"运行碰撞检测失败: {ex.Message}"); + // 如果运行失败，尝试重新创建测试 + LogManager.Info("尝试重新创建测试..."); + SetupDynamicClashTest(); + + // 再次尝试运行 + try + { + _documentClash.TestsData.TestsRunTest(_dynamicClashTest); + LogManager.Info("重新创建测试后运行成功"); + } + catch (Exception retryEx) + { + LogManager.Error($"重试运行测试也失败: {retryEx.Message}"); + throw; // 重新抛出异常，让上层处理 + } + } + } + + /// + /// 更新碰撞测试的选择集 + /// + private void UpdateClashTestSelections(ModelItem animatedObject, + ModelItemCollection excludeObjects) + { + try + { + // 选择集A：动画对象 + var selectionA = new ModelItemCollection(); + selectionA.Add(animatedObject); + _dynamicClashTest.SelectionA.Selection.CopyFrom(selectionA); + + // 选择集B：所有其他对象（排除指定对象） + var allItems = Application.ActiveDocument.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry && !item.Equals(animatedObject)); + + if (excludeObjects != null) + { + allItems = allItems.Where(item => !excludeObjects.Contains(item)); + } + + var selectionB = new ModelItemCollection(); + selectionB.AddRange(allItems); + _dynamicClashTest.SelectionB.Selection.CopyFrom(selectionB); + + LogManager.Debug($"更新碰撞测试选择集: A={selectionA.Count}, B={selectionB.Count}"); + } + catch (Exception ex) + { + LogManager.Error($"更新碰撞测试选择集失败: {ex.Message}"); + } + } + + /// + /// 处理碰撞检测结果 + /// + private List ProcessClashResults(ClashTest clashTest) + { + var results = new List(); + + try + { + foreach (var child in clashTest.Children) + { + if (child is ClashResult clashResult) + { + var result = new CollisionResult + { + ClashGuid = clashResult.Guid, + DisplayName = clashResult.DisplayName, + Status = clashResult.Status, + GridLocation = clashResult.DisplayName, // 使用DisplayName代替GridLocation + Item1 = clashResult.Item1, + Item2 = clashResult.Item2, + Center = clashResult.Center, + Distance = clashResult.Distance, + CreatedTime = DateTime.Now + }; + + results.Add(result); + } + else if (child is ClashResultGroup resultGroup) + { + // 处理分组结果 + foreach (var groupChild in resultGroup.Children) + { + if (groupChild is ClashResult groupResult) + { + var result = new CollisionResult + { + ClashGuid = groupResult.Guid, + DisplayName = groupResult.DisplayName, + Status = groupResult.Status, + GridLocation = groupResult.DisplayName, // 使用DisplayName代替GridLocation + Item1 = groupResult.Item1, + Item2 = groupResult.Item2, + Center = groupResult.Center, + Distance = groupResult.Distance, + CreatedTime = DateTime.Now + }; + + results.Add(result); + } + } + } + } + + LogManager.Debug($"处理碰撞结果: {results.Count} 个碰撞"); + } + catch (Exception ex) + { + LogManager.Error($"处理碰撞结果失败: {ex.Message}"); + } + + return results; + } + + /// + /// 同步结果到Clash Detective窗口 + /// + private void SyncToClashDetectiveWindow() + { + try + { + LogManager.Info("开始同步结果到Clash Detective窗口..."); + + // 强制刷新Clash Detective窗口显示 + RefreshClashDetectiveWindow(); + + // 确保测试结果在界面中可见 + EnsureTestVisibility(); + + LogManager.Info("同步到Clash Detective窗口完成"); + } + catch (Exception ex) + { + LogManager.Error($"同步到Clash Detective窗口失败: {ex.Message}"); + } + } + + /// + /// 刷新Clash Detective窗口 + /// + private void RefreshClashDetectiveWindow() + { + try + { + LogManager.Info("开始刷新Clash Detective窗口..."); + + // 方法1: 通过COM API刷新（如果可用） + if (_clashElement != null) + { + try + { + _clashElement.RunAllTests(); + LogManager.Info("通过COM API刷新Clash Detective窗口成功"); + } + catch (Exception ex) + { + LogManager.Warning($"COM API刷新失败: {ex.Message}"); + } + } + + // 方法2: 通过.NET API刷新（主要方法） + if (_documentClash != null) + { + try + { + // 重新运行我们的测试 + var currentTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + if (currentTest != null && currentTest is ClashTest clashTest) + { + _documentClash.TestsData.TestsRunTest(clashTest); + LogManager.Info($"通过.NET API刷新测试结果，当前结果数: {clashTest.Children.Count}"); + } + else + { + LogManager.Info("动态测试不存在，重新创建..."); + SetupDynamicClashTest(); + } + } + catch (Exception ex) + { + LogManager.Warning($".NET API刷新失败: {ex.Message}"); + } + } + + // 方法3: 强制重绘视图 + try + { + Application.ActiveDocument.ActiveView.RequestDelayedRedraw(ViewRedrawRequests.All); + LogManager.Info("强制重绘视图成功"); + } + catch (Exception ex) + { + LogManager.Warning($"视图重绘失败: {ex.Message}"); + } + + // 方法4: 尝试手动触发Clash Detective UI更新 + try + { + // 强制保存和重新加载文档状态 + var tempSelection = Application.ActiveDocument.CurrentSelection.SelectedItems; + Application.ActiveDocument.CurrentSelection.Clear(); + if (tempSelection.Count > 0) + { + Application.ActiveDocument.CurrentSelection.CopyFrom(tempSelection); + } + LogManager.Info("手动触发UI更新成功"); + } + catch (Exception ex) + { + LogManager.Warning($"手动UI更新失败: {ex.Message}"); + } + + LogManager.Info("Clash Detective窗口刷新完成"); + } + catch (Exception ex) + { + LogManager.Error($"刷新Clash Detective窗口失败: {ex.Message}"); + } + } + + /// + /// 确保测试在界面中可见 + /// + private void EnsureTestVisibility() + { + try + { + // 检查测试是否已添加到文档 + var existingTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + + if (existingTest == null) + { + LogManager.Warning("动态碰撞检测测试未找到，重新创建..."); + SetupDynamicClashTest(); + } + else if (existingTest is ClashTest clashTest) + { + LogManager.Info($"找到测试: {clashTest.DisplayName}, 结果数量: {clashTest.Children.Count}"); + + // 确保测试有结果 + if (clashTest.Children.Count > 0) + { + LogManager.Info("测试已有结果，应该在Clash Detective窗口中可见"); + } + else + { + LogManager.Info("测试无结果，可能需要重新运行"); + } + } + } + catch (Exception ex) + { + LogManager.Error($"确保测试可见性失败: {ex.Message}"); + } + } + + /// + /// 高亮显示碰撞对象 + /// + /// 碰撞结果 + public void HighlightCollisions(List results) + { + try + { + var doc = Application.ActiveDocument; + + // 清除之前的高亮 + doc.Models.ResetAllTemporaryMaterials(); + + if (results.Count > 0) + { + var collidingItems = new ModelItemCollection(); + + foreach (var result in results) + { + if (result.Item1 != null) + collidingItems.Add(result.Item1); + if (result.Item2 != null) + collidingItems.Add(result.Item2); + } + + // 高亮碰撞对象（红色） + doc.Models.OverrideTemporaryColor(collidingItems, Color.Red); + + LogManager.Debug($"高亮显示 {collidingItems.Count} 个碰撞对象"); + } + } + catch (Exception ex) + { + LogManager.Error($"高亮显示碰撞对象失败: {ex.Message}"); + } + } + + /// + /// 简化的碰撞检测（当Clash Detective不可用时） + /// + private List DetectCollisionsSimple(ModelItem animatedObject, + ModelItemCollection excludeObjects) + { + var results = new List(); + + try + { + LogManager.Debug($"开始简化碰撞检测，动画对象: {animatedObject.DisplayName}"); + + var animatedBoundingBox = animatedObject.BoundingBox(); + LogManager.Debug($"动画对象包围盒: Min({animatedBoundingBox.Min.X:F2}, {animatedBoundingBox.Min.Y:F2}, {animatedBoundingBox.Min.Z:F2}) Max({animatedBoundingBox.Max.X:F2}, {animatedBoundingBox.Max.Y:F2}, {animatedBoundingBox.Max.Z:F2})"); + + var allItems = Application.ActiveDocument.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry && !item.Equals(animatedObject)); + + if (excludeObjects != null) + { + allItems = allItems.Where(item => !excludeObjects.Contains(item)); + } + + var itemList = allItems.ToList(); + LogManager.Debug($"检测对象总数: {itemList.Count}"); + + int checkedCount = 0; + foreach (var item in itemList) + { + try + { + var itemBoundingBox = item.BoundingBox(); + + // 恢复原来的容差设置 + var tolerance = 100.0; // 100单位的容差 + + if (BoundingBoxesIntersectWithTolerance(animatedBoundingBox, itemBoundingBox, tolerance)) + { + var result = new CollisionResult + { + ClashGuid = Guid.NewGuid(), + DisplayName = $"简化碰撞检测: {animatedObject.DisplayName} <-> {item.DisplayName}", + Status = ClashResultStatus.New, + Item1 = animatedObject, + Item2 = item, + CreatedTime = DateTime.Now, + Distance = CalculateDistance(animatedBoundingBox, itemBoundingBox), + Center = CalculateCenter(animatedBoundingBox, itemBoundingBox) + }; + + results.Add(result); + LogManager.Info($"检测到碰撞: {animatedObject.DisplayName} <-> {item.DisplayName}，距离: {result.Distance:F2}"); + } + + checkedCount++; + } + catch (Exception itemEx) + { + LogManager.Warning($"检查单个对象碰撞时出错 {item.DisplayName}: {itemEx.Message}"); + } + } + + LogManager.Debug($"简化碰撞检测完成: 检查了 {checkedCount} 个对象，发现 {results.Count} 个碰撞"); + } + catch (Exception ex) + { + LogManager.Error($"简化碰撞检测失败: {ex.Message}"); + } + + return results; + } + + /// + /// 计算两个包围盒之间的距离 + /// + private double CalculateDistance(BoundingBox3D box1, BoundingBox3D box2) + { + var center1 = new Point3D( + (box1.Min.X + box1.Max.X) / 2, + (box1.Min.Y + box1.Max.Y) / 2, + (box1.Min.Z + box1.Max.Z) / 2 + ); + + var center2 = new Point3D( + (box2.Min.X + box2.Max.X) / 2, + (box2.Min.Y + box2.Max.Y) / 2, + (box2.Min.Z + box2.Max.Z) / 2 + ); + + return Math.Sqrt( + Math.Pow(center2.X - center1.X, 2) + + Math.Pow(center2.Y - center1.Y, 2) + + Math.Pow(center2.Z - center1.Z, 2) + ); + } + + /// + /// 计算两个包围盒之间的中心点 + /// + private Point3D CalculateCenter(BoundingBox3D box1, BoundingBox3D box2) + { + var center1 = new Point3D( + (box1.Min.X + box1.Max.X) / 2, + (box1.Min.Y + box1.Max.Y) / 2, + (box1.Min.Z + box1.Max.Z) / 2 + ); + + var center2 = new Point3D( + (box2.Min.X + box2.Max.X) / 2, + (box2.Min.Y + box2.Max.Y) / 2, + (box2.Min.Z + box2.Max.Z) / 2 + ); + + return new Point3D( + (center1.X + center2.X) / 2, + (center1.Y + center2.Y) / 2, + (center1.Z + center2.Z) / 2 + ); + } + + /// + /// 检查两个包围盒是否相交（带容差） + /// + private bool BoundingBoxesIntersectWithTolerance(BoundingBox3D box1, BoundingBox3D box2, double tolerance) + { + return box1.Min.X <= box2.Max.X + tolerance && box1.Max.X >= box2.Min.X - tolerance && + box1.Min.Y <= box2.Max.Y + tolerance && box1.Max.Y >= box2.Min.Y - tolerance && + box1.Min.Z <= box2.Max.Z + tolerance && box1.Max.Z >= box2.Min.Z - tolerance; + } + + /// + /// 检查两个包围盒是否相交 + /// + private bool BoundingBoxesIntersect(BoundingBox3D box1, BoundingBox3D box2) + { + return box1.Min.X <= box2.Max.X && box1.Max.X >= box2.Min.X && + box1.Min.Y <= box2.Max.Y && box1.Max.Y >= box2.Min.Y && + box1.Min.Z <= box2.Max.Z && box1.Max.Z >= box2.Min.Z; + } + + /// + /// 获取当前测试状态信息（用于调试和验证） + /// + /// 测试状态信息 + public string GetTestStatusInfo() + { + try + { + if (!_isInitialized) + { + return "Clash Detective 集成未初始化"; + } + + if (_documentClash == null) + { + return "无法访问 Clash Detective 文档"; + } + + var testInfo = new StringBuilder(); + testInfo.AppendLine("=== Clash Detective 集成状态 ==="); + testInfo.AppendLine($"初始化状态: {(_isInitialized ? "已初始化" : "未初始化")}"); + testInfo.AppendLine($"COM API 连接: {(_clashElement != null ? "已连接" : "未连接")}"); + testInfo.AppendLine($"文档 Clash 对象: {(_documentClash != null ? "可用" : "不可用")}"); + + // 检查测试列表 + var tests = _documentClash.TestsData.Tests; + testInfo.AppendLine($"总测试数量: {tests.Count}"); + + var dynamicTest = tests.FirstOrDefault(t => t.DisplayName == "动态运输路径碰撞检测"); + if (dynamicTest != null && dynamicTest is ClashTest clashTest) + { + testInfo.AppendLine($"动态测试: 已找到"); + testInfo.AppendLine($"测试类型: {clashTest.TestType}"); + testInfo.AppendLine($"容差: {clashTest.Tolerance}"); + testInfo.AppendLine($"结果数量: {clashTest.Children.Count}"); + + if (clashTest.Children.Count > 0) + { + testInfo.AppendLine("最近结果:"); + int count = 0; + foreach (var child in clashTest.Children) + { + if (child is ClashResult result && count < 3) + { + testInfo.AppendLine($" - {result.DisplayName}: {result.Status}"); + count++; + } + } + } + } + else + { + testInfo.AppendLine($"动态测试: 未找到"); + } + + testInfo.AppendLine("=== 状态信息结束 ==="); + return testInfo.ToString(); + } + catch (Exception ex) + { + return $"获取测试状态失败: {ex.Message}"; + } + } + + /// + /// 强制显示测试结果（用于调试） + /// + public void ForceShowTestResults() + { + try + { + LogManager.Info("强制显示测试结果..."); + + if (!_isInitialized) + { + LogManager.Warning("集成未初始化，重新初始化..."); + Initialize(); + } + + if (_documentClash == null) + { + LogManager.Error("无法访问Clash Detective文档"); + return; + } + + // 创建一个完整的演示测试 + CreateDemoTest(); + + // 如果有最近的碰撞结果，也创建一个快照 + if (_currentCollisions.Count > 0) + { + var collisionResults = _currentCollisions.Select(c => new CollisionResult + { + ClashGuid = c.Guid, + DisplayName = c.DisplayName, + Status = c.Status, + Item1 = c.Item1, + Item2 = c.Item2, + Center = c.Center, + Distance = c.Distance, + CreatedTime = DateTime.Now + }).ToList(); + + CreateCollisionSnapshot(collisionResults); + } + + // 强制刷新显示 + RefreshClashDetectiveWindow(); + + // 记录最终状态 + LogManager.Info(GetTestStatusInfo()); + + } + catch (Exception ex) + { + LogManager.Error($"强制显示测试结果失败: {ex.Message}"); + } + } + + /// + /// 创建演示测试 + /// + private void CreateDemoTest() + { + try + { + // 获取一些测试对象，使用更安全的方法 + var doc = Application.ActiveDocument; + var allItems = doc.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry) + .ToList(); + + // 过滤出有效的对象 + var validItems = new List(); + foreach (var item in allItems) + { + if (IsModelItemValid(item)) + { + validItems.Add(item); + } + } + + LogManager.Info($"找到 {validItems.Count} 个有效的几何对象"); + + if (validItems.Count >= 2) + { + // 创建演示测试 + var demoTest = new ClashTest(); + demoTest.DisplayName = "Clash Detective 集成演示"; + demoTest.TestType = ClashTestType.Hard; + demoTest.Tolerance = 0.01; + + // 设置测试选择 - 使用更保守的方法 + var selectionA = new ModelItemCollection(); + var selectionB = new ModelItemCollection(); + + // 选择A：前几个对象 + int countA = Math.Min(5, validItems.Count / 2); + for (int i = 0; i < countA; i++) + { + if (IsModelItemValid(validItems[i])) + { + selectionA.Add(validItems[i]); + } + } + + // 选择B：后几个对象 + int startB = Math.Max(countA, validItems.Count / 2); + int countB = Math.Min(5, validItems.Count - startB); + for (int i = 0; i < countB; i++) + { + int index = startB + i; + if (index < validItems.Count && IsModelItemValid(validItems[index])) + { + selectionB.Add(validItems[index]); + } + } + + if (selectionA.Count > 0 && selectionB.Count > 0) + { + demoTest.SelectionA.Selection.CopyFrom(selectionA); + demoTest.SelectionB.Selection.CopyFrom(selectionB); + + LogManager.Info($"创建演示测试: A={selectionA.Count}, B={selectionB.Count}"); + + // 添加到文档 + _documentClash.TestsData.TestsAddCopy(demoTest); + + // 重新获取并运行测试 + var addedTest = _documentClash.TestsData.Tests.FirstOrDefault(t => t.DisplayName == "Clash Detective 集成演示"); + if (addedTest is ClashTest runTest) + { + _documentClash.TestsData.TestsRunTest(runTest); + LogManager.Info($"演示测试运行完成，结果数量: {runTest.Children.Count}"); + } + } + else + { + LogManager.Warning("没有足够的有效对象来创建演示测试"); + } + } + else + { + LogManager.Warning($"有效对象数量不足: {validItems.Count}，需要至少2个"); + } + } + catch (Exception ex) + { + LogManager.Error($"创建演示测试失败: {ex.Message}"); + } + } + + /// + /// 清理资源 + /// + public void Cleanup() + { + try + { + // 清除临时高亮 + if (Application.ActiveDocument != null) + { + Application.ActiveDocument.Models.ResetAllTemporaryMaterials(); + } + + // 清空结果 + _currentCollisions.Clear(); + + // 清理过多的快照测试（保留最近的5个） + CleanupSnapshotTests(); + + LogManager.Info("Clash Detective集成清理完成"); + } + catch (Exception ex) + { + LogManager.Error($"清理资源失败: {ex.Message}"); + } + } + + /// + /// 清理过多的快照测试 + /// + private void CleanupSnapshotTests() + { + try + { + if (_documentClash == null) + return; + + // 查找所有快照测试 + var snapshotTests = _documentClash.TestsData.Tests + .Where(t => t.DisplayName.StartsWith("动画碰撞快照_")) + .Cast() + .ToList(); + + // 如果超过5个，删除最旧的 + if (snapshotTests.Count > 5) + { + var testsToRemove = snapshotTests.Take(snapshotTests.Count - 5); + foreach (var test in testsToRemove) + { + _documentClash.TestsData.TestsRemove(test); + LogManager.Debug($"已删除旧快照测试: {test.DisplayName}"); + } + } + } + catch (Exception ex) + { + LogManager.Error($"清理快照测试失败: {ex.Message}"); + } + } + + /// + /// 触发碰撞检测事件 + /// + private void OnCollisionDetected(CollisionDetectedEventArgs e) + { + CollisionDetected?.Invoke(this, e); + } + } + + /// + /// 碰撞结果数据结构 + /// + public class CollisionResult + { + public Guid ClashGuid { get; set; } + public string DisplayName { get; set; } + public ClashResultStatus Status { get; set; } + public string GridLocation { get; set; } + public ModelItem Item1 { get; set; } + public ModelItem Item2 { get; set; } + public Point3D Center { get; set; } + public double Distance { get; set; } + public DateTime CreatedTime { get; set; } + } + + /// + /// 碰撞检测事件参数 + /// + public class CollisionDetectedEventArgs : EventArgs + { + public List Results { get; private set; } + public int CollisionCount { get; private set; } + + public CollisionDetectedEventArgs(List results) + { + Results = results; + CollisionCount = results.Count; + } + } +} \ No newline at end of file diff --git a/src/ClashDetectiveIntegrationTest.cs b/src/ClashDetectiveIntegrationTest.cs new file mode 100644 index 0000000..3ea3d96 --- /dev/null +++ b/src/ClashDetectiveIntegrationTest.cs @@ -0,0 +1,490 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Threading.Tasks; +using Autodesk.Navisworks.Api; +using NavisApplication = Autodesk.Navisworks.Api.Application; + +namespace NavisworksTransport +{ + /// + /// Clash Detective 集成测试管理器 + /// 用于测试和验证碰撞检测功能 + /// + public class ClashDetectiveIntegrationTest + { + /// + /// 测试结果数据结构 + /// + public class TestResult + { + public bool IsSuccess { get; set; } + public string TestName { get; set; } + public string Message { get; set; } + public TimeSpan ExecutionTime { get; set; } + public int CollisionCount { get; set; } + public Exception Exception { get; set; } + } + + /// + /// 执行完整的集成测试 + /// + /// 测试结果列表 + public static List RunFullIntegrationTest() + { + var results = new List(); + + LogManager.Info("开始执行 Clash Detective 集成测试..."); + + // 测试1: 初始化集成 + results.Add(TestInitialization()); + + // 测试2: 插件检测 + results.Add(TestPluginDetection()); + + // 测试3: 简单碰撞检测 + results.Add(TestSimpleCollisionDetection()); + + // 测试4: 动态碰撞检测 + results.Add(TestDynamicCollisionDetection()); + + // 测试5: 高亮显示功能 + results.Add(TestHighlightingFeature()); + + // 测试6: 窗口同步功能 + results.Add(TestWindowSynchronization()); + + // 测试7: 清理功能 + results.Add(TestCleanupFunction()); + + // 输出测试报告 + GenerateTestReport(results); + + return results; + } + + /// + /// 测试初始化功能 + /// + private static TestResult TestInitialization() + { + var result = new TestResult { TestName = "初始化集成测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 测试集成初始化 + var instance = ClashDetectiveIntegration.Instance; + instance.Initialize(); + + result.IsSuccess = true; + result.Message = "集成初始化成功"; + + LogManager.Info("[测试] 初始化集成测试 - 通过"); + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"初始化失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 初始化集成测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 测试插件检测功能 + /// + private static TestResult TestPluginDetection() + { + var result = new TestResult { TestName = "插件检测测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 检查COM API状态 + var state = Autodesk.Navisworks.Api.ComApi.ComApiBridge.State; + if (state == null) + { + throw new Exception("COM API 状态为空"); + } + + // 检查插件数量 + var plugins = state.Plugins(); + if (plugins == null || plugins.Count == 0) + { + throw new Exception("未找到任何插件"); + } + + result.IsSuccess = true; + result.Message = $"找到 {plugins.Count} 个插件"; + + LogManager.Info($"[测试] 插件检测测试 - 通过: {plugins.Count} 个插件"); + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"插件检测失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 插件检测测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 测试简单碰撞检测 + /// + private static TestResult TestSimpleCollisionDetection() + { + var result = new TestResult { TestName = "简单碰撞检测测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 获取文档中的模型项 + var doc = NavisApplication.ActiveDocument; + if (doc?.Models?.RootItemDescendantsAndSelf == null) + { + throw new Exception("文档或模型为空"); + } + + var items = doc.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry) + .Take(2) + .ToList(); + + if (items.Count < 2) + { + throw new Exception("可用于测试的模型元素不足"); + } + + // 执行碰撞检测 + var collisions = ClashDetectiveIntegration.Instance.DetectCollisions(items[0]); + + result.IsSuccess = true; + result.CollisionCount = collisions.Count; + result.Message = $"检测到 {collisions.Count} 个碰撞"; + + LogManager.Info($"[测试] 简单碰撞检测测试 - 通过: {collisions.Count} 个碰撞"); + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"简单碰撞检测失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 简单碰撞检测测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 测试动态碰撞检测 + /// + private static TestResult TestDynamicCollisionDetection() + { + var result = new TestResult { TestName = "动态碰撞检测测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 测试动态检测功能 + var instance = ClashDetectiveIntegration.Instance; + var eventFired = false; + + // 订阅事件 + instance.CollisionDetected += (sender, e) => + { + eventFired = true; + result.CollisionCount = e.CollisionCount; + }; + + // 模拟动态检测 + var doc = NavisApplication.ActiveDocument; + var testItems = doc.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry) + .Take(1) + .ToList(); + + if (testItems.Count > 0) + { + var collisions = instance.DetectCollisions(testItems[0]); + + result.IsSuccess = true; + result.Message = $"动态检测完成，事件触发: {eventFired}"; + + LogManager.Info($"[测试] 动态碰撞检测测试 - 通过: 事件触发={eventFired}"); + } + else + { + throw new Exception("没有可用的测试对象"); + } + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"动态碰撞检测失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 动态碰撞检测测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 测试高亮显示功能 + /// + private static TestResult TestHighlightingFeature() + { + var result = new TestResult { TestName = "高亮显示功能测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 创建测试碰撞结果 + var testResults = new List(); + + var doc = NavisApplication.ActiveDocument; + var testItems = doc.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry) + .Take(2) + .ToList(); + + if (testItems.Count >= 2) + { + testResults.Add(new CollisionResult + { + ClashGuid = Guid.NewGuid(), + DisplayName = "测试碰撞", + Item1 = testItems[0], + Item2 = testItems[1], + CreatedTime = DateTime.Now + }); + } + + // 测试高亮显示 + ClashDetectiveIntegration.Instance.HighlightCollisions(testResults); + + result.IsSuccess = true; + result.Message = $"高亮显示 {testResults.Count} 个碰撞对象"; + + LogManager.Info($"[测试] 高亮显示功能测试 - 通过: {testResults.Count} 个对象"); + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"高亮显示功能失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 高亮显示功能测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 测试窗口同步功能 + /// + private static TestResult TestWindowSynchronization() + { + var result = new TestResult { TestName = "窗口同步功能测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 测试窗口同步 + // 这里只是验证不抛出异常 + var instance = ClashDetectiveIntegration.Instance; + + // 尝试同步（内部方法会处理Clash Detective不可用的情况） + var doc = NavisApplication.ActiveDocument; + var testItems = doc.Models.RootItemDescendantsAndSelf + .Where(item => item.HasGeometry) + .Take(1) + .ToList(); + + if (testItems.Count > 0) + { + var collisions = instance.DetectCollisions(testItems[0]); + + result.IsSuccess = true; + result.Message = "窗口同步测试完成（无异常）"; + + LogManager.Info("[测试] 窗口同步功能测试 - 通过"); + } + else + { + result.IsSuccess = true; + result.Message = "窗口同步测试完成（无测试对象）"; + } + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"窗口同步功能失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 窗口同步功能测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 测试清理功能 + /// + private static TestResult TestCleanupFunction() + { + var result = new TestResult { TestName = "清理功能测试" }; + var stopwatch = Stopwatch.StartNew(); + + try + { + // 测试清理功能 + ClashDetectiveIntegration.Instance.Cleanup(); + + result.IsSuccess = true; + result.Message = "清理功能测试完成"; + + LogManager.Info("[测试] 清理功能测试 - 通过"); + } + catch (Exception ex) + { + result.IsSuccess = false; + result.Message = $"清理功能失败: {ex.Message}"; + result.Exception = ex; + + LogManager.Error($"[测试] 清理功能测试 - 失败: {ex.Message}"); + } + finally + { + stopwatch.Stop(); + result.ExecutionTime = stopwatch.Elapsed; + } + + return result; + } + + /// + /// 生成测试报告 + /// + private static void GenerateTestReport(List results) + { + try + { + var passedCount = results.Count(r => r.IsSuccess); + var failedCount = results.Count(r => !r.IsSuccess); + var totalTime = TimeSpan.FromMilliseconds(results.Sum(r => r.ExecutionTime.TotalMilliseconds)); + + LogManager.Info("=== Clash Detective 集成测试报告 ==="); + LogManager.Info($"总测试数: {results.Count}"); + LogManager.Info($"通过测试: {passedCount}"); + LogManager.Info($"失败测试: {failedCount}"); + LogManager.Info($"总执行时间: {totalTime.TotalSeconds:F2} 秒"); + LogManager.Info(""); + + foreach (var result in results) + { + var status = result.IsSuccess ? "✓" : "✗"; + LogManager.Info($"{status} {result.TestName}: {result.Message} ({result.ExecutionTime.TotalMilliseconds:F0}ms)"); + + if (!result.IsSuccess && result.Exception != null) + { + LogManager.Error($" 错误详情: {result.Exception.Message}"); + } + } + + LogManager.Info("=== 测试报告结束 ==="); + } + catch (Exception ex) + { + LogManager.Error($"生成测试报告失败: {ex.Message}"); + } + } + + /// + /// 快速验证集成功能 + /// + /// 验证是否成功 + public static bool QuickValidation() + { + try + { + LogManager.Info("执行快速验证..."); + + // 1. 检查实例创建 + var instance = ClashDetectiveIntegration.Instance; + if (instance == null) + { + LogManager.Error("快速验证失败: 无法创建实例"); + return false; + } + + // 2. 检查初始化 + instance.Initialize(); + + // 3. 检查基本功能 + var doc = NavisApplication.ActiveDocument; + if (doc?.Models?.RootItemDescendantsAndSelf != null) + { + var testItem = doc.Models.RootItemDescendantsAndSelf + .FirstOrDefault(item => item.HasGeometry); + + if (testItem != null) + { + var collisions = instance.DetectCollisions(testItem); + LogManager.Info($"快速验证成功: 检测到 {collisions.Count} 个碰撞"); + } + } + + // 4. 清理 + instance.Cleanup(); + + LogManager.Info("快速验证完成"); + return true; + } + catch (Exception ex) + { + LogManager.Error($"快速验证失败: {ex.Message}"); + return false; + } + } + } +} \ No newline at end of file diff --git a/CoordinateConverter.cs b/src/CoordinateConverter.cs similarity index 100% rename from CoordinateConverter.cs rename to src/CoordinateConverter.cs diff --git a/FloorDetector.cs b/src/FloorDetector.cs similarity index 100% rename from FloorDetector.cs rename to src/FloorDetector.cs diff --git a/GeometryExtractor.cs b/src/GeometryExtractor.cs similarity index 100% rename from GeometryExtractor.cs rename to src/GeometryExtractor.cs diff --git a/LogManager.cs b/src/LogManager.cs similarity index 100% rename from LogManager.cs rename to src/LogManager.cs diff --git a/LogisticsPropertyEditDialog.cs b/src/LogisticsPropertyEditDialog.cs similarity index 100% rename from LogisticsPropertyEditDialog.cs rename to src/LogisticsPropertyEditDialog.cs diff --git a/MainPlugin.cs b/src/MainPlugin.cs similarity index 96% rename from MainPlugin.cs rename to src/MainPlugin.cs index f148a63..f3e5f61 100644 --- a/MainPlugin.cs +++ b/src/MainPlugin.cs @@ -183,6 +183,26 @@ namespace NavisworksTransport } } + /// + /// 清理 Clash Detective 集成相关资源 + /// + public static void CleanupClashDetectiveIntegration() + { + try + { + LogManager.Info("[清理] 开始清理 Clash Detective 集成..."); + + // 清理 Clash Detective 集成 + ClashDetectiveIntegration.Instance.Cleanup(); + + LogManager.Info("[清理] Clash Detective 集成清理完成"); + } + catch (Exception ex) + { + LogManager.Error($"[清理] Clash Detective 集成清理失败: {ex.Message}"); + } + } + /// /// 尝试恢复关键组件 /// @@ -207,6 +227,9 @@ namespace NavisworksTransport LogManager.Info("[全局异常] 已清除临时材质"); } + // 清理 Clash Detective 集成 + CleanupClashDetectiveIntegration(); + LogManager.Info("[全局异常] 组件恢复完成"); } catch (Exception ex) @@ -483,6 +506,16 @@ namespace NavisworksTransport LogManager.Error($"清理物流属性变更事件监听失败: {ex.Message}"); } + // 清理 Clash Detective 集成 + try + { + GlobalExceptionHandler.CleanupClashDetectiveIntegration(); + } + catch (Exception ex) + { + LogManager.Error($"清理 Clash Detective 集成失败: {ex.Message}"); + } + _controlPanelForm = null; // 清空引用 _instructionLabel = null; _selectedModelsLabel = null; @@ -1434,6 +1467,75 @@ namespace NavisworksTransport Value = 0 }; groupBox.Controls.Add(_animationProgressBar); + + // 测试Clash Detective集成按钮 + Button testClashDetectiveButton = new Button + { + Text = "测试Clash Detective集成", + Location = new Point(175, 25), + Size = new Size(150, 30), + Font = new Font("微软雅黑", 8), + BackColor = System.Drawing.Color.LightBlue + }; + + testClashDetectiveButton.Click += (sender, e) => + { + GlobalExceptionHandler.SafeExecute(() => + { + // 执行快速验证 + LogManager.Info("开始测试 Clash Detective 集成..."); + + bool quickValidation = ClashDetectiveIntegrationTest.QuickValidation(); + + if (quickValidation) + { + // 执行完整测试 + var testResults = ClashDetectiveIntegrationTest.RunFullIntegrationTest(); + + int passedTests = testResults.Count(r => r.IsSuccess); + int totalTests = testResults.Count; + + string message = $"测试完成！通过 {passedTests}/{totalTests} 个测试\n\n"; + + // 获取当前状态信息 + var statusInfo = ClashDetectiveIntegration.Instance.GetTestStatusInfo(); + + // 强制显示测试结果 + ClashDetectiveIntegration.Instance.ForceShowTestResults(); + + if (passedTests == totalTests) + { + message += "请检查 Clash Detective 窗口查看测试结果。\n"; + message += "如果窗口中没有显示测试，请：\n"; + message += "1. 确认 Clash Detective 窗口已打开\n"; + message += "2. 查看测试列表中的'动态运输路径碰撞检测'项\n"; + message += "3. 检查日志文件获取详细信息"; + + MessageBox.Show(message, "测试结果", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + else + { + message += "部分测试失败，详细信息：\n"; + foreach (var result in testResults.Where(r => !r.IsSuccess)) + { + message += $"- {result.TestName}: {result.Message}\n"; + } + message += "\n详细日志请查看日志文件"; + + MessageBox.Show(message, "测试结果", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + + // 显示状态信息 + LogManager.Info(statusInfo); + } + else + { + MessageBox.Show("快速验证失败，请检查日志了解详情", "测试失败", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + }, "测试Clash Detective集成"); + }; + + groupBox.Controls.Add(testClashDetectiveButton); } /// @@ -2571,6 +2673,9 @@ namespace NavisworksTransport _startAnimationButton.Enabled = true; _stopAnimationButton.Enabled = false; createAnimationButton.Enabled = true; + + // 清理 Clash Detective 集成 + GlobalExceptionHandler.CleanupClashDetectiveIntegration(); } }, "停止动画"); }; diff --git a/ModelSplitterDialog.cs b/src/ModelSplitterDialog.cs similarity index 100% rename from ModelSplitterDialog.cs rename to src/ModelSplitterDialog.cs diff --git a/ModelSplitterManager.cs b/src/ModelSplitterManager.cs similarity index 100% rename from ModelSplitterManager.cs rename to src/ModelSplitterManager.cs diff --git a/NavisworksFileExporter.cs b/src/NavisworksFileExporter.cs similarity index 100% rename from NavisworksFileExporter.cs rename to src/NavisworksFileExporter.cs diff --git a/PathAnimationManager.cs b/src/PathAnimationManager.cs similarity index 92% rename from PathAnimationManager.cs rename to src/PathAnimationManager.cs index c45391e..5b370dd 100644 --- a/PathAnimationManager.cs +++ b/src/PathAnimationManager.cs @@ -55,6 +55,11 @@ namespace NavisworksTransport // 动画完成事件 (旧版，保留兼容性) public event EventHandler AnimationCompleted; + /// + /// 当检测到碰撞时触发 + /// + public event EventHandler CollisionDetected; + public PathAnimationManager() { _pathPoints = new List(); @@ -332,8 +337,8 @@ namespace NavisworksTransport Point3D newPosition = InterpolatePosition(progress); UpdateObjectPosition(newPosition); - // 检查碰撞 - CheckAndHighlightCollisions(); + // 使用 Clash Detective 集成进行碰撞检测 + CheckAndHighlightCollisionsWithClashDetective(); if (progress >= 1.0) { @@ -578,13 +583,52 @@ namespace NavisworksTransport } /// - /// 设置动态碰撞检测（简化版本，因为Clash Detective API在2017版本中有限制） + /// 使用 Clash Detective 集成进行碰撞检测和高亮显示 + /// + private void CheckAndHighlightCollisionsWithClashDetective() + { + try + { + if (_animatedObject == null) + return; + + // 使用 Clash Detective 集成进行碰撞检测 + var collisionResults = ClashDetectiveIntegration.Instance.DetectCollisions(_animatedObject); + + // 高亮显示碰撞对象 + ClashDetectiveIntegration.Instance.HighlightCollisions(collisionResults); + + // 触发碰撞检测事件 + if (collisionResults.Count > 0) + { + OnCollisionDetected(new CollisionDetectedEventArgs(collisionResults)); + } + + LogManager.Debug($"碰撞检测完成: {collisionResults.Count} 个碰撞"); + } + catch (Exception ex) + { + LogManager.Error($"碰撞检测失败: {ex.Message}"); + + // 如果新方法失败，回退到简化版本 + CheckAndHighlightCollisions(); + } + } + + /// + /// 设置动态碰撞检测（升级版本，集成 Clash Detective） /// private void SetupDynamicClashDetection() { try { - LogManager.Info("动态碰撞检测设置完成（简化版本）"); + // 初始化 Clash Detective 集成 + ClashDetectiveIntegration.Instance.Initialize(); + + // 订阅碰撞检测事件 + ClashDetectiveIntegration.Instance.CollisionDetected += OnClashDetectiveCollisionDetected; + + LogManager.Info("动态碰撞检测设置完成（集成 Clash Detective）"); } catch (Exception ex) { @@ -592,6 +636,32 @@ namespace NavisworksTransport } } + /// + /// 处理 Clash Detective 碰撞检测事件 + /// + private void OnClashDetectiveCollisionDetected(object sender, CollisionDetectedEventArgs e) + { + try + { + // 将碰撞结果转发到动画管理器的事件 + OnCollisionDetected(e); + + LogManager.Debug($"Clash Detective 检测到 {e.CollisionCount} 个碰撞"); + } + catch (Exception ex) + { + LogManager.Error($"处理 Clash Detective 碰撞事件失败: {ex.Message}"); + } + } + + /// + /// 触发碰撞检测事件 + /// + protected virtual void OnCollisionDetected(CollisionDetectedEventArgs e) + { + CollisionDetected?.Invoke(this, e); + } + /// /// 检查并高亮碰撞（简化版本） /// diff --git a/PathClickToolPlugin.cs b/src/PathClickToolPlugin.cs similarity index 100% rename from PathClickToolPlugin.cs rename to src/PathClickToolPlugin.cs diff --git a/PathDataManager.cs b/src/PathDataManager.cs similarity index 100% rename from PathDataManager.cs rename to src/PathDataManager.cs diff --git a/PathPlanningManager.cs b/src/PathPlanningManager.cs similarity index 100% rename from PathPlanningManager.cs rename to src/PathPlanningManager.cs diff --git a/PathPlanningModels.cs b/src/PathPlanningModels.cs similarity index 100% rename from PathPlanningModels.cs rename to src/PathPlanningModels.cs diff --git a/PathPointRenderPlugin.cs b/src/PathPointRenderPlugin.cs similarity index 100% rename from PathPointRenderPlugin.cs rename to src/PathPointRenderPlugin.cs diff --git a/TimeLinerIntegrationManager.cs b/src/TimeLinerIntegrationManager.cs similarity index 100% rename from TimeLinerIntegrationManager.cs rename to src/TimeLinerIntegrationManager.cs diff --git a/VisibilityManager.cs b/src/VisibilityManager.cs similarity index 100% rename from VisibilityManager.cs rename to src/VisibilityManager.cs diff --git a/LogViewer.bat b/tool/LogViewer.bat similarity index 100% rename from LogViewer.bat rename to tool/LogViewer.bat diff --git a/compile.bat b/tool/compile.bat similarity index 100% rename from compile.bat rename to tool/compile.bat