geometry

几何体相关 CLI 命令。

cmd_geometry_create(fmt, geometries=None, file_id=None, layer_id=None, feature=None, geo_type=None, point=None, points=None, faces=None, color=None)

在图层中创建几何体对象（需 Dimine 运行）。

两种模式： 1. 扁平参数（单几何体）: --file --layer --feature --type --point/--points [--color] 2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/-

Source code in dimine_python_sdk\cli\commands\geometry.py

def cmd_geometry_create(fmt: str, geometries: str | None = None,
                         file_id: str | None = None, layer_id: str | None = None,
                         feature: str | None = None, geo_type: str | None = None,
                         point: str | None = None, points: str | None = None,
                         faces: str | None = None, color: str | None = None) -> None:
    """在图层中创建几何体对象（需 Dimine 运行）。

    两种模式：
    1. 扁平参数（单几何体）: --file --layer --feature --type --point/--points [--color]
    2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/-
    """
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    if geometries is not None:
        try:
            raw_geos = _read_geometries_input(geometries)
        except ValueError as e:
            output_error(str(e), fmt)
    elif geo_type and file_id and layer_id and feature:
        try:
            raw_geos = _build_single_geo_from_flat(
                file_id=file_id, layer_id=layer_id, feature=feature,
                geo_type=geo_type, point=point, points=points, faces=faces, color=color,
            )
        except ValueError as e:
            output_error(str(e), fmt)
    else:
        output_error("请提供 --geometries（批量）或 --file、--layer、--feature、--type（单个）", fmt)

    # 根据来源处理：_read_geometries_input 返回 dicts，_build_single_geo_from_flat 返回 SDK 对象
    if raw_geos and isinstance(raw_geos[0], dict):
        try:
            _validate_geometries(raw_geos, require_geometry=True)
            geo_objects = _build_geometry_objects(raw_geos)
        except Exception as e:
            output_error(f"构建几何体对象失败: {e}", fmt)
    else:
        geo_objects = raw_geos

    async def _run():
        client = await get_client()
        result = await client.create_geometry(geo_objects)
        return {
            "success": True,
            "created_count": len(geo_objects),
            "result": str(result),
            "message": f"已成功创建 {len(geo_objects)} 个几何体",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "创建几何体失败")

cmd_geometry_list(fmt, file_id, layer_id, entity_types=None, features=None, with_geometry=False, inline_geometry=False)

获取图层中的几何体对象（需 Dimine 运行）。

默认只返回几何体的基础信息（id、file、layer、feature、type、color、properties）。 提供 --with-geometry 时额外给出坐标数据所在的 dmf 文件路径，按实体 id 去该 文件取坐标。当不提供 layer_id 时，返回文件下所有图层中几何体的基础信息。

坐标不走 websocket（大模型坐标会撑爆通信、请求超时），一律由服务端落盘成 dmf 文件，因此默认只输出 geometry_file 路径 + 实体元信息，由调用方按需自己读； 确实要把坐标内联进输出时，显式加 --inline-geometry（CLI 会读回那个文件）。

Source code in dimine_python_sdk\cli\commands\geometry.py

