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:
            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 = asyncio.run(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "创建几何体失败")

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

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

默认只返回几何体的基础信息（id、file、layer、feature、type、color、properties）。 只有显式提供 --with-geometry 时，才会返回几何坐标数据。 当不提供 layer_id 时，返回文件下所有图层中几何体的基础信息。

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

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

    默认只返回几何体的基础信息（id、file、layer、feature、type、color、properties）。
    只有显式提供 --with-geometry 时，才会返回几何坐标数据。
    当不提供 layer_id 时，返回文件下所有图层中几何体的基础信息。
    """
    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()]

    def _geometry_to_dict(g):
        return _geometry_to_full_dict(g) if with_geometry else _geometry_to_basic_dict(g)

    async def _run():
        client = await get_client()
        if layer_id:
            geometries = await client.get_geometry(
                file_id=file_id, layer_id=layer_id,
                entity_types=et_list, features=feat_list,
                with_geometry=with_geometry,
            )
            result_geos = [_geometry_to_dict(g) for g in geometries]
            return {
                "file_id": file_id,
                "layer_id": layer_id,
                "entity_count": len(result_geos),
                "geometries": result_geos,
            }
        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,
                    with_geometry=False,
                )
                for g in layer_geos:
                    all_geometries.append(_geometry_to_basic_dict(g))
            return {
                "file_id": file_id,
                "layer_count": len(layers),
                "entity_count": len(all_geometries),
                "geometries": all_geometries,
            }

    try:
        result = asyncio.run(_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 and 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,
                entity_id=entity_id,
            )
        except ValueError as e:
            output_error(str(e), fmt)
    else:
        output_error("请提供 --geometries（批量）或 --id、--file、--layer、--feature、--type（单个更新）", fmt)

    if raw_geos and isinstance(raw_geos[0], dict):
        try:
            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.update_geometry(geo_objects)
        return {
            "success": True,
            "updated_count": len(geo_objects),
            "result": str(result),
            "message": f"已成功更新 {len(geo_objects)} 个几何体",
        }

    try:
        result = asyncio.run(_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] 2. JSON/文件/stdin（批量）: --geometries JSON/@file.json/-

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]
    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,
                entity_id=entity_id,
            )
        except ValueError as e:
            output_error(str(e), fmt)
    else:
        output_error("请提供 --geometries（批量）或 --file、--layer、--feature、--type（单个）", fmt)

    if raw_geos and isinstance(raw_geos[0], dict):
        try:
            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.update_or_create_geometry(geo_objects)
        return {
            "success": True,
            "processed_count": len(geo_objects),
            "result": str(result),
            "message": f"已成功处理 {len(geo_objects)} 个几何体",
        }

    try:
        result = asyncio.run(_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,shell'")
    p.add_argument("--features", default=None, help="逗号分隔的要素名称")
    p.add_argument("--with-geometry", action="store_true", default=False, dest="with_geometry",
                   help="返回几何坐标数据；不提供时默认只返回基础信息")

    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", "shell"], help="几何体类型（单几何体模式）")
    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/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（单几何体模式，必需）")
    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", "shell"], help="几何体类型（单几何体模式）")
    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]]")
    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", "shell"], help="几何体类型（单几何体模式）")
    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]]")
    p.add_argument("--color", default=None, help="颜色 r,g,b")