进行了剖面盒的研究和测试，整理改进方案

NavisworksTransportPlugin.csproj

@@ -299,6 +299,7 @@
     <Compile Include="src\Utils\CoordinateConverter.cs" />
     <Compile Include="src\Utils\FloorDetector.cs" />
     <Compile Include="src\Utils\ModelItemAnalysisHelper.cs" />
+    <Compile Include="src\Utils\SectionClipHelper.cs" />
     <Compile Include="src\Utils\GeometryHelper.cs" />
     <Compile Include="src\Utils\GeometryCacheManager.cs" />
     <Compile Include="src\Utils\LogManager.cs" />

doc/working/section-clip-optimization-plan.md

@@ -0,0 +1,399 @@
+# 剖面盒优化碰撞检测方案
+
+## 概述
+
+通过 Navisworks 剖面盒功能，只处理路径周围的对象，大幅提升大型模型碰撞检测性能。
+
+## 预期性能提升
+
+| 模型规模 | 优化前 | 优化后 | 提升倍数 |
+|---------|--------|--------|---------|
+| 10层建筑（全模型） | 80秒 | ~1秒 | **80x** |
+| 单层检测 | 80秒 | ~0.5秒 | **160x** |
+
+## 核心思路
+
+1. **路径范围分析** → 计算路径的3D包围盒
+2. **设置剖面盒** → 只保留路径周围一定范围内的模型
+3. **裁剪缓存构建** → 遍历模型时快速跳过剖面外对象
+4. **ClashDetective检测** → 在裁剪后的空间内执行碰撞检测
+
+---
+
+## 技术实现
+
+### 1. 剖面盒辅助类 (`src/Utils/SectionClipHelper.cs`)
+
+提供剖面盒设置、查询、测试等基础功能。
+
+#### 关键实现：JSON 方式设置剖面盒
+
+> ⚠️ **重要发现**：Navisworks 的 `ClipPlaneSet` 对象在用户手工打开剖面功能后会变为**只读**，直接修改属性会导致 `NotSupportedException: Object is Read-Only` 错误。
+>
+> **解决方案**：使用 `View.TrySetClippingPlanes(string json)` 方法，通过 JSON 字符串设置剖面盒配置。
+
+```csharp
+/// <summary>
+/// 构建 ClipPlaneSet 的 JSON 字符串
+/// </summary>
+private static string BuildClipPlaneSetJson(BoundingBox3D box, bool enabled)
+{
+    // Navisworks ClipPlaneSet JSON 格式：
+    // {
+    //   "Type": "ClipPlaneSet",
+    //   "Version": 1,
+    //   "OrientedBox": {
+    //     "Type": "OrientedBox3D",
+    //     "Version": 1,
+    //     "Box": [[minX, minY, minZ], [maxX, maxY, maxZ]],
+    //     "Rotation": [0, 0, 0]
+    //   },
+    //   "Enabled": true/false
+    // }
+    
+    return string.Format(
+        "{{\"Type\":\"ClipPlaneSet\",\"Version\":1," +
+        "\"OrientedBox\":{{\"Type\":\"OrientedBox3D\",\"Version\":1," +
+        "\"Box\":[[{0},{1},{2}],[{3},{4},{5}]]," +
+        "\"Rotation\":[0,0,0]}},\"Enabled\":{6}}}",
+        box.Min.X.ToString("G17"),
+        box.Min.Y.ToString("G17"),
+        box.Min.Z.ToString("G17"),
+        box.Max.X.ToString("G17"),
+        box.Max.Y.ToString("G17"),
+        box.Max.Z.ToString("G17"),
+        enabled.ToString().ToLowerInvariant());
+}
+
+/// <summary>
+/// 应用剖面盒到视口
+/// </summary>
+private static void ApplyClipBox(BoundingBox3D box)
+{
+    string json = BuildClipPlaneSetJson(box, true);
+    var view = Application.ActiveDocument.ActiveView;
+    
+    // 使用 TrySetClippingPlanes 避免异常
+    bool success = view.TrySetClippingPlanes(json);
+    
+    if (!success)
+    {
+        // 备选方案：使用 SetClippingPlanes（可能抛出异常）
+        view.SetClippingPlanes(json);
+    }
+}
+```
+
+#### API 方法列表
+
+| 方法 | 功能 | 参数 |
+|------|------|------|
+| `SetClipBoxByPath` | 根据路径点列表设置剖面盒 | `pathPoints`, `marginMeters`, `heightMarginMeters` |
+| `SetClipBoxByPoint` | 根据中心点设置剖面盒 | `centerPoint`, `rangeMeters`, `heightRangeMeters` |
+| `SetClipBoxByFloor` | 根据楼层设置剖面盒 | `floorItem`, `marginMeters` |
+| `ClearClipBox` | 清除剖面盒 | - |
+| `IsPointInClipBox` | 测试点是否在剖面盒内 | `point` |
+| `IntersectsClipBox` | 测试包围盒是否与剖面盒相交 | `box` |
+| `CountObjectsInClipBox` | 统计剖面盒内/外对象数量 | - |
+
+---
+
+### 2. 几何缓存优化 (`Core/Collision/ClashDetectiveIntegration.cs`)
+
+修改 `BuildNonHidddenGeometryItemsCache` 方法，支持剖面过滤：
+
+```csharp
+private void BuildNonHidddenGeometryItemsCache()
+{
+    // ... 原有代码 ...
+    
+    // 获取当前剖面盒（如果启用）
+    BoundingBox3D clipBox;
+    bool hasClipBox = SectionClipHelper.TryGetCurrentClipBox(out clipBox);
+    
+    // 遍历模型树
+    var stack = new Stack<ModelItem>();
+    foreach (var model in _document.Models)
+    {
+        stack.Push(model.RootItem);
+    }
+
+    while (stack.Count > 0)
+    {
+        var item = stack.Pop();
+        
+        // 剖面盒过滤：如果对象在剖面盒外，整棵子树跳过
+        if (hasClipBox)
+        {
+            BoundingBox3D itemBox = item.BoundingBox();
+            if (!clipBox.Intersects(itemBox))
+            {
+                continue; // 剪枝：跳过此节点及其所有子节点
+            }
+        }
+        
+        // ... 原有缓存逻辑 ...
+    }
+}
+```
+
+---
+
+### 3. 通道缓存优化
+
+修改 `BuildChannelObjectsCache` 方法：
+
+```csharp
+private void BuildChannelObjectsCache()
+{
+    // ... 原有代码 ...
+    
+    // 获取当前剖面盒
+    BoundingBox3D clipBox;
+    bool hasClipBox = SectionClipHelper.TryGetCurrentClipBox(out clipBox);
+    
+    foreach (var channel in channels)
+    {
+        // 剖面盒过滤
+        if (hasClipBox)
+        {
+            BoundingBox3D channelBox = channel.BoundingBox();
+            if (!clipBox.Intersects(channelBox))
+            {
+                continue; // 跳过剖面外的通道
+            }
+        }
+        
+        // ... 原有通道缓存逻辑 ...
+    }
+}
+```
+
+---
+
+### 4. 空间索引优化（可选）
+
+`SpatialIndexManager` 利用剖面盒二次过滤：
+
+```csharp
+public IEnumerable<ModelItem> QueryVisibleItems()
+{
+    // 先查询空间索引
+    var candidates = _spatialIndex.Query(_viewFrustum);
+    
+    // 再用剖面盒过滤
+    return candidates.Where(item => 
+        !SectionClipHelper.IsClipBoxEnabled || 
+        SectionClipHelper.IntersectsClipBox(item.BoundingBox()));
+}
+```
+
+---
+
+## API 使用说明
+
+### 设置剖面盒
+
+```csharp
+// 根据路径设置（推荐用于路径规划场景）
+SectionClipHelper.SetClipBoxByPath(
+    pathPoints, 
+    marginMeters: 3.0,      // 路径周围水平边距
+    heightMarginMeters: 2.0 // 上下高度边距
+);
+
+// 根据点设置（推荐用于吊装路径单点场景）
+SectionClipHelper.SetClipBoxByPoint(
+    centerPoint, 
+    rangeMeters: 10.0,       // 水平范围
+    heightRangeMeters: 5.0   // 高度范围
+);
+
+// 根据楼层设置（推荐用于单层检测）
+SectionClipHelper.SetClipBoxByFloor(
+    floorItem, 
+    marginMeters: 1.0  // 楼层周围边距
+);
+
+// 清除剖面盒（恢复全模型显示）
+SectionClipHelper.ClearClipBox();
+```
+
+### 测试点/包围盒
+
+```csharp
+// 测试点是否在剖面内
+bool inside = SectionClipHelper.IsPointInClipBox(point);
+
+// 测试包围盒是否与剖面相交
+bool intersects = SectionClipHelper.IntersectsClipBox(box);
+
+// 获取当前剖面盒
+BoundingBox3D clipBox;
+if (SectionClipHelper.TryGetCurrentClipBox(out clipBox))
+{
+    // 使用 clipBox 进行自定义过滤
+}
+```
+
+### 统计对象数量（调试用）
+
+```csharp
+// 输出剖面盒内/外对象数量到日志
+SectionClipHelper.CountObjectsInClipBox(
+    out int total, 
+    out int inside, 
+    out int outside);
+
+LogManager.Info($"过滤率: {(outside * 100.0 / total):F1}%");
+```
+
+---
+
+## 测试结果
+
+### 基础功能测试（✅ 已完成）
+
+**测试场景**：10层建筑模型，在模型中心设置 10m x 10m x 5m 剖面盒
+
+| 指标 | 数值 | 说明 |
+|------|------|------|
+| 总对象数 | 848 | 模型总对象 |
+| 剖面盒内 | 10 | 需要检测的对象 |
+| 剖面盒外 | 838 | 可跳过的对象 |
+| **过滤率** | **98.8%** | 性能提升关键指标 |
+
+**点检测测试**：
+- 中心点 (-108.50, -2.94, 27.24): `True` ✅
+- 远点 (-8.50, 97.06, 127.24): `False` ✅
+
+### 性能测试计划
+
+| 测试项 | 状态 | 预期结果 |
+|--------|------|----------|
+| 10层建筑全模型 | ⏳ 待测 | 80秒 → ~1秒 (80x) |
+| 单层检测 | ⏳ 待测 | 80秒 → ~0.5秒 (160x) |
+| 内存占用分析 | ⏳ 待测 | 无显著增加 |
+
+---
+
+## 已知问题与解决方案
+
+### 问题1：Object is Read-Only 错误
+
+**现象**：用户手工打开剖面功能后，调用 `clipPlanes.Box = box` 抛出异常。
+
+**原因**：Navisworks 的 `ClipPlaneSet` 对象在手工操作后变为只读。
+
+**解决**：使用 JSON 字符串方式设置剖面盒（见上文技术实现）。
+
+### 问题2：路径跨越多层时优化效果降低
+
+**现象**：垂直跨越多个楼层的长路径，剖面盒范围大，过滤率下降。
+
+**建议**：
+1. 分段设置剖面盒（每层单独检测）
+2. 使用多个剖面盒（Navisworks 支持最多 6 个剖面）
+3. 动态调整剖面盒大小
+
+### 问题3：坐标系单位转换
+
+**注意**：`SectionClipHelper` 的输入参数使用**米**为单位，内部自动转换为模型单位。
+
+```csharp
+// 正确：使用米作为输入
+SectionClipHelper.SetClipBoxByPoint(centerPoint, rangeMeters: 10.0);
+
+// 内部转换逻辑
+double factor = UnitsConverter.GetMetersToUnitsConversionFactor(document.Units);
+double rangeInModelUnits = rangeMeters * factor;
+```
+
+---
+
+## 文件变更清单
+
+### 新增文件
+
+| 文件路径 | 说明 |
+|----------|------|
+| `src/Utils/SectionClipHelper.cs` | 剖面盒辅助类（JSON 方式设置） |
+
+### 修改文件
+
+| 文件路径 | 修改内容 |
+|----------|----------|
+| `src/Core/Collision/ClashDetectiveIntegration.cs` | 添加剖面过滤支持到缓存构建 |
+| `src/UI/WPF/Views/SystemManagementView.xaml` | 添加剖面盒测试按钮 |
+| `src/UI/WPF/ViewModels/SystemManagementViewModel.cs` | 添加 `ExecuteTestSectionClip()` 方法 |
+
+---
+
+## 集成到碰撞检测流程
+
+### 步骤1：路径规划后自动设置剖面盒
+
+```csharp
+// 在 PathPlanningManager 中
+public void GeneratePath(PathRequest request)
+{
+    // ... 路径计算 ...
+    
+    // 自动设置剖面盒
+    if (pathPoints != null && pathPoints.Count > 0)
+    {
+        SectionClipHelper.SetClipBoxByPath(
+            pathPoints, 
+            marginMeters: 3.0,  // 可配置
+            heightMarginMeters: 2.0);
+    }
+    
+    // ... 后续处理 ...
+}
+```
+
+### 步骤2：碰撞检测前应用过滤
+
+```csharp
+// 在 ClashDetectiveIntegration 中
+public async Task<CollisionResult> PerformCollisionDetectionAsync()
+{
+    // 1. 构建缓存时自动应用剖面过滤
+    BuildNonHidddenGeometryItemsCache();
+    
+    // 2. 执行检测（只处理剖面内对象）
+    var result = await RunClashDetectionAsync();
+    
+    // 3. 可选：检测完成后清除剖面盒
+    // SectionClipHelper.ClearClipBox();
+    
+    return result;
+}
+```
+
+### 步骤3：UI 交互控制
+
+```xml
+<!-- 在路径编辑界面添加剖面盒控制 -->
+<CheckBox Content="启用剖面盒优化" IsChecked="{Binding EnableSectionClip}" />
+<Button Content="设置剖面盒到当前路径" Command="{Binding SetClipBoxCommand}" />
+<Button Content="清除剖面盒" Command="{Binding ClearClipBoxCommand}" />
+```
+
+---
+
+## 后续优化方向
+
+1. **多剖面盒支持**：利用 Navisworks 支持 6 个剖面的特性，处理复杂路径
+2. **动态剖面盒**：动画播放时动态调整剖面盒位置
+3. **智能边距计算**：根据车辆尺寸自动计算合适的边距
+4. **剖面盒可视化**：在 3D 视图中显示剖面盒边界
+
+---
+
+## 参考文档
+
+- Navisworks API: `doc/navisworks_api/NET/documentation/NetAPIHtml/html/T_Autodesk_Navisworks_Api_ClipPlaneSet.htm`
+- `View.SetClippingPlanes` - JSON 方式设置剖面盒
+- `View.TrySetClippingPlanes` - 安全设置剖面盒（返回 bool）
+- `ClipPlaneSet` 属性（只读场景下慎用）