def cmd_geometry_list(fmt: str, file_id: str, layer_id: str | None,
                      entity_types: str | None = None, features: str | None = None,
                      with_geometry: bool = False, inline_geometry: bool = False) -> None:
    """获取图层中的几何体对象（需 Dimine 运行）。

    默认只返回几何体的基础信息（id、file、layer、feature、type、color、properties）。
    提供 --with-geometry 时额外给出坐标数据**所在的 dmf 文件路径**，按实体 id 去该
    文件取坐标。当不提供 layer_id 时，返回文件下所有图层中几何体的基础信息。

    坐标不走 websocket（大模型坐标会撑爆通信、请求超时），一律由服务端落盘成 dmf
    文件，因此默认只输出 ``geometry_file`` 路径 + 实体元信息，由调用方按需自己读；
    确实要把坐标内联进输出时，显式加 --inline-geometry（CLI 会读回那个文件）。
    """
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    et_list = []
    if entity_types:
        et_list = [t.strip() for t in entity_types.split(",") if t.strip()]

    feat_list = []
    if features:
        feat_list = [f.strip() for f in features.split(",") if f.strip()]

    async def _run():
        client = await get_client()
        if layer_id:
            gathered = await client.get_geometry_file(
                file_id=file_id, layer_id=layer_id,
                entity_types=et_list, features=feat_list,
            )
            if not (with_geometry and inline_geometry):
                # 默认：只给坐标所在的 dmf 路径，不读文件
                return {
                    "file_id": file_id,
                    "layer_id": layer_id,
                    "entity_count": len(gathered.entities),
                    "geometry_file": gathered.geometry_file if with_geometry else "",
                    "geometries": [_geometry_to_basic_dict(g) for g in gathered.entities],
                }
            # --with-geometry --inline-geometry：读回服务端落盘的坐标再内联输出
            if gathered.geometry_file:
                client._fill_geometry_from_dmf(gathered)
            return {
                "file_id": file_id,
                "layer_id": layer_id,
                "entity_count": len(gathered.entities),
                "geometries": [_geometry_to_full_dict(g) for g in gathered.entities],
            }
        else:
            layers = await client.get_layers(file_id)
            all_geometries = []
            for layer in layers:
                layer_geos = await client.get_geometry(
                    file_id=file_id, layer_id=layer.id,
                    entity_types=et_list, features=feat_list,
                )
                for g in layer_geos:
                    all_geometries.append(_geometry_to_basic_dict(g))
            result = {
                "file_id": file_id,
                "layer_count": len(layers),
                "entity_count": len(all_geometries),
                "geometries": all_geometries,
            }
            if with_geometry:
                # 坐标文件按图层产出，拿 geometry_file 必须限定单个图层
                result["notice"] = (
                    "--with-geometry 需要同时指定 --layer：坐标文件按图层产出，"
                    "不指定图层时只能返回基础信息"
                )
            return result

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "获取几何体失败")

cmd_geometry_update(fmt, geometries=None, entity_id=None, file_id=None, layer_id=None, feature=None, geo_type=None, point=None, points=None, faces=None, color=None)

更新现有几何体对象（需 Dimine 运行）。

两种模式： 1. 扁平参数（单几何体）: --id [--type --point/--points][--file --layer --feature --color] 不传的字段保持服务端原值不变。 2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/- 字典中只包含需要更新的字段。

Source code in dimine_python_sdk\cli\commands\geometry.py

def cmd_geometry_update(fmt: str, geometries: str | None = None,
                         entity_id: str | None = None,
                         file_id: str | None = None, layer_id: str | None = None,
                         feature: str | None = None, geo_type: str | None = None,
                         point: str | None = None, points: str | None = None,
                         faces: str | None = None, color: str | None = None) -> None:
    """更新现有几何体对象（需 Dimine 运行）。

    两种模式：
    1. 扁平参数（单几何体）: --id [--type --point/--points] [--file --layer --feature --color]
       不传的字段保持服务端原值不变。
    2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/-
       字典中只包含需要更新的字段。
    """
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    if geometries is not None:
        try:
            raw_geos = _read_geometries_input(geometries)
        except ValueError as e:
            output_error(str(e), fmt)
    elif entity_id:
        try:
            raw_geos = _build_partial_geo_from_flat(
                entity_id=entity_id, geo_type=geo_type,
                file_id=file_id, layer_id=layer_id, feature=feature,
                point=point, points=points, faces=faces, color=color,
            )
        except ValueError as e:
            output_error(str(e), fmt)
    else:
        output_error("请提供 --geometries（批量）或 --id（单个更新）", fmt)

    if raw_geos and isinstance(raw_geos[0], dict):
        try:
            _validate_geometries(raw_geos, require_geometry=None, require_identity=True)
            geo_objects = _build_partial_geometry_objects(raw_geos)
        except Exception as e:
            output_error(f"构建几何体对象失败: {e}", fmt)
    else:
        geo_objects = raw_geos

    async def _run():
        client = await get_client()
        result = await client.update_geometry(geo_objects)
        return {
            "success": True,
            "updated_count": len(geo_objects),
            "result": str(result),
            "message": f"已成功更新 {len(geo_objects)} 个几何体",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "更新几何体失败")

