[
  {
    "slug": "1-ku-gai-shu",
    "title": "库概述",
    "section": "快速入门",
    "headings": [
      "核心架构",
      "模块功能概览",
      "主要特性",
      "快速上手",
      "项目结构",
      "学习路径建议"
    ],
    "content": "sunvpy是SunvStation地理信息系统的Python脚本接口库，专为二次开发和自动化数据处理任务设计。该库通过SWIG封装技术将C++核心功能暴露给Python，提供了完整的地理对象管理、空间查询、数据交换和质量检查能力。\n\n\n\n## 核心架构\n\nsunvpy采用分层架构设计，底层为SWIG封装的C++扩展模块，上层为面向Python的高级API封装。SSProcessManager作为主要入口类，通过Mixin模式组织功能模块，实现了关注点分离和代码复用。\n\n```mermaid\ngraph TB\n    subgraph \"Python API层\"\n        A[SSProcessManager<br/>进程管理器]\n        B[ObjBaseAttr<br/>属性管理器]\n        C[SelectionMixin<br/>选择集操作]\n        D[GeoEditMixin<br/>地理编辑]\n        E[ProjectMixin<br/>工程管理]\n        F[LogMixin<br/>日志记录]\n        G[ProgressMixin<br/>进度管理]\n    end\n    \n    subgraph \"SWIG封装层\"\n        H[PySSCore.pyd<br/>核心功能]\n        I[PySSMap.pyd<br/>地图操作]\n        J[PySSDataSource.pyd<br/>数据源管理]\n        K[PySSDatabase.pyd<br/>数据库操作]\n        L[PySSDataX.pyd<br/>数据交换]\n        M[PySSCheck.pyd<br/>数据检查]\n        N[PySSMath.pyd<br/>数学计算]\n        O[PySSWidget.pyd<br/>UI组件]\n        P[PySSView.pyd<br/>视图控制]\n        Q[PySSGisDBUpdate.pyd<br/>GIS数据库更新]\n    end\n    \n    subgraph \"C++核心层\"\n        R[SunvStation<br/>C++引擎]\n    end\n    \n    A --> C\n    A --> D\n    A --> E\n    A --> F\n    A --> G\n    A --> H\n    A --> I\n    A --> J\n    A --> K\n    A --> L\n    A --> M\n    A --> N\n    A --> O\n    A --> P\n    A --> Q\n    B --> H\n    \n    H -.-> R\n    I -.-> R\n    J -.-> R\n    K -.-> R\n    L -.-> R\n    M -.-> R\n    N -.-> R\n    O -.-> R\n    P -.-> R\n    Q -.-> R\n```\n\nSSProcessManager继承自五个功能Mixin类，每个Mixin负责特定的功能域。这种设计使得代码组织清晰，易于维护和扩展。全局单例SSProcess提供统一访问入口，确保工作空间和地图实例的一致性。\n\n\n\n## 模块功能概览\n\nsunvpy包含多个功能模块，每个模块对应特定的地理信息系统操作领域。下表列出了主要模块及其功能描述。\n\n| 模块名称 | 文件名 | 功能描述 | 封装类型 |\n|---------|--------|---------|---------|\n| 核心功能 | PySSCore.pyd | 提供基础数据结构、工作空间管理、地物对象等核心类 | SWIG封装 |\n| 地图操作 | PySSMap.pyd | 地图显示、缩放控制、坐标系转换等地图相关功能 | SWIG封装 |\n| 数据源管理 | PySSDataSource.pyd | 数据集访问、数据源管理、数据浏览等功能 | SWIG封装 |\n| 数据库操作 | PySSDatabase.pyd | 数据库连接、查询、更新等数据库操作功能 | SWIG封装 |\n| 数据交换 | PySSDataX.pyd | 数据导入导出、格式转换等数据交换功能 | SWIG封装 |\n| 数据检查 | PySSCheck.pyd | 拓扑检查、规则验证等数据质量检查功能 | SWIG封装 |\n| 数学计算 | PySSMath.pyd | 几何计算、坐标变换、数学运算等数学工具 | SWIG封装 |\n| UI组件 | PySSWidget.pyd | 进"
  },
  {
    "slug": "2-an-zhuang-yu-huan-jing-pei-zhi",
    "title": "安装与环境配置",
    "section": "快速入门",
    "headings": [
      "系统要求",
      "安装方法",
      "自动安装",
      "手动安装",
      "环境验证",
      "导入测试",
      "功能测试",
      "版本信息检查",
      "常见问题排查",
      "调试技巧",
      "目录结构说明",
      "环境配置最佳实践",
      "推荐开发环境设置",
      "下一步学习"
    ],
    "content": "本页面介绍 sunvpy Python 库的安装流程、环境配置要求以及验证方法。sunvpy 是 SunvStation 地理信息系统的官方 Python 脚本接口，通过 SWIG 技术将 C++ 核心功能封装为 Python 模块，为开发者提供高效的二次开发和自动化数据处理能力。\n\n\n\n## 系统要求\n\n使用 sunvpy 库需要满足以下软硬件环境要求。下表详细列出了各项配置要求和建议。\n\n| 配置项 | 最低要求 | 推荐配置 | 说明 |\n|-------|---------|---------|------|\n| 操作系统 | Windows 7/8.1/10 | Windows 10/11 | sunvpy 目前仅支持 Windows 平台 |\n| Python 版本 | Python 3.8+ | Python 3.10 - 3.13 | 需要与 SunvStation 版本匹配的 Python 版本 |\n| SunvStation | SunvStation 10.0+ | 最新稳定版 | SunvStation 软件本体必须已正确安装 |\n| 磁盘空间 | 100 MB | 200 MB+ | 包含 sunvpy 模块及其依赖库 |\n| 内存 | 2 GB RAM | 4 GB RAM+ | 处理大规模数据集时需要更多内存 |\n| 架构 | x86-64 | x86-64 | 仅支持 64 位操作系统和 Python |\n\nPython 版本的选择尤为重要，因为 sunvpy 中的 `.pyd` 扩展模块是编译好的二进制文件，必须与 Python 解释器的版本和位数完全匹配。错误的环境配置会导致模块加载失败。\n\n\n\n## 安装方法\n\nsunvpy 通常作为 SunvStation 安装包的一部分自动安装到 Python 的 site-packages 目录。安装流程可以分为自动安装和手动安装两种方式。\n\n### 自动安装\n\n自动安装是最推荐的方式，由 SunvStation 安装程序自动完成所有配置工作。\n\n```mermaid\nflowchart LR\n    A[运行 SunvStation 安装程序] --> B{选择 Python 版本}\n    B -->|指定 Python 安装路径| C[安装程序自动检测 Python 环境]\n    B -->|使用自带 Python| D[安装程序部署内置 Python 环境]\n    C --> E[复制 sunvpy 到 site-packages]\n    D --> E\n    E --> F[注册环境变量]\n    F --> G[创建桌面快捷方式]\n    G --> H[完成安装]\n```\n\n在安装 SunvStation 时，安装程序会自动检测系统中的 Python 环境，并提示用户选择使用现有的 Python 解释器还是安装 SunvStation 自带的 Python 版本。安装程序会将 sunvpy 包复制到指定 Python 版本的 `Lib\\site-packages\\sunvpy` 目录下。\n\n### 手动安装\n\n如果需要手动配置 sunvpy 环境，可以按照以下步骤操作。\n\n| 步骤 | 操作 | 详细说明 |\n|-----|------|---------|\n| 1 | 定位安装目录 | 找到 SunvStation 安装目录下的 script 子目录 |\n| 2 | 复制文件 | 将 sunvpy 整个文件夹复制到 Python 的 site-packages 目录 |\n| 3 | 验证依赖 | 确保所有 .pyd 文件和对应的 .py 文件完整 |\n| 4 | 配置环境变量 | 如有需要，添加相关路径到 PATH 环境变量 |\n| 5 | 测试导入 | 运行 Python 测试导入是否成功 |\n\n手动安装需要确保所有模块文件完整，包括 Python 封装文件（.py）和 C++ 扩展文件（.pyd）。缺失任何一个文件都可能导致模块功能异常。\n\n\n\n## 环境验证\n\n安装完成后，通过以下步骤验证环境配置是否正确。验证过程分为导入测试、功能测试和版本检查三个环节。\n\n### 导入测试\n\n打开命令行或 Python 解释器，尝试导入 sunvpy 模块。\n\n```python\n# 测试基本导入\nimport sunvpy\nprint(f\"sunvpy 版本: {sunvpy.get_version()}\")\n\n# 测试 SSProcess 导入\nfrom sunvpy import SSProcess\nprint(\"SSProcess 导入成功\")\n```\n\n如果导入成功且没有报错，说明基本环境配置正确。如果出现 `ModuleN"
  },
  {
    "slug": "3-di-ge-jiao-ben-cha-xun-di-wu-shu-xing",
    "title": "第一个脚本：查询地物属性",
    "section": "快速入门",
    "headings": [
      "脚本功能概览",
      "完整工作流程",
      "步骤一：准备环境与初始化",
      "步骤二：清理选择集与条件",
      "步骤三：设置选择条件",
      "条件类型说明",
      "操作符支持",
      "设置选择条件代码",
      "步骤四：执行过滤查询",
      "步骤五：获取选择集对象数量",
      "步骤六：遍历选择集并读取属性",
      "常用地物属性速查表",
      "遍历代码示例",
      "完整示例脚本",
      "脚本执行结果示例",
      "常见问题与解决方案",
      "问题1：选择集为空",
      "问题2：属性值为空",
      "问题3：扩展属性无法读取",
      "架构原理补充说明",
      "SSProcess 的内部结构",
      "属性读取机制",
      "下一步学习建议",
      "继续深入选择集与查询",
      "学习地物属性操作",
      "探索高级功能"
    ],
    "content": "本页面将引导您编写第一个 SunvStation Python 脚本，从最基础的地物属性查询开始。通过实际案例，您将学习如何使用选择集过滤地物对象，并读取它们的属性信息。这是所有数据处理和编辑操作的基础起点。\n\n## 脚本功能概览\n\n我们的第一个脚本将实现以下完整流程：在当前地图中按照编码条件筛选地物对象，然后遍历选择集中的每个对象，读取并显示其核心属性信息。这个示例涵盖了脚本开发的四个核心环节——准备工作、筛选对象、遍历结果、输出信息。\n\n\n\n## 完整工作流程\n\n让我们先通过一个流程图理解整个脚本的数据流转过程，这有助于把握各步骤之间的逻辑关系：\n\n```mermaid\nflowchart LR\n    A[初始化 SSProcess<br>获取工作空间与地图] --> B[清除旧选择集<br>clearSelection]\n    B --> C[清除旧选择条件<br>clearSelectCondition]\n    C --> D[设置筛选条件<br>setSelectCondition]\n    D --> E[执行过滤查询<br>selectFilter]\n    E --> F{选择集非空?}\n    F -->|是| G[获取对象数量<br>getSelGeoCount]\n    F -->|否| H[脚本结束]\n    G --> I[循环遍历对象]\n    I --> J[获取对象属性<br>getSelGeoValue]\n    J --> K[输出属性信息]\n    K --> L{还有对象?}\n    L -->|是| I\n    L -->|否| H\n```\n\n这个流程图展示了脚本的核心执行路径，其中每个节点对应一个关键的 API 调用。接下来的详细教程将逐步解析每个节点的具体实现。\n\n\n\n## 步骤一：准备环境与初始化\n\n在编写任何脚本之前，首先需要导入 sunvpy 模块中的核心类 `SSProcess`。这是一个全局单例对象，封装了工作空间、地图、选择集以及所有地物操作的核心功能。初始化完成后，`SSProcess` 会自动获取当前 SunvStation 系统的工作空间和活动地图实例，为后续操作做好准备。\n\n```python\nfrom sunvpy import SSProcess\n```\n\n这个简单的导入语句就完成了所有必要的准备工作。`SSProcess` 内部维护了 `WorkSpace`（工作空间）和 `ScaleMap`（比例尺地图）两个核心对象，以及 `GeoBaseList`（地物列表）、`SSearchHelper`（搜索助手）等辅助对象，共同构成了脚本运行的基础环境。\n\n\n\n## 步骤二：清理选择集与条件\n\n在开始新的查询之前，良好的习惯是清理之前可能残留的选择集和选择条件。这确保了脚本的执行结果不受上一次操作的影响，提高了脚本的可重复性和可靠性。\n\n```python\nSSProcess.clearSelection()      # 清除脚本选择集中的所有对象\nSSProcess.clearSelectCondition() # 清除之前设置的选择条件\n```\n\n`clearSelection()` 会清空 `selGeoList`（点线面地物列表）和 `selNoteList`（注记对象列表），而 `clearSelectCondition()` 则会清空 `searchHelper` 中存储的过滤条件。这两个方法都是无参数的简单调用，为后续操作提供一个干净的开始状态。\n\n\n\n## 步骤三：设置选择条件\n\n选择条件定义了我们要筛选地物的规则。SunvStation 支持三种类型的属性：基本属性、几何特性和扩展属性，它们通过不同的前缀标识符来区分。\n\n### 条件类型说明\n\n| 属性类型 | 前缀标识 | 示例 | 说明 |\n|---------|---------|------|------|\n| 基本属性 | `SSObj_` | `SSObj_Code` | 以 SSObj_ 开头的系统内置属性 |\n| 几何特性 | `< >` | `<Overlap>` | 用尖括号括住的几何判断条件 |\n| 扩展属性 | `[ ]` | `[JG]` | 用方括号括住的自定义扩展属性 |\n\n### 操作符支持\n\n系统提供了丰富的比较操作符，满足各种查询需求：\n\n| 操作符 | 含义 | 示例 |\n|--------|------|------|\n| `==` | 等于 | `SSObj_Code == \"3103013\"` |\n| `>` | 大于 | `SSObj_Length > \"100\"` |\n| `<` | 小于 | `SSObj_Area < \"500\"` |"
  },
  {
    "slug": "4-shi-yong-ssprocess-guan-li-xuan-ze-ji",
    "title": "使用 SSProcess 管理选择集",
    "section": "快速入门",
    "headings": [
      "SSProcess 架构概览",
      "核心组件说明",
      "选择集管理基础流程",
      "选择集与系统选择集的关系",
      "选择条件详解",
      "属性类型分类",
      "常用基本属性速查",
      "操作符说明",
      "条件值格式",
      "选择集操作核心 API",
      "初始化与清理",
      "执行查询",
      "读取对象属性",
      "修改对象属性",
      "同步到系统选择集",
      "完整示例：批量修改对象属性",
      "高级功能：选择集打散操作",
      "选择集管理最佳实践",
      "性能优化建议",
      "错误处理",
      "常见问题排查",
      "下一步学习路径"
    ],
    "content": "本页面将引导初学者了解如何使用 SSProcess 管理和操作地理对象的选择集。选择集是地理信息系统中的核心概念，它允许您针对一组特定的对象执行批量操作，如属性修改、坐标编辑、数据导出等。SSProcess 提供了完整的选择集管理 API，支持基于条件的复杂查询、属性读写和系统同步等功能。\n\n在学习本页内容后，建议按照以下路径继续深入：\n- [第一个脚本：查询地物属性](3-di-ge-jiao-ben-cha-xun-di-wu-shu-xing) — 了解属性查询的基础用法\n- [清除与初始化选择集](11-qing-chu-yu-chu-shi-hua-xuan-ze-ji) — 深入学习选择集的生命周期管理\n- [设置选择条件](12-she-zhi-xuan-ze-tiao-jian) — 掌握复杂条件查询技巧\n\n## SSProcess 架构概览\n\nSSProcess 采用 **Mixin 设计模式** 将不同功能模块化，选择集管理功能位于 `SelectionMixin` 中。这种架构使得代码职责清晰、易于维护和扩展。`SSProcessManager` 类通过多重继承组合了选择集、地理编辑、项目管理、日志和进度等多个功能模块，最终导出全局单例 `SSProcess` 供脚本直接使用。\n\n```mermaid\nclassDiagram\n    class SSProcessManager {\n        +workspace: WorkSpace\n        +map: ScaleMap\n        +selGeoList: GeoBaseList\n        +selNoteList: GeoBaseList\n        +searchHelper: SSearchHelper\n        +objBaseAttr: ObjBaseAttr\n        +clearSelection()\n        +setSelectCondition(name, mode, value)\n        +selectFilter()\n        +getSelGeoValue(index, fieldName)\n        +setSelGeoValue(index, fieldName, value)\n        +updateSysSelection(mode)\n    }\n    \n    class SelectionMixin {\n        <<mixin>>\n        +clearSelection()\n        +clearSelectCondition()\n        +setSelectCondition()\n        +selectFilter()\n        +getSelGeoCount()\n        +getSelNoteCount()\n        +getSelGeoValue()\n        +setSelGeoValue()\n        +updateSysSelection()\n        +resetSelGeoByCode()\n        +explodeSelectionObj()\n    }\n    \n    class GeoEditMixin {\n        <<mixin>>\n        +createDefaultGeoBase()\n        +explodeGeoObject()\n    }\n    \n    class LogMixin {\n        <<mixin>>\n        +set_logger()\n        +log_error_msg()\n    }\n    \n    class ProgressMixin {\n        <<mixin>>\n        +startProgress()\n        +stepProgress()\n        +closeProgress()\n    }\n    \n    class ProjectMixin {\n        <<mixin>>\n        +getCurrentMap()\n        +getSysSelGeoList()\n    }\n    \n    SSProcessManager *-- SelectionMixin\n    SSProcessManager *-- GeoEditMixin\n    SSProcessManager *-- LogMixin\n    SSProcessManager *-- ProgressMixin\n  "
  },
  {
    "slug": "5-yun-xing-nei-zhi-shi-li-jiao-ben",
    "title": "运行内置示例脚本",
    "section": "快速入门",
    "headings": [
      "示例脚本架构概览",
      "脚本运行方式",
      "方法一：直接执行模块",
      "方法二：从Python脚本导入",
      "示例脚本详解",
      "阶段一：初始化与筛选",
      "阶段二：属性字段列表",
      "阶段三：读取并显示原始属性",
      "阶段四：批量修改属性",
      "阶段五：验证修改结果",
      "注意事项与最佳实践",
      "运行前准备",
      "修改建议",
      "学习价值",
      "下一步学习"
    ],
    "content": "sunvpy提供了一个内置的示例脚本，帮助初学者快速理解如何使用SSProcess进行地物查询、属性读取和修改操作。这个示例脚本位于PySSProcess模块的`__main__`代码块中，展示了完整的数据处理工作流程，从筛选对象到修改属性再到验证结果的全部过程。\n\n\n\n## 示例脚本架构概览\n\n内置示例脚本通过一个连贯的演示，将之前学习的选择集管理和属性操作知识整合在一起。该脚本展示了如何在SunvStation环境中执行典型的批量数据处理任务：筛选特定编码的地物对象、查看其属性信息、批量修改多个属性字段，并最终验证修改结果。\n\n```mermaid\ngraph TB\n    A[脚本执行入口] --> B[初始化阶段<br>清理选择集与条件]\n    B --> C[筛选阶段<br>按编码过滤地物]\n    C --> D[读取阶段<br>遍历并显示原始属性]\n    D --> E[修改阶段<br>批量更新属性值]\n    E --> F[验证阶段<br>显示修改后属性]\n\n    B --> B1[clearSelection<br>清空选择集]\n    B --> B2[clearSelectCondition<br>清空筛选条件]\n\n    C --> C1[setSelectCondition<br>设置编码条件]\n    C --> C2[selectFilter<br>执行查询]\n\n    D --> D1[getSelGeoCount<br>获取对象数量]\n    D --> D2[getSelGeoValue<br>读取属性值]\n\n    E --> E1[基本属性修改<br>ID/线型/颜色等]\n    E --> E2[扩展属性修改<br>#91;JG#93;,#91;CS#93;等]\n\n    F --> F1[二次遍历对象]\n    F --> F2[对比显示结果]\n```\n\n这个流程图清晰地展示了脚本的四个主要阶段：初始化、筛选、修改和验证。每个阶段都对应一组核心API调用，形成了一个完整的数据处理闭环。\n\n\n\n## 脚本运行方式\n\n### 方法一：直接执行模块\n\n在Windows命令行中，通过Python解释器直接执行PySSProcess模块文件：\n\n```cmd\npython D:\\1SunvStationDev\\sunvstation-release\\build\\bin\\Release\\script\\python313\\Lib\\site-packages\\sunvpy\\PySSProcess.py\n```\n\n这种方式的优点是简单直接，无需额外代码即可运行示例。\n\n### 方法二：从Python脚本导入\n\n创建一个Python脚本文件（如`run_example.py`），通过导入执行：\n\n```python\nimport sunvpy.PySSProcess\n```\n\n这种方法更加灵活，可以在执行前后添加自己的代码逻辑。\n\n\n\n## 示例脚本详解\n\n### 阶段一：初始化与筛选\n\n脚本首先清理环境并建立筛选条件，确保操作的准确性和可重复性。\n\n```python\nSSProcess.clearSelection()      # 清除之前的选择集\nSSProcess.clearSelectCondition() # 清除之前的筛选条件\nSSProcess.setSelectCondition(\"SSObj_Code\", \"==\", \"3103013\") # 按编码筛选\nSSProcess.selectFilter()       # 执行查询\nprint(f\"选择集中的点线面对象数量: {SSProcess.getSelGeoCount()}\")\n```\n\n这几行代码完成了所有准备工作。`3103013`是示例使用的地物编码，在实际运行前应替换为当前地图中实际存在的编码值。\n\n\n\n### 阶段二：属性字段列表\n\n脚本定义了一个包含35个属性字段的列表，涵盖了基本属性、几何特性和扩展属性：\n\n```python\nfields = [\n    \"SSObj_ID\", \"SSObj_Code\", \"SSObj_LayerName\", \"SSObj_Type\", \"SSObj_Color\",\n    \"SSObj_LineType\", \"SSObj_LineWidth\", \"SSObj_Name\", \"SSObj_Byname\", \"SSObj_Angle\",\n    \"SSObj_DataMark\", \"SSObj_CreateTime\", \"SSObj_ModifyTime\", \"SSObj_ExplodeStatus\",\n    \"SSObj_FontWidth\", \"SSObj_Font"
  },
  {
    "slug": "6-sunvstation-xi-tong-jia-gou",
    "title": "SunvStation 系统架构",
    "section": "核心概念与架构",
    "headings": [
      "整体架构概览",
      "架构层次说明",
      "核心组件详解",
      "SWIG 封装层",
      "SSProcessManager 核心管理类",
      "Mixin 设计模式",
      "属性管理系统",
      "模块架构与职责",
      "核心模块",
      "功能域划分",
      "设计模式与架构特性",
      "Mixin 设计模式",
      "单例模式",
      "抽象基类模式",
      "依赖注入模式",
      "技术栈与依赖",
      "SWIG 封装技术",
      "Python 类型提示",
      "抽象基类（ABC）",
      "数据流与交互",
      "初始化流程",
      "操作流程",
      "缓存管理",
      "推荐学习路径"
    ],
    "content": "本文档从架构层面阐述 SunvStation 系统的设计理念、核心组件及其交互关系，帮助开发者理解系统的整体结构，为深入学习和二次开发奠定基础。\n\n## 整体架构概览\n\nSunvStation 采用分层架构设计，将 C++ 核心能力、Python 接口封装和业务逻辑管理清晰分离，形成高内聚、低耦合的系统结构。整个系统围绕 SSProcessManager 核心管理类展开，通过 Mixin 设计模式将功能模块化组合，同时借助 SWIG 技术实现 C++ 与 Python 的无缝集成。\n\n\n\n```mermaid\ngraph TB\n    subgraph \"应用层 Python 业务逻辑\"\n        SSProcess[SSProcessManager<br/>核心管理类]\n        \n        subgraph \"Mixin 功能模块\"\n            SelectionM[SelectionMixin<br/>选择集操作]\n            GeoEditM[GeoEditMixin<br/>地理对象编辑]\n            ProjectM[ProjectMixin<br/>项目管理]\n            LogM[LogMixin<br/>日志记录]\n            ProgressM[ProgressMixin<br/>进度管理]\n        end\n        \n        ObjBase[ObjBaseAttr<br/>属性管理器]\n    end\n    \n    subgraph \"接口层 SWIG 封装\"\n        Core[PySSCore<br/>核心类型与工作空间]\n        Database[PySSDatabase<br/>数据库操作]\n        Map[PySSMap<br/>地图与数据集]\n        DataSource[PySSDataSource<br/>数据源访问]\n        View[PySSView<br/>视图控制]\n        DataX[PySSDataX<br/>数据交换]\n        Check[PySSCheck<br/>数据检查]\n        Math[PySSMath<br/>数学计算]\n        Widget[PySSWidget<br/>UI组件]\n    end\n    \n    subgraph \"实现层 C++ 核心库\"\n        CoreDL[_PySSCore.pyd]\n        DatabaseDL[_PySSDatabase.pyd]\n        MapDL[_PySSMap.pyd]\n        DataSourceDL[_PySSDataSource.pyd]\n        ViewDL[_PySSView.pyd]\n        DataXDL[_PySSDataX.pyd]\n        CheckDL[_PySSCheck.pyd]\n        MathDL[_PySSMath.pyd]\n        WidgetDL[_PySSWidget.pyd]\n    end\n    \n    SSProcess -.->|继承| SelectionM\n    SSProcess -.->|继承| GeoEditM\n    SSProcess -.->|继承| ProjectM\n    SSProcess -.->|继承| LogM\n    SSProcess -.->|继承| ProgressM\n    SSProcess -->|使用| ObjBase\n    \n    SelectionM -->|调用| Core\n    SelectionM -->|调用| DataSource\n    GeoEditM -->|调用| Core\n    GeoEditM -->|调用| Database\n    ProjectM -->|调用| Core\n    ProjectM -->|调用| Map\n    LogM -.->|回调| Widget\n    ProgressM -->|调用| Widget\n    \n    Core -->|加载| CoreDL\n    Database -->|加载| DatabaseDL\n    Map -->|加载| MapDL\n    DataSource -->|加载| DataSourceDL\n    View -->|加载| ViewDL\n    DataX -->|加载| DataXDL\n    Check -->|加载| CheckDL\n    Math -->"
  },
  {
    "slug": "7-swig-feng-zhuang-ji-zhi-shuo-ming",
    "title": "SWIG 封装机制说明",
    "section": "核心概念与架构",
    "headings": [
      "SWIG 封装架构概览",
      "双层架构交互流程",
      "代理对象机制",
      "核心代理类结构",
      "内存所有权管理",
      "内存所有权状态表",
      "非动态属性限制机制",
      "迭代器支持与集合类型",
      "类型转换系统",
      "类型转换关系图",
      "模块组织结构",
      "模块功能对照表",
      "与 Python 生态的集成",
      "封装机制与 Mixin 设计的协同",
      "架构层次关系图",
      "性能考虑与优化建议",
      "调试与问题排查",
      "下一步学习"
    ],
    "content": "本文档详细说明 sunvpy 库中使用的 SWIG（Simplified Wrapper and Interface Generator）封装机制，阐述 Python 接口如何通过 SWIG 与 C++ 核心库进行交互。这种封装机制使开发者能够以 Pythonic 的方式调用高性能的 C++ 地理信息系统功能，同时保持接近原生 C++ 的执行效率。理解这一机制对于高级功能开发、性能优化和问题调试具有重要意义。\n\n\n\n## SWIG 封装架构概览\n\nsunvpy 采用双层架构设计实现 SWIG 封装：顶层是 Python 代理类，底层是 C++ 扩展动态链接库。每个功能模块都对应一个模块对，例如 PySSCore.py（Python 接口层）和 _PySSCore.pyd（C++ 实现层）。SWIG 4.4.0 版本自动生成了这些 Python 代理文件，将复杂的 C++ 对象模型映射为 Python 类和函数。Python 代码通过这些代理类调用底层 C++ 方法，代理类负责参数类型转换、异常处理和内存管理协调。这种设计既保持了 Python 的易用性，又充分利用了 C++ 的计算性能，特别适合地理信息系统中的大规模空间数据处理需求。\n\n\n\n### 双层架构交互流程\n\n```mermaid\nsequenceDiagram\n    participant User as 用户 Python 代码\n    participant Proxy as Python 代理类<br/>(PySS*.py)\n    participant Module as C++ 扩展模块<br/>(_PySS*.pyd)\n    participant Core as C++ 核心库\n    \n    User->>Proxy: geo = GeoBase()\n    Proxy->>Module: new_GeoBase(*args)\n    Module->>Core: 创建 C++ 对象\n    Core-->>Module: 返回 C++ 指针\n    Module-->>Proxy: 返回代理对象引用\n    Proxy->>Proxy: 设置 thisown = True\n    Proxy-->>User: 返回 GeoBase 实例\n    \n    User->>Proxy: geo.getId()\n    Proxy->>Module: GeoBase_getId(self)\n    Module->>Core: 调用 C++ 方法\n    Core-->>Module: 返回 ID 值\n    Module-->>Proxy: 返回 Python 值\n    Proxy-->>User: 返回 ID\n```\n\n此序列图展示了从 Python 代码到 C++ 核心库的完整调用路径。代理类作为桥梁，将 Python 对象操作转换为底层 C++ 方法调用，实现了无缝的语言边界穿越。SWIG 自动生成的代理代码处理了所有底层细节，包括指针传递、类型转换和引用计数。\n\n\n\n## 代理对象机制\n\n每个 SWIG 封装的类都继承自特定的元类系统，确保对象行为的一致性。代理类包含几个关键组件：`this` 属性持有 C++ 对象的指针引用，`thisown` 属性控制内存所有权，`__swig_repr__` 方法提供调试信息，以及一系列特殊方法支持 Python 语义。例如 GeoBase 类在 [PySSCore.py](PySSCore.py#L1930) 中定义，其构造函数通过 `_PySSCore.GeoBase_swiginit` 初始化，该方法将新创建的 C++ 对象指针绑定到 Python 代理实例。这种设计使得 Python 代码可以像操作原生对象一样操作 C++ 对象，而无需关心底层实现细节。\n\n\n\n### 核心代理类结构\n\n```mermaid\nclassDiagram\n    class SwigPyObject {\n        +this: C++ 指针\n        +own(): 设置所有权\n        +thisown: 所有权标志\n    }\n    \n    class ProxyClass {\n        +thisown: property\n        +__repr__(): 调试用\n        +__swig_destroy__(): 析构函数\n        +业务方法(): 转发到 C++\n    }\n    \n    class _SwigNonDynamicMeta {\n        <<metaclass>>\n        +__setattr__: 限制动态属性\n "
  },
  {
    "slug": "8-gong-zuo-kong-jian-yu-di-tu-gai-nian",
    "title": "工作空间与地图概念",
    "section": "核心概念与架构",
    "headings": [
      "系统架构概览",
      "工作空间",
      "核心特性",
      "获取工作空间实例",
      "主要职责",
      "便捷访问方法",
      "地图",
      "地图对象定义",
      "地图组成结构",
      "图层管理",
      "数据源管理",
      "地物搜索与检索",
      "撤销与重做",
      "工作空间与地图的关系",
      "访问当前地图",
      "地图切换",
      "系统路径管理",
      "路径类型表",
      "使用示例",
      "符号表管理",
      "地图图幅管理",
      "最佳实践",
      "1. 始终检查空引用",
      "2. 使用便捷方法优先",
      "3. 批量操作使用撤销标记",
      "4. 及时释放资源",
      "5. 尊重图层锁定状态",
      "与其他文档的关联"
    ],
    "content": "SunvStation 地理信息系统采用分层架构设计，其中工作空间与地图是理解整个系统的核心概念。本页将详细阐述这两个核心组件的职责、相互关系以及在 Python 脚本中的使用方式。掌握这些概念是高效使用 sunvpy 库进行二次开发的基础。\n\n## 系统架构概览\n\nSunvStation 系统采用单例模式的工作空间作为顶级容器，管理所有地图实例和系统资源。工作空间通过 `getInstance()` 方法获取全局唯一实例，确保整个应用程序共享同一资源上下文。地图对象则表示特定比例尺的地理数据视图，包含图层、地物、数据源等子组件。\n\n```mermaid\ngraph TB\n    subgraph \"应用程序级别\"\n        WS[WorkSpace 工作空间<br/>单例实例]\n    end\n    \n    subgraph \"地图级别\"\n        SM1[ScaleMap 地图1<br/>比例尺1:500]\n        SM2[ScaleMap 地图2<br/>比例尺1:1000]\n    end\n    \n    subgraph \"SM1 组件\"\n        L1[图层1]\n        L2[图层2]\n        DS1[数据源EPS]\n    end\n    \n    subgraph \"SM2 组件\"\n        L3[图层3]\n        L4[图层4]\n        DS2[数据源EPS]\n    end\n    \n    subgraph \"Python 脚本\"\n        PSS[SSProcessManager<br/>SSProcess全局实例]\n    end\n    \n    PSS --> |WorkSpace.getInstance| WS\n    PSS --> |getCurrentScaleMap| SM1\n    WS --> |管理多个| SM1\n    WS --> |管理多个| SM2\n    SM1 --> |包含| L1\n    SM1 --> |包含| L2\n    SM1 --> |引用| DS1\n    SM2 --> |包含| L3\n    SM2 --> |包含| L4\n    SM2 --> |引用| DS2\n```\n\n上图展示了系统的核心架构。工作空间作为顶级容器，管理所有地图实例。每个地图对象包含一组图层和关联的数据源。Python 脚本通过 `SSProcess` 全局实例访问工作空间和当前地图，实现与系统资源的交互。\n\n\n\n## 工作空间\n\n工作空间是 SunvStation 系统的全局单例对象，负责管理整个应用程序的资源和上下文。它提供统一的入口点来访问当前活动的地图、配置信息和系统路径。\n\n### 核心特性\n\n工作空间采用单例设计模式，确保整个应用程序中只有一个工作空间实例。这种设计有以下优势：\n\n- **资源统一管理**：所有地图实例和共享资源由工作空间统一分配和协调\n- **全局状态一致性**：确保不同模块访问的系统状态保持一致\n- **生命周期控制**：工作空间控制整个应用程序的生命周期，包括资源的创建和销毁\n\n### 获取工作空间实例\n\n在 Python 脚本中，通过 `WorkSpace.getInstance()` 方法获取工作空间实例。`SSProcessManager` 在初始化时会自动获取工作空间实例并存储为成员变量 `self.workspace`。\n\n\n\n### 主要职责\n\n工作空间的核心职责包括：\n\n- **地图管理**：维护所有打开的地图实例，提供获取当前活动地图的接口\n- **资源协调**：协调地图之间的资源共享和互斥访问\n- **全局配置**：存储和管理全局配置信息\n- **系统路径**：提供系统级路径信息（配置路径、模板路径、脚本路径等）\n\n### 便捷访问方法\n\n`ProjectMixin` 提供了便捷方法 `getWorkspace()` 来获取工作空间实例：\n\n\n\n## 地图\n\n地图对象（`ScaleMap`）表示特定比例尺的地理数据视图，是工作空间中最核心的可视化和编辑单元。每个地图包含一组图层、地物对象和关联的数据源。\n\n### 地图对象定义\n\n`ScaleMap` 类定义在 `PySSMap` 模块中，通过 SWIG 从 C++ 封装而来。它是地图数据的主要容器和管理者。\n\n\n\n### 地图组成结构\n\n地图由以下核心组件构成：\n\n| 组件类型 | 职责 | Python 类型 |\n|---------|------|-----------|\n| 图层 | 组织和管理地物对象，控制可见性和锁定状态 | Layer |\n| 数据源 | 存储地物数据的底层存储（EPS 数"
  },
  {
    "slug": "9-mixin-she-ji-mo-shi",
    "title": "Mixin 设计模式",
    "section": "核心概念与架构",
    "headings": [
      "Mixin 架构概览",
      "Mixin 组合关系",
      "功能模块详解",
      "日志记录模块（LogMixin）",
      "进度显示模块（ProgressMixin）",
      "地理编辑模块（GeoEditMixin）",
      "项目管理模块（ProjectMixin）",
      "选择集管理模块（SelectionMixin）",
      "共享状态管理",
      "Mixin 模式对比",
      "设计模式应用实例",
      "扩展与定制",
      "最佳实践与注意事项",
      "相关文档"
    ],
    "content": "Mixin 设计模式是一种通过**多重继承**实现代码复用的技术，它将不同功能模块拆分为独立的可复用单元，并在运行时动态组合成完整的类实例。在 SunvStation 地理信息系统开发中，Mixin 模式被用于构建 SSProcessManager 核心类，将选择集管理、地理对象编辑、进度显示、日志记录和项目操作等功能模块化，实现了高度解耦和灵活复用的架构设计。该模式的核心优势在于：通过组合而非继承来扩展功能，避免了复杂的类层次结构，同时保持了代码的清晰性和可维护性。\n\n## Mixin 架构概览\n\nSunvStation 的 Mixin 架构采用**抽象基类（ABC）定义接口 + Mixin 类实现功能**的双重设计模式。每个功能领域都有对应的 `*Aware` 抽象基类定义契约，以及 `*Mixin` 实现类提供具体实现。SSProcessManager 作为最终的组合类，通过多重继承将所有 Mixin 组合成一个功能完整的管理器实例。\n\n```mermaid\nclassDiagram\n    class SSProcessManager {\n        +WorkSpace workspace\n        +ScaleMap map\n        +GlobalOptions global_options\n        +ObjBaseAttr objBaseAttr\n        +GeoBaseList selGeoList\n        +GeoBaseList selNoteList\n        +SSearchHelper searchHelper\n        +GeoBase curSelGeo\n        +StringArray curSelGeoFields\n        +StringArray curSelGeoValues\n        +GeoBaseList bufferObjList\n        +list newBufferObjList\n        +tuple curNewObj\n        +bool enable_progress\n        +Progress progress\n        +Logger logger\n    }\n    \n    class LogAware {\n        <<ABC>>\n        +set_logger(Logger) abstract\n        +log_error_msg(str) abstract\n    }\n    \n    class LogMixin {\n        +Logger logger\n        +set_logger(Logger)\n        +log_error_msg(str)\n    }\n    \n    class ProgressAware {\n        <<ABC>>\n        +disable_progress() abstract\n        +startProgress(str, int) abstract\n        +stepProgress(str) abstract\n        +closeProgress() abstract\n    }\n    \n    class ProgressMixin {\n        +bool enable_progress\n        +Progress progress\n        +disable_progress()\n        +startProgress(str, int)\n        +stepProgress(str)\n        +closeProgress()\n    }\n    \n    class GeoEditAware {\n        <<ABC>>\n        +createDefaultGeoBase(int, Dataset) abstract\n        +getPolar(Point3D, Point3D) abstract\n        +createNewObjByCode(int) abstract\n        +addNewObjPoint(float, float, float, int, str) abstract\n        +saveBufferObjToDatabase() abstract\n        +updateRequest() abstract\n    }\n    \n    class GeoEditMixin {\n        +cre"
  },
  {
    "slug": "10-c-kuo-zhan-mo-kuai-yu-python-jie-kou",
    "title": "C++ 扩展模块与 Python 接口",
    "section": "核心概念与架构",
    "headings": [
      "架构概览",
      "SWIG 封装机制",
      "SWIG 自动生成特征",
      "模块导入机制",
      "C++ 扩展模块清单",
      "Python 类型封装",
      "内存管理机制",
      "动态属性控制",
      "迭代器支持",
      "高层架构设计",
      "SSProcessManager 类",
      "Mixin 类层次",
      "全局单例模式",
      "数据类型映射",
      "变体类型系统",
      "调用路径分析",
      "错误处理与异常机制",
      "性能优化策略",
      "延迟加载设计",
      "对象缓存机制",
      "扩展开发指南",
      "理解模块依赖关系",
      "类型注解规范",
      "学习路径建议",
      "总结"
    ],
    "content": "本文档深入解析 sunvpy 库的 C++ 扩展模块架构、SWIG 封装机制以及 Python 接口设计模式，帮助高级开发者理解系统的底层实现原理和技术架构。\n\n\n\n## 架构概览\n\nsunvpy 采用了**三层架构设计**，将底层 C++ 功能无缝集成到 Python 生态系统中。这种架构既保证了核心功能的高性能执行，又提供了灵活易用的 Python 接口。\n\n\n\n```mermaid\ngraph TB\n    subgraph \"Python 应用层\"\n        A[SSProcessManager<br/>高级API]\n        B[Mixin 类集合<br/>SelectionMixin, GeoEditMixin等]\n    end\n    \n    subgraph \"SWIG 封装层\"\n        C[PySSCore.py]\n        D[PySSMap.py]\n        E[PySSDatabase.py]\n        F[其他 PySS*.py 模块]\n    end\n    \n    subgraph \"C++ 扩展层\"\n        G[_PySSCore.pyd]\n        H[_PySSMap.pyd]\n        I[_PySSDatabase.pyd]\n        J[其他 _PySS*.pyd 模块]\n    end\n    \n    subgraph \"原生 C++ 核心\"\n        K[Core C++ 类库]\n    end\n    \n    A --> B\n    B --> C\n    B --> D\n    B --> E\n    B --> F\n    C --> G\n    D --> H\n    E --> I\n    F --> J\n    G --> K\n    H --> K\n    I --> K\n    J --> K\n```\n\n## SWIG 封装机制\n\nsunvpy 使用 **SWIG 4.4.0** 作为 C++ 到 Python 的桥接工具，自动生成 Python 包装代码。每个功能模块对应两个文件：`.pyd` 二进制扩展和 `.py` 接口封装。\n\n\n\n### SWIG 自动生成特征\n\n所有 SWIG 生成的 Python 模块都包含标准的头注释，明确标识其自动生成性质：\n\n```python\n# This file was automatically generated by SWIG (https://www.swig.org).\n# Version 4.4.0\n#\n# Do not make changes to this file unless you know what you are doing - modify\n# the SWIG interface file instead.\n```\n\n\n\n### 模块导入机制\n\nSWIG 生成的模块采用条件导入策略，确保在不同上下文中正确加载底层 C++ 扩展：\n\n```python\nfrom sys import version_info as _swig_python_version_info\n# Import the low-level C/C++ module\nif getattr(globals().get(\"__spec__\"), \"parent\", None) or __package__ or \".\" in __name__:\n    from . import _PySSCore\nelse:\n    import _PySSCore\n```\n\n\n\n这种设计支持模块的独立运行和包内导入两种场景。\n\n## C++ 扩展模块清单\n\nsunvpy 包含 10 个 C++ 扩展模块，每个模块负责特定的功能域：\n\n| 模块名称 | C++ 扩展文件 | SWIG 封装文件 | 功能描述 |\n|---------|-------------|--------------|---------|\n| Core | _PySSCore.pyd | PySSCore.py | 核心数据结构、基础类型、字段约束 |\n| Map | _PySSMap.pyd | PySSMap.py | 地图操作、工作空间、SDL 接口 |\n| Database | _PySSDatabase.pyd | PySSDatabase.py | 数据库访问、事务管理 |\n| DataSource | _PySSDataSource.pyd | PySSDataSource.py | 数据源管理、数据集操作 |\n| Widget | _PySSWidget.pyd | PySS"
  },
  {
    "slug": "11-qing-chu-yu-chu-shi-hua-xuan-ze-ji",
    "title": "清除与初始化选择集",
    "section": "选择集与查询",
    "headings": [
      "选择集基本概念",
      "选择集的自动初始化",
      "清除脚本选择集",
      "清除选择条件",
      "清除系统选择集",
      "典型使用场景",
      "场景一：开始新的查询操作",
      "场景二：脚本结束前的清理",
      "场景三：条件筛选后重试",
      "三种清除方法的对比",
      "选择集状态检查",
      "完整工作流程示例",
      "常见问题与注意事项",
      "学习路径建议"
    ],
    "content": "本页面介绍 SunvStation Python 脚本中选择集的初始化机制与清除操作。选择集是脚本操作地理对象的核心容器，掌握其初始化和清除方法对于编写稳定的数据处理脚本至关重要。\n\n## 选择集基本概念\n\n在 SunvStation 脚本环境中，存在两种类型的选择集：**脚本选择集**和**系统选择集**。脚本选择集由 `SSProcessManager` 在内存中维护，用于批量操作地理对象；系统选择集则是地图界面中当前选中的对象集合，直接影响地图显示效果。两者可以相互同步，但具有不同的生命周期和管理方式。\n\n脚本选择集由两个核心列表组成：`selGeoList` 存储点、线、面对象，`selNoteList` 存储注记对象。这种分离设计便于对不同类型的地理对象进行差异化管理。\n\n\n\n## 选择集的自动初始化\n\n当导入 `sunvpy` 模块或创建 `SSProcessManager` 实例时，选择集会自动完成初始化。初始化过程不需要开发者手动干预，确保脚本一开始就拥有可用的选择集容器。\n\n自动初始化包含以下步骤：获取当前工作空间实例、获取当前比例尺地图、创建地物和注记的空列表、初始化搜索助手、配置数据源和数据集列表。\n\n```mermaid\nflowchart LR\n    A[模块导入] --> B[创建 SSProcessManager 实例]\n    B --> C[获取工作空间 WorkSpace]\n    C --> D[获取当前地图 ScaleMap]\n    D --> E[初始化选择集容器]\n    E --> F[selGeoList = GeoBaseList]\n    E --> G[selNoteList = GeoBaseList]\n    E --> H[searchHelper = SSearchHelper]\n    H --> I[配置数据源和数据集]\n    I --> J[初始化完成,准备就绪]\n```\n\n\n\n**关键初始化代码**展示了这一过程的实现：\n\n```python\n# 脚本选择集容器（在 __init__ 中自动创建）\nself.selGeoList = GeoBaseList()   # 点线面对象列表\nself.selNoteList = GeoBaseList()  # 注记对象列表\nself.searchHelper = SSearchHelper()  # 搜索助手\n```\n\n\n\n## 清除脚本选择集\n\n`clearSelection()` 方法用于清空脚本选择集中的所有对象。该方法会同时清除地物列表和注记列表，将选择集恢复到初始空状态。这个操作不会影响系统选择集（地图上显示的选中状态），也不会影响数据库中的原始数据。\n\n```python\n# 清除脚本选择集中的所有地物和注记\nSSProcess.clearSelection()\n```\n\n\n\n**清除操作的实际效果**：调用 `clearSelection()` 后，`selGeoList` 和 `selNoteList` 都会变为空列表，后续的选择查询和遍历操作将基于空集进行。这是开启新一轮选择操作前的标准准备步骤。\n\n## 清除选择条件\n\n`clearSelectCondition()` 方法专门用于清除选择条件，而不影响选择集对象本身。选择条件由 `searchHelper` 内部维护，包含用于过滤查询的各种规则。清除条件后，新的查询将不再受之前设置条件的约束。\n\n```python\n# 清除之前设置的所有选择条件\nSSProcess.clearSelectCondition()\n```\n\n\n\n选择条件与选择集对象的区别：选择条件是\"筛选规则\"，选择集对象是\"筛选结果\"。`clearSelectCondition()` 清除规则，保留结果；`clearSelection()` 清除结果，保留规则。在实际脚本中，通常先清除条件，再设置新条件，最后执行查询。\n\n## 清除系统选择集\n\n`clearSysSelection()` 方法操作的是地图系统选择集，会移除地图界面上所有高亮显示的选中对象。这直接影响地图的视觉效果，使地图恢复到无选中状态。\n\n```python\n# 清除地图系统选择集（移除地图上的高亮显示）\nSSProcess.clearSysSelection()\n```\n\n\n\n**脚本选择集与系统选择集的协同**：在需要完全重置选择状态的场景下，通常连续调用三种清除方法：先清除脚本选择集对象，再清除选择条件，最后清除系统选择集的高亮显示。\n\n## 典型使用场景\n\n### 场景一：开始新的查询操作\n\n在执行新一轮数据查询前，需要重置选择集状态，确保不受到之前查询结果的干扰。\n\n```mermaid\nf"
  },
  {
    "slug": "12-she-zhi-xuan-ze-tiao-jian",
    "title": "设置选择条件",
    "section": "选择集与查询",
    "headings": [
      "核心方法概述",
      "条件名称类型",
      "基本属性",
      "几何特性",
      "扩展属性",
      "操作模式",
      "基本比较操作符",
      "字符串匹配操作符",
      "特殊操作符",
      "条件值方式",
      "单值方式",
      "多值方式",
      "区间方式",
      "条件设置流程",
      "基础使用示例",
      "示例一：精确匹配查询",
      "示例二：组合条件查询",
      "高级使用示例",
      "示例三：模糊匹配与扩展属性",
      "示例四：几何特性查询",
      "示例五：区间数值查询",
      "示例六：多值匹配查询",
      "条件设置的注意事项",
      "条件的累积特性",
      "条件与查询的分离",
      "值格式的正确使用",
      "扩展属性的大小写敏感性",
      "典型应用场景",
      "场景一：按图层批量处理",
      "场景二：数据质量检查",
      "场景三：按时间范围查询",
      "场景四：按类型批量查询",
      "条件设置的性能考虑",
      "多条件的查询效率",
      "避免过度复杂的条件",
      "下一步学习"
    ],
    "content": "本页面介绍 SunvStation Python 脚本中设置选择条件的方法。选择条件是过滤地理对象的查询规则，通过组合不同条件可以精确筛选出符合特定要求的地物对象。掌握条件设置的语法和技巧，能够显著提升数据处理脚本的效率和准确性。\n\n\n\n## 核心方法概述\n\n`setSelectCondition()` 方法是设置选择条件的主要接口。该方法将指定的条件添加到脚本选择集的查询规则中，可以多次调用以构建复合查询条件。条件由三个部分组成：条件名称、操作模式和条件值，三者组合形成一个完整的查询表达式。\n\n```python\nSSProcess.setSelectCondition(conditionName, operateMode, conditionValue)\n```\n\n\n\n**方法的底层实现**通过调用 `searchHelper.addCondition()` 将条件添加到内部维护的条件列表中。这些条件在调用 `selectFilter()` 时被实际执行，从而过滤出符合所有条件的地理对象。\n\n\n\n## 条件名称类型\n\n选择条件的名称（conditionName）决定了查询的目标属性。系统支持三种类型的条件名称：基本属性、几何特性和扩展属性，每种类型有不同的前缀标识规则。\n\n\n\n### 基本属性\n\n以 `SSObj_` 开头的属性称为基本属性，这些是地理对象的内置属性，涵盖对象的标识、外观、几何信息等。基本属性是最常用的查询条件，覆盖了大多数常规筛选需求。\n\n\n\n**常用基本属性列表**：\n\n| 属性名称 | 说明 | 示例值 |\n|---------|------|--------|\n| `SSObj_ID` | 对象唯一标识 | \"1001\" |\n| `SSObj_Code` | 编码 | \"3103013\" |\n| `SSObj_LayerName` | 层名 | \"Default_A\" |\n| `SSObj_Type` | 对象类型 | \"POINT\", \"LINE\", \"AREA\", \"NOTE\" |\n| `SSObj_Color` | 颜色 | \"RGB(255,0,0)\", \"16777215\" |\n| `SSObj_Name` | 对象名称 | \"建筑物1\" |\n| `SSObj_Area` | 面积 | \"150.5\" |\n| `SSObj_Length` | 长度 | \"230.8\" |\n| `SSObj_PointCount` | 点数 | \"1\", \"1,2,4\" |\n| `SSObj_X` / `SSObj_Y` / `SSObj_Z` | 坐标 | \"12345.67\", \"2345.89\", \"0\" |\n| `SSObj_CreateTime` | 创建时间 | \"2023-07-01 12:00:00\" |\n| `SSObj_ModifyTime` | 修改时间 | \"2023-08-15 09:30:00\" |\n\n\n\n**注记对象特有属性**：\n\n| 属性名称 | 说明 |\n|---------|------|\n| `SSObj_FontWidth` | 字宽 |\n| `SSObj_FontHeight` | 字高 |\n| `SSObj_FontName` | 字体名 |\n| `SSObj_FontClass` | 注记分类号 |\n| `SSObj_FontAlignment` | 对齐方式 |\n| `SSObj_FontString` | 注记内容 |\n\n\n\n### 几何特性\n\n使用尖括号 `<>` 括住的属性称为几何特性，用于查询对象的拓扑或几何状态特征。这些条件不直接比较属性值，而是判断对象是否满足特定的几何条件。\n\n\n\n**常用几何特性**：\n\n| 特性名称 | 说明 | 常用操作符 |\n|---------|------|----------|\n| `<Overlap>` | 重叠 | \"==\" |\n| `<Close>` | 封闭 | \"==\" |\n\n\n\n几何特性通常使用 `\"==\"` 操作符，条件值为 `\"True\"` 或 `\"False\"`，用于筛选出具有特定拓扑状态的对象。\n\n\n\n### 扩展属性\n\n使用方括号 `[]` 括住的属性称为扩展属性，这些是用户自定义的属性字段，存储在对象的扩展属性表中。扩展属性允许根据业务需求灵活定义查询条件，是数据查询的强大工具。\n\n\n\n**扩展属性示例**：\n\n```python\n# 查询扩展属性名为\"建筑结构\"的对象\nSSProcess.setSelectCondition(\"[建筑结构]\", \"==\", \"砖混\")\n\n# 查询扩展属性为\"层数\"大于10的对象\nSSProcess.setSelectCondition(\"[层数]\", \">"
  },
  {
    "slug": "13-zhi-xing-guo-lu-cha-xun",
    "title": "执行过滤查询",
    "section": "选择集与查询",
    "headings": [
      "核心方法概述",
      "执行流程",
      "详细执行步骤",
      "步骤一：清理缓存",
      "步骤二：获取候选对象",
      "步骤三：精确过滤",
      "步骤四：结果分类存储",
      "完整使用示例",
      "基础查询示例",
      "多条件复合查询",
      "使用多值和区间查询",
      "查询前后的选择集状态对比",
      "结果处理最佳实践",
      "检查查询结果",
      "批量处理对象",
      "同步到系统选择集",
      "常见问题与故障排除",
      "问题一：查询结果为空",
      "问题二：查询结果不符合预期",
      "问题三：进度条不显示",
      "问题四：性能问题",
      "完整工作流示例",
      "与其他方法的协作关系",
      "延伸阅读"
    ],
    "content": "本页面介绍 SunvStation Python 脚本中执行过滤查询的方法。`selectFilter()` 方法是选择集查询的核心执行环节，它根据之前设置的选择条件，从数据源中筛选出符合条件的地理对象，并将结果填充到脚本选择集中。掌握此方法的执行机制和结果处理，是构建高效数据查询脚本的关键。\n\n\n\n## 核心方法概述\n\n`selectFilter()` 方法负责执行实际的选择集过滤操作。该方法内部协调搜索助手 `searchHelper`，通过两阶段查询机制完成对象筛选：首先获取候选对象列表，然后根据完整条件进行精确过滤，最后将结果分类存储到脚本选择集中。\n\n```python\nSSProcess.selectFilter()\n```\n\n\n\n**方法返回值**：该方法无返回值，执行结果通过脚本选择集成员变量 `selGeoList`（点线面对象）和 `selNoteList`（注记对象）提供访问。查询成功后，可以使用 `getSelGeoCount()` 和 `getSelNoteCount()` 获取结果数量，使用 `getSelGeoValue()` 等方法遍历对象属性。\n\n\n\n## 执行流程\n\n过滤查询的执行过程包含四个关键阶段：缓存清理、候选对象获取、精确过滤、结果分类存储。整个流程由进度条模块提供可视化反馈，确保操作透明可控。\n\n```mermaid\nflowchart TD\n    A[调用 selectFilter] --> B[清理缓存]\n    B --> C[清空 curSelGeoFields]\n    C --> D[清空 curSelGeoValues]\n    D --> E[执行选择过滤]\n    E --> F[创建临时 GeoBaseList]\n    F --> G[getFilterObj 获取候选对象]\n    G --> H{候选对象非空?}\n    H -->|是| I[filterObj 精确过滤]\n    H -->|否| J[跳过过滤步骤]\n    I --> K[遍历结果列表]\n    J --> K\n    K --> L{对象类型判断}\n    L -->|注记对象| M[添加到 selNoteList]\n    L -->|点线面对象| N[添加到 selGeoList]\n    M --> O[完成选择集过滤]\n    N --> O\n    O --> P[关闭进度条]\n```\n\n\n\n**进度反馈机制**：方法执行过程中会调用 `stepProgress()` 方法报告当前进度，包括\"清理缓存\"、\"执行选择过滤\"、\"更新选择集\"、\"完成选择集过滤\"四个阶段。开发者可以通过 `enable_progress` 属性控制是否显示进度条。\n\n\n\n## 详细执行步骤\n\n### 步骤一：清理缓存\n\n执行查询前，方法首先清理属性缓存字段 `curSelGeoFields` 和 `curSelGeoValues`。这两个字符串数组用于存储当前选中对象的属性字段和对应值，清理缓存确保新的查询结果不会受到之前属性访问的干扰。\n\n\n\n### 步骤二：获取候选对象\n\n方法创建临时的 `GeoBaseList` 容器，并调用 `searchHelper.getFilterObj()` 方法。该方法根据 `m_selectConditions` 中存储的选择条件，从当前数据源中获取满足条件的候选对象列表。这一步是初步筛选，可能包含部分不完全符合所有条件的对象。\n\n\n\n### 步骤三：精确过滤\n\n如果候选对象列表非空，方法调用 `searchHelper.filterObj()` 进行精确过滤。这一步对候选对象应用完整的条件规则集合，确保最终结果严格满足所有设置的条件。只有通过精确过滤的对象才会被加入最终的选择集。\n\n\n\n### 步骤四：结果分类存储\n\n最后，方法遍历过滤后的对象列表，根据对象类型将其分类存储：注记对象（`e_Note_Obj`）添加到 `selNoteList`，其他类型的点线面对象添加到 `selGeoList`。这种分离存储便于后续对不同类型对象进行差异化处理。\n\n\n\n## 完整使用示例\n\n以下示例展示了一个完整的过滤查询流程，从条件设置到结果处理的各个步骤。\n\n```mermaid\nflowchart LR\n    A[开始查询] --> B[clearSelection<br/>清除旧结果]\n    B --> C[clearSelectCondition<br/>清除旧条件]\n    C --> D[setSelectCondition<br/>设置查询条件]\n    D --> E[selectFilter<br/>执行过滤]\n    E --> F{检查结果数"
  },
  {
    "slug": "14-bian-li-xuan-ze-ji-dui-xiang",
    "title": "遍历选择集对象",
    "section": "选择集与查询",
    "headings": [
      "选择集数据结构概述",
      "核心迭代 API 方法",
      "基本遍历流程",
      "完整工作流示例",
      "坐标点遍历",
      "扩展属性遍历",
      "最佳实践与注意事项",
      "应用场景示例",
      "下一步学习"
    ],
    "content": "遍历选择集对象是 SunvStation 自动化脚本中的核心操作，用于批量处理地理对象的属性和几何信息。通过遍历选择集，可以高效地读取、修改、验证或分析大量地理数据，实现数据质量检查、批量属性更新、统计分析等复杂业务逻辑。\n\n## 选择集数据结构概述\n\nSunvStation 的选择集由两个核心列表组成：`selGeoList` 存储点线面等几何对象，`selNoteList` 存储注记对象。这两个列表都是 `GeoBaseList` 类型，支持索引访问和迭代操作。选择集对象通过 `SSProcessManager` 类统一管理，该类通过 `SelectionMixin` 提供了完整的迭代 API。\n\n```mermaid\nflowchart TD\n    A[SSProcessManager] --> B[SelectionMixin]\n    B --> C[selGeoList<br/>点线面对象列表]\n    B --> D[selNoteList<br/>注记对象列表]\n    C --> E[GeoBaseList<br/>索引访问]\n    D --> E\n    E --> F[getSelGeoValue<br/>getSelNoteValue<br/>getSelGeoPoint]\n    E --> G[setSelGeoValue<br/>setSelNoteValue]\n    F --> H[属性读取循环]\n    G --> I[属性修改循环]\n```\n\n选择集对象通常通过两种方式构建：一是通过 `setSelectCondition` 和 `selectFilter` 基于条件过滤生成；二是通过 `updateSysSelection(0)` 从系统地图的选择集中同步。构建完成后，即可使用索引方式遍历处理每个对象。\n\n\n\n## 核心迭代 API 方法\n\n遍历选择集依赖于以下关键方法，这些方法提供了从对象数量统计到具体属性访问的完整功能链。\n\n| 方法名称 | 参数说明 | 返回值 | 功能描述 |\n|---------|---------|--------|---------|\n| `getSelGeoCount()` | 无 | int | 获取选择集中点线面对象的数量 |\n| `getSelNoteCount()` | 无 | int | 获取选择集中注记对象的数量 |\n| `getSelGeoValue(index, fieldName)` | index: 对象索引, fieldName: 属性名称 | str | 获取指定几何对象的属性值 |\n| `getSelNoteValue(index, fieldName)` | index: 对象索引, fieldName: 属性名称 | str | 获取指定注记对象的属性值 |\n| `setSelGeoValue(index, fieldName, value)` | index: 对象索引, fieldName: 属性名称, value: 属性值 | None | 设置指定几何对象的属性值 |\n| `setSelNoteValue(index, fieldName, value)` | index: 对象索引, fieldName: 属性名称, value: 属性值 | None | 设置指定注记对象的属性值 |\n| `getSelGeoPoint(index, pointIndex)` | index: 对象索引, pointIndex: 点索引 | Point | 获取指定几何对象的坐标点 |\n\n`index` 参数从 0 开始，最大值为对象数量减 1。属性名称包括以 `SSObj_` 开头的基本属性（如 `SSObj_Code`、`SSObj_Area`）、以 `<>` 括住的几何特性（如 `<Overlap>`）、以 `[]` 括住的扩展属性（如 `[建筑结构]`）。当索引越界时，`getSelGeoValue` 和 `getSelNoteValue` 返回空字符串，而 `setSelGeoValue` 和 `setSelNoteValue` 则直接返回不执行操作。\n\n\n\n## 基本遍历流程\n\n遍历选择集对象遵循标准的索引循环模式。首先获取对象总数，然后使用 `for` 循环遍历每个索引，在每个迭代中读取或修改对象属性。\n\n```mermaid\nflowchart LR\n    A[开始] --> B[获取对象数量<br/>getSelGeoCount / getSelNoteCount]\n    B --> C[初始化循环索引 i = 0]\n    C --> D{i < 对象数量?}\n    D -->|是| E[访问对象属性"
  },
  {
    "slug": "15-huo-qu-di-wu-shu-xing-zhi",
    "title": "获取地物属性值",
    "section": "选择集与查询",
    "headings": [
      "属性类型与命名规则",
      "基本属性",
      "几何特性",
      "扩展属性",
      "核心 API 方法",
      "getSelGeoValue 方法",
      "getSelNoteValue 方法",
      "属性获取流程",
      "基本属性读取示例",
      "示例 1：读取单个对象的多个属性",
      "示例 2：批量读取所有对象的核心属性",
      "坐标点属性读取",
      "几何特性读取示例",
      "扩展属性读取示例",
      "读取单个扩展属性",
      "读取多个扩展属性",
      "获取对象的完整扩展属性列表",
      "注记对象属性读取",
      "综合应用示例",
      "常见问题与解决方案",
      "问题 1：属性值返回空字符串",
      "问题 2：扩展属性无法读取",
      "问题 3：坐标点属性读取失败",
      "问题 4：几何特性返回值不是预期的布尔值",
      "属性读取性能优化建议",
      "建议 1：批量读取多个属性",
      "建议 2：避免重复读取",
      "建议 3：使用字典存储对象属性",
      "下一步学习"
    ],
    "content": "本文档详细说明如何在 SunvStation Python 脚本中读取地物对象的属性值，涵盖基本属性、几何特性和扩展属性三种类型的属性访问方式。通过掌握这些方法，您可以高效地获取和分析地理对象的各类信息，为后续的数据处理、质量检查和统计分析奠定基础。\n\n## 属性类型与命名规则\n\nSunvStation 系统中，地物属性根据来源和用途分为三类，每类属性使用特定的前缀标识符进行区分。理解这些分类和命名规则是正确读取属性的前提。\n\n```mermaid\nflowchart TD\n    A[地物属性] --> B[基本属性 SSObj_]\n    A --> C[几何特性 #60; #62;]\n    A --> D[扩展属性 #91; #93;]\n    \n    B --> B1[对象标识<br/>SSObj_ID, SSObj_Code]\n    B --> B2[外观属性<br/>SSObj_Color, SSObj_LineType, SSObj_LineWidth]\n    B --> B3[名称属性<br/>SSObj_Name, SSObj_Byname, SSObj_LayerName]\n    B --> B4[几何参量<br/>SSObj_Area, SSObj_Length, SSObj_PointCount]\n    B --> B5[时间属性<br/>SSObj_CreateTime, SSObj_ModifyTime]\n    B --> B6[坐标信息<br/>SSObj_X, SSObj_Y, SSObj_Z, SSObj_PointName]\n    B --> B7[注记属性<br/>SSObj_FontString, SSObj_FontHeight, SSObj_FontWidth]\n    \n    C --> C1[拓扑判断<br/>#60;Overlap#62;, #60;Close#62;]\n    C --> C2[几何判断<br/>#60;Convex#62;, #60;SelfIntersect#62;]\n    \n    D --> D1[业务属性<br/>#91;JG#93;, #91;CS#93;, #91;建筑结构#93;]\n    D --> D2[自定义属性<br/>#91;自定义字段1#93;, #91;自定义字段2#93;]\n```\n\n### 基本属性\n\n以 `SSObj_` 开头，表示系统内置的地物基本属性，包括对象标识、外观、几何参量、时间戳等。这些属性直接存储在地理对象内部，访问效率最高。\n\n| 属性名称 | 属性说明 | 数据类型 | 适用对象类型 |\n|---------|---------|---------|------------|\n| `SSObj_ID` | 对象唯一标识 | 整数 | 所有类型 |\n| `SSObj_Code` | 地物编码 | 整数 | 所有类型 |\n| `SSObj_LayerName` | 所在图层名 | 字符串 | 所有类型 |\n| `SSObj_Type` | 对象类型 | 字符串（POINT/LINE/AREA/NOTE） | 所有类型 |\n| `SSObj_Color` | 颜色值 | 整数 | 所有类型 |\n| `SSObj_LineType` | 线型 | 整数 | LINE/AREA |\n| `SSObj_LineWidth` | 线宽 | 整数 | LINE/AREA |\n| `SSObj_Name` | 对象名称 | 字符串 | 所有类型 |\n| `SSObj_Byname` | 对象别名 | 字符串 | 所有类型 |\n| `SSObj_Angle` | 旋转角度 | 浮点数 | 所有类型 |\n| `SSObj_ScaleX` | X 方向缩放 | 浮点数 | 所有类型 |\n| `SSObj_ScaleY` | Y 方向缩放 | 浮点数 | 所有类型 |\n| `SSObj_Area` | 面积 | 浮点数 | AREA |\n| `SSObj_Length` | 周长/长度 | 浮点数 | LINE/AREA |\n| `SSObj_3DLength` | 三维长度 | 浮点数 | LINE/AREA |\n| `SSObj_PointCount` | 坐标点数量 | 整数 | POINT/LINE/AREA |\n| `SSObj_X` | X 坐标 | 浮点数 | POINT/线对象指定点 |\n| `SSObj_Y` | Y 坐标 | 浮点数 | POINT/线对象指定点 |\n| `SSObj_Z` | Z 坐标 | 浮点数 | POINT/线对象指定点 |\n| `SSObj_PointName` | "
  },
  {
    "slug": "16-xiu-gai-di-wu-shu-xing-zhi",
    "title": "修改地物属性值",
    "section": "选择集与查询",
    "headings": [
      "属性修改架构概览",
      "属性类型与命名规范",
      "基本属性分类",
      "修改新建对象的属性",
      "基本属性设置",
      "扩展属性设置",
      "注记属性设置",
      "修改选择集中对象的属性",
      "选择集对象属性修改流程",
      "修改单个对象的属性",
      "批量修改选择集对象的属性",
      "修改注记对象的属性",
      "特殊属性处理",
      "编码属性（SSObj_Code）修改",
      "图层属性（SSObj_LayerName）修改",
      "点坐标修改（SSObj_X, SSObj_Y, SSObj_Z）",
      "点名称与类型修改（SSObj_PointName, SSObj_PointType）",
      "颜色属性设置详解",
      "完整示例：批量更新道路属性",
      "完整示例：创建并设置新对象",
      "注意事项与最佳实践",
      "属性修改注意事项",
      "保存机制",
      "错误处理",
      "进阶操作：通过对象ID直接修改属性",
      "下一步学习"
    ],
    "content": "修改地物属性值是 SunvStation Python API 中最核心的数据操作功能之一。本页将系统性地介绍如何通过脚本修改地物的基本属性、扩展属性以及几何属性，并确保修改内容正确保存到数据库。\n\n## 属性修改架构概览\n\n地物属性修改涉及三个核心层次：**新建对象属性设置**、**选择集对象属性修改**和**批量保存机制**。理解这个架构对于正确使用 API 至关重要。\n\n```mermaid\nflowchart TB\n    A[开始属性修改] --> B{修改场景}\n    B --> C[新建对象]\n    B --> D[选择集对象]\n    B --> E[批量修改]\n    \n    C --> C1[createDefaultGeoBase<br/>创建对象]\n    C1 --> C2[setNewObjValue<br/>设置属性]\n    C2 --> C3[addNewObjToSaveObjList<br/>添加到保存列表]\n    \n    D --> D1[遍历选择集对象]\n    D1 --> D2{属性类型}\n    D2 --> D3[SSObj_Code/LayerName<br/>特殊处理]\n    D2 --> D4[基本属性<br/>setGeoValue]\n    D2 --> D5[扩展属性<br/>setMemoData]\n    D3 --> D6[addSelGeoToSaveGeoList<br/>添加到保存列表]\n    D4 --> D6\n    D5 --> D6\n    \n    E --> E1[setSelGeoValue -1<br/>批量设置]\n    E1 --> E2[addSelGeoToSaveGeoList -1<br/>批量添加]\n    \n    C3 --> F[saveBufferObjToDatabase<br/>保存到数据库]\n    D6 --> F\n    E2 --> F\n    F --> G[updateRequest<br/>刷新地图显示]\n    G --> H[完成]\n```\n\n## 属性类型与命名规范\n\nSunvStation 支持三种不同类型的属性，每种类型使用特定的命名前缀和语法规则。\n\n| 属性类型 | 命名格式 | 示例 | 说明 |\n|---------|---------|------|------|\n| **基本属性** | `SSObj_` 开头 | `SSObj_Code`, `SSObj_Name`, `SSObj_Color` | 系统预定义的固有属性 |\n| **扩展属性** | `[属性名]` 格式 | `[建筑类型]`, `[施工状态]` | 用户自定义的扩展字段 |\n| **几何属性** | `<属性名>` 格式 | `<Area>`, `<Length>`, `<X(0)>` | 对象的几何特性和坐标信息 |\n\n### 基本属性分类\n\n**通用属性**：涵盖对象的标识、图层和图形表现。这包括对象 ID、编码、图层名称、颜色、线型和线宽等关键属性。\n\n**几何属性**：涉及对象的坐标、几何尺寸和拓扑特征。包括坐标点（X, Y, Z）、面积、长度、边界框等几何信息。\n\n**注记属性**：专门针对文本标注的样式和格式。包括字体宽度、高度、名称、内容、对齐方式和角度等详细属性。\n\n**时间与状态**：记录对象的创建和修改时间，以及对象的状态标记。\n\n\n\n## 修改新建对象的属性\n\n当通过 `createDefaultGeoBase()` 或 `createNewObjByCode()` 创建新地物对象后，可以使用 `setNewObjValue()` 方法设置其属性。这种方法适用于单次创建并立即设置属性的场景。\n\n### 基本属性设置\n\n```python\n# 创建编码为 100 的线对象\nobj, geo = ssp.createNewObjByCode(100)\n\n# 设置基本属性\nssp.setNewObjValue(\"SSObj_Name\", \"主干道\")\nssp.setNewObjValue(\"SSObj_Color\", \"16711680\")      # RGB 红色\nssp.setNewObjValue(\"SSObj_LineWidth\", \"2\")\nssp.setNewObjValue(\"SSObj_Angle\", \"45.0\")\n```\n\n### 扩展属性设置\n\n扩展属性使用方括号 `[]` 包裹属性名，可以同时设置多个属性：\n\n```python\n# 设置单个扩展属性\nssp.setNewObjValue(\"[建筑类型]\", \"住宅楼\")\nssp.setNewObjVa"
  },
  {
    "slug": "17-di-wu-ji-ben-shu-xing-xiang-jie",
    "title": "地物基本属性详解",
    "section": "选择集与查询",
    "headings": [
      "属性体系概览",
      "标识属性详解",
      "SSObj_ID：系统唯一标识",
      "SSObj_Code：业务编码",
      "SSObj_Name 与 SSObj_Byname",
      "SSObj_LayerName 与 SSObj_GroupID",
      "几何属性详解",
      "坐标点属性体系",
      "几何尺寸属性",
      "边界框属性",
      "几何变换属性",
      "外观属性详解",
      "颜色属性（SSObj_Color）",
      "线型属性（SSObj_LineType）",
      "填充样式属性",
      "时间属性详解",
      "SSObj_CreateTime：创建时间戳",
      "SSObj_ModifyTime：修改时间戳",
      "注记属性详解",
      "字体属性组",
      "内容属性组",
      "布局属性组",
      "属性访问机制深入",
      "属性名称注册与索引映射",
      "参数化属性解析",
      "属性值获取流程",
      "属性修改机制深入",
      "扩展属性的特殊处理",
      "基本属性的值转换",
      "批量操作与循环优化",
      "只读属性保护",
      "应用场景与最佳实践",
      "数据质量检查与验证",
      "批量属性更新",
      "空间分析与统计",
      "注记符号化与布局",
      "最佳实践建议",
      "总结"
    ],
    "content": "本文档深入解析 SunvStation 地物基本属性体系，阐述各类属性的物理含义、存储机制、应用场景以及底层实现原理。通过系统地理解这些属性，开发者可以更高效地进行地理数据管理和空间分析。\n\n## 属性体系概览\n\n地物基本属性体系是一个层次化的概念架构，将地理对象的各种特征抽象为可管理和可查询的属性集合。这个体系遵循从抽象到具体的分层原则，覆盖了对象的标识、几何、外观、时间等完整维度的信息。\n\n```mermaid\nflowchart TB\n    A[地物基本属性体系] --> B[标识属性组]\n    A --> C[几何属性组]\n    A --> D[外观属性组]\n    A --> E[时间属性组]\n    A --> F[注记属性组]\n    \n    B --> B1[SSObj_ID<br/>系统唯一标识]\n    B --> B2[SSObj_Code<br/>业务编码]\n    B --> B3[SSObj_Name<br/>对象名称]\n    B --> B4[SSObj_Byname<br/>对象别名]\n    B --> B5[SSObj_LayerName<br/>图层归属]\n    B --> B6[SSObj_GroupID<br/>分组标识]\n    \n    C --> C1[坐标点<br/>X, Y, Z, PointName, PointType]\n    C --> C2[几何尺寸<br/>Area, Length, 3DLength]\n    C --> C3[边界框<br/>minX, minY, maxX, maxY]\n    C --> C4[变换参数<br/>Angle, ScaleX, ScaleY]\n    \n    D --> D1[颜色属性<br/>Color, HatchStyle]\n    D --> D2[线条属性<br/>LineType, LineWidth]\n    D --> D3[状态属性<br/>Status, DataMark]\n    \n    E --> E1[CreateTime<br/>创建时间戳]\n    E --> E2[ModifyTime<br/>修改时间戳]\n    \n    F --> F1[字体属性<br/>FontName, FontWidth, FontHeight]\n    F --> F2[内容属性<br/>FontString, FontStringCount]\n    F --> F3[样式属性<br/>FontAlignment, FontDirection, FontWeight]\n```\n\n这个属性体系通过 `ObjBaseAttr` 类进行统一管理。该类在初始化时会注册所有预定义的属性名称，并分配唯一的索引值，用于高效的属性访问和查找。属性索引化的设计使得属性访问从字符串匹配转换为整数索引查找，显著提升了性能，特别是在批量处理大量地物对象时。\n\n\n\n## 标识属性详解\n\n标识属性是地物对象的身份特征，用于唯一确定和组织地理对象。理解这些属性的含义和作用，是构建有效数据管理策略的基础。\n\n### SSObj_ID：系统唯一标识\n\n`SSObj_ID` 是系统分配的地物对象全局唯一标识符，通常为长整型数值。该属性具有以下关键特性：**不可变性**（对象创建后不会改变）、**全局唯一性**（在整个工作空间范围内唯一）、**自动分配**（由系统自动生成，无需手动指定）。该属性主要用于对象间引用关系管理、数据关联操作以及撤销操作的对象定位。\n\n在实际应用中，当对象间需要建立关联时，通过 `SSObj_ID` 进行引用是最可靠的方式。例如，对象 A 需要引用对象 B，应存储对象 B 的 `SSObj_ID` 而非 `SSObj_Code`，因为编码可能在业务流程中被修改，而 ID 保持不变。\n\n### SSObj_Code：业务编码\n\n`SSObj_Code` 是地物对象的业务分类编码，通常对应国家或行业标准中的要素代码。该属性反映了地物的**语义分类**，如 100 代表控制点、200 代表道路等。与 `SSObj_ID` 不同，`SSObj_Code` 是业务概念层面的标识，可以在一定规则下修改。\n\n在数据交换和跨系统集成场景中，`SSObj_Code` 扮演着关键角色。它使得不同系统间的数据映射成为可能，同时保证了数据语义的一致性。开发者在设计业务逻辑时，应优先基于 `SSObj_Code` 进行对象分类和功能分发，而不是硬编码具体的对象类型。\n\n### SSObj_Name 与 SSObj_Byname\n\n`SSObj_Name` 是地物对象的正式名称，通常用于地图标注、报表输出等展示场景。`SSObj_Byn"
  },
  {
    "slug": "18-kuo-zhan-shu-xing-yu-zi-ding-yi-shu-xing",
    "title": "扩展属性与自定义属性",
    "section": "选择集与查询",
    "headings": [
      "扩展属性体系架构",
      "扩展属性命名与语法规则",
      "单个属性访问",
      "多个属性访问",
      "读取扩展属性",
      "读取几何对象扩展属性",
      "读取注记对象扩展属性",
      "扩展属性读取流程",
      "设置扩展属性",
      "修改已有对象的扩展属性",
      "批量修改扩展属性",
      "设置多个扩展属性",
      "为新建对象设置扩展属性",
      "完整的新建对象流程",
      "新建对象扩展属性设置机制",
      "在选择条件中使用扩展属性",
      "基于扩展属性的选择",
      "复合选择条件",
      "支持的操作符",
      "扩展属性应用场景与最佳实践",
      "典型应用场景",
      "最佳实践",
      "常见问题与故障排除",
      "问题1：扩展属性读取返回空字符串",
      "问题2：批量设置多个属性失败",
      "问题3：基于扩展属性的选择无结果",
      "问题4：修改后的扩展属性未保存",
      "完整示例：建筑物维护管理系统",
      "示例输出",
      "下一步学习"
    ],
    "content": "本页专门讲解 SunvStation 中**扩展属性与自定义属性**的使用方法。扩展属性是存储在对象扩展属性表中的用户自定义字段，用于满足业务特定的数据管理需求。通过扩展属性，开发者可以在不修改系统架构的前提下，为地物对象添加任意的业务信息，如建筑结构、施工状态、维护记录等。\n\n## 扩展属性体系架构\n\n扩展属性与系统基本属性（SSObj_）不同，它采用灵活的键值对存储机制，允许开发者根据业务需求动态定义属性名称和值。理解这个架构有助于正确使用扩展属性功能。\n\n```mermaid\nflowchart TB\n    A[扩展属性体系] --> B[存储机制<br/>MemoData StringArray]\n    A --> C[访问语法<br/>方括号包裹]\n    A --> D[应用场景<br/>业务特定信息]\n    \n    B --> B1[Fields: 属性名数组]\n    B --> B2[Values: 属性值数组]\n    B1 --> B3[getMemoData/setMemoData]\n    B2 --> B3\n    \n    C --> C1[单个属性: #91属性名#92]\n    C --> C2[多个属性: #91属性1#92,#91属性2#92,...]\n    \n    D --> D1[建筑管理: 结构, 层数, 面积]\n    D --> D2[道路管理: 宽度, 材质, 等级]\n    D --> D3[设施管理: 状态, 维护日期, 责任人]\n```\n\n扩展属性的核心优势在于其**灵活性和可扩展性**。与固定的系统属性不同，扩展属性可以根据项目需求随时添加新的字段，无需修改数据库结构或系统代码。这种设计使得 SunvStation 能够适应各种专业领域的需求。\n\n\n\n## 扩展属性命名与语法规则\n\n扩展属性使用特定的命名约定，以区别于系统基本属性和几何特性。掌握这些规则是正确使用扩展属性的前提。\n\n| 属性类型 | 命名格式 | 示例 | 存储位置 | 适用场景 |\n|---------|---------|------|---------|---------|\n| **扩展属性** | `[属性名]` | `[建筑结构]`、`[施工状态]` | 对象扩展属性表 | 用户自定义业务字段 |\n| **基本属性** | `SSObj_属性名` | `SSObj_Code`、`SSObj_Name` | 对象内部属性 | 系统预定义固有属性 |\n| **几何特性** | `<属性名>` | `<Area>`、`<Length>` | 几何计算结果 | 拓扑和几何判断 |\n\n### 单个属性访问\n\n访问单个扩展属性时，使用方括号包裹属性名：\n\n```python\n# 获取扩展属性值\nstructure = SSProcess.getSelGeoValue(0, \"[建筑结构]\")\nprint(f\"建筑结构: {structure}\")\n\n# 设置扩展属性值\nSSProcess.setSelGeoValue(0, \"[建筑结构]\", \"钢筋混凝土\")\n```\n\n### 多个属性访问\n\n使用逗号分隔可以一次性访问或设置多个扩展属性：\n\n```python\n# 获取多个扩展属性（逗号分隔属性名）\ncombined_value = SSProcess.getSelGeoValue(0, \"[建筑结构],[层数],[建成年份]\")\n# 返回格式: \"钢筋混凝土,18,2020\"\nprint(combined_value)\n\n# 设置多个扩展属性（逗号分隔属性名和值）\nSSProcess.setSelGeoValue(0, \"[建筑结构],[层数],[建成年份]\", \"钢结构,25,2015\")\n```\n\n**注意**：设置多个属性时，属性名和值的数量必须一一对应，否则操作不会执行。\n\n\n\n## 读取扩展属性\n\n读取扩展属性主要通过 `getSelGeoValue()` 和 `getSelNoteValue()` 方法实现。这两个方法会自动识别方括号语法，从对象的扩展属性表中提取对应的值。\n\n### 读取几何对象扩展属性\n\n```python\nfrom sunvpy import SSProcess\n\n# 清除并设置选择条件\nSSProcess.clearSelection()\nSSProcess.clearSelectCondition()\nSSProcess.setSelectCondition(\"SSObj_Code\", \"==\", \"100\")  # 选择建筑物\nSSProcess.selectFilter()\n\nif SSProcess.getSelGeoCount() > 0:\n "
  },
  {
    "slug": "19-chuang-jian-mo-ren-di-wu-dui-xiang",
    "title": "创建默认地物对象",
    "section": "地理对象编辑",
    "headings": [
      "地物对象类型概述",
      "createDefaultGeoBase 方法详解",
      "方法签名",
      "参数说明",
      "返回值",
      "创建地物对象的工作流程",
      "基础创建示例",
      "创建点对象",
      "创建线对象",
      "创建面对象",
      "创建注记对象",
      "完整创建流程示例",
      "创建并保存点对象",
      "创建并保存线对象",
      "错误处理与验证",
      "常见错误及处理方式",
      "错误处理示例",
      "与其他创建方法的对比",
      "使用场景对比示例",
      "属性设置与扩展",
      "基本属性设置",
      "扩展属性设置",
      "批量创建与性能优化",
      "批量创建流程",
      "性能优化建议",
      "下一步学习"
    ],
    "content": "本文档详细介绍如何在 SunvStation 系统中创建默认地物对象。地物对象是地理信息系统中的核心数据单元，包括点、线、面和注记四种基本类型。创建默认地物对象是进行地理数据编辑和管理的第一步，为后续的属性设置、坐标添加和数据持久化奠定基础。\n\n建议在学习本页面之前，先了解 [SSProcess 基础概念](4-shi-yong-ssprocess-guan-li-xuan-ze-ji) 和 [地物基本属性](17-di-wu-ji-ben-shu-xing-xiang-jie)。完成本页面学习后，可以继续学习 [通过编码创建对象](20-tong-guo-bian-ma-chuang-jian-dui-xiang) 和 [添加对象坐标点](21-tian-jia-dui-xiang-zuo-biao-dian)。\n\n\n\n## 地物对象类型概述\n\nSunvStation 系统支持四种基本的地物对象类型，每种类型对应不同的几何形态和应用场景。理解这些类型的差异是正确使用创建方法的前提。\n\n| 对象类型 | 类型标识 | 几何类 | 典型应用场景 |\n|---------|---------|--------|------------|\n| 点对象 | 0 | PointObject | 控制点、界碑、建筑物中心点 |\n| 线对象 | 1 | LineObject | 道路、管线、河流中心线 |\n| 面对象 | 2 | AreaObject | 建筑物轮廓、湖泊、行政区划 |\n| 注记对象 | 3 | MarkNote | 文字标注、地名说明 |\n\n地物对象由两个核心组件构成：`GeoObject` 容器对象和具体的几何对象（`PointObject`、`LineObject`、`AreaObject`、`MarkNote`）。`GeoObject` 负责管理对象的数据集关联和唯一标识，而几何对象负责存储具体的几何数据和图形属性。\n\n\n\n## createDefaultGeoBase 方法详解\n\n`createDefaultGeoBase` 是创建默认地物对象的核心方法，属于 `GeoEditMixin` 混入类。该方法接受对象类型和数据集两个参数，返回包含 `GeoObject` 和几何对象的元组。\n\n### 方法签名\n\n```python\ndef createDefaultGeoBase(self, obj_type: int, dataset) -> tuple:\n```\n\n### 参数说明\n\n| 参数名 | 类型 | 必需 | 说明 |\n|--------|------|------|------|\n| obj_type | int | 是 | 地物对象类型（0-点，1-线，2-面，3-注记） |\n| dataset | Dataset | 是 | 目标数据集实例，用于存储对象 |\n\n### 返回值\n\n返回一个包含两个元素的元组：\n- 第一个元素：`GeoObject` 实例，作为地物对象的容器\n- 第二个元素：具体的几何对象实例（`PointObject`/`LineObject`/`AreaObject`/`MarkNote`）\n\n\n\n## 创建地物对象的工作流程\n\n创建默认地物对象涉及多个步骤，从获取数据集到最终保存到数据库。理解完整的流程有助于正确地组织代码和处理异常情况。\n\n```mermaid\nflowchart TD\n    A[开始] --> B[获取当前数据源EPS]\n    B --> C{EPS是否有效?}\n    C -->|否| D[记录错误并返回]\n    C -->|是| E[获取目标数据集]\n    E --> F{数据集是否有效?}\n    F -->|否| G[记录错误并返回]\n    F -->|是| H[调用createDefaultGeoBase]\n    H --> I[创建GeoObject容器]\n    I --> J{对象类型?}\n    J -->|0| K[创建PointObject]\n    J -->|1| L[创建LineObject]\n    J -->|2| M[创建AreaObject]\n    J -->|3| N[创建MarkNote]\n    K --> O[设置几何对象]\n    L --> O\n    M --> O\n    N --> O\n    O --> P[返回对象元组]\n    P --> Q[设置对象属性]\n    Q --> R[添加坐标点]\n    R --> S[添加到保存列表]\n    S --> T[保存到数据库]\n    T --> U[结束]\n```\n\n\n\n## 基础创建示例\n\n以下示例展示了如何使用 `createDef"
  },
  {
    "slug": "20-tong-guo-bian-ma-chuang-jian-dui-xiang",
    "title": "通过编码创建对象",
    "section": "地理对象编辑",
    "headings": [
      "地物编码体系概念",
      "createNewObjByCode 方法详解",
      "方法签名",
      "参数说明",
      "返回值",
      "对象创建工作流程",
      "Feature 编码解析机制",
      "对比：编码创建 vs 默认创建",
      "基础创建示例",
      "创建点对象",
      "创建线对象",
      "创建面对象",
      "属性设置与自定义",
      "属性设置示例",
      "批量对象创建",
      "注记对象创建",
      "错误处理与调试",
      "常见错误类型",
      "完整错误处理示例",
      "完整应用示例：创建标准地图要素",
      "对象选择集集成",
      "性能优化建议",
      "批量创建优化策略",
      "性能对比",
      "学习路径建议"
    ],
    "content": "本页面详细介绍如何使用地物编码（Feature Code）在 SunvStation 系统中创建地理对象。通过编码创建对象是一种快速、标准化的对象创建方式，系统会根据预定义的地物编码自动应用对应的符号样式、图层属性和几何类型，确保创建的对象符合制图规范和数据标准。\n\n建议在学习本页面之前，先了解[创建默认地物对象](19-chuang-jian-mo-ren-di-wu-dui-xiang)和[地物基本属性详解](17-di-wu-ji-ben-shu-xing-xiang-jie)。完成本页面学习后，可以继续学习[添加对象坐标点](21-tian-jia-dui-xiang-zuo-biao-dian)和[对象缓存机制](23-dui-xiang-huan-cun-ji-zhi)。\n\n\n\n## 地物编码体系概念\n\n地物编码（Feature Code）是 SunvStation 系统中用于标识和管理不同类型地理对象的数字标识系统。每个地物编码对应一组预定义的属性配置，包括对象类型、颜色、线型、线宽等显示属性，以及所属的数据集（图层）。通过编码创建对象时，系统会自动从编码定义中读取这些属性并应用到新创建的对象上，确保对象符合制图规范。\n\n**地物编码的核心优势**在于将对象的几何定义与符号化表达分离。开发者只需指定编码值，系统即可自动处理所有的符号化细节，这大大简化了对象的创建流程，并保证了数据的一致性。编码体系通常遵循行业标准或企业内部规范，例如控制点可能使用编码 100，道路可能使用编码 200，建筑物可能使用编码 300 等。\n\n\n\n## createNewObjByCode 方法详解\n\n`createNewObjByCode` 是通过编码创建地理对象的核心方法，该方法封装了从编码查询、对象创建到属性设置的完整流程。与 `createDefaultGeoBase` 不同，该方法不需要开发者手动指定对象类型和数据集，这些信息会根据编码自动推断和获取。\n\n### 方法签名\n\n```python\ndef createNewObjByCode(self, code: int) -> tuple:\n```\n\n### 参数说明\n\n| 参数名 | 类型 | 必需 | 说明 |\n|--------|------|------|------|\n| code | int | 是 | 地物编码值，用于标识要创建的对象类型 |\n\n### 返回值\n\n返回一个包含两个元素的元组：\n- 第一个元素：`GeoObject` 实例，作为地物对象的容器\n- 第二个元素：具体的几何对象实例（`PointObject`/`LineObject`/`AreaObject`）\n\n如果创建失败，返回 `(None, None)`。\n\n\n\n## 对象创建工作流程\n\n通过编码创建对象是一个多步骤的自动化流程，系统会执行从编码解析到对象初始化的一系列操作。理解这个流程有助于开发者在出现问题时快速定位原因，并在需要时进行扩展或自定义。\n\n```mermaid\nflowchart TD\n    A[调用 createNewObjByCode] --> B[重置当前新建对象]\n    B --> C[获取当前数据源EPS]\n    C --> D{数据源EPS有效?}\n    D -->|否| E[记录错误并返回 None,None]\n    D -->|是| F[根据编码查询Feature定义]\n    F --> G{Feature存在?}\n    G -->|否| H[使用默认编码0的Feature]\n    G -->|是| I[获取Feature对象]\n    H --> I\n    I --> J[从Feature获取数据集]\n    J --> K{数据集有效?}\n    K -->|否| L[记录错误并返回 None,None]\n    K -->|是| M[读取对象类型]\n    M --> N[调用createDefaultGeoBase创建对象]\n    N --> O[应用Feature样式属性]\n    O --> P[设置编码值]\n    P --> Q[设置颜色]\n    Q --> R[设置填充颜色]\n    R --> S[设置线宽]\n    S --> T[设置线型]\n    T --> U[保存到curNewObj]\n    U --> V[返回对象元组]\n```\n\n\n\n## Feature 编码解析机制\n\nFeature 编码解析是创建过程的核心环节。系统首先通过 `getCurrentDataSourceEPS()` 获取当前地图的数据源 EPS（Extended Parameter System）对象，该对象维护了所有预定义的 Feat"
  },
  {
    "slug": "21-tian-jia-dui-xiang-zuo-biao-dian",
    "title": "添加对象坐标点",
    "section": "地理对象编辑",
    "headings": [
      "方法概述",
      "工作流程",
      "使用场景",
      "代码示例",
      "示例 1: 创建点对象并添加坐标",
      "示例 2: 创建线对象并添加多个坐标点",
      "示例 3: 创建面对象并形成闭合多边形",
      "点类型枚举",
      "注意事项",
      "前置条件检查",
      "坐标系统",
      "对象类型适配",
      "保存机制",
      "错误处理",
      "相关功能",
      "最佳实践"
    ],
    "content": "本文档详细说明如何为新建的地理对象添加坐标点，这是地理对象编辑流程中的核心步骤。通过坐标点的添加，可以构建点、线、面等不同类型的几何对象，为后续的保存和数据库存储奠定基础。\n\n## 方法概述\n\n`addNewObjPoint` 方法用于向当前新建的地理对象添加一个空间坐标点。该方法属于 `GeoEditMixin` 混合类，通过 `SSProcessManager` 实例调用。它支持三维坐标输入，并可设置点的类型和名称属性。\n\n**方法签名**:\n```python\naddNewObjPoint(x: float, y: float, z: float, type: int, name: str) -> bool\n```\n\n**参数说明**:\n\n| 参数名 | 类型 | 说明 |\n|--------|------|------|\n| x | float | 点的 X 坐标值 |\n| y | float | 点的 Y 坐标值 |\n| z | float | 点的 Z 坐标值（高程） |\n| type | int | 点的类型，使用 PointInfoEnum 点信息枚举的二进制位存储 |\n| name | str | 点的名称标识 |\n\n**返回值**:\n- `True`: 添加成功\n- `False`: 添加失败（通常是因为当前没有新建对象）\n\n\n\n## 工作流程\n\n添加坐标点的操作必须建立在已创建地理对象的基础上。完整的工作流程包括对象创建、坐标点添加、对象保存等步骤。\n\n```mermaid\nflowchart TD\n    A[开始] --> B[创建地理对象<br/>createNewObjByCode]\n    B --> C[是否创建成功?]\n    C -->|否| D[返回错误]\n    C -->|是| E[添加第一个坐标点<br/>addNewObjPoint]\n    E --> F[需要添加更多点?]\n    F -->|是| G[添加后续坐标点<br/>addNewObjPoint]\n    G --> F\n    F -->|否| H[添加到选择集<br/>addNewObjToSelObjList]\n    H --> I[添加到保存列表<br/>addNewObjToSaveObjList]\n    I --> J[保存到数据库<br/>saveBufferObjToDatabase]\n    J --> K[结束]\n```\n\n\n\n## 使用场景\n\n根据几何对象类型的不同，添加坐标点的行为有所差异：\n\n| 对象类型 | 所需点数 | 点的顺序要求 | 典型应用 |\n|----------|---------|-------------|---------|\n| 点对象 | 1个 | 无 | 地标点、测量控制点 |\n| 线对象 | ≥2个 | 需按路径顺序 | 道路中心线、管线 |\n| 面对象 | ≥3个 | 按顺时针或逆时针闭合 | 建筑物轮廓、地块边界 |\n| 注记对象 | 1个（定位点） | 无 | 文字标注位置 |\n\n\n\n## 代码示例\n\n### 示例 1: 创建点对象并添加坐标\n\n```python\n# 创建点对象（代码 1001 表示某种特定类型的点）\nobj, geo = SSProcess.createNewObjByCode(1001)\nif obj and geo:\n    # 添加唯一坐标点\n    success = SSProcess.addNewObjPoint(\n        x=123456.789,\n        y=3456789.012,\n        z=45.5,\n        type=ATTR_NORMAL_POINT,\n        name=\"控制点P1\"\n    )\n    if success:\n        # 添加到选择集和保存列表\n        SSProcess.addNewObjToSelObjList()\n        SSProcess.addNewObjToSaveObjList()\n        SSProcess.saveBufferObjToDatabase()\n```\n\n\n\n### 示例 2: 创建线对象并添加多个坐标点\n\n```python\n# 创建线对象（代码 2001 表示道路中心线）\nobj, geo = SSProcess.createNewObjByCode(2001)\nif obj and geo:\n    # 添加路径上的坐标点\n    points = [\n        (123456.789, 3456789.012, 45.5, \"起点\"),\n        (123460.78"
  },
  {
    "slug": "22-shan-chu-dui-xiang-cao-zuo",
    "title": "删除对象操作",
    "section": "地理对象编辑",
    "headings": [
      "删除操作概述",
      "deleteNewObj 方法详解",
      "方法签名",
      "功能说明",
      "特点",
      "删除新建对象的工作流程",
      "使用场景与示例",
      "场景 1: 取消创建过程中的对象",
      "场景 2: 条件判断后删除",
      "场景 3: 异常处理中的清理",
      "批量删除机制",
      "批量删除的工作原理",
      "批量删除的实现",
      "批量删除示例",
      "示例 1: 基于选择集的批量删除",
      "示例 2: 删除指定图层中的所有对象",
      "示例 3: 基于属性条件的批量删除",
      "删除操作与选择集的结合",
      "操作流程",
      "综合示例：条件判断后批量删除",
      "方法对比",
      "注意事项",
      "前置条件检查",
      "对象生命周期",
      "批量删除的保存要求",
      "数据完整性",
      "性能考虑",
      "并发与锁定",
      "错误处理与调试",
      "常见问题",
      "调试技巧"
    ],
    "content": "本文档详细说明如何在 SunvStation 系统中删除地理对象。删除操作是地理数据维护的重要环节，包括删除当前新建对象、批量删除多个对象以及与选择集结合的删除场景。掌握删除操作的机制和使用方法，能够帮助开发者有效管理地图数据，确保数据的准确性和一致性。\n\n建议在学习本页面之前，先了解 [创建默认地物对象](19-chuang-jian-mo-ren-di-wu-dui-xiang) 和 [添加对象坐标点](21-tian-jia-dui-xiang-zuo-biao-dian)。完成本页面学习后，可以继续学习 [对象缓存机制](23-dui-xiang-huan-cun-ji-zhi) 和 [批量保存到数据库](24-pi-liang-bao-cun-dao-shu-ju-ku)。\n\n\n\n## 删除操作概述\n\nSunvStation 提供了两种主要的删除方式：单对象删除和批量删除。单对象删除主要用于删除当前正在创建的对象，而批量删除则适用于处理多个已存在的地理对象。\n\n| 删除方式 | 方法名称 | 适用场景 | 操作时机 |\n|---------|---------|---------|---------|\n| 单对象删除 | `deleteNewObj` | 删除当前新建对象 | 对象创建后、保存前 |\n| 批量删除 | `delBufferGeoList` + `saveBufferObjToDatabase` | 删除多个对象 | 对象已添加到删除缓冲区后 |\n\n删除操作的核心机制基于 `delBufferGeoList` 缓冲区，该缓冲区存储待删除的地理对象。当调用 `saveBufferObjToDatabase()` 方法时，系统会自动处理这些删除操作。\n\n\n\n## deleteNewObj 方法详解\n\n`deleteNewObj` 方法用于删除当前新建的地理对象。这是一个即时的删除操作，不需要保存到数据库即可生效。\n\n### 方法签名\n\n```python\ndef deleteNewObj(self):\n```\n\n### 功能说明\n\n该方法执行以下操作：\n1. 检查当前是否有新建对象（`self.curNewObj` 不为空）\n2. 如果存在新建对象，调用地图的 `delGeoObject` 方法删除该对象\n3. 将 `self.curNewObj` 重置为 `(None, None)`，表示当前没有新建对象\n\n### 特点\n\n- **无需参数**：该方法不接受任何参数\n- **无返回值**：不返回任何结果，仅执行删除操作\n- **即时生效**：删除操作立即执行，无需等待数据库保存\n- **仅限新建对象**：只能删除通过创建方法生成的当前对象\n\n\n\n## 删除新建对象的工作流程\n\n删除当前新建对象是一个简单直接的操作，但需要了解其在整个对象生命周期中的位置。\n\n```mermaid\nflowchart TD\n    A[开始] --> B[创建新对象<br/>createNewObjByCode]\n    B --> C{是否需要保留?}\n    C -->|是| D[添加坐标点<br/>addNewObjPoint]\n    D --> E[添加到保存列表<br/>addNewObjToSaveObjList]\n    E --> F[保存到数据库<br/>saveBufferObjToDatabase]\n    F --> G[对象持久化成功]\n    C -->|否| H[删除对象<br/>deleteNewObj]\n    H --> I[curNewObj 重置为 None]\n    I --> J[对象从内存中移除]\n    J --> K[结束]\n    G --> K\n```\n\n\n\n## 使用场景与示例\n\n### 场景 1: 取消创建过程中的对象\n\n在创建对象的过程中，如果发现对象不符合要求或需要中止创建，可以使用 `deleteNewObj` 方法取消。\n\n```python\n# 尝试创建一个线对象\nobj, geo = SSProcess.createNewObjByCode(2001)\nif obj and geo:\n    # 添加第一个坐标点\n    SSProcess.addNewObjPoint(100.0, 200.0, 0.0, 0, \"起点\")\n    \n    # 发现该线对象不符合要求，决定删除\n    SSProcess.deleteNewObj()\n    print(\"新创建的线对象已被删除\")\n    \n    # 重新创建符合要求的对象\n    obj, geo = SSProcess.createNewObjByCode(2002)\n    if obj a"
  },
  {
    "slug": "23-dui-xiang-huan-cun-ji-zhi",
    "title": "对象缓存机制",
    "section": "地理对象编辑",
    "headings": [
      "缓存架构概述",
      "缓存类型与分类",
      "按操作状态分类",
      "按对象类型分类",
      "缓存生命周期管理",
      "核心API详解",
      "对象创建API",
      "属性设置API",
      "批量持久化API",
      "备忘数据转换API",
      "缓存与选择集的关系",
      "最佳实践与注意事项",
      "批量操作的性能优化",
      "内存管理注意事项",
      "并发安全注意事项",
      "与撤销系统的集成",
      "相关主题"
    ],
    "content": "对象缓存机制是SunvStation地理编辑系统的核心组件，用于在批量创建和修改地理对象时提供高效的内存管理。该机制通过在内存中暂存对象，避免频繁的数据库I/O操作，显著提升大批量数据处理的性能。缓存机制区分了新建对象和修改对象两种场景，分别采用不同的缓存策略，并通过统一的事务性接口完成数据库持久化。\n\n\n\n## 缓存架构概述\n\n对象缓存机制采用多层次的缓存架构，通过SSProcessManager类的成员变量管理不同类型的缓存。缓存系统分为三大类别：新建对象缓存、修改对象缓存和删除对象缓存，每种类别又进一步区分为地物对象和注记对象。\n\n```mermaid\nclassDiagram\n    class SSProcessManager {\n        +GeoBaseList bufferObjList\n        +GeoBaseList bufferNoteList\n        +list newBufferObjList\n        +list newBufferNoteList\n        +tuple curNewObj\n        +GeoBaseList delBufferGeoList\n        +createNewObjByCode(code)\n        +setNewObjValue(field, value)\n        +addNewObjPoint(x, y, z, type, name)\n        +addNewObjToSaveObjList()\n        +saveBufferObjToDatabase()\n    }\n    \n    class GeoEditMixin {\n        <<Mixin>>\n        +transMemoDataToExtendAttr(geoList)\n        +persistTempGeoList(geoVec)\n        +persistTempNoteList(noteVec)\n    }\n    \n    class GeoBaseList {\n        +append(geo)\n        +empty()\n        +clear()\n    }\n    \n    class GeoBase {\n        +getObjectType()\n        +getCode()\n        +setMemoData(fields, values)\n        +getDatasetName()\n    }\n    \n    SSProcessManager *-- GeoBaseList : 管理缓存列表\n    SSProcessManager *-- GeoBase : 封装几何对象\n    SSProcessManager --> GeoEditMixin : 继承缓存操作\n    GeoBaseList o-- GeoBase : 包含对象\n```\n\n该架构体现了**关注点分离**的设计原则：SSProcessManager负责缓存容器管理，GeoEditMixin提供缓存操作的具体实现，GeoBase和GeoBaseList作为数据载体。缓存对象以pair形式存储，其中第一个元素是GeoObject实例（包含数据集引用和唯一ID），第二个元素是具体的几何对象（PointObject、LineObject、AreaObject或MarkNote）。\n\n\n\n## 缓存类型与分类\n\n缓存机制根据对象状态和类型进行明确分类，这种设计使得系统能够对不同场景采用优化的处理策略。\n\n### 按操作状态分类\n\n| 缓存类型 | 存储容器 | 对象来源 | 持久化方式 | 典型应用场景 |\n|---------|---------|---------|-----------|------------|\n| 新建对象缓存 | `newBufferObjList` / `newBufferNoteList` | 脚本创建的新对象 | `addGeoObject()` 添加到地图 | 批量导入数据、程序化生成地物 |\n| 修改对象缓存 | `bufferObjList` / `bufferNoteList` | 从地图加载并修改的对象 | `saveDatabase()` 更新数据库 | 属性批量更新、几何形状编辑 |\n| 删除对象缓存 | `delBufferGeoList` | 标记为删除的对象 | `delGeoBaseComponent()` 执行删除 | 清理过期数据、对象合并操作 |\n| 当前新建对象 | `curNewObj` | 正在创建过程"
  },
  {
    "slug": "24-pi-liang-bao-cun-dao-shu-ju-ku",
    "title": "批量保存到数据库",
    "section": "地理对象编辑",
    "headings": [
      "批量保存架构设计",
      "核心方法详解",
      "saveBufferObjToDatabase()",
      "transMemoDataToExtendAttr()",
      "操作类型与处理流程",
      "新建对象的保存流程",
      "修改对象的保存流程",
      "删除对象的保存流程",
      "使用场景与最佳实践",
      "场景一：批量新建地物对象",
      "场景二：批量更新对象属性",
      "场景三：对象替换（删除旧对象，创建新对象）",
      "性能优化建议",
      "数据集分组优化",
      "事务边界管理",
      "缓存容量控制",
      "错误处理与异常管理",
      "与其他功能的关联",
      "与对象缓存机制的关系",
      "与撤销标记管理的关系",
      "与地图视图更新的关系"
    ],
    "content": "批量保存到数据库是SunvStation地理编辑系统中实现高效数据持久化的核心机制。该功能通过统一的事务接口，将缓存中新建、修改和删除的地理对象批量提交到数据库，避免了逐个对象保存带来的性能开销和事务一致性问题。批量保存机制与[对象缓存机制](23-dui-xiang-huan-cun-ji-zhi)紧密配合，构成了完整的对象生命周期管理体系。\n\n\n\n## 批量保存架构设计\n\n批量保存采用三段式处理架构，针对不同状态的对象采用差异化的持久化策略。新建对象通过`addGeoObject()`添加到地图并自动保存，修改对象通过`saveDatabase()`更新数据库，删除对象通过`delGeoBaseComponent()`从数据库中移除。这种设计遵循了**单一职责原则**，使每种操作类型都有专门的处理路径。\n\n```mermaid\nflowchart TB\n    Start[saveBufferObjToDatabase] --> NewObj{新建对象?}\n    Start --> ModObj{修改对象?}\n    Start --> DelObj{删除对象?}\n    \n    NewObj -->|是| GroupByDataset[按数据集分组]\n    GroupByDataset --> AddGeo[map.addGeoObject]\n    AddGeo --> TransAttr1[transMemoDataToExtendAttr]\n    TransAttr1 --> ClearNew[清空newBuffer列表]\n    \n    ModObj -->|是| CheckBuffer1[bufferObjList非空?]\n    CheckBuffer1 -->|是| TransAttr2[transMemoDataToExtendAttr]\n    TransAttr2 --> SaveDB1[map.saveDatabase]\n    SaveDB1 --> ClearBuffer1[清空bufferObjList]\n    \n    CheckBuffer1 -->|否| CheckNote1[bufferNoteList非空?]\n    CheckNote1 -->|是| TransAttr3[transMemoDataToExtendAttr]\n    TransAttr3 --> SaveDB2[map.saveDatabase]\n    SaveDB2 --> ClearBuffer2[清空bufferNoteList]\n    \n    DelObj -->|是| CheckDel[delBufferGeoList非空?]\n    CheckDel -->|是| DeleteGeo[map.delGeoBaseComponent]\n    DeleteGeo --> ClearDel[清空delBufferGeoList]\n    \n    ClearNew --> End[完成]\n    ClearBuffer1 --> End\n    ClearBuffer2 --> End\n    ClearDel --> End\n    \n    style Start fill:#e1f5ff\n    style End fill:#e1f5ff\n    style AddGeo fill:#fff4e1\n    style SaveDB1 fill:#fff4e1\n    style SaveDB2 fill:#fff4e1\n    style DeleteGeo fill:#ffe1e1\n```\n\n该架构体现了**分离关注点**的设计理念：新建对象的添加操作由地图对象负责，修改对象的更新操作由数据库事务处理，删除操作通过地理组件接口执行。这种分工使得系统能够针对不同场景进行性能优化，例如对新对象按数据集分组处理以减少数据库锁的粒度。\n\n\n\n## 核心方法详解\n\n### saveBufferObjToDatabase()\n\n`saveBufferObjToDatabase()` 方法是批量保存的统一入口，负责处理所有缓存对象的事务性持久化。该方法无参数且无返回值，其执行结果通过内部日志记录。\n\n**方法签名：**\n```python\ndef saveBufferObjToDatabase(self) -> None:\n```\n\n**执行步骤：**\n\n1. **处理新建对象**：合并`newBufferObjList`和`newBufferNoteList`，按数据集名称分组，对每个数据集调用`map.addGeoObject(geoList)`批量添加，然后调用`transMemoDat"
  },
  {
    "slug": "25-che-xiao-biao-ji-guan-li",
    "title": "撤销标记管理",
    "section": "地理对象编辑",
    "headings": [
      "撤销标记系统架构",
      "核心 API 方法",
      "创建撤销标记",
      "执行撤销操作",
      "执行重做操作",
      "栈状态查询与控制",
      "手动压栈操作",
      "操作流程规范",
      "标准编辑流程",
      "标记创建时机",
      "典型应用场景",
      "批量属性修改",
      "对象创建与删除",
      "几何变换操作",
      "最佳实践建议",
      "标记命名规范",
      "性能优化建议",
      "错误处理机制",
      "与其他模块的集成"
    ],
    "content": "撤销标记管理是 SunvStation 地理编辑系统中的一项核心功能，它通过在执行可撤销操作前创建标记，支持用户对编辑操作进行撤销和重做。该机制基于命令模式，将每次可撤销操作封装为独立的命令单元，存储在 Undo/Redo 栈中，确保数据编辑的安全性和可追溯性。\n\n撤销标记管理在批量地理对象编辑、属性修改和几何变换等场景中尤为重要，能够有效防止误操作导致的数据丢失，提升编辑流程的容错能力和用户体验。\n\n## 撤销标记系统架构\n\n撤销标记系统采用双层架构设计：上层通过 `SSProcessManager` 提供统一的 Python 接口，下层由 `ScaleMap` 的 C++ 核心实现命令存储和状态管理。系统维护两个命令栈：Undo 栈存储已执行的操作历史，Redo 栈存储被撤销的操作，两者协同工作实现操作的双向回溯。\n\n```mermaid\nflowchart TD\n    A[用户操作] --> B[SSProcessManager<br/>pushUndoMark]\n    B --> C[ScaleMap<br/>pushUndoMark]\n    C --> D{创建命令标记}\n    D --> E[命令序列化]\n    E --> F[Undo栈<br/>LIFO结构]\n    F --> G[操作执行]\n    G --> H{用户触发撤销?}\n    H -->|是| I[undo方法]\n    H -->|否| J{用户触发重做?}\n    I --> K[弹出Undo栈顶命令]\n    K --> L[执行逆向操作]\n    L --> M[压入Redo栈]\n    J -->|是| N[redo方法]\n    N --> O[弹出Redo栈顶命令]\n    O --> P[执行正向操作]\n    P --> Q[压入Undo栈]\n```\n\n## 核心 API 方法\n\n### 创建撤销标记\n\n`pushUndoMark()` 方法是撤销标记管理的入口，在执行任何可撤销操作前调用，为后续操作建立撤销点。该方法接受可选的操作描述参数，用于标识命令组的用途。\n\n| 方法 | 参数 | 返回值 | 说明 |\n|------|------|--------|------|\n| `pushUndoMark(action=\"CommandGroup\")` | `action`: 命令组名称（可选） | void | 在 Undo 栈中创建新的标记位置 |\n\n**使用示例**：\n\n```python\n# 批量修改前创建撤销标记\nSSProcess.pushUndoMark(\"批量修改管线属性\")\n\nfor i in range(SSProcess.getSelGeoCount()):\n    SSProcess.setSelGeoValue(i, \"SSObj_Color\", \"16777215\")\n    SSProcess.setSelGeoValue(i, \"SSObj_LineWidth\", \"2\")\n\n# 修改完成后，用户可通过 Ctrl+Z 或调用 undo() 方法撤销\n```\n\n\n\n### 执行撤销操作\n\n`undo()` 方法从 Undo 栈中弹出最近执行的命令并执行逆向操作，恢复数据到操作前的状态。支持指定步数或使用标记进行批量撤销。\n\n| 方法 | 参数 | 返回值 | 说明 |\n|------|------|--------|------|\n| `undo(step=1)` | `step`: 执行步数，-1 时使用 undo 标签 | void | 撤销指定步数的操作 |\n\n**使用示例**：\n\n```python\n# 撤销最近一次操作\nSSProcess.undo()\n\n# 撤销最近 5 次操作\nSSProcess.undo(5)\n\n# 撤销到上一个标记位置\nSSProcess.undo(-1)\n```\n\n\n\n### 执行重做操作\n\n`redo()` 方法从 Redo 栈中弹出被撤销的命令并重新执行，恢复之前撤销的操作。与 `undo()` 方法形成对称操作。\n\n| 方法 | 参数 | 返回值 | 说明 |\n|------|------|--------|------|\n| `redo(step=1)` | `step`: 执行步数，-1 时使用 undo 标签 | void | 重做指定步数的操作 |\n\n**使用示例**：\n\n```python\n# 重做最近一次撤销的操作\nSSProcess.redo()\n\n# 重做最近 3 次撤销的操作\nSSProcess.redo(3)\n```\n\n\n\n### 栈状态查询与控制\n\n系统提供多个方法用于查询 Undo/Redo 栈的状态，以及重置栈内容，便于"
  },
  {
    "slug": "26-shu-ju-jiao-huan-can-shu-pei-zhi",
    "title": "数据交换参数配置",
    "section": "数据交换与导入导出",
    "headings": [
      "核心概念与架构",
      "参数管理核心方法",
      "设置数据交换参数",
      "读取数据交换参数",
      "清除数据交换参数",
      "数据交换工作流程",
      "数据导入流程",
      "数据导出流程",
      "常见参数类型参考",
      "文件路径相关参数",
      "格式和编码相关参数",
      "坐标系统和投影参数",
      "数据处理相关参数",
      "完整实践示例",
      "最佳实践与注意事项",
      "参数配置建议",
      "常见问题排查",
      "性能优化建议",
      "学习路径建议"
    ],
    "content": "本页面介绍数据交换的参数配置机制，这是进行数据导入导出操作前的关键步骤。通过正确配置数据交换参数，您可以精确控制数据转换的行为，包括格式映射、编码规则、坐标系统等关键属性。掌握参数配置是构建可靠数据交换流程的基础。\n\n\n\n## 核心概念与架构\n\n数据交换参数配置基于 **DataXScript** 类实现，该类采用经典的 **参数-执行模式** 设计。用户首先通过一系列参数设置方法配置数据转换的各项属性，然后调用执行方法触发实际的导入或导出操作。这种设计将配置逻辑与执行逻辑分离，提高了代码的可读性和可维护性。\n\n```mermaid\ngraph LR\n    A[创建 DataXScript 实例] --> B[配置交换参数<br/>setDataXParameter]\n    B --> C[可选：读取参数<br/>getDataXParameter]\n    C --> D{参数配置完成?}\n    D -->|否| B\n    D -->|是| E[选择操作类型]\n    E -->|导入| F[调用 importData]\n    E -->|导出| G[调用 exportData]\n    F --> H[数据交换完成]\n    G --> H\n    H --> I[可选：清理参数<br/>clearDataXParameter]\n```\n\nDataXScript 类的实例不作为 sunvpy 的全局单例对象暴露，因此每次需要进行数据交换时都需要创建新的实例。这种设计确保了不同数据交换任务的参数不会相互干扰，提高了脚本的隔离性和安全性。\n\n\n\n## 参数管理核心方法\n\nDataXScript 类提供了三个核心方法用于参数的配置、读取和清理操作。这些方法是所有数据交换操作的基础，理解它们的用法是掌握数据交换功能的第一步。\n\n| 方法名称 | 方法签名 | 功能描述 | 返回值 |\n|---------|---------|---------|--------|\n| `setDataXParameter` | `setDataXParameter(name, value)` | 设置单个数据转换参数 | 无 |\n| `getDataXParameter` | `getDataXParameter(name)` | 获取指定参数的当前值 | 字符串形式的参数值 |\n| `clearDataXParameter` | `clearDataXParameter()` | 清除所有已配置的参数 | 无 |\n\n这些方法的设计遵循简单直观的原则，所有参数都以字符串形式传入和传出，底层会根据参数名称自动进行类型转换和验证。\n\n\n\n### 设置数据交换参数\n\n`setDataXParameter()` 方法是配置数据交换的主要方法，它接受两个参数：参数名称和参数值。参数名称是系统预定义的键，用于标识特定的配置项；参数值则是用户希望设置的值，可以是字符串、数字等各种类型，但都会以字符串形式传递。\n\n```python\nfrom sunvpy.PySSDataX import DataXScript\n\n# 创建数据交换脚本实例\ndatax = DataXScript()\n\n# 设置文件路径参数\ndatax.setDataXParameter(\"ImportPath\", \"D:\\\\data\\\\import\\\\roads.shp\")\ndatax.setDataXParameter(\"ExportPath\", \"D:\\\\data\\\\export\\\\output.mdb\")\n\n# 设置编码参数\ndatax.setDataXParameter(\"SourceEncoding\", \"GBK\")\ndatax.setDataXParameter(\"TargetEncoding\", \"UTF-8\")\n\n# 设置坐标系统参数\ndatax.setDataXParameter(\"CoordSystem\", \"EPSG:4326\")\n```\n\n参数名称通常采用大驼峰命名法，如 `ImportPath`、`CoordSystem` 等。在实际使用中，应根据具体的导入导出格式选择合适的参数名称。错误的参数名称可能会被忽略或导致后续执行失败。\n\n\n\n### 读取数据交换参数\n\n`getDataXParameter()` 方法允许您获取当前已设置的参数值，这对于参数验证和调试非常有用。该方法接受一个参数名称，返回该参数的当前值。如果参数未被设置，可能返回空字符串或默认值。\n\n```python\n# 读取之前设置的参数\nimport_path = datax.getDataXParameter(\"ImportPath\")\nprint(f\"导入路径: {import_path"
  },
  {
    "slug": "27-dao-ru-wai-bu-shu-ju",
    "title": "导入外部数据",
    "section": "数据交换与导入导出",
    "headings": [
      "数据导入架构概览",
      "支持的数据源类型",
      "标准矢量数据格式",
      "CAD 和工程数据格式",
      "栅格和影像数据格式",
      "三维和点云数据格式",
      "数据导入核心方法",
      "执行数据导入",
      "获取导入文件名",
      "数据导入流程详解",
      "第一步：准备和验证源文件",
      "第二步：配置导入参数",
      "第三步：执行数据导入",
      "第四步：验证导入结果",
      "完整导入示例",
      "批量导入数据",
      "常见导入场景与参数配置",
      "场景一：导入带中文字段的 Shapefile",
      "场景二：导入不同坐标系统的数据",
      "场景三：导入 CAD 数据（DXF/DWG）",
      "场景四：增量导入数据",
      "错误排查与问题解决",
      "常见错误与解决方案",
      "调试技巧",
      "性能优化建议",
      "优化参数配置",
      "分批导入策略",
      "学习路径建议"
    ],
    "content": "本页面详细介绍如何将各种格式的外部数据导入到 SunvStation 工作空间中。数据导入是地理信息系统中最常用的功能之一，通过合理配置导入参数，您可以精确控制数据转换行为，包括坐标系统、编码方式、图层映射等关键属性。掌握数据导入功能是构建数据处理流程的基础技能。\n\n\n\n## 数据导入架构概览\n\n数据导入功能基于 **DataXScript** 类实现，该类通过参数配置与执行分离的设计模式，提供了灵活且可扩展的数据交换框架。导入过程涉及数据源类型识别、参数配置、坐标转换和数据验证等多个环节，确保导入的数据能够正确集成到 SunvStation 工作空间中。\n\n```mermaid\ngraph TB\n    A[开始数据导入] --> B[准备导入参数]\n    B --> C{识别数据源类型}\n    C -->|Shapefile| D[SHP 格式处理]\n    C -->|MDB| E[数据库格式处理]\n    C -->|DXF| F[CAD 格式处理]\n    C -->|其他| G[GDAL 通用处理]\n    D --> H[创建 DataXScript 实例]\n    E --> H\n    F --> H\n    G --> H\n    H --> I[配置导入参数]\n    I --> J[importData 执行导入]\n    J --> K{导入成功?}\n    K -->|是| L[验证导入结果]\n    K -->|否| M[检查错误信息]\n    L --> N[更新工作空间]\n    M --> N\n```\n\n数据导入的核心是 **DataXScript** 类，该类不作为全局单例暴露，因此每次导入任务都需要创建新的实例。这种设计避免了不同导入任务之间的参数污染，提高了脚本的隔离性和安全性。\n\n\n\n## 支持的数据源类型\n\nSunvStation 支持通过 GDAL 和 OGR 库导入多种常见的数据格式。系统通过静态方法 `DataSource.getDataSourceTypeByExt()` 自动识别文件扩展名并选择合适的数据源处理器。\n\n### 标准矢量数据格式\n\n| 格式名称 | 文件扩展名 | 数据源类型 | 支持的几何类型 | 适用场景 |\n|---------|-----------|-----------|--------------|---------|\n| Shapefile | `.shp` | `e_DataSource_EPS_GDAL` | 点、线、面 | 基础矢量数据交换 |\n| Personal Geodatabase | `.mdb` | `e_DataSource_EPS_GDAL` | 点、线、面 | ArcGIS 数据格式 |\n| File Geodatabase | `.gdb` | `e_DataSource_EPS_GDAL` | 点、线、面 | 大型空间数据库 |\n| GeoPackage | `.gpkg` | `e_DataSource_EPS_GDAL` | 点、线、面 | 现代 GIS 数据格式 |\n| KML/KMZ | `.kml`, `.kmz` | `e_DataSource_EPS_GDAL` | 点、线、面 | Google Earth 数据 |\n| GeoJSON | `.geojson`, `.json` | `e_DataSource_EPS_GDAL` | 点、线、面 | Web GIS 数据 |\n| CSV | `.csv` | `e_DataSource_EPS_GDAL` | 点（含坐标） | 表格坐标数据 |\n\n### CAD 和工程数据格式\n\n| 格式名称 | 文件扩展名 | 数据源类型 | 支持的几何类型 | 适用场景 |\n|---------|-----------|-----------|--------------|---------|\n| AutoCAD DXF | `.dxf` | `e_DataSource_DWG` | 点、线、面、文字 | CAD 数据交换 |\n| AutoCAD DWG | `.dwg` | `e_DataSource_DWG` | 点、线、面、文字 | AutoCAD 原生格式 |\n\n### 栅格和影像数据格式\n\n| 格式名称 | 文件扩展名 | 数据源类型 | 支持的数据类型 | 适用场景 |\n|---------|-----------|-----------|--------------|---------|\n| GeoTIFF | `.tif`, `.tiff` | `e_DataSource_IMG` | 栅格影像 | 高精度正射影像 |\n| ECW | `.e"
  },
  {
    "slug": "28-dao-chu-shu-ju-dao-wen-jian",
    "title": "导出数据到文件",
    "section": "数据交换与导入导出",
    "headings": [
      "数据导出架构概览",
      "支持的导出格式",
      "标准矢量数据格式",
      "CAD 和工程数据格式",
      "栅格和影像数据格式",
      "数据导出核心方法",
      "执行数据导出",
      "完整导出流程",
      "导出参数配置详解",
      "基础路径和格式参数",
      "坐标系统参数",
      "字段映射和筛选参数",
      "导出场景实战",
      "场景一：导出选择集数据为 Shapefile",
      "场景二：导出为 GeoJSON 用于 Web 地图",
      "场景三：导出为 AutoCAD DXF 格式",
      "场景四：批量导出多个图层",
      "错误处理与故障排除",
      "常见导出错误及解决方案",
      "导出前参数验证清单",
      "最佳实践与性能优化",
      "性能优化建议",
      "代码组织建议",
      "进阶学习路径"
    ],
    "content": "本页面详细介绍如何将 SunvStation 工作空间中的地理数据导出为各种格式的文件。数据导出是地理信息系统数据共享和交换的重要手段，通过合理配置导出参数，您可以精确控制输出格式、编码方式、坐标系统和属性字段映射等关键属性，确保导出的数据能够满足不同应用场景的需求。\n\n\n\n## 数据导出架构概览\n\n数据导出功能基于 **DataXScript** 类实现，该类采用与数据导入相同的架构设计，通过参数配置与执行分离的模式，提供了灵活且可扩展的数据交换框架。导出过程涉及数据源识别、参数配置、坐标转换、属性映射和文件生成等多个环节，确保导出的数据能够在其他系统中正确加载和使用。\n\n```mermaid\ngraph TB\n    A[开始数据导出] --> B[准备导出数据源]\n    B --> C{识别导出格式}\n    C -->|Shapefile| D[SHP 格式处理]\n    C -->|MDB| E[数据库格式处理]\n    C -->|DXF| F[CAD 格式处理]\n    C -->|GeoJSON| G[Web 格式处理]\n    C -->|其他| H[GDAL 通用处理]\n    D --> I[创建 DataXScript 实例]\n    E --> I\n    F --> I\n    G --> I\n    H --> I\n    I --> J[配置导出参数]\n    J --> K[exportData 执行导出]\n    K --> L{导出成功?}\n    L -->|是| M[验证输出文件]\n    L -->|否| N[检查错误信息]\n    M --> O[导出完成]\n    N --> O\n```\n\nDataXScript 类作为数据导出的核心组件，提供了完整的参数管理和执行接口。与数据导入类似，导出功能也不依赖全局单例，每次导出任务都需要创建新的实例。这种设计确保了不同导出任务之间的参数隔离，提高了脚本的可靠性和可维护性。\n\n\n\n## 支持的导出格式\n\nSunvStation 支持通过 GDAL 和 OGR 库导出多种常见的数据格式，覆盖了从传统 GIS 格式到现代 Web GIS 格式的广泛范围。系统会根据指定的输出文件扩展名自动选择合适的导出驱动器，并应用相应的格式转换规则。\n\n### 标准矢量数据格式\n\n| 格式名称 | 文件扩展名 | 导出特点 | 几何类型支持 | 属性字段限制 |\n|---------|-----------|---------|------------|------------|\n| Shapefile | `.shp` | 最常用的交换格式，字段名限制 10 字符 | 点、线、面 | 单文件 2GB 限制 |\n| Personal Geodatabase | `.mdb` | Microsoft Access 数据库，支持复杂关系 | 点、线、面 | 2GB 数据库限制 |\n| File Geodatabase | `.gdb` | Esri 现代格式，支持大数据量 | 点、线、面 | 单数据集 1TB 限制 |\n| GeoPackage | `.gpkg` | OGC 标准，轻量级跨平台 | 点、线、面 | 无明确大小限制 |\n| KML/KMZ | `.kml`, `.kmz` | Google Earth 格式，支持样式和标注 | 点、线、面 | 适合可视化展示 |\n| GeoJSON | `.geojson`, `.json` | Web 标准，基于 JSON | 点、线、面 | 适合 Web 应用 |\n| CSV | `.csv` | 文本表格格式，可导出坐标信息 | 点（带坐标） | 适合表格处理 |\n\n### CAD 和工程数据格式\n\n| 格式名称 | 文件扩展名 | 导出特点 | 几何类型支持 | 样式保留 |\n|---------|-----------|---------|------------|---------|\n| AutoCAD DXF | `.dxf` | 开放的 CAD 交换格式 | 点、线、面、文字 | 部分样式保留 |\n| AutoCAD DWG | `.dwg` | AutoCAD 原生格式 | 点、线、面、文字 | 完整样式保留 |\n\n### 栅格和影像数据格式\n\n| 格式名称 | 文件扩展名 | 导出特点 | 压缩支持 | 适用场景 |\n|---------|-----------|---------|---------|---------|\n| GeoTIFF | `.tif`, `.tiff` | 地理信息标准格式 | LZW, DEFLATE, JPEG | 高质量影像输出 |\n| ECW | `.ecw"
  },
  {
    "slug": "29-zi-ding-yi-shu-ju-jiao-huan-liu-cheng",
    "title": "自定义数据交换流程",
    "section": "数据交换与导入导出",
    "headings": [
      "自定义数据交换架构",
      "模式一：带数据预处理的交换流程",
      "流程架构与步骤",
      "完整代码示例",
      "关键步骤对比表",
      "模式二：批量文件处理流程",
      "批量处理架构",
      "批量处理完整示例",
      "批量处理优化技巧",
      "模式三：带日志记录和进度跟踪的增强流程",
      "增强流程架构",
      "增强流程实现示例",
      "日志和进度功能对比",
      "自定义流程设计模式",
      "模式一：流程模板模式",
      "模式二：管道模式",
      "错误处理与最佳实践",
      "错误处理策略",
      "最佳实践总结",
      "常见问题排查",
      "学习路径建议"
    ],
    "content": "本页面详细讲解如何构建自定义数据交换流程，将基础的数据导入导出功能组合成复杂的工作流。通过将 DataXScript 与 SSProcessManager 集合，并结合选择集操作、数据处理和进度跟踪等功能，您可以实现自动化的批量数据转换、质量检查和多格式同步导出等高级场景。\n\n\n\n## 自定义数据交换架构\n\n自定义数据交换流程的核心思想是将数据交换作为数据处理工作流中的一个环节，与选择集管理、属性编辑、数据验证等功能有机结合。这种架构允许在数据导入后进行预处理，在数据导出前进行质量检查，实现端到端的自动化数据处理。\n\n```mermaid\ngraph TB\n    A[开始自定义数据交换流程] --> B{选择流程类型}\n    B -->|简单导入导出| C[基础模式]\n    B -->|带数据预处理| D[处理模式]\n    B -->|批量文件处理| E[批量模式]\n    B -->|多格式同步导出| F[同步模式]\n    \n    C --> C1[配置参数]\n    C1 --> C2[执行交换]\n    C2 --> C3[结果验证]\n    \n    D --> D1[数据导入]\n    D1 --> D2[选择集筛选]\n    D2 --> D3[数据转换]\n    D3 --> D4[质量检查]\n    D4 --> D5[数据导出]\n    \n    E --> E1[遍历文件列表]\n    E1 --> E2[逐个导入]\n    E2 --> E3[进度跟踪]\n    E3 --> E4[错误恢复]\n    \n    F --> F1[数据准备]\n    F1 --> F2[配置多目标参数]\n    F2 --> F3[并行/串行导出]\n    F3 --> F4[结果汇总]\n    \n    C3 --> G[流程完成]\n    D5 --> G\n    E4 --> G\n    F4 --> G\n```\n\n自定义数据交换流程基于以下核心组件构建：**DataXScript** 负责数据交换，**SSProcessManager** 提供工作流控制，**Mixin 模块** 提供日志、进度等辅助功能。这种模块化设计使您能够根据需求灵活组合功能。\n\n\n\n## 模式一：带数据预处理的交换流程\n\n这种模式适用于需要在数据导入后进行数据处理再导出的场景，例如数据清洗、属性标准化、坐标转换等。典型的应用包括：将外部数据导入后根据业务规则修改属性，然后导出为标准格式。\n\n### 流程架构与步骤\n\n```mermaid\nflowchart TD\n    Start([开始预处理交换流程]) --> Init[初始化 SSProcessManager]\n    Init --> InitDataX[创建 DataXScript 实例]\n    InitDataX --> ConfigImport[配置导入参数]\n    ConfigImport --> ExecuteImport[执行 importData]\n    ExecuteImport --> CheckImport{导入成功?}\n    CheckImport -->|否| LogImportError[记录导入错误] --> ErrorEnd([流程失败])\n    CheckImport -->|是| SelectData[筛选需要处理的数据]\n    SelectData --> SetCondition[设置筛选条件]\n    SetCondition --> Filter[执行 selectFilter]\n    Filter --> CheckData{有选择集?}\n    CheckData -->|否| NoDataEnd([无数据需处理])\n    CheckData -->|是| ProcessData[遍历选择集处理数据]\n    ProcessData --> ModifyAttributes[修改属性]\n    ModifyAttributes --> SaveChanges[保存到数据库]\n    SaveChanges --> ConfigExport[配置导出参数]\n    ConfigExport --> ExecuteExport[执行 exportData]\n    ExecuteExport --> CheckExport{导出成功?}\n    CheckExport -->|否| LogExportError[记录导出错误] --> ErrorEnd\n    CheckExport -->|是| VerifyResult[验证输出文件]\n    VerifyResult --> SuccessEnd([流程成功"
  },
  {
    "slug": "30-shu-ju-jian-cha-ji-lu-guan-li",
    "title": "数据检查记录管理",
    "section": "数据检查与验证",
    "headings": [
      "系统架构概览",
      "核心功能模块",
      "记录生命周期管理",
      "持久化与IO操作",
      "查询与访问",
      "检查记录数据结构",
      "关键字段说明",
      "典型使用流程",
      "基础实例化",
      "添加检查记录",
      "统计与查询",
      "持久化与清理",
      "检查记录的高级应用",
      "与选择集的协同",
      "历史记录对比",
      "性能考虑与最佳实践",
      "批量操作优化",
      "记录内容优化",
      "常见问题与故障排除",
      "记录无法保存",
      "geoids 和 noteids 格式错误",
      "GetCheckRecordValue 返回空值",
      "学习路径建议"
    ],
    "content": "数据检查记录管理是 SunvStation 数据质量保证系统的核心组件，用于记录、追踪和管理数据验证过程中发现的各类问题。通过该机制，您可以系统地捕获检查结果、定位问题对象、记录问题描述，并支持后续的统计分析和问题修复工作。数据检查记录为数据生产流程提供了可追溯的质量控制能力。\n\n\n\n## 系统架构概览\n\n数据检查记录管理基于 **CheckFunForPY** 类实现，该类通过 SWIG 封装技术连接 Python 业务逻辑与 C++ 核心检查引擎。在整个系统架构中，CheckFunForPY 位于接口层，与工作空间、地图管理等核心模块协同工作，形成完整的数据质量保障体系。\n\n```mermaid\ngraph TB\n    subgraph \"应用层 Python 业务逻辑\"\n        Script[检查脚本]\n    end\n    \n    subgraph \"接口层 SWIG 封装\"\n        CheckFun[CheckFunForPY<br/>检查记录管理类]\n        OtherMods[其他接口模块<br/>PySSCore, PySSMap等]\n    end\n    \n    subgraph \"实现层 C++ 核心库\"\n        CheckDL[_PySSCheck.pyd<br/>检查引擎实现]\n        OtherDL[其他核心库<br/>_PySSCore.pyd等]\n    end\n    \n    Script -->|实例化| CheckFun\n    Script -->|可能调用| OtherMods\n    \n    CheckFun -->|调用| CheckDL\n    CheckFun -.->|协作| OtherMods\n    OtherMods --> OtherDL\n    \n    style CheckFun fill:#e1f5ff\n    style CheckDL fill:#fff4e1\n```\n\nCheckFunForPY 类采用了 **记录集管理模式**，检查记录以集合形式在内存中维护，提供增删改查的完整操作。与 SSProcessManager 的单例模式不同，CheckFunForPY 需要显式实例化，这种设计允许同时维护多个独立的检查记录集合，适用于并行检查或分段检查等复杂场景。\n\n\n\n## 核心功能模块\n\n数据检查记录管理包含六大核心功能模块，每个模块对应一组相关的方法，共同构成完整的检查记录生命周期管理能力。\n\n### 记录生命周期管理\n\n| 方法名称 | 功能说明 | 典型应用场景 |\n|---------|---------|------------|\n| `AddCheckRecord()` | 添加一条新的检查记录 | 数据验证脚本发现问题时记录 |\n| `RemoveCheckRecord()` | 删除指定的检查记录 | 误报修正或批量清理 |\n| `GetCheckRecordCount()` | 获取当前检查记录总数 | 统计分析、进度监控 |\n| `ClearCheckRecord()` | 清空所有检查记录 | 开始新一轮检查前初始化 |\n\n记录的生命周期从添加开始，经过可能的删除操作，最终通过保存操作持久化。这种设计遵循**最小状态原则**，检查记录仅在内存中维护显式状态，避免隐式的后台同步操作。\n\n\n\n### 持久化与IO操作\n\n| 方法名称 | 功能说明 | 操作目标 |\n|---------|---------|---------|\n| `LoadCheckRecord()` | 从文件加载历史检查记录 | 恢复之前保存的检查结果 |\n| `SaveCheckRecord()` | 将当前检查记录保存到文件 | 持久化存储检查结果 |\n| `WriteCheckRecord()` | 将检查记录写入系统输出 | 与系统检查模块集成 |\n\n持久化操作支持检查结果的跨会话复用，您可以在不同时间点加载和比较检查结果，追踪数据质量的演变趋势。\n\n\n\n### 查询与访问\n\n| 方法名称 | 功能说明 | 参数说明 |\n|---------|---------|---------|\n| `GetCheckRecordValue()` | 获取指定记录的字段值 | 支持批量获取多个字段 |\n| `ShowCheckOutput()` | 显示检查输出结果 | 在系统界面中呈现 |\n\n查询方法提供了灵活的数据访问能力，支持按索引定位记录并提取特定字段，便于生成定制化的报告或进行深度分析。\n\n\n\n## 检查记录数据结构\n\n每条检查记录包含丰富的元数据信息，用于完整描述检查发现的问题。理解这些字段的结构是有效使"
  },
  {
    "slug": "31-tian-jia-yu-jia-zai-jian-cha-ji-lu",
    "title": "添加与加载检查记录",
    "section": "数据检查与验证",
    "headings": [
      "添加检查记录详解",
      "方法签名与参数说明",
      "添加操作的工作流程",
      "基础添加示例",
      "多对象关联添加",
      "加载检查记录详解",
      "方法功能与返回值",
      "加载操作的执行过程",
      "基础加载示例",
      "加载前的清空处理",
      "实践案例：质量追踪系统",
      "场景说明",
      "完整实现代码",
      "最佳实践与注意事项",
      "参数传递的最佳实践",
      "坐标信息的准确获取",
      "加载操作的错误处理",
      "批量加载与增量更新",
      "进阶主题：与系统集成",
      "与地图显示的集成",
      "学习路径建议"
    ],
    "content": "数据检查记录的添加与加载是 SunvStation 数据质量保证系统中最为核心的两个操作。添加操作用于在数据验证过程中实时记录发现的问题，加载操作则用于恢复历史检查结果或在不同检查会话之间共享数据。这两个操作共同构成了检查记录管理的基础，支撑着完整的数据质量控制生命周期。\n\n通过精心设计的参数体系和灵活的持久化机制，添加与加载操作能够适应从快速原型验证到大规模生产检查的各种应用场景。掌握这两个操作的使用方法，是编写高质量数据检查脚本的关键技能。\n\n\n\n## 添加检查记录详解\n\n添加检查记录是数据验证脚本中最为频繁的操作，通过 `AddCheckRecord()` 方法将发现的数据问题记录到内存中的检查记录集合中。该方法通过丰富的参数体系完整地描述了检查发现的问题，包括问题分类、空间位置、关联对象等多维度信息。\n\n### 方法签名与参数说明\n\n`AddCheckRecord()` 方法的完整签名包含10个参数，每个参数都有其特定的语义和使用场景：\n\n```python\ndef AddCheckRecord(self, group, check, checkmodel, description, x, y, z, objtype, geoids, noteids):\n```\n\n| 参数名 | 数据类型 | 必需 | 说明 | 典型值 |\n|--------|---------|------|------|--------|\n| `group` | string | 是 | 检查组名称，用于逻辑分组 | \"拓扑检查\"、\"属性完整性\" |\n| `check` | string | 是 | 检查项名称，标识具体检查类型 | \"重叠检查\"、\"必填项缺失\" |\n| `checkmodel` | int | 是 | 检查模式标识符 | 0-255之间的整数值 |\n| `description` | string | 是 | 问题描述或错误详情 | 简洁清晰的问题描述文本 |\n| `x` | float | 是 | 问题位置X坐标 | 地理坐标系统中的X值 |\n| `y` | float | 是 | 问题位置Y坐标 | 地理坐标系统中的Y值 |\n| `z` | float | 是 | 问题位置Z坐标 | 高程值，通常为0.0 |\n| `objtype` | int | 是 | 关联对象的类型 | 1=点，2=线，3=面等 |\n| `geoids` | string | 是 | 地物对象ID列表，逗号分隔 | \"1001,1002,1003\" |\n| `noteids` | string | 是 | 注记对象ID列表，逗号分隔 | \"2001,2002\" |\n\n该设计遵循**信息完整性原则**，确保每条记录包含问题追踪和定位所需的所有信息，同时通过字符串形式的ID列表支持多对象关联场景。\n\n\n\n### 添加操作的工作流程\n\n理解添加操作的内部处理流程有助于编写更高效的检查脚本。当调用 `AddCheckRecord()` 时，系统会执行一系列验证和处理步骤：\n\n```mermaid\nflowchart TD\n    A[调用 AddCheckRecord] --> B{参数有效性验证}\n    B -->|通过| C[创建检查记录对象]\n    B -->|失败| D[记录添加失败]\n    \n    C --> E[设置 group 和 check 字段]\n    E --> F[设置空间坐标 x, y, z]\n    F --> G[设置 objtype 对象类型]\n    G --> H[解析 geoids 字符串为ID列表]\n    H --> I[解析 noteids 字符串为ID列表]\n    I --> J[设置 description 描述信息]\n    J --> K[记录添加到内存集合]\n    K --> L[返回成功状态]\n    \n    D --> M[抛出异常或返回错误]\n    \n    style C fill:#e1f5ff\n    style K fill:#fff4e1\n    style L fill:#d4edda\n```\n\n该流程体现了**防御性编程**的设计思想，在添加记录前进行参数验证，避免无效数据污染检查记录集合。坐标和对象类型信息的设置支持后续的空间查询和类型过滤，而ID列表的解析则实现了从字符串表示到结构化数据的转换。\n\n\n\n### 基础添加示例\n\n以下是一个完整的添加检查记录示例，展示了如何在实际脚本中记录拓扑重叠问题：\n\n```python\nfrom sunvpy.PySSCheck import CheckFunForPY\nfrom sunvpy import SSProcess\n\n#"
  },
  {
    "slug": "32-xian-shi-jian-cha-jie-guo",
    "title": "显示检查结果",
    "section": "数据检查与验证",
    "headings": [
      "核心功能概述",
      "基础使用方法",
      "方法签名",
      "最简示例",
      "检查结果窗口界面",
      "窗口结构",
      "记录显示内容",
      "交互功能",
      "完整工作流程示例",
      "多类型检查结果展示",
      "混合检查示例",
      "显示前的准备工作",
      "记录数量检查",
      "记录有效性验证",
      "保存后显示",
      "高级应用场景",
      "批量检查后的结果展示",
      "历史对比显示",
      "常见问题与解决方案",
      "窗口无法显示",
      "大量记录显示缓慢",
      "空间定位不准确",
      "最佳实践总结",
      "显示时机建议",
      "代码模板",
      "学习路径建议"
    ],
    "content": "显示检查结果是数据质量验证流程的最后一步，通过可视化界面呈现检查记录中记录的所有问题，帮助用户快速定位、分析和修复数据缺陷。通过 `ShowCheckOutput()` 方法，系统将内存中的检查记录转换为直观的检查结果窗口，提供交互式的问题浏览和定位功能。\n\n\n\n## 核心功能概述\n\n`ShowCheckOutput()` 是 CheckFunForPY 类提供的关键方法，用于在系统界面中弹出一个独立的检查结果查看窗口。该窗口以表格或列表形式展示所有检查记录，支持按检查组、检查项进行分类展示，并提供空间定位功能，点击某条记录即可自动缩放地图到问题发生的位置。\n\n该方法的设计遵循**最小调用原则**，无需任何参数即可完成完整的显示操作，系统会自动读取当前 CheckFunForPY 实例中的所有检查记录并渲染到界面。这种设计降低了使用门槛，使得在检查完成后只需一行代码即可呈现结果。\n\n```mermaid\ngraph TB\n    subgraph \"检查脚本执行流程\"\n        A[创建 CheckFunForPY 实例] --> B[执行数据检查逻辑]\n        B --> C[调用 AddCheckRecord 记录问题]\n        C --> D[检查完成]\n    end\n    \n    subgraph \"结果显示阶段\"\n        D --> E[调用 ShowCheckOutput]\n        E --> F[读取内存中的检查记录集合]\n        F --> G[生成检查结果窗口]\n        G --> H[用户交互浏览问题]\n        H --> I[点击定位到地图]\n    end\n    \n    style E fill:#e1f5ff\n    style G fill:#fff4e1\n    style I fill:#d4edda\n```\n\n\n\n## 基础使用方法\n\n### 方法签名\n\n`ShowCheckOutput()` 方法的签名非常简洁：\n\n```python\ndef ShowCheckOutput(self):\n```\n\n- **返回值**: 无明确文档说明返回值类型，从调用方代码推断为布尔值或无返回\n- **参数**: 无需任何参数\n- **异常**: 调用失败时可能抛出异常，建议在 try-except 结构中调用\n\n### 最简示例\n\n以下是使用 ShowCheckOutput 的最简示例，展示了典型的检查-记录-显示流程：\n\n```python\nfrom sunvpy.PySSCheck import CheckFunForPY\n\n# 创建检查记录管理实例\ncheck_fun = CheckFunForPY()\n\n# ... 执行检查逻辑，调用 AddCheckRecord 添加问题记录 ...\ncheck_fun.AddCheckRecord(\n    group=\"拓扑检查\",\n    check=\"重叠检查\",\n    checkmodel=1,\n    description=\"建筑物A与建筑物B存在重叠\",\n    x=123456.78, y=345678.90, z=0.0,\n    objtype=3,\n    geoids=\"1001,1002\",\n    noteids=\"\"\n)\n\n# 显示检查结果\ncheck_fun.ShowCheckOutput()\n```\n\n执行上述代码后，系统会弹出一个检查结果窗口，显示所有已添加的检查记录。\n\n\n\n## 检查结果窗口界面\n\n### 窗口结构\n\n检查结果窗口通常包含以下主要区域：\n\n| 区域 | 功能 | 说明 |\n|------|------|------|\n| **记录列表区** | 显示所有检查记录的摘要信息 | 包括组名、检查项、描述、位置等 |\n| **详情面板** | 显示当前选中记录的完整信息 | 展示所有字段的详细值 |\n| **工具栏** | 提供常用操作按钮 | 定位、刷新、导出等功能 |\n| **统计信息** | 显示问题统计概览 | 按组分类统计问题数量 |\n\n### 记录显示内容\n\n每条检查记录在窗口中显示以下核心信息：\n\n- **检查组**: 用于逻辑分组，如\"拓扑检查\"、\"属性检查\"\n- **检查项**: 标识具体检查类型，如\"重叠检查\"、\"名称缺失\"\n- **问题描述**: 简要描述发现的问题\n- **位置坐标**: 问题发生的 X、Y、Z 坐标\n- **关联对象**: 涉及的地物 ID 和注记 ID 列表\n\n### 交互功能\n\n检查结果窗口支持多种交互操作，提升问题处理的效率：\n\n```mermaid\nflowchart LR\n    A[检"
  },
  {
    "slug": "33-zi-ding-yi-jian-cha-gui-ze",
    "title": "自定义检查规则",
    "section": "数据检查与验证",
    "headings": [
      "检查规则架构设计",
      "核心组件角色",
      "检查规则的基本结构",
      "标准模板",
      "常见检查类型实现",
      "属性完整性检查",
      "拓扑关系检查",
      "几何规则检查",
      "业务规则检查",
      "高级检查模式",
      "组合检查模式",
      "增量检查模式",
      "性能优化最佳实践",
      "数据访问优化",
      "算法复杂度控制",
      "进度反馈优化",
      "错误处理与调试",
      "检查规则的部署与管理",
      "配置化检查规则",
      "学习路径建议"
    ],
    "content": "自定义检查规则是 SunvStation 数据质量保证系统中最为灵活和强大的功能，允许开发者根据特定的业务需求和技术规范编写专属的数据验证逻辑。通过组合 CheckFunForPY 的检查记录管理能力、SSProcessManager 的选择集操作能力以及 Python 的丰富生态系统，您可以构建从简单的属性完整性检查到复杂的空间拓扑验证等各类检查规则。\n\n自定义检查规则的核心价值在于**将通用的检查框架与特定的业务逻辑分离**。系统提供了检查记录管理、结果显示、持久化存储等通用能力，而您只需要专注于实现具体的检查算法和数据验证逻辑。这种设计既降低了开发门槛，又保持了系统的扩展性。\n\n\n\n## 检查规则架构设计\n\n自定义检查规则采用**分层架构模式**，将检查任务分解为数据准备、检查执行、结果记录三个阶段。每个阶段由不同的组件负责，通过明确定义的接口协作，形成清晰的职责划分。\n\n```mermaid\ngraph TB\n    subgraph \"检查规则脚本层\"\n        Script[检查规则脚本<br/>自定义业务逻辑]\n    end\n    \n    subgraph \"功能组件层\"\n        CF[CheckFunForPY<br/>检查记录管理]\n        SS[SSProcessManager<br/>选择集与数据操作]\n        Logger[日志组件<br/>日志与进度]\n    end\n    \n    subgraph \"数据层\"\n        WS[工作空间<br/>WorkSpace]\n        Map[地图数据<br/>ScaleMap]\n        DS[数据源<br/>DataSource]\n    end\n    \n    subgraph \"持久化层\"\n        File[检查记录文件]\n    end\n    \n    Script -->|实例化| CF\n    Script -->|调用| SS\n    Script -->|使用| Logger\n    \n    SS -->|访问| WS\n    SS -->|操作| Map\n    WS -->|获取| DS\n    \n    CF -->|保存/加载| File\n    \n    style Script fill:#e1f5ff\n    style CF fill:#fff4e1\n    style SS fill:#ffe1f5\n```\n\n该架构体现了**关注点分离**的设计原则。检查脚本专注于业务逻辑的实现，不关心底层的记录管理和数据访问细节。这种分层设计使得检查规则易于测试、维护和复用。\n\n\n\n### 核心组件角色\n\n| 组件 | 职责 | 主要方法/特性 |\n|------|------|-------------|\n| **检查规则脚本** | 实现具体的检查逻辑，协调各组件协作 | 自定义函数、类、算法实现 |\n| **CheckFunForPY** | 管理检查记录的生命周期 | AddCheckRecord、GetCheckRecordCount、ShowCheckOutput |\n| **SSProcessManager** | 提供数据查询、遍历、编辑能力 | setSelectCondition、selectFilter、getSelGeoValue |\n| **日志组件** | 记录检查过程，提供进度反馈 | logger.info、startProgress、stepProgress |\n\n这种设计允许开发者**组合基础组件**构建复杂的检查规则，而不需要从零开始实现所有功能。每个组件都经过充分测试，提供了稳定的 API 接口。\n\n\n\n## 检查规则的基本结构\n\n一个规范的自定义检查规则脚本通常包含五个关键部分：**初始化、数据准备、检查执行、结果处理、清理退出**。遵循这种结构可以确保脚本的逻辑清晰、易于维护。\n\n```mermaid\nflowchart TD\n    A[脚本开始] --> B[初始化阶段<br/>创建组件实例]\n    B --> C[数据准备阶段<br/>设置选择条件、加载数据]\n    C --> D[检查执行阶段<br/>遍历对象、应用检查逻辑]\n    D --> E{发现问题?}\n    E -->|是| F[添加检查记录]\n    E -->|否| G[继续下一个对象]\n    F --> G\n    G --> D\n    \n    D --> H{检查完成?}\n    H -->|否| D\n    H -->|是| I[结果处理阶段<br/>统计、显示、保存]\n    I --> J[清理退出阶段<br/>释放资源]\n  "
  },
  {
    "slug": "34-huo-qu-gong-zuo-kong-jian-xin-xi",
    "title": "获取工作空间信息",
    "section": "高级功能",
    "headings": [
      "架构概览",
      "获取工作空间实例",
      "基本用法",
      "使用场景",
      "获取当前地图",
      "获取方法",
      "地图信息获取表",
      "获取系统路径",
      "路径模式对照表",
      "使用示例",
      "路径获取流程",
      "获取图层信息",
      "图层操作方法",
      "使用示例",
      "图层信息获取流程",
      "获取符号表信息",
      "符号表查询方法",
      "使用示例",
      "符号表切换",
      "获取地图图幅信息",
      "图幅操作方法",
      "使用示例",
      "图幅处理流程",
      "综合应用示例",
      "最佳实践",
      "1. 始终检查空引用",
      "2. 合理使用系统路径",
      "3. 及时释放资源",
      "4. 批量操作前检查图层状态",
      "5. 使用日志记录关键信息",
      "错误处理与调试",
      "常见错误类型",
      "错误处理示例",
      "API 快速参考",
      "下一步学习"
    ],
    "content": "获取工作空间信息是 SunvStation 开发中的基础操作，它允许脚本访问当前活动的地图实例、系统路径、图层配置以及各种表管理信息。掌握这些信息获取方法对于构建功能完善的脚本至关重要。\n\n## 架构概览\n\n工作空间信息获取通过 `ProjectMixin` 提供的便捷方法实现，这些方法封装了底层的 `WorkSpace` 和 `ScaleMap` 对象访问逻辑。以下展示了获取工作空间信息的调用层次结构：\n\n```mermaid\ngraph TD\n    A[Python 脚本] -->|调用| B[SSProcess 实例]\n    B -->|继承| C[ProjectMixin]\n    C -->|提供方法| D[getWorkspace]\n    C -->|提供方法| E[getCurrentMap]\n    C -->|提供方法| F[getSysPathName]\n    C -->|提供方法| G[getLayerCount/Name]\n    C -->|提供方法| H[getFeatureCodeTB]\n    \n    D -->|访问| WS[WorkSpace 单例]\n    E -->|调用| WS\n    WS -->|返回| SM[ScaleMap 当前地图]\n    F -->|使用| GO[GlobalOptions 单例]\n    G -->|访问| SM\n    H -->|访问| SM\n    \n    style B fill:#e1f5ff\n    style C fill:#fff4e1\n    style WS fill:#f0f0f0\n    style SM fill:#f0f0f0\n```\n\n\n\n## 获取工作空间实例\n\n工作空间是 SunvStation 系统的全局单例对象，通过 `getWorkspace()` 方法可以获取当前工作空间的实例。这个实例提供了访问系统级资源和配置的入口。\n\n### 基本用法\n\n```python\n# 获取工作空间实例\nworkspace = SSProcess.getWorkspace()\n\n# 获取当前活动的地图\ncurrent_map = workspace.getCurrentScaleMap()\n```\n\n\n\n### 使用场景\n\n获取工作空间实例的主要使用场景包括：\n\n- **访问多个地图**：当需要操作非当前活动的地图时\n- **系统级配置**：获取全局配置选项和路径信息\n- **资源协调**：在不同地图间协调资源访问\n\n## 获取当前地图\n\n`getCurrentMap()` 方法返回当前活动的地图实例（`ScaleMap` 类型），这是进行地图操作的主要入口。\n\n### 获取方法\n\n```python\n# 获取当前地图\ncurrent_map = SSProcess.getCurrentMap()\n\n# 检查地图是否存在\nif current_map is None:\n    print(\"当前没有打开的地图\")\n    return\n\n# 获取地图项目名称\nproject_name = current_map.getProjectName()\n```\n\n\n\n### 地图信息获取表\n\n| 信息类型 | 获取方法 | 说明 |\n|---------|---------|------|\n| 项目名称 | `getProjectName()` | 返回当前工程文件路径 |\n| 图层数量 | `getLayerSize()` | 返回地图中的图层数量 |\n| 数据源 | `getCurrentDataSource()` | 返回当前活动的数据源 |\n\n\n\n## 获取系统路径\n\n系统路径信息对于脚本访问配置文件、模板、脚本目录等非常重要。`getSysPathName(mode)` 方法根据模式参数返回不同类型的系统路径。\n\n### 路径模式对照表\n\n| 模式 | 路径类型 | 说明 | 典型用途 |\n|-----|---------|------|---------|\n| 0 | 配置路径 | 存放系统配置文件 | 读取系统配置 |\n| 1 | 模板路径 | 存放模板文件 | 加载数据模板 |\n| 2 | Comm 路径 | 公共资源路径 | 访问共享资源 |\n| 3 | Script 路径 | 脚本文件路径 | 动态加载脚本 |\n| 4 | SSTemp 路径 | 临时文件路径 | 存储临时数据 |\n| 5 | 工程文件路径 | 当前工程所在目录 | 相对路径计算 |\n| 6 | 系统目录 | Windows 系统目录或 Unix /usr | 访问系统文件 |\n| 7/8 | 工作台面目录 | 用户工作台面目录 | 输出文件"
  },
  {
    "slug": "35-xi-tong-lu-jing-guan-li",
    "title": "系统路径管理",
    "section": "高级功能",
    "headings": [
      "架构概览",
      "路径模式详解",
      "路径模式对照表",
      "路径特点说明",
      "基本用法",
      "获取各类系统路径",
      "构造完整文件路径",
      "高级用法",
      "获取工程文件路径",
      "跨平台系统目录访问",
      "工作台面目录操作",
      "路径获取流程",
      "综合应用示例",
      "最佳实践",
      "1. 优先使用系统路径而非硬编码",
      "2. 始终检查路径有效性",
      "3. 使用 pathlib 进行路径操作",
      "4. 临时文件及时清理",
      "5. 处理路径中的斜杠",
      "错误处理与调试",
      "常见错误类型",
      "错误处理示例",
      "API 快速参考",
      "下一步学习"
    ],
    "content": "系统路径管理是 SunvStation 二次开发中的核心功能之一，它允许脚本动态访问系统配置文件、模板、脚本目录、临时文件目录等关键资源路径。通过统一的接口获取路径信息，可以确保脚本在不同安装环境和操作系统上的兼容性和可移植性。\n\n## 架构概览\n\n系统路径管理通过 `ProjectMixin` 提供的 `getSysPathName(mode)` 方法实现，该方法封装了底层的 `GlobalOptions` 单例对象访问逻辑，根据模式参数返回不同类型的系统路径。以下展示了系统路径管理的调用层次结构：\n\n```mermaid\ngraph TD\n    A[Python 脚本] -->|调用| B[SSProcess 实例]\n    B -->|继承| C[ProjectMixin]\n    C -->|提供方法| D[getSysPathName]\n    D -->|使用| E[GlobalOptions 单例]\n    \n    D -->|mode=0| F[getConfigurePath]\n    D -->|mode=1| G[getTemplatePath]\n    D -->|mode=2| H[getCommonPath]\n    D -->|mode=3| I[getSchemeFilePath]\n    D -->|mode=4| J[getEpsTempPath]\n    D -->|mode=5| K[getCurrentMap]\n    D -->|mode=6| L[os.environ]\n    D -->|mode=7/8| M[getSchemeFilePath]\n    \n    K -->|获取| N[getProjectName]\n    N -->|Path.parent| O[工程目录]\n    \n    style B fill:#e1f5ff\n    style C fill:#fff4e1\n    style E fill:#f0f0f0\n```\n\n\n\n## 路径模式详解\n\n`getSysPathName(mode)` 方法支持 9 种路径模式（0-8），每种模式对应不同类型的系统路径。理解这些路径模式的用途对于构建健壮的脚本至关重要。\n\n### 路径模式对照表\n\n| 模式 | 路径类型 | 底层方法 | 说明 | 典型用途 |\n|-----|---------|---------|------|---------|\n| 0 | 配置路径 | `getConfigurePath()` | 存放系统配置文件（Windows 下为应用程序路径） | 读取 SSGlobal.xml 等配置文件 |\n| 1 | 模板路径 | `getTemplatePath()` | 存放地物模板文件 | 加载 .egdb 模板创建新工程 |\n| 2 | Comm 路径 | `getCommonPath()` | 公共资源目录 | 访问共享的数据符号库 |\n| 3 | Script 路径 | `getSchemeFilePath(\"scripts\")` | 脚本文件目录 | 动态加载或引用其他脚本 |\n| 4 | SSTemp 路径 | `getEpsTempPath()` | 临时文件目录 | 存储中间处理结果 |\n| 5 | 工程文件路径 | `getCurrentMap().getProjectName()` | 当前工程文件所在目录 | 计算相对路径、保存输出 |\n| 6 | 系统目录 | `WINDIR` 或 `/usr` | 操作系统目录 | 访问系统级文件 |\n| 7 | 工作台面目录 | `getSchemeFilePath(\"\")` | 用户工作台面根目录 | 访问用户自定义配置 |\n| 8 | 工作台面目录 | `getSchemeFilePath(\"\")` | 用户工作台面根目录 | 同模式 7，保留兼容性 |\n\n\n\n### 路径特点说明\n\n**配置路径（mode 0）**：在 Windows 系统中通常为应用程序安装目录，在 Unix 系统中可能为 `/etc` 或 `/opt` 等系统配置目录。此路径用于存放全局配置文件，如 `SSGlobal.xml`。\n\n**模板路径（mode 1）**：存放预定义的地物模板文件（.egdb 格式）。当需要创建新的工程文件时，通常基于这些模板进行初始化。\n\n**Comm 路径（mode 2）**：公共资源目录，包含符号库、样式表等跨工程共享的资源文件。\n\n**Script 路径（mode 3）**：存放 Python 脚本文件的目录。此路径对于脚本间的相互引用（import）和动态加载（exec）非常重要。\n\n**SSTemp 路径（m"
  },
  {
    "slug": "36-di-tu-suo-fang-kong-zhi",
    "title": "地图缩放控制",
    "section": "高级功能",
    "headings": [
      "架构概览",
      "地图比例尺控制",
      "比例尺控制方法",
      "设置比例尺流程",
      "使用示例",
      "窗口缩放控制",
      "窗口缩放方法",
      "窗口缩放流程",
      "使用示例",
      "坐标系统转换",
      "坐标转换方法表",
      "坐标转换流程",
      "使用示例",
      "视图平移控制",
      "平移控制方法",
      "平移流程",
      "使用示例",
      "获取视图缩放比例",
      "获取缩放比例方法",
      "使用示例",
      "视图刷新控制",
      "视图刷新方法",
      "使用示例",
      "获取地图矩形信息",
      "地图矩形方法",
      "使用示例",
      "对象缩放操作",
      "对象缩放方法",
      "对象缩放流程",
      "使用示例",
      "综合应用示例",
      "示例：自动定位到指定区域并调整比例尺",
      "常见问题与解决方案",
      "问题1：比例尺设置失败",
      "问题2：坐标转换结果不准确",
      "问题3：视图刷新后显示异常",
      "最佳实践",
      "1. 批量操作前创建撤销标记",
      "2. 缩放操作后刷新视图",
      "3. 使用坐标转换实现精确定位",
      "4. 检查地图有效性",
      "相关页面"
    ],
    "content": "地图缩放控制是 SunvStation 二次开发中的核心功能之一，它允许脚本程序动态调整地图视图的显示范围、比例尺和视角。通过精确的缩放控制，可以实现自动定位、视图切换、数据浏览等丰富的交互功能。本页将系统地介绍地图缩放控制的各项功能、使用方法和最佳实践。\n\n\n\n## 架构概览\n\nSunvStation 的地图缩放控制采用分层架构设计，底层的 `ScaleMap` 对象负责地图数据的逻辑管理，顶层的 `VkPainter2D` 或 `VkPainter3D` 对象负责视图的渲染和交互。以下展示了地图缩放控制的调用层次结构：\n\n```mermaid\ngraph TB\n    A[Python 脚本] -->|调用| B[SSProcess 实例]\n    B -->|继承| C[ProjectMixin]\n    C -->|提供方法| D[getCurrentMap]\n    D -->|返回| SM[ScaleMap 地图对象]\n    \n    SM -->|包含| VL[ViewList 视图列表]\n    VL -->|包含| VP2[VkPainter2D 2D视图]\n    VL -->|包含| VP3[VkPainter3D 3D视图]\n    \n    SM -->|提供| MS[map_scale: 比例尺控制]\n    SM -->|提供| MR[getMapRect: 地图矩形]\n    SM -->|提供| ZM[zoom: 对象缩放]\n    \n    VP2 -->|提供| ZW[zoomWindow: 窗口缩放]\n    VP2 -->|提供| MP[moveScreenByPoint: 平移]\n    VP2 -->|提供| GS[getImgScale: 获取缩放比例]\n    VP2 -->|提供| CTS[坐标转换方法组]\n    VP2 -->|提供| LC[长度转换方法组]\n    \n    VP3 -->|提供| ZW2[zoomWindow: 窗口缩放]\n    VP3 -->|提供| MP2[moveScreenByPoint: 平移]\n    VP3 -->|提供| GS2[getImgScale: 获取缩放比例]\n    VP3 -->|提供| CTS2[坐标转换方法组]\n    VP3 -->|提供| LC2[长度转换方法组]\n    \n    style B fill:#e1f5ff\n    style C fill:#fff4e1\n    style SM fill:#f0f0f0\n    style VP2 fill:#e8f5e9\n    style VP3 fill:#e8f5e9\n```\n\n上图展示了地图缩放控制的双层架构。`ScaleMap` 对象管理地图数据和比例尺，通过 `setMapScale()` 和 `getMapScale()` 方法实现比例尺的设置和查询。`VkPainter2D` 和 `VkPainter3D` 对象负责视图渲染，提供了窗口缩放、平移、坐标转换等视图操作方法。\n\n\n\n## 地图比例尺控制\n\n地图比例尺是地图缩放控制的核心参数，它决定了地图上地理要素的显示大小。SunvStation 提供了直接设置和查询地图比例尺的方法，适用于需要精确控制显示比例的场景。\n\n### 比例尺控制方法\n\n| 方法 | 功能描述 | 返回值 |\n|-----|---------|--------|\n| `map.setMapScale(lScale)` | 设置地图比例尺 | boolean |\n| `map.getMapScale()` | 获取当前地图比例尺 | long |\n\n**参数说明**：\n\n- `lScale`：比例尺分母，例如 500 表示 1:500 的比例尺\n\n\n\n### 设置比例尺流程\n\n```mermaid\nflowchart LR\n    A[开始设置比例尺] --> B[获取当前地图]\n    B -->|map| C[调用 setMapScale]\n    C -->|传入 lScale| D{设置是否成功}\n    D -->|成功| E[比例尺已更新]\n    D -->|失败| F[检查参数有效性]\n    F --> G[重新调用 setMapScale]\n    E --> H[调用 repaint 更新视图]\n    H --> I[完成]\n    \n    style A fill:#e1f5ff\n    style D fill:#fff4e1\n    style H fill:#ffe8e1\n```\n\n### 使用示例\n\n```python\nfrom sunvpy import SSProcess\n\n# "
  },
  {
    "slug": "37-pei-zhi-ri-zhi-ji-lu-qi",
    "title": "配置日志记录器",
    "section": "高级功能",
    "headings": [
      "日志系统架构概览",
      "配置日志记录器流程",
      "步骤一：创建 Logger 实例",
      "日志级别说明",
      "步骤二：配置 Handler 处理器",
      "文件处理器配置",
      "控制台处理器配置",
      "步骤三：设置 Formatter 格式化器",
      "基本格式示例",
      "格式化参数说明",
      "完整格式示例（包含位置信息）",
      "步骤四：组装并注入到 SSProcess",
      "常用日志配置方案",
      "方案一：开发调试配置",
      "方案二：生产环境配置",
      "方案三：简洁配置",
      "日志记录方法说明",
      "自动记录（系统内部调用）",
      "手动记录（自定义日志）",
      "日志记录最佳实践",
      "完整示例：带日志的属性修改脚本",
      "故障排查",
      "日志文件未生成",
      "日志输出乱码",
      "未记录 SSProcess 内部错误",
      "下一步学习"
    ],
    "content": "日志记录是脚本开发中不可或缺的调试和监控手段，它能帮助您跟踪脚本执行过程、记录错误信息、排查问题根源。本页面将指导您为 SunvStation 脚本配置一个功能完善的日志记录器，让您的脚本具备专业级的日志管理能力。\n\n## 日志系统架构概览\n\nSunvStation 的日志功能通过 **LogMixin** 混入类实现，这是 SSProcessManager 继承体系中的基础模块之一。日志系统采用**依赖注入**设计模式，允许您将自定义配置的日志记录器注入到 SSProcess 中，从而灵活控制日志的输出方式、格式和级别。\n\n```mermaid\nclassDiagram\n    class Logger {\n        <<Python标准库>>\n        +debug(msg)\n        +info(msg)\n        +warning(msg)\n        +error(msg)\n        +critical(msg)\n    }\n    \n    class LogAware {\n        <<抽象基类>>\n        +set_logger(Logger)*\n        +log_error_msg(str)*\n    }\n    \n    class LogMixin {\n        +Logger logger\n        +set_logger(Logger)\n        +log_error_msg(str)\n    }\n    \n    class SSProcessManager {\n        +Logger logger\n        +set_logger(Logger)\n        +log_error_msg(str)\n    }\n    \n    LogAware <|-- LogMixin\n    LogMixin <|-- SSProcessManager\n    SSProcessManager ..> Logger : 使用\n```\n\n这个架构设计的核心优势在于**关注点分离**：SSProcessManager 只负责调用日志接口，而日志的具体配置（输出到文件、控制台或远程服务器）完全由您控制，不会影响业务逻辑代码。\n\n\n\n## 配置日志记录器流程\n\n配置日志记录器的过程分为四个关键步骤，下图清晰地展示了从创建到使用的完整流程：\n\n```mermaid\nflowchart TD\n    A[开始配置日志] --> B[创建Logger实例]\n    B --> C[配置Handler处理器]\n    C --> D[设置Formatter格式化器]\n    D --> E[配置日志级别]\n    E --> F[注入到SSProcess]\n    F --> G[开始使用日志功能]\n    \n    C --> C1[文件处理器<br>FileHandler]\n    C --> C2[控制台处理器<br>StreamHandler]\n    C --> C3[综合配置<br>多处理器]\n    \n    E --> E1[DEBUG]\n    E --> E2[INFO]\n    E --> E3[WARNING]\n    E --> E4[ERROR]\n    \n    G --> G1[自动记录错误]\n    G --> G2[手动记录日志]\n    \n    style F fill:#e1f5ff\n    style G fill:#fff4e1\n```\n\n理解这个流程后，我们将逐步详细解析每个环节的具体实现方法。\n\n\n\n## 步骤一：创建 Logger 实例\n\n首先需要创建一个 Python 标准库的 Logger 实例。建议使用脚本文件名作为 Logger 的名称，这样可以在日志输出中清晰地识别日志来源。\n\n```python\nimport logging\n\n# 创建 Logger 实例，使用脚本文件名作为标识符\nlogger = logging.getLogger('my_script')\nlogger.setLevel(logging.DEBUG)  # 设置最低日志级别\n```\n\n### 日志级别说明\n\nPython logging 模块提供了五个标准日志级别，按严重程度从低到高排列：\n\n| 级别 | 数值 | 说明 | 使用场景 |\n|-----|------|------|---------|\n| DEBUG | 10 | 调试信息 | 详细的程序运行细节，仅在开发和调试时使用 |\n| INFO | 20 | 一般信息 | 程序正常运行的关键步骤确认 |\n| WARNING | 30 | 警告"
  },
  {
    "slug": "38-jin-du-tiao-shi-yong-zhi-nan",
    "title": "进度条使用指南",
    "section": "高级功能",
    "headings": [
      "进度条系统架构概览",
      "核心组件说明",
      "进度条使用基本流程",
      "步骤一：启动进度条",
      "基本用法",
      "方法参数说明",
      "实现原理",
      "步骤二：更新进度条",
      "基本用法",
      "方法参数说明",
      "智能步进机制",
      "更新频率对比",
      "步骤三：关闭进度条",
      "基本用法",
      "方法行为",
      "关闭时机的重要性",
      "最佳实践：使用 finally 确保关闭",
      "完整示例：批量导出数据",
      "代码实现",
      "代码解析",
      "禁用进度条",
      "基本用法",
      "方法行为",
      "使用场景对比",
      "条件禁用示例",
      "进度条与日志配合使用",
      "配合模式",
      "完整示例",
      "日志级别与进度条的配合策略",
      "常见问题与解决方案",
      "问题一：进度条不显示",
      "问题二：进度条卡住不动",
      "问题三：进度条关闭后程序无响应",
      "最佳实践总结",
      "1. 进度条使用检查清单",
      "2. 性能优化建议",
      "3. 代码模板",
      "下一步学习"
    ],
    "content": "进度条是向用户反馈长时间操作进度的关键交互组件，它能让用户清晰了解任务的执行状态，提升用户体验。本指南将系统讲解如何在 SunvStation 脚本中高效使用进度条功能，涵盖基础用法、高级技巧和最佳实践。\n\n在学习本页内容后，建议按照以下路径继续深入：\n- [配置日志记录器](37-pei-zhi-ri-zhi-ji-lu-qi) — 了解日志记录的配置方法，与进度条配合使用\n- [错误处理与异常管理](39-cuo-wu-chu-li-yu-yi-chang-guan-li) — 掌握进度条操作中的错误处理\n- [批量保存到数据库](24-pi-liang-bao-cun-dao-shu-ju-ku) — 查看进度条在实际批量操作中的应用\n\n## 进度条系统架构概览\n\nSunvStation 的进度条功能采用**分层架构设计**，通过 `ProgressMixin` 混入类与 SSProcessManager 集成，结合底层 C++ 封装的 `Progress` 类和进度条控制函数，形成完整的三层架构体系。\n\n```mermaid\nclassDiagram\n    class ProgressAware {\n        <<抽象基类>>\n        +disable_progress()*\n        +startProgress(title, total)*\n        +stepProgress(message)*\n        +closeProgress()*\n    }\n    \n    class ProgressMixin {\n        +enable_progress: bool\n        +progress: Progress\n        +disable_progress()\n        +startProgress(title, total)\n        +stepProgress(message)\n        +closeProgress()\n    }\n    \n    class SSProcessManager {\n        +enable_progress: bool\n        +progress: Progress\n        +startProgress(title, total)\n        +stepProgress(message)\n        +closeProgress()\n    }\n    \n    class Progress {\n        <<C++封装类>>\n        +setSize(nSize)\n        +step() boolean\n        +getPos() int\n        +getStep() int\n    }\n    \n    class GlobalFunctions {\n        <<函数模块>>\n        +startProgress(title, barCount)\n        +closeProgress()\n        +setProgressRange(min, max)\n        +stepProgress(pos, title)\n    }\n    \n    ProgressAware <|-- ProgressMixin\n    ProgressMixin <|-- SSProcessManager\n    ProgressMixin ..> Progress : 使用\n    ProgressMixin ..> GlobalFunctions : 调用\n```\n\n这种架构设计的核心优势在于**关注点分离**：`ProgressMixin` 负责进度条的业务逻辑封装，底层函数处理进度条的创建和更新，而 `Progress` 类则提供了防抖动的智能步进机制，避免频繁更新导致的性能问题。\n\n\n\n### 核心组件说明\n\n| 组件 | 类型 | 职责描述 |\n|------|------|----------|\n| `ProgressMixin` | Mixin 类 | 提供进度条的封装方法，管理 `enable_progress` 开关 |\n| `Progress` | C++ 封装类 | 智能步进控制器，将循环总数映射到 0-100 的进度范围 |\n| `enable_progress` | bool 属性 | 控制进度条是否显示的全局开关 |\n| `progress` | Progress 实例 | 当前进度条控制器实例 |\n| `startProgress()` | 全局函数 | 创建并显示进度条对话框 |"
  },
  {
    "slug": "39-cuo-wu-chu-li-yu-yi-chang-guan-li",
    "title": "错误处理与异常管理",
    "section": "高级功能",
    "headings": [
      "错误处理架构概览",
      "错误处理机制层次",
      "第一层：参数验证与空值检查",
      "第二层：类型转换异常捕获",
      "第三层：业务操作错误处理",
      "第四层：静默异常处理",
      "错误日志记录机制",
      "日志记录接口",
      "日志配置流程",
      "日志级别选择指南",
      "常见错误场景与处理策略",
      "场景一：数据源和数据集访问错误",
      "场景二：属性类型转换错误",
      "场景三：索引越界与空对象访问",
      "场景四：资源清理错误",
      "错误处理最佳实践",
      "实践一：前置条件检查",
      "实践二：精确的异常捕获",
      "实践三：错误恢复与回滚",
      "实践四：日志与用户反馈结合",
      "实践五：错误码与状态管理",
      "错误调试与问题排查",
      "错误调试流程",
      "常见错误排查清单",
      "调试辅助代码",
      "错误处理与相关功能的集成",
      "错误处理与进度条管理",
      "错误处理与对象缓存机制",
      "错误处理与选择集管理",
      "下一步学习建议"
    ],
    "content": "错误处理与异常管理是构建健壮 SunvStation 脚本的核心能力。通过系统化的错误处理机制，您的脚本能够优雅地处理异常情况、记录关键错误信息、确保数据完整性，并在用户界面中提供清晰的反馈。本页面将深入解析 sunvpy 库的错误处理架构、实用模式和最佳实践。\n\n## 错误处理架构概览\n\nsunvpy 库采用分层设计，通过 **LogMixin** 混入类提供统一的错误记录能力，结合多种防御性编程模式形成完整的错误处理体系。这种架构将错误记录、异常捕获和状态验证分离到不同层次，确保代码的可维护性和扩展性。\n\n```mermaid\nclassDiagram\n    class Logger {\n        <<Python标准库>>\n        +debug(msg)\n        +info(msg)\n        +warning(msg)\n        +error(msg)\n        +critical(msg)\n    }\n    \n    class LogAware {\n        <<抽象基类>>\n        +set_logger(Logger)*\n        +log_error_msg(str)*\n    }\n    \n    class LogMixin {\n        +Logger logger\n        +set_logger(Logger)\n        +log_error_msg(str)\n    }\n    \n    class SSProcessManager {\n        +Logger logger\n        +log_error_msg(str)\n    }\n    \n    class ErrorPatterns {\n        <<错误处理模式>>\n        +null_check_return\n        +type_conversion_try\n        +silent_exception_pass\n        +early_return_validation\n    }\n    \n    LogAware <|-- LogMixin\n    LogMixin <|-- SSProcessManager\n    SSProcessManager ..> Logger : 使用\n    SSProcessManager ..> ErrorPatterns : 应用\n```\n\n这种架构设计的核心优势在于**关注点分离**：业务逻辑代码通过统一的 `log_error_msg()` 接口记录错误，而日志的具体输出配置由您完全掌控。错误处理模式则分布在各个 Mixin 类中，针对不同场景提供灵活的应对策略。\n\n\n\n## 错误处理机制层次\n\nsunvpy 的错误处理分为四个层次，每个层次应对不同类型的错误场景。理解这个层次结构对于编写健壮的脚本至关重要。\n\n```mermaid\nflowchart LR\n    A[错误输入] --> B[第一层：参数验证<br/>空值检查/范围检查]\n    B --> C{是否通过?}\n    C -->|否| D[返回默认值/空值<br/>记录警告日志]\n    C -->|是| E[第二层：类型转换<br/>try-except 捕获]\n    E --> F{转换成功?}\n    F -->|否| G[使用容错值/返回 False<br/>记录错误日志]\n    F -->|是| H[第三层：业务操作<br/>空指针检查]\n    H --> I{操作成功?}\n    I -->|否| J[返回空结果/失败标志<br/>记录错误日志]\n    I -->|是| K[第四层：资源清理<br/>try-finally 确保]\n    K --> L[正常返回结果]\n    \n    style D fill:#fff4e1\n    style G fill:#ffe1e1\n    style J fill:#ffe1e1\n    style L fill:#e1ffe1\n```\n\n### 第一层：参数验证与空值检查\n\n这是错误处理的第一道防线，通过前置条件检查防止无效输入进入核心逻辑。sunvpy 广泛使用**边界检查**和**空值检查**模式。\n\n**空值检查返回默认值模式：**\n\n```python\ndef getSysSelGeoList(self):\n    \"\"\"获取当前选中的几何对象列表。\"\"\"\n    map = self.getCurrentMap()\n    if map is None:\n        return None  # 空值检查，返"
  },
  {
    "slug": "40-ssprocessmanager-wan-zheng-api",
    "title": "SSProcessManager 完整 API",
    "section": "参考手册",
    "headings": [
      "核心架构设计",
      "类继承结构",
      "模块职责划分",
      "选择集操作 API",
      "基础选择集管理",
      "条件设置与过滤",
      "选择集查询",
      "属性读写",
      "坐标操作",
      "选择集同步",
      "地理对象编辑 API",
      "对象创建",
      "新建对象操作",
      "缓存与持久化",
      "对象重置",
      "对象打散",
      "辅助计算",
      "项目与工作空间 API",
      "工作空间与地图",
      "系统路径管理",
      "图层管理",
      "地图帧操作",
      "系统表管理",
      "进度与日志 API",
      "进度条管理",
      "日志记录",
      "完整 API 参考表",
      "实例化与使用",
      "相关文档"
    ],
    "content": "SSProcessManager 是 SunvStation 地理信息系统中的核心进程管理类，提供了对工作空间、地图、几何对象选择与编辑的完整操作能力。该类通过 Mixin 设计模式将功能模块化，为高级开发者提供了灵活且强大的地理数据处理接口。本文档将系统性地介绍 SSProcessManager 的完整 API 接口、架构设计以及使用方法。\n\n## 核心架构设计\n\nSSProcessManager 采用多重继承的 Mixin 设计模式，将复杂的功能拆分为五个独立的模块，每个模块负责特定的领域功能。这种设计使得代码具有高度的可维护性和扩展性，同时保持了良好的关注点分离原则。\n\n### 类继承结构\n\n```mermaid\nclassDiagram\n    class SSProcessManager {\n        +workspace: WorkSpace\n        +map: ScaleMap\n        +selGeoList: GeoBaseList\n        +selNoteList: GeoBaseList\n        +bufferObjList: GeoBaseList\n        +curNewObj: tuple\n        +logger: Logger\n        +progress: Progress\n        -__init__()\n    }\n    \n    class SelectionMixin {\n        +clearSelection()\n        +clearSelectCondition()\n        +setSelectCondition()\n        +selectFilter()\n        +getSelGeoCount()\n        +getSelGeoValue()\n        +setSelGeoValue()\n        +updateSysSelection()\n    }\n    \n    class GeoEditMixin {\n        +createDefaultGeoBase()\n        +createNewObjByCode()\n        +createNewObjByClass()\n        +setNewObjValue()\n        +addNewObjPoint()\n        +saveBufferObjToDatabase()\n        +explodeGeoObject()\n    }\n    \n    class ProjectMixin {\n        +getWorkspace()\n        +getCurrentMap()\n        +getSysPathName()\n        +getLayerCount()\n        +setLayerStatus()\n        +pushUndoMark()\n    }\n    \n    class LogMixin {\n        +set_logger()\n        +log_error_msg()\n    }\n    \n    class ProgressMixin {\n        +disable_progress()\n        +startProgress()\n        +stepProgress()\n        +closeProgress()\n    }\n    \n    SSProcessManager --> SelectionMixin\n    SSProcessManager --> GeoEditMixin\n    SSProcessManager --> ProjectMixin\n    SSProcessManager --> LogMixin\n    SSProcessManager --> ProgressMixin\n```\n\n### 模块职责划分\n\n**SelectionMixin** - 负责选择集管理，提供条件过滤、属性读写和系统选择集同步功能\n**GeoEditMixin** - 负责地理对象编辑，包括对象创建、属性设置、缓存管理和打散操作\n**ProjectMixin** - 负责项目和工作空间管理，包括图层控制、路径管理和地图帧操作\n**LogMixin** - 负责日志记录，提供统一的错误日志接口\n**ProgressMixin** - 负责进度条管理，提供可视化进度反馈\n\n\n\n## 选择集操作 API\n\n选择集操作是 SSProcessManager 的核心功"
  },
  {
    "slug": "41-objbaseattr-shu-xing-suo-yin",
    "title": "ObjBaseAttr 属性索引",
    "section": "参考手册",
    "headings": [
      "属性分类体系",
      "属性分类概览",
      "点属性索引",
      "地物通用属性索引",
      "几何参量属性索引",
      "注记属性索引",
      "操作属性索引",
      "核心方法参考",
      "属性索引管理",
      "属性值读写",
      "属性索引值映射表",
      "使用场景与最佳实践",
      "基础属性访问",
      "坐标点操作",
      "扩展属性管理",
      "注记对象样式控制",
      "与其他模块的交互",
      "参考文档延伸"
    ],
    "content": "ObjBaseAttr 类是 SunvStation 系统中地物对象属性管理的核心组件，提供统一的属性名称注册、索引映射和属性值读写接口。该类通过集中管理所有地物属性的名称与索引映射关系，实现了属性访问的标准化和高效化，支持点、线、面、注记等多种地物类型的属性操作。\n\n\n\n## 属性分类体系\n\nObjBaseAttr 将地物属性划分为五大类别，每类属性对应不同的功能维度和数据类型。这种分类设计既体现了属性的业务语义，也便于开发者快速定位所需属性。\n\n### 属性分类概览\n\n```mermaid\ngraph TB\n    A[ObjBaseAttr 属性体系] --> B[点属性]\n    A --> C[地物通用属性]\n    A --> D[几何参量属性]\n    A --> E[注记属性]\n    A --> F[操作属性]\n    \n    B --> B1[SSObj_PointName<br/>坐标点名称]\n    B --> B2[SSObj_PointCount<br/>坐标点数量]\n    B --> B3[SSObj_PointType<br/>坐标点类型]\n    B --> B4[SSObj_X/Y/Z<br/>坐标值]\n    \n    C --> C1[标识属性<br/>ID, Code, Name]\n    C --> C2[图形属性<br/>Color, LineType, LineWidth]\n    C --> C3[变换属性<br/>Angle, ScaleX, ScaleY]\n    C --> C4[时间属性<br/>CreateTime, ModifyTime]\n    \n    D --> D1[面积属性<br/>Area, EllipsoidArea]\n    D --> D2[长度属性<br/>Length, 3DLength]\n    D --> D3[边界属性<br/>minX, minY, maxX, maxY]\n    \n    E --> E1[字体属性<br/>FontWidth, FontHeight, FontName]\n    E --> E2[文本属性<br/>FontString, FontStringCount]\n    E --> E3[样式属性<br/>Alignment, FontWeight, ItalicAngle]\n    \n    F --> F1[SSObj_Reverse<br/>方向反转]\n    F --> F2[SSObj_Reference<br/>引用关系]\n```\n\n### 点属性索引\n\n点属性用于描述地物对象的坐标点信息，是构成线、面等复杂几何形状的基础元素。此类属性支持通过参数索引访问特定位置的坐标点。\n\n\n\n| 属性常量 | 属性名 | 数据类型 | 说明 | 参数支持 |\n|---------|--------|---------|------|---------|\n| `pointName` | SSObj_PointName | string | 坐标点名称 | (n) - 第n个点 |\n| `pointCount` | SSObj_PointCount | int | 坐标点数量 | 无 |\n| `pointType` | SSObj_PointType | int | 坐标点类型 | (n) - 第n个点 |\n| `x` | SSObj_X | double | X坐标值 | (n) - 第n个点 |\n| `y` | SSObj_Y | double | Y坐标值 | (n) - 第n个点 |\n| `z` | SSObj_Z | double | Z坐标值 | (n) - 第n个点 |\n\n**参数说明**：括号内的数字表示坐标点索引（从0开始）。例如 `SSObj_X(0)` 获取第一个点的X坐标。\n\n### 地物通用属性索引\n\n通用属性适用于所有地物类型，涵盖了对象标识、图形表现、变换参数和元数据等核心信息。\n\n\n\n| 属性常量 | 属性名 | 数据类型 | 说明 | 可读写 |\n|---------|--------|---------|------|-------|\n| **标识属性** |||||\n| `id` | SSObj_ID | int | 对象唯一标识 | 只读 |\n| `groupID` | SSObj_GroupID | int | 分组标识 | 可写 |\n| `code` | SSObj_Code | int | 地物编码 | 只读 |\n| `byname` | SSObj_Byname | string | 地物别名 | 可写 |\n| `name` | SSObj_Name | str"
  },
  {
    "slug": "42-di-li-dui-xiang-lei-xing-ding-yi",
    "title": "地理对象类型定义",
    "section": "参考手册",
    "headings": [
      "地理对象类型体系",
      "四种基础类型",
      "类型标识的作用",
      "类继承架构",
      "继承层次结构",
      "GeoBase 基类",
      "派生类特性",
      "GeoObject 容器对象",
      "容器与几何对象的分离设计",
      "GeoObject 核心功能",
      "类型识别与转换机制",
      "getObjectType() 类型识别方法",
      "类型转换函数",
      "类型转换的工作原理",
      "地理对象列表类型",
      "列表类型体系",
      "列表通用方法",
      "类型转换列表",
      "属性系统与地物基本属性",
      "ObjBaseAttr 类结构",
      "属性分类体系",
      "属性索引机制",
      "对象类型与属性的关系",
      "通用属性 vs 特定类型属性",
      "属性有效性判断",
      "总结与最佳实践",
      "核心概念回顾",
      "类型识别与处理最佳实践",
      "属性访问最佳实践",
      "创建对象时的类型选择",
      "后续学习建议"
    ],
    "content": "地理对象类型定义是 SunvStation 系统中地理数据模型的核心组成部分。系统采用面向对象的设计模式，通过类继承体系和类型标识来管理不同形态的地理要素。理解这些类型定义及其相互关系，是进行地理数据处理、空间分析和可视化的基础。\n\n本页面将系统性地介绍地理对象的类型体系、类结构、属性机制以及相关的类型识别和转换方法。建议在学习本页面之前，先了解 [SunvStation 系统架构](6-sunvstation-xi-tong-jia-gou) 和 [C++ 扩展模块与 Python 接口](10-c-kuo-zhan-mo-kuai-yu-python-jie-kou)。完成本页面学习后，可以继续学习 [创建默认地物对象](19-chuang-jian-mo-ren-di-wu-dui-xiang) 和 [地物基本属性详解](17-di-wu-ji-ben-shu-xing-xiang-jie)。\n\n\n\n## 地理对象类型体系\n\nSunvStation 系统定义了四种基础地理对象类型，每种类型对应不同的几何形态和应用场景。这些类型通过整数标识符进行区分，并与特定的几何类相对应。类型体系的设计遵循简单、明确、可扩展的原则，为地理数据的存储、查询和展示提供了统一的抽象层次。\n\n### 四种基础类型\n\n| 类型标识 | 类型名称 | 几何类 | 典型应用场景 | 几何特征 |\n|---------|---------|--------|------------|---------|\n| 0 | 点对象 | PointObject | 控制点、界碑、建筑物中心点、测量点 | 零维几何，由单个坐标点定义 |\n| 1 | 线对象 | LineObject | 道路、管线、河流中心线、边界线 | 一维几何，由有序坐标点序列定义 |\n| 2 | 面对象 | AreaObject | 建筑物轮廓、湖泊、行政区划、地块 | 二维几何，由闭合坐标环定义 |\n| 3 | 注记对象 | MarkNote | 文字标注、地名说明、图例说明 | 特殊对象，结合文本与定位点 |\n\n### 类型标识的作用\n\n类型标识是系统内部识别对象类型的核心机制，其作用体现在以下几个方面：\n\n- **对象创建**：`createDefaultGeoBase(obj_type, dataset)` 方法通过类型标识决定创建具体的几何对象实例\n- **类型判断**：`getObjectType()` 方法返回当前对象的类型标识，用于运行时类型识别\n- **数据查询**：查询条件中可以通过类型标识过滤特定类型的地理对象\n- **符号化渲染**：系统根据对象类型应用不同的符号化规则和渲染策略\n\n\n\n## 类继承架构\n\n地理对象类型体系基于面向对象的继承架构设计，通过基类和派生类的层次结构实现代码复用和多态性。理解这个架构有助于掌握各类地理对象的共性和特性，以及如何正确使用它们提供的方法和属性。\n\n### 继承层次结构\n\n```mermaid\nclassDiagram\n    GeoBase <|-- PointObject\n    GeoBase <|-- LineObject\n    GeoBase <|-- AreaObject\n    GeoBase <|-- MarkNote\n    \n    class GeoBase {\n        <<抽象基类>>\n        +getId() int\n        +setId(id)\n        +getCode() int\n        +setCode(code)\n        +getColor() int\n        +setColor(color)\n        +getObjectType() int\n        +getArea(haveSign) float\n        +getPerimeter() float\n        +setStatus(flag, status)\n        +getStatus(status) bool\n    }\n    \n    class PointObject {\n        +getObjectType() int\n        +getScaleX/Y/Z() float\n        +setScaleX/Y/Z(scale)\n        +rotate(point, vct)\n    }\n    \n    class LineObject {\n        +getObjectType() int\n        +getPerimeter() float\n        +getArea(haveSign) fl"
  },
  {
    "slug": "43-shu-xue-ji-suan-gong-ju",
    "title": "数学计算工具",
    "section": "参考手册",
    "headings": [
      "模块架构概览",
      "基础数据结构",
      "Point3D - 三维点类",
      "Vec3d - 三维向量类",
      "容器类",
      "坐标系统转换",
      "角度格式转换",
      "极坐标与直角坐标转换",
      "距离与长度计算",
      "点与点距离",
      "点到线距离",
      "线段长度",
      "高级距离查询",
      "面积计算",
      "多边形面积",
      "三角形面积",
      "角度与方位角计算",
      "方位角计算",
      "夹角计算",
      "方向计算",
      "几何变换操作",
      "二维/三维变换",
      "系统坐标旋转",
      "几何关系判断",
      "点与点关系",
      "点与线关系",
      "点与多边形关系",
      "线与线关系",
      "多边形与多边形关系",
      "其他几何关系",
      "弧线与圆操作",
      "弧长计算",
      "弧线属性判断",
      "弧线中点",
      "弧线打断与插入",
      "极坐标弧生成",
      "点与线操作",
      "点插入与延伸",
      "点修剪与去重",
      "线段打断",
      "中点与垂足",
      "高程插值",
      "高级几何操作",
      "平行线生成",
      "曲线生成",
      "椭圆操作",
      "线型重建",
      "矩形与边界操作",
      "点集排序",
      "辅助计算工具",
      "数值精度处理",
      "法向量计算",
      "线段交点",
      "三角形计算",
      "多边形焦点",
      "常用常量",
      "应用示例",
      "基础距离与面积计算",
      "坐标转换与角度计算",
      "几何变换操作",
      "空间关系判断",
      "点线操作",
      "API 快速索引表",
      "按功能分类",
      "性能优化建议",
      "进阶主题",
      "复杂多边形处理",
      "弧线重建与识别",
      "高级几何变换",
      "相关文档"
    ],
    "content": "PySSMath 模块提供了丰富的数学计算功能，专为 GIS 和测绘应用设计。该模块通过 SWIG 封装底层 C++ 实现，提供高性能的几何计算、坐标转换、空间关系判断等核心算法库。本文档面向高级开发者，详细说明各类数学计算工具的 API 接口与应用场景。\n\n\n\n## 模块架构概览\n\nPySSMath 模块采用分层架构设计，将数学计算功能划分为多个功能域。底层通过 `_PySSMath.pyd` C++ 扩展模块实现高效计算，上层 Python 接口提供类型安全的函数调用。\n\n```mermaid\ngraph TB\n    A[PySSMath 模块] --> B[坐标系统转换]\n    A --> C[距离与长度计算]\n    A --> D[面积计算]\n    A --> E[角度与方位角]\n    A --> F[几何变换]\n    A --> G[空间关系判断]\n    A --> H[弧线与圆操作]\n    A --> I[点与线操作]\n    \n    B --> B1[deg/radian/dms转换]\n    C --> C1[点距离/线长度]\n    D --> D1[多边形面积/三角形面积]\n    E --> E1[方位角/夹角/方向]\n    F --> F1[旋转/偏移/缩放/镜像]\n    G --> G1[相交/包含/共线]\n    H --> H1[弧长/中点/打断]\n    I --> I1[插入/延伸/修剪]\n    \n    A --> J[基础数据结构]\n    J --> J1[Point3D]\n    J --> J2[Vec3d]\n    J --> J3[POINT3DLIST]\n    J --> J4[LINE3DLIST]\n```\n\n\n\n## 基础数据结构\n\n### Point3D - 三维点类\n\nPoint3D 是模块的核心数据结构，表示三维空间中的点，支持 x、y、z 坐标访问和丰富的运算符重载。\n\n**构造方法**：\n- `Point3D()` - 默认构造函数\n- `Point3D(x, y, z)` - 使用坐标构造\n- `Point3D(other)` - 拷贝构造\n\n**核心属性与方法**：\n- `x()`, `y()`, `z()` - 获取坐标分量\n- `set(x_arg, y_arg, z_arg)` - 设置坐标\n- `__getitem__(i)` / `__setitem__(i, value)` - 索引访问坐标（0=x, 1=y, 2=z）\n- `__add__`, `__sub__`, `__neg__` - 向量运算\n- `epsilonEqual(other, epsilon)` - 带容差的相等判断\n- `getName()`, `setName(name)` - 点名称管理\n\n\n\n### Vec3d - 三维向量类\n\nVec3d 提供完整的向量运算功能，包括点积、叉积、缩放等操作。\n\n**构造方法**：\n- `Vec3d()` - 默认构造\n- `Vec3d(x, y, z)` - 使用分量构造\n- `Vec3d(other)` - 拷贝构造\n\n**核心方法**：\n- `dot(rhs)` - 点积运算\n- `cross(rhs)` - 叉积运算\n- `__mul__`, `__truediv__` - 标量乘除\n- `set(x_arg, y_arg, z_arg)` - 设置分量\n- `epsilonEqual(other, epsilon)` - 带容差的相等判断\n\n\n\n### 容器类\n\n模块提供多种容器类用于管理点的集合：\n- `POINT3DLIST` - 点列表容器\n- `LINE3DLIST` - 线列表容器\n- `LOOP3DLIST` - 环列表容器（支持带岛复杂面）\n- `StringArray` - 字符串数组容器\n\n这些容器均支持迭代器模式，提供 `size()`, `empty()`, `clear()`, `push_back()` 等标准容器操作。\n\n\n\n## 坐标系统转换\n\n### 角度格式转换\n\nPySSMath 提供多种角度表示形式之间的转换功能，支持弧度制、十进制度数、度分秒（DMS）格式互转。\n\n| 函数名 | 功能描述 | 参数 | 返回值 |\n|--------|----------|------|--------|\n| `degToRadian(deg)` | 十进制度数转弧度 | deg: float | 弧度值 |\n| `radianToDeg(dRadian)` | 弧度转十进制度数 | dRadian: float | 度数值 |\n| `degToDms(deg)` | 十进制度"
  },
  {
    "slug": "44-zuo-biao-zhuan-huan-gong-ju",
    "title": "坐标转换工具",
    "section": "参考手册",
    "headings": [
      "角度格式转换",
      "基础角度转换",
      "角度调整函数",
      "角度转换示例",
      "极坐标与直角坐标转换",
      "坐标转换函数",
      "极坐标转换示例",
      "方位角计算",
      "方位角计算函数",
      "角度计算函数",
      "方位角计算示例",
      "几何变换操作",
      "二维几何变换",
      "三维几何变换",
      "系统坐标变换",
      "几何变换示例",
      "坐标转换应用场景",
      "测绘坐标转换",
      "GIS 坐标变换",
      "工程应用变换",
      "最佳实践与注意事项",
      "角度单位处理",
      "坐标变换顺序",
      "精度控制",
      "相关页面"
    ],
    "content": "坐标转换工具为 GIS 和测绘应用提供了一套完整的坐标系统转换功能，涵盖角度格式转换、坐标系统转换、几何变换等核心能力。本模块通过 PySSMath 提供高性能的坐标转换算法，支持从基础的角度格式互转到复杂的坐标系统映射变换。本文档面向高级开发者，详细说明各类坐标转换工具的 API 使用方法和应用场景。\n\n\n\n## 角度格式转换\n\nPySSMath 提供了多种角度表示形式之间的转换功能，支持弧度制、十进制度数、度分秒（DMS）格式之间的灵活互转，满足测绘应用中不同角度表示需求。\n\n### 基础角度转换\n\n| 函数名 | 功能描述 | 参数 | 返回值 |\n|--------|----------|------|--------|\n| `degToRadian(deg)` | 十进制度数转弧度 | deg: float | 弧度值 |\n| `radianToDeg(dRadian)` | 弧度转十进制度数 | dRadian: float | 度数值 |\n| `degToDms(deg)` | 十进制度数转度分秒 | deg: float | DMS 值 |\n| `dmsToDeg(dms)` | 度分秒转十进制度数 | dms: float | 度数值 |\n| `dmsToRadian(dDms)` | 度分秒转弧度 | dDms: float | 弧度值 |\n| `radianToDms(dRadian)` | 弧度转度分秒 | dRadian: float | DMS 值 |\n| `dmsToSec(dms)` | 度分秒转秒数 | dms: float | 秒数 |\n| `secToDms(sec)` | 秒数转度分秒 | sec: float | DMS 值 |\n\n### 角度调整函数\n\n| 函数名 | 功能描述 | 参数说明 |\n|--------|----------|----------|\n| `adjustAngle(dRadian)` | 调整弧度值到 [-π, π] 范围 | dRadian: 待调整的弧度值 |\n| `adjustDmsAngle(dAngle)` | 调整 DMS 角度值 | dAngle: 待调整的 DMS 角度值 |\n| `adjustDegAngle(dAngle)` | 调整度数值到 [0, 360] 范围 | dAngle: 待调整的度数值 |\n\n### 角度转换示例\n\n```python\nimport sunvpy.PySSMath as ssMath\n\n# 十进制度数转弧度\ndeg_value = 45.5\nrad_value = ssMath.degToRadian(deg_value)\nprint(f\"{deg_value}° = {rad_value:.6f} rad\")\n\n# 弧度转度分秒\ndms_value = ssMath.radianToDms(1.5708)\nprint(f\"1.5708 rad = {dms_value:.4f} (DMS格式)\")\n\n# 角度调整到标准范围\nadjusted_angle = ssMath.adjustAngle(7.0)  # 超出范围的角度\nprint(f\"调整后角度: {adjusted_angle:.6f} rad\")\n```\n\n\n\n## 极坐标与直角坐标转换\n\n极坐标和直角坐标是两种常用的坐标表示方式，适用于不同的应用场景。PySSMath 提供了两者之间的双向转换功能。\n\n### 坐标转换函数\n\n| 函数名 | 功能描述 | 参数说明 |\n|--------|----------|----------|\n| `rightToPolar(x, y)` | 直角坐标转极坐标 | x, y: 直角坐标值，返回 (距离, 方位角) |\n| `polarToRight(r, angle)` | 极坐标转直角坐标 | r: 距离；angle: 方位角（弧度） |\n| `getPolar(p1, p2, dist, dRadian)` | 从基点按距离和方位角获取点 | p1: 基点；p2: 参考点；dist: 距离；dRadian: 方位角 |\n| `getPoint(p1, p2, dist, dRadian)` | 同 getPolar | 参数同 getPolar |\n\n### 极坐标转换示例\n\n```python\nimport sunvpy.PySSMath as ssMath\n\n# 直角坐标转极坐标\nx, y = 100.0, 100.0\ndistance, angle = ssMath.rightToPolar(x, y)\nprint(f\"直角坐标 ({x}, {y}) -> 极坐标: 距离={distance:"
  },
  {
    "slug": "45-shu-ju-ku-geng-xin-jie-kou",
    "title": "数据库更新接口",
    "section": "参考手册",
    "headings": [
      "架构概览",
      "SSDbScript 核心接口",
      "连接与认证管理",
      "数据下载接口",
      "数据上传接口",
      "地物操作接口",
      "表记录管理接口",
      "数据库同步接口",
      "备份与恢复接口",
      "高级操作接口",
      "Database 底层数据库接口",
      "连接与事务管理",
      "几何对象存取",
      "对象保存与删除",
      "状态与时间管理",
      "GeoEditMixin 高级编辑接口",
      "对象创建与缓存流程",
      "MemoData 与扩展属性转换",
      "删除缓存管理",
      "数据结构容器",
      "StringArray 字符串数组",
      "AttrList 属性列表",
      "FeatureList 地物列表",
      "完整工作流示例",
      "错误处理与日志",
      "日志信息获取",
      "常见错误处理",
      "性能优化建议",
      "批量操作优先",
      "合理使用事务",
      "使用增量下载",
      "限制查询范围",
      "使用对象缓存",
      "相关接口与扩展",
      "与数据交换的集成",
      "与地理对象编辑的集成",
      "下一步学习"
    ],
    "content": "数据库更新接口是 SunvStation GIS 系统中用于管理和执行数据库操作的核心组件，提供了从底层 SQL 执行到高级对象同步的完整功能层次。该接口采用 SWIG 封装技术将 C++ 核心功能暴露给 Python，实现了高性能的数据库操作与 Python 脚本的无缝集成。\n\n## 架构概览\n\n数据库更新接口采用分层架构设计，从底层的直接数据库操作到上层的业务对象管理，提供了不同抽象级别的接口以满足不同场景的需求。\n\n```mermaid\ngraph TB\n    subgraph \"应用层\"\n        GeoEditMixin[GeoEditMixin<br/>地理编辑混合类]\n        SSProcess[SSProcessManager<br/>流程管理器]\n    end\n    \n    subgraph \"业务逻辑层\"\n        SSDbScript[SSDbScript<br/>GIS数据库脚本接口]\n        DataXScript[DataXScript<br/>数据交换接口]\n    end\n    \n    subgraph \"数据访问层\"\n        Database[Database<br/>数据库抽象接口]\n        StringArray[StringArray<br/>字符串数组容器]\n        AttrList[AttrList<br/>属性列表]\n        FeatureList[FeatureList<br/>地物列表]\n    end\n    \n    subgraph \"C++核心层\"\n        _PySSGisDBUpdate[_PySSGisDBUpdate<br/>C++GIS数据库模块]\n        _PySSDatabase[_PySSDatabase<br/>C++数据库模块]\n        _PySSDataX[_PySSDataX<br/>C++数据交换模块]\n    end\n    \n    GeoEditMixin --> SSDbScript\n    SSProcess --> GeoEditMixin\n    SSDbScript --> _PySSGisDBUpdate\n    DataXScript --> _PySSDataX\n    Database --> _PySSDatabase\n    SSDbScript --> Database\n    Database --> StringArray\n    Database --> AttrList\n    Database --> FeatureList\n```\n\n**核心设计原则**：该架构通过多层抽象，实现了从底层 SQL 执行到高级对象操作的完整覆盖，同时保持了各层之间的清晰边界。SWIG 封装机制确保了 Python 接口与 C++ 实现的透明交互，[7-swig-feng-zhuang-ji-zhi-shuo-ming](7-swig-feng-zhuang-ji-zhi-shuo-ming) 详细解释了这一机制的实现原理。\n\n\n\n## SSDbScript 核心接口\n\nSSDbScript 是 GIS 数据库更新操作的主要接口类，提供了从服务器数据库到本地数据库的数据同步、地物属性更新、表记录管理等完整功能集。\n\n### 连接与认证管理\n\nSSDbScript 支持多种认证模式，包括基础用户认证和角色认证，确保数据库操作的安全性和权限控制。\n\n```mermaid\nsequenceDiagram\n    participant Python\n    participant SSDbScript\n    participant Database\n    participant SDEServer\n    \n    Python->>SSDbScript: SSDbScript()\n    Python->>SSDbScript: login(userName, password)\n    SSDbScript->>Database: 验证凭证\n    Database->>SDEServer: 建立连接\n    SDEServer-->>Database: 连接成功\n    Database-->>SSDbScript: 认证通过\n    SSDbScript-->>Python: 返回 True\n    \n    Python->>SSDbScript: connectToTablespace(name)\n    SSDbScript->>Database: 切换工作空间\n    Database-->>SSDbScript: 工"
  }
]