src/UI/WPF/ViewModels/SystemManagementViewModel.cs

@@ -3,6 +3,7 @@ using System.Collections.ObjectModel;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Input;
+using Autodesk.Navisworks.Api;
 using NavisworksTransport.UI.WPF.Collections;
 using NavisworksTransport.Core;
 using NavisworksTransport.Core.Config;
@@ -171,6 +172,7 @@ namespace NavisworksTransport.UI.WPF.ViewModels
         public ICommand TestVoxelPathFindingCommand { get; private set; }
         public ICommand ReadTransformTestCommand { get; private set; }
         public ICommand CoordinateSystemExplorerCommand { get; private set; }
+        public ICommand TestSectionClipCommand { get; private set; }
 
         // 坐标系设置
         public ObservableCollection<string> CoordinateSystemOptions { get; private set; }
@@ -308,6 +310,7 @@ namespace NavisworksTransport.UI.WPF.ViewModels
                 TestVoxelPathFindingCommand = new RelayCommand(() => ExecuteTestVoxelPathFinding());
                 ReadTransformTestCommand = new RelayCommand(() => ExecuteReadTransformTest());
                 CoordinateSystemExplorerCommand = new RelayCommand(() => ExecuteCoordinateSystemExplorer());
+                TestSectionClipCommand = new RelayCommand(() => ExecuteTestSectionClip());
 
                 // 初始化坐标系选项
                 CoordinateSystemOptions = new ObservableCollection<string> { "AutoDetect", "ZUp", "YUp" };