cmd_geometry_upsert(fmt, geometries=None, entity_id=None, file_id=None, layer_id=None, feature=None, geo_type=None, point=None, points=None, faces=None, color=None)

创建或更新几何体（有 --id 则更新，无 --id 则创建，需 Dimine 运行）。

两种模式： 1. 扁平参数（单几何体）: --file --layer --feature --type [--id] --point/--points [--color] - 有 --id: 部分更新，不传的字段保持不变 - 无 --id: 新建几何体 2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/- - 字典中含 "id" 则部分更新，不含则新建

Source code in dimine_python_sdk\cli\commands\geometry.py

def cmd_geometry_upsert(fmt: str, geometries: str | None = None,
                         entity_id: str | None = None,
                         file_id: str | None = None, layer_id: str | None = None,
                         feature: str | None = None, geo_type: str | None = None,
                         point: str | None = None, points: str | None = None,
                         faces: str | None = None, color: str | None = None) -> None:
    """创建或更新几何体（有 --id 则更新，无 --id 则创建，需 Dimine 运行）。

    两种模式：
    1. 扁平参数（单几何体）: --file --layer --feature --type [--id] --point/--points [--color]
       - 有 --id: 部分更新，不传的字段保持不变
       - 无 --id: 新建几何体
    2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/-
       - 字典中含 "id" 则部分更新，不含则新建
    """
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    if geometries is not None:
        try:
            raw_geos = _read_geometries_input(geometries)
        except ValueError as e:
            output_error(str(e), fmt)
        # 按是否有 id 分离：有 id 的部分更新，无 id 的新建
        update_dicts = [g for g in raw_geos if g.get("id")]
        create_dicts = [g for g in raw_geos if not g.get("id")]
        geo_objects = []
        try:
            if update_dicts:
                _validate_geometries(update_dicts, require_geometry=None, require_identity=True)
                geo_objects.extend(_build_partial_geometry_objects(update_dicts))
            if create_dicts:
                _validate_geometries(create_dicts, require_geometry=True)
                geo_objects.extend(_build_geometry_objects(create_dicts))
        except Exception as e:
            output_error(f"构建几何体对象失败: {e}", fmt)
    elif geo_type and file_id and layer_id and feature:
        try:
            if entity_id:
                raw_geos = _build_partial_geo_from_flat(
                    entity_id=entity_id, geo_type=geo_type,
                    file_id=file_id, layer_id=layer_id, feature=feature,
                    point=point, points=points, faces=faces, color=color,
                )
            else:
                raw_geos = _build_single_geo_from_flat(
                    file_id=file_id, layer_id=layer_id, feature=feature,
                    geo_type=geo_type, point=point, points=points, faces=faces, color=color,
                )
        except ValueError as e:
            output_error(str(e), fmt)
        geo_objects = raw_geos
    else:
        output_error("请提供 --geometries（批量）或 --file、--layer、--feature、--type（单个）", fmt)

    async def _run():
        client = await get_client()
        result = await client.update_or_create_geometry(geo_objects)
        return {
            "success": True,
            "processed_count": len(geo_objects),
            "result": str(result),
            "message": f"已成功处理 {len(geo_objects)} 个几何体",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "处理几何体失败")

register_commands(subparsers, format_parent)

向 subparsers 注册几何体相关子命令。

Source code in dimine_python_sdk\cli\commands\geometry.py

def register_commands(subparsers, format_parent) -> None:
    """向 subparsers 注册几何体相关子命令。"""
    p = subparsers.add_parser("geometry-list", parents=[format_parent], help="获取图层中的几何体")
    p.add_argument("--file", required=True, dest="file_id", help="文件ID")
    p.add_argument("--layer", default=None, dest="layer_id", help="图层ID，不提供则获取文件下所有模型基础信息（不含几何数据）")
    p.add_argument("--types", default=None, dest="entity_types", help="逗号分隔的实体类型，如 'point,line,polyline,shell'")
    p.add_argument("--features", default=None, help="逗号分隔的要素名称")
    p.add_argument("--with-geometry", action="store_true", default=False, dest="with_geometry",
                   help="返回几何坐标数据；不提供时默认只返回基础信息")
    p.add_argument("--inline-geometry", action="store_true", default=False, dest="inline_geometry",
                   help="与 --with-geometry 同用时把坐标内联进输出（坐标落到临时 dmf 文件时由 CLI 读回）；"
                        "不提供时只输出 geometry_file 路径与实体元信息，避免大模型坐标撑爆输出")

    p = subparsers.add_parser("geometry-create", parents=[format_parent], help="创建几何体")
    p.add_argument("--geometries", default=None, help="GeoJSON FeatureCollection 文件，支持 @path、.json 路径或 stdin(-)")
    p.add_argument("--file", default=None, dest="file_id", help="文件ID（单几何体模式）")
    p.add_argument("--layer", default=None, dest="layer_id", help="图层ID（单几何体模式）")
    p.add_argument("--feature", default="0", help="要素名称（单几何体模式）")
    p.add_argument("--type", default=None, dest="geo_type", choices=["point", "line", "polyline", "shell"], help="几何体类型（带几何时由顶点数判定 line/polyline；单几何体模式）")
    p.add_argument("--point", default=None, help="点坐标 x,y,z（--type point 时使用）")
    p.add_argument("--points", default=None, help="点列表 JSON 数组 [[x,y,z],[x,y,z],...]（--type line/polyline/shell 时使用）")
    p.add_argument("--faces", default=None, help="面索引列表 JSON 数组 [[0,1,2],[0,2,3]]（--type shell 时必需）")
    p.add_argument("--color", default=None, help="颜色 r,g,b 默认 255,255,255")

    p = subparsers.add_parser("geometry-update", parents=[format_parent], help="更新几何体")
    p.add_argument("--geometries", default=None, help="GeoJSON FeatureCollection 文件（含 id），支持 @path、.json 路径或 stdin(-)")
    p.add_argument("--id", default=None, dest="entity_id",
                   help="实体ID（单几何体模式，必需；同时必须提供 --file/--layer/--feature/--type）")
    p.add_argument("--file", default=None, dest="file_id", help="文件ID（单几何体模式）")
    p.add_argument("--layer", default=None, dest="layer_id", help="图层ID（单几何体模式）")
    p.add_argument("--feature", default=None, help="要素名称（单几何体模式）")
    p.add_argument("--type", default=None, dest="geo_type", choices=["point", "line", "polyline", "shell"],
                   help="几何体类型（不传几何时原样作为 entity_type 下发，必须与库中实体一致；geometry-update 单几何体模式下必需）")
    p.add_argument("--point", default=None, help="点坐标 x,y,z")
    p.add_argument("--points", default=None, help="点列表 JSON 数组 [[x,y,z],[x,y,z],...]")
    p.add_argument("--faces", default=None, help="面索引列表 JSON 数组 [[0,1,2],[0,2,3]]（--type shell 时必需）")
    p.add_argument("--color", default=None, help="颜色 r,g,b")

    p = subparsers.add_parser("geometry-upsert", parents=[format_parent], help="创建或更新几何体")
    p.add_argument("--geometries", default=None, help="GeoJSON FeatureCollection 文件，支持 @path、.json 路径或 stdin(-)")
    p.add_argument("--id", default=None, dest="entity_id", help="实体ID（提供则更新，不提供则创建）")
    p.add_argument("--file", default=None, dest="file_id", help="文件ID（单几何体模式）")
    p.add_argument("--layer", default=None, dest="layer_id", help="图层ID（单几何体模式）")
    p.add_argument("--feature", default=None, help="要素名称（单几何体模式）")
    p.add_argument("--type", default=None, dest="geo_type", choices=["point", "line", "polyline", "shell"], help="几何体类型（带几何时由顶点数判定 line/polyline；单几何体模式）")
    p.add_argument("--point", default=None, help="点坐标 x,y,z")
    p.add_argument("--points", default=None, help="点列表 JSON 数组 [[x,y,z],[x,y,z],...]")
    p.add_argument("--faces", default=None, help="面索引列表 JSON 数组 [[0,1,2],[0,2,3]]（--type shell 时必需）")
    p.add_argument("--color", default=None, help="颜色 r,g,b")