@@ -1819,6 +1822,157 @@ namespace NavisworksTransport.UI.WPF.ViewModels
 
         #endregion
 
+        #region 剖面盒测试
+
+        /// <summary>
+        /// 执行剖面盒测试命令
+        /// </summary>
+        private void ExecuteTestSectionClip()
+        {
+            SafeExecute(() =>
+            {
+                try
+                {
+                    UpdateMainStatus("正在执行剖面盒测试...");
+                    LogManager.Info("开始剖面盒功能测试");
+
+                    var doc = Autodesk.Navisworks.Api.Application.ActiveDocument;
+                    if (doc == null || doc.IsClear)
+                    {
+                        System.Windows.MessageBox.Show(
+                            "没有活动的文档！请先打开一个模型。",
+                            "错误",
+                            System.Windows.MessageBoxButton.OK,
+                            System.Windows.MessageBoxImage.Error);
+                        UpdateMainStatus("剖面盒测试失败：无活动文档");
+                        return;
+                    }
+
+                    var sb = new StringBuilder();
+                    sb.AppendLine("=== 剖面盒功能测试 ===\n");
+
+                    // 1. 测试前统计
+                    sb.AppendLine("【1. 测试前状态】");
+                    sb.AppendLine($"剖面盒当前状态: {(SectionClipHelper.IsClipBoxEnabled ? "已启用" : "未启用")}");
+                    
+                    BoundingBox3D currentBox;
+                    if (SectionClipHelper.TryGetCurrentClipBox(out currentBox))
+                    {
+                        sb.AppendLine($"当前剖面盒范围:");
+                        sb.AppendLine($"  X: [{currentBox.Min.X:F2}, {currentBox.Max.X:F2}]");
+                        sb.AppendLine($"  Y: [{currentBox.Min.Y:F2}, {currentBox.Max.Y:F2}]");
+                        sb.AppendLine($"  Z: [{currentBox.Min.Z:F2}, {currentBox.Max.Z:F2}]");
+                        
+                        // 先清除，重新测试
+                        SectionClipHelper.ClearClipBox();
+                        sb.AppendLine("已清除现有剖面盒");
+                    }
+                    sb.AppendLine();
+
+                    // 2. 获取当前选择或模型中心
+                    sb.AppendLine("【2. 设置测试剖面盒】");
+                    var selection = doc.CurrentSelection.SelectedItems;
+                    Point3D centerPoint;
+                    
+                    if (selection.Count > 0)
+                    {
+                        // 使用选中对象的中心
+                        var selectedItem = selection[0];
+                        BoundingBox3D bounds1 = selectedItem.BoundingBox();
+                        centerPoint = bounds1.Center;
+                        sb.AppendLine($"使用选中对象中心: ({centerPoint.X:F2}, {centerPoint.Y:F2}, {centerPoint.Z:F2})");
+                        sb.AppendLine($"选中对象: {selectedItem.DisplayName}");
+                    }
+                    else
+                    {
+                        // 使用模型整体中心
+                        var rootItem = doc.Models[0].RootItem;
+                        BoundingBox3D bounds2 = rootItem.BoundingBox();
+                        centerPoint = bounds2.Center;
+                        sb.AppendLine($"使用模型中心: ({centerPoint.X:F2}, {centerPoint.Y:F2}, {centerPoint.Z:F2})");
+                    }
+
+                    // 设置剖面盒（10米 x 10米 x 5米）
+                    bool success = SectionClipHelper.SetClipBoxByPoint(centerPoint, 
+                        rangeMeters: 10.0, heightRangeMeters: 5.0);
+                    
+                    if (!success)
+                    {
+                        sb.AppendLine("❌ 剖面盒设置失败！");
+                        System.Windows.MessageBox.Show(sb.ToString(), "剖面盒测试", 
+                            System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
+                        return;
+                    }
+                    
+                    sb.AppendLine("✅ 剖面盒设置成功（10m x 10m x 5m）");
+                    sb.AppendLine();
+
+                    // 3. 统计对象数量
+                    sb.AppendLine("【3. 对象数量统计】");
+                    int totalCount, insideCount, outsideCount;
+                    SectionClipHelper.CountObjectsInClipBox(out totalCount, out insideCount, out outsideCount);
+                    
+                    sb.AppendLine($"总对象数: {totalCount}");
+                    sb.AppendLine($"剖面盒内: {insideCount}");
+                    sb.AppendLine($"剖面盒外: {outsideCount}");
+                    if (totalCount > 0)
+                    {
+                        double filterRate = (double)outsideCount / totalCount * 100;
+                        sb.AppendLine($"过滤率: {filterRate:F1}%");
+                    }
+                    sb.AppendLine();
+
+                    // 4. 测试相交检测
+                    sb.AppendLine("【4. 相交检测测试】");
+                    SectionClipHelper.TestIntersection();
+                    sb.AppendLine("相交检测测试完成（查看日志详情）");
+                    sb.AppendLine();
+
+                    // 5. 测试点检测
+                    sb.AppendLine("【5. 点检测测试】");
+                    var testPointInside = new Point3D(centerPoint.X, centerPoint.Y, centerPoint.Z);
+                    var testPointOutside = new Point3D(centerPoint.X + 100, centerPoint.Y + 100, centerPoint.Z + 100);
+                    
+                    bool isInside1 = SectionClipHelper.IsPointInClipBox(testPointInside);
+                    bool isInside2 = SectionClipHelper.IsPointInClipBox(testPointOutside);
+                    
+                    sb.AppendLine($"中心点 ({testPointInside.X:F2}, {testPointInside.Y:F2}, {testPointInside.Z:F2}): {isInside1} (应为 True)");
+                    sb.AppendLine($"远点 ({testPointOutside.X:F2}, {testPointOutside.Y:F2}, {testPointOutside.Z:F2}): {isInside2} (应为 False)");
+                    
+                    if (isInside1 && !isInside2)
+                    {
+                        sb.AppendLine("✅ 点检测测试通过！");
+                    }
+                    else
+                    {
+                        sb.AppendLine("❌ 点检测测试失败！");
+                    }
+                    sb.AppendLine();
+
+                    // 6. 保持剖面盒或清除（询问用户）
+                    sb.AppendLine("【6. 测试完成】");
+                    sb.AppendLine("剖面盒已保留，可在视图中查看效果。");
+                    sb.AppendLine("使用 SystemManagementViewModel.ClearClipBox() 清除。");
+
+                    LogManager.Info("剖面盒功能测试完成");
+                    UpdateMainStatus("剖面盒测试完成");
+
+                    // 显示结果
+                    System.Windows.MessageBox.Show(sb.ToString(), "剖面盒功能测试", 
+                        System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Information);
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Error($"剖面盒测试失败: {ex.Message}", ex);
+                    System.Windows.MessageBox.Show($"测试失败: {ex.Message}", "错误", 
+                        System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
+                    UpdateMainStatus("剖面盒测试失败");
+                }
+            }, "剖面盒测试");
+        }
+
+        #endregion
+
         #region 清理资源和IDisposable实现
 
         /// <summary>

src/UI/WPF/Views/SystemManagementView.xaml

@@ -292,6 +292,15 @@ NavisworksTransport 系统管理页签视图 - 采用与其他页签一致的Nav
                                 Style="{StaticResource ActionButtonStyle}"
                                 ToolTip="探索当前文档的坐标系信息（用于适配Y-up坐标系模型）"/>
                     </StackPanel>
+                    
+                    <!-- 剖面盒优化测试 -->
+                    <StackPanel Orientation="Horizontal" Margin="0,5,0,5">
+                        <!-- 测试剖面盒按钮 -->
+                        <Button Content="测试剖面盒"
+                                Command="{Binding TestSectionClipCommand}"
+                                Style="{StaticResource ActionButtonStyle}"
+                                ToolTip="测试剖面盒功能：设置剖面、统计对象、测试过滤"/>
+                    </StackPanel>
                 </StackPanel>
             </Border>
         </StackPanel>

src/Utils/SectionClipHelper.cs

@@ -0,0 +1,427 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Navisworks.Api;
+
+namespace NavisworksTransport.Utils
+{
+    /// <summary>
+    /// 剖面盒辅助类 - 用于优化碰撞检测性能
+    /// 通过设置视口剖面盒，只处理路径周围的对象
+    /// 
+    /// 注意：Navisworks 的 ClipPlaneSet API 需要使用 JSON 字符串方式设置
+    /// 直接修改 ClipPlaneSet 对象的属性在手工打开剖面功能后会导致 "Object is Read-Only" 错误
+    /// </summary>
+    public static class SectionClipHelper
+    {
+        // 默认边距（米）：路径周围保留的空间
+        private const double DEFAULT_MARGIN_METERS = 2.0;
+        
+        // 默认高度范围（米）：上下各延伸的高度
+        private const double DEFAULT_HEIGHT_MARGIN_METERS = 1.0;
+
+        /// <summary>
+        /// 根据路径点列表设置剖面盒
+        /// </summary>
+        /// <param name="pathPoints">路径点列表</param>
+        /// <param name="marginMeters">水平边距（米）</param>
+        /// <param name="heightMarginMeters">高度边距（米）</param>
+        /// <returns>是否成功设置</returns>
+        public static bool SetClipBoxByPath(List<Point3D> pathPoints, 
+            double marginMeters = DEFAULT_MARGIN_METERS, 
+            double heightMarginMeters = DEFAULT_HEIGHT_MARGIN_METERS)
+        {
+            try
+            {
+                if (pathPoints == null || pathPoints.Count == 0)
+                {
+                    LogManager.Warning("[剖面盒] 路径点为空，无法设置剖面盒");
+                    return false;
+                }
+
+                // 计算路径的包围盒
+                var pathBounds = CalculatePathBoundingBox(pathPoints);
+                
+                // 扩展边距
+                var clipBox = ExpandBoundingBox(pathBounds, marginMeters, heightMarginMeters);
+                
+                // 应用到视口
+                ApplyClipBox(clipBox);
+                
+                LogManager.Info($"[剖面盒] 已设置 - 范围: X[{clipBox.Min.X:F2}, {clipBox.Max.X:F2}], " +
+                    $"Y[{clipBox.Min.Y:F2}, {clipBox.Max.Y:F2}], Z[{clipBox.Min.Z:F2}, {clipBox.Max.Z:F2}]");
+                
+                return true;
+            }
+            catch (Exception ex)
+            {
+                LogManager.Error($"[剖面盒] 设置失败: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 根据单个点设置剖面盒（用于吊装路径等单点场景）
+        /// </summary>
+        /// <param name="centerPoint">中心点</param>
+        /// <param name="rangeMeters">范围（米）</param>
+        /// <param name="heightRangeMeters">高度范围（米）</param>
+        /// <returns>是否成功设置</returns>
+        public static bool SetClipBoxByPoint(Point3D centerPoint, 
+            double rangeMeters = 10.0, 
+            double heightRangeMeters = 5.0)
+        {
+            try
+            {
+                var min = new Point3D(
+                    centerPoint.X - rangeMeters,
+                    centerPoint.Y - rangeMeters,
+                    centerPoint.Z - heightRangeMeters);
+                var max = new Point3D(
+                    centerPoint.X + rangeMeters,
+                    centerPoint.Y + rangeMeters,
+                    centerPoint.Z + heightRangeMeters);
+                
+                var clipBox = new BoundingBox3D(min, max);
+                ApplyClipBox(clipBox);
+                
+                LogManager.Info($"[剖面盒] 已设置 - 中心: ({centerPoint.X:F2}, {centerPoint.Y:F2}, {centerPoint.Z:F2}), " +
+                    $"范围: {rangeMeters}m x {rangeMeters}m x {heightRangeMeters}m");
+                
+                return true;
+            }
+            catch (Exception ex)
+            {
+                LogManager.Error($"[剖面盒] 设置失败: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 根据楼层设置剖面盒
+        /// </summary>
+        /// <param name="floorItem">楼层模型项</param>
+        /// <param name="marginMeters">边距（米）</param>
+        /// <returns>是否成功设置</returns>
+        public static bool SetClipBoxByFloor(ModelItem floorItem, double marginMeters = 1.0)
+        {
+            try
+            {
+                if (floorItem == null)
+                {
+                    LogManager.Warning("[剖面盒] 楼层对象为空");
+                    return false;
+                }
+
+                BoundingBox3D floorBounds = floorItem.BoundingBox();
+                BoundingBox3D clipBox = ExpandBoundingBox(floorBounds, marginMeters, marginMeters);
+                ApplyClipBox(clipBox);
+                
+                LogManager.Info($"[剖面盒] 已设置到楼层: {floorItem.DisplayName}");
+                return true;
+            }
+            catch (Exception ex)
+            {
+                LogManager.Error($"[剖面盒] 设置失败: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 清除剖面盒（显示全部模型）
+        /// 使用 JSON 字符串方式设置 Enabled = false
+        /// </summary>
+        public static void ClearClipBox()
+        {
+            try
+            {
+                // 构建禁用剖面的 JSON
+                string json = BuildClipPlaneSetJson(
+                    new BoundingBox3D(new Point3D(0, 0, 0), new Point3D(0, 0, 0)), 
+                    false);
+                
+                var view = Application.ActiveDocument.ActiveView;
+                view.TrySetClippingPlanes(json);
+                
+                LogManager.Info("[剖面盒] 已清除");
+            }
+            catch (Exception ex)
+            {
+                LogManager.Error($"[剖面盒] 清除失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 检查剖面盒是否已启用
+        /// </summary>
+        public static bool IsClipBoxEnabled
+        {
+            get
+            {
+                try
+                {
+                    return Application.ActiveDocument.CurrentViewpoint.Value.ClipPlanes.Enabled;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取当前剖面盒
+        /// </summary>
+        /// <param name="clipBox">输出剖面盒</param>
+        /// <returns>是否成功获取</returns>
+        public static bool TryGetCurrentClipBox(out BoundingBox3D clipBox)
+        {
+            clipBox = new BoundingBox3D();
+            try
+            {
+                var clipPlanes = Application.ActiveDocument.CurrentViewpoint.Value.ClipPlanes;
+                if (!clipPlanes.Enabled || clipPlanes.Mode != ClipPlaneSetMode.Box)
+                    return false;
+                
+                clipBox = clipPlanes.Box;
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 测试点是否在剖面盒内
+        /// </summary>
+        public static bool IsPointInClipBox(Point3D point)
+        {
+            if (!TryGetCurrentClipBox(out var clipBox)) return true; // 无剖面盒时默认全部包含
+            
+            return clipBox.Contains(point);
+        }
+
+        /// <summary>
+        /// 测试包围盒是否与剖面盒相交
+        /// </summary>
+        public static bool IntersectsClipBox(BoundingBox3D box)
+        {
+            if (!TryGetCurrentClipBox(out var clipBox)) return true; // 无剖面盒时默认全部相交
+            
+            return clipBox.Intersects(box);
+        }
+
+        /// <summary>
+        /// 统计剖面盒内/外的对象数量（用于测试）
+        /// </summary>
+        /// <param name="totalCount">总对象数</param>
+        /// <param name="insideCount">在剖面盒内的对象数</param>
+        /// <param name="outsideCount">在剖面盒外的对象数</param>
+        public static void CountObjectsInClipBox(out int totalCount, out int insideCount, out int outsideCount)
+        {
+            totalCount = 0;
+            insideCount = 0;
+            outsideCount = 0;
+
+            try
+            {
+                if (!TryGetCurrentClipBox(out var clipBox))
+                {
+                    LogManager.Warning("[剖面盒统计] 剖面盒未启用");
+                    return;
+                }
+
+                var stack = new Stack<ModelItem>();
+                foreach (var model in Application.ActiveDocument.Models)
+                {
+                    stack.Push(model.RootItem);
+                }
+
+                while (stack.Count > 0)
+                {
+                    var item = stack.Pop();
+                    totalCount++;
+
+                    // 测试包围盒是否相交
+                    BoundingBox3D itemBox = item.BoundingBox();
+                    if (clipBox.Intersects(itemBox))
+                    {
+                        insideCount++;
+                    }
+                    else
+                    {
+                        outsideCount++;
+                        continue; // 跳过子节点（剪枝）
+                    }
+
+                    // 继续遍历子节点
+                    foreach (var child in item.Children)
+                    {
+                        stack.Push(child);
+                    }
+                }
+
+                LogManager.Info($"[剖面盒统计] 总数: {totalCount}, 盒内: {insideCount}, 盒外: {outsideCount}, " +
+                    $"过滤率: {(outsideCount * 100.0 / totalCount):F1}%");
+            }
+            catch (Exception ex)
+            {
+                LogManager.Error($"[剖面盒统计] 失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 测试包围盒相交检测（用于验证）
+        /// </summary>
+        public static void TestIntersection()
+        {
+            try
+            {
+                if (!TryGetCurrentClipBox(out var clipBox))
+                {
+                    LogManager.Warning("[剖面盒测试] 请先设置剖面盒");
+                    return;
+                }
+
+                // 测试点
+                var center = clipBox.Center;
+                var testPointInside = new Point3D(center.X, center.Y, center.Z);
+                var testPointOutside = new Point3D(
+                    center.X + 1000, 
+                    center.Y + 1000, 
+                    center.Z + 1000);
+
+                bool inside1 = IsPointInClipBox(testPointInside);
+                bool inside2 = IsPointInClipBox(testPointOutside);
+
+                LogManager.Info($"[剖面盒测试] 中心点: {inside1} (应为 True)");
+                LogManager.Info($"[剖面盒测试] 远点: {inside2} (应为 False)");
+
+                // 测试包围盒
+                var boxInside = new BoundingBox3D(
+                    new Point3D(center.X - 1, center.Y - 1, center.Z - 1),
+                    new Point3D(center.X + 1, center.Y + 1, center.Z + 1));
+                var boxOutside = new BoundingBox3D(
+                    new Point3D(center.X + 100, center.Y + 100, center.Z + 100),
+                    new Point3D(center.X + 200, center.Y + 200, center.Z + 200));
+
+                bool intersect1 = IntersectsClipBox(boxInside);
+                bool intersect2 = IntersectsClipBox(boxOutside);
+
+                LogManager.Info($"[剖面盒测试] 内部包围盒相交: {intersect1} (应为 True)");
+                LogManager.Info($"[剖面盒测试] 外部包围盒相交: {intersect2} (应为 False)");
+            }
+            catch (Exception ex)
+            {
+                LogManager.Error($"[剖面盒测试] 失败: {ex.Message}");
+            }
+        }
+
+        #region 私有方法
+
+        /// <summary>
+        /// 计算路径点的包围盒
+        /// </summary>
+        private static BoundingBox3D CalculatePathBoundingBox(List<Point3D> points)
+        {
+            if (points.Count == 1)
+            {
+                return new BoundingBox3D(points[0], points[0]);
+            }
+
+            double minX = double.MaxValue, minY = double.MaxValue, minZ = double.MaxValue;
+            double maxX = double.MinValue, maxY = double.MinValue, maxZ = double.MinValue;
+
+            foreach (var p in points)
+            {
+                minX = Math.Min(minX, p.X);
+                minY = Math.Min(minY, p.Y);
+                minZ = Math.Min(minZ, p.Z);
+                maxX = Math.Max(maxX, p.X);
+                maxY = Math.Max(maxY, p.Y);
+                maxZ = Math.Max(maxZ, p.Z);
+            }
+
+            return new BoundingBox3D(
+                new Point3D(minX, minY, minZ),
+                new Point3D(maxX, maxY, maxZ));
+        }
+
+        /// <summary>
+        /// 扩展包围盒
+        /// </summary>
+        private static BoundingBox3D ExpandBoundingBox(BoundingBox3D box, 
+            double horizontalMargin, double verticalMargin)
+        {
+            var min = new Point3D(
+                box.Min.X - horizontalMargin,
+                box.Min.Y - horizontalMargin,
+                box.Min.Z - verticalMargin);
+            var max = new Point3D(
+                box.Max.X + horizontalMargin,
+                box.Max.Y + horizontalMargin,
+                box.Max.Z + verticalMargin);
+            
+            return new BoundingBox3D(min, max);
+        }
+
+        /// <summary>
+        /// 应用剖面盒到视口
+        /// 使用 JSON 字符串方式设置，避免 "Object is Read-Only" 错误
+        /// </summary>
+        private static void ApplyClipBox(BoundingBox3D box)
+        {
+            // 构建 JSON 格式的 ClipPlaneSet
+            string json = BuildClipPlaneSetJson(box, true);
+            
+            // 使用 View.SetClippingPlanes 方法设置
+            var view = Application.ActiveDocument.ActiveView;
+            
+            // TrySetClippingPlanes 返回 bool 表示是否成功，不会抛出异常
+            bool success = view.TrySetClippingPlanes(json);
+            
+            if (!success)
+            {
+                // 如果 Try 方法失败，尝试使用 SetClippingPlanes（会抛出异常）
+                view.SetClippingPlanes(json);
+            }
+        }
+
+        /// <summary>
+        /// 构建 ClipPlaneSet 的 JSON 字符串
+        /// </summary>
+        /// <param name="box">包围盒</param>
+        /// <param name="enabled">是否启用</param>
+        /// <returns>JSON 字符串</returns>
+        private static string BuildClipPlaneSetJson(BoundingBox3D box, bool enabled)
+        {
+            // Navisworks ClipPlaneSet JSON 格式：
+            // {
+            //   "Type": "ClipPlaneSet",
+            //   "Version": 1,
+            //   "OrientedBox": {
+            //     "Type": "OrientedBox3D",
+            //     "Version": 1,
+            //     "Box": [[minX, minY, minZ], [maxX, maxY, maxZ]],
+            //     "Rotation": [0, 0, 0]
+            //   },
+            //   "Enabled": true/false
+            // }
+            
+            return string.Format(
+                "{{\"Type\":\"ClipPlaneSet\",\"Version\":1," +
+                "\"OrientedBox\":{{\"Type\":\"OrientedBox3D\",\"Version\":1," +
+                "\"Box\":[[{0},{1},{2}],[{3},{4},{5}]]," +
+                "\"Rotation\":[0,0,0]}},\"Enabled\":{6}}}",
+                box.Min.X.ToString("G17"),
+                box.Min.Y.ToString("G17"),
+                box.Min.Z.ToString("G17"),
+                box.Max.X.ToString("G17"),
+                box.Max.Y.ToString("G17"),
+                box.Max.Z.ToString("G17"),
+                enabled.ToString().ToLowerInvariant());
+        }
+
+        #endregion
+    }
+}