dimine-python-sdk 0.1.8__py3-none-any.whl

dimine_python_sdk/lib/io/project_plotting.py

@@ -0,0 +1,40 @@
+import typing
+from typing import Optional, Tuple
+import DmPyBindInterface as Dm
+
+from dimine_python_sdk.lib.io.models import LayoutParam,SetupParams
+
+#工程出图
+def project_data_plotting(
+        input_file: str,
+        layout_json: LayoutParam,
+        setup_json: SetupParams,
+        output_file: str
+) -> str:
+    """
+    工程数据出图（实体/钻孔/块段模型），根据输入文件扩展名自动切换
+
+    Args:
+        input_file: 输入文件路径（支持实体/钻孔/块段模型文件）
+        layout_json: 绘图布局配置参数
+        setup_json: 绘图设置参数
+        output_file: 输出文件路径
+
+    Returns:
+        str: 成功时返回提示消息，失败时抛出异常
+
+    Raises:
+        ValueError: 出图失败时抛出，包含错误消息
+    """
+    success, message = Dm.ProjectDataPlotting(
+        input_file,
+        layout_json.to_dict(),
+        setup_json.to_dict(),
+        output_file
+    )
+
+    # 错误处理：Python风格用异常替代返回错误码
+    if not success:
+        raise ValueError(f"出图失败: {message}")
+
+    return message

dimine_python_sdk/lib/prospecting/__init__.py

@@ -0,0 +1,3 @@
+from dimine_python_sdk.lib.prospecting.block_data import *
+from dimine_python_sdk.lib.prospecting.drill_db import *
+from dimine_python_sdk.lib.prospecting.valuation import *

dimine_python_sdk/lib/prospecting/block_data.py

@@ -0,0 +1,289 @@
+import json
+import DmPyBindInterface as Dm
+from typing import Dict, Any, List, Tuple
+
+from dimine_python_sdk.lib.prospecting.models import BlockModelConstraint, ModelTransformParams
+from dimine_python_sdk.lib.types import DmDPoint
+
+class DmBlockData:
+    """
+    二次封装 dmBlockDataNew 类，提供 Python 化的块段模型操作接口
+    职责：加载块段模型文件、获取模型属性、遍历块段数据
+    """
+    def __init__(self):
+        # 初始化底层块段模型对象
+        self._block_data = Dm.dmBlockDataNew()
+        # 标记模型是否已成功加载
+        self._is_open = False
+
+    def open(self, file_path: str) -> bool:
+        """
+        加载块段模型文件
+        :param file_path: 块段模型文件路径（自动处理编码转换）
+        :raises RuntimeError: 加载失败时抛出异常
+
+        :result: 是否成功加载模型
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        success = block_data.open("model.dmf")
+        if success:
+            print("模型加载成功")
+        else:
+            print("模型加载失败")
+        ```
+        """
+        result = self._block_data.Open(file_path)
+        if not result:
+            raise RuntimeError(f"加载块段模型失败: {file_path}")
+        self._is_open = True
+        return result
+
+    def _check_open(self) -> None:
+        """内部校验：确保模型已成功加载"""
+        if not self._is_open:
+            raise RuntimeError("请先调用 open() 加载块段模型")
+
+    def get_origin(self) -> DmDPoint:
+        """
+        获取模型原点坐标 (x, y, z)
+        :return: 模型原点坐标点对象
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        origin = block_data.get_origin()
+        print(f"模型原点坐标: {origin}")
+        ```
+        """
+        self._check_open()
+        cpp_result = self._block_data.GetOrigin()
+        return DmDPoint._from_obj(cpp_result)
+
+    def get_xyz_length(self) -> List[float]:
+        """
+        获取模型在 X/Y/Z 三个方向的总长度
+        :return: 包含 X/Y/Z 方向总长度的列表 [x_len, y_len, z_len]
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        xyz_len = block_data.get_xyz_length()
+        print(f"模型在 X/Y/Z 方向的总长度: {xyz_len}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetXYZLen()
+
+    def get_max_level(self) -> int:
+        """
+        获取模型的最大精度层级
+        :return: 模型的最大精度层级整数
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        max_level = block_data.get_max_level()
+        print(f"模型最大精度层级: {max_level}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetMaxLevel()
+
+    def get_min_size(self) -> List[float]:
+        """
+        获取模型最小块段的尺寸 (x, y, z)
+        :return: 包含最小块段尺寸的列表 [x_size, y_size, z_size]
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        min_size = block_data.get_min_size()
+        print(f"模型最小块段尺寸: {min_size}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetMinSize()
+
+    def get_rotation(self) -> List[float]:
+        """
+        获取模型的旋转角度 (x, y, z)
+        :return: 包含旋转角度的列表 [x_angle, y_angle, z_angle]
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        rotation = block_data.get_rotation()
+        print(f"模型旋转角度: {rotation}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetRotation()
+
+    def get_field_definitions(self) -> List[Dict[str, Any]]:
+        """
+        获取模型的字段定义列表，每个字段包含 name/type/size 信息
+        :return: 包含字段定义的列表，每个元素为字典 {"name": str, "type": str, "size": int}
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        field_defs = block_data.get_field_definitions()
+        print(f"模型字段定义: {field_defs}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetFieldDefine()
+
+    def get_total_block_count(self) -> int:
+        """
+        获取模型中块段的总数量
+        :return: 模型中块段的总数量整数
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        total_count = block_data.get_total_block_count()
+        print(f"模型中块段总数量: {total_count}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetTotalBlockCount()
+
+    def init_cursor(self) -> int:
+        """
+        初始化块段遍历游标，用于遍历所有块段
+        :return: 初始化结果整数（0 表示成功）
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        cursor = block_data.init_cursor()
+        print(f"初始化游标结果: {cursor}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.InitCursor()
+
+    def advance_cursor(self) -> bool:
+        """将游标移动到下一个块段
+        :return: 是否成功移动（False 表示已遍历结束）
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        cursor = block_data.init_cursor()
+        while block_data.advance_cursor():
+            # 处理当前块段数据
+            pass
+        ```
+        """
+        self._check_open()
+        return self._block_data.AdvCursor()
+
+    def get_cursor_data(self, field_name: str) -> Tuple[bool, str]:
+        """获取当前游标指向块段的指定字段值
+        :param field_name: 字段名称
+        :return: (是否成功, 字段值JSON字符串)
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        cursor = block_data.init_cursor()
+        while block_data.advance_cursor():
+            success, data = block_data.get_cursor_data("field_name")
+            if success:
+                print(f"当前块段字段值: {data}")
+        ```
+        """
+        self._check_open()
+        return self._block_data.GetCursorData(field_name)
+
+    def is_beyond_boundary(self) -> bool:
+        """
+        检查当前游标是否超出模型边界
+        :return: 是否超出边界（True/False）
+
+        example:
+        ```python
+        block_data = DmBlockData()
+        block_data.open("model.dmf")
+        cursor = block_data.init_cursor()
+        while block_data.advance_cursor():
+            if block_data.is_beyond_boundary():
+                print("游标超出模型边界")
+                break
+        ```
+        """
+        self._check_open()
+        return self._block_data.IsBeyondBoundaryNode()
+
+    # 上下文管理器，支持 with 语句
+    # def __enter__(self) -> "BlockModelCore":
+    #     return self
+    #
+    # def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+    #     """资源释放逻辑"""
+    #     self._is_open = False
+    @staticmethod
+    def create_block_model(params: ModelTransformParams) -> dict:
+        """
+        创建空块段模型
+        :param params: Python字典，包含样长组合所需的参数
+        :return: 处理结果，成功返回{"state": "ok", "message": "..."}，失败抛出异常
+
+        example:
+        ```python
+        params = ModelTransformParams(
+        file_name: "123",
+        # 原点
+        origin_x = 3.0,origin_y = 3.0,origin_z = 3.0,
+        # 旋转角度
+        rotate_x = 0.0,rotate_y = 0.0,rotate_z = 0.0,
+        # 单元块尺寸
+        size_x = 1.0,size_y = 1.0,size_z = 1.0,
+        # 延伸长度
+        length_x = 10.0,length_y = 10.0,length_z = 10.0,
+        )
+        response = DmBlockData.create_block_model(params)
+        print(f"创建空块段模型结果: {response}")
+        ```
+        """
+        json_param = json.dumps(params.to_dict(), ensure_ascii=False)
+        raw_response = Dm.CreateBlockModel(json_param)
+        response = json.loads(raw_response)
+        if response["state"] == "failed":
+            raise RuntimeError(f"样长组合失败: {response['message']}")
+        return response
+
+    @staticmethod
+    def block_constrain_to_dmc_file(block_model_file: str,constrain_json_param:BlockModelConstraint,constrain_result_file:str) -> bool:
+        """
+        块约束保存到约束结果dmc文件
+        :param block_model_file:
+        :param constrain_json_param:
+        :param constrain_result_file:
+        :return: 处理结果，返回True/False
+
+        example:
+        ```python
+        params = BlockModelConstraint(
+        type = 0,file = "model.dmf",range = 0,inside_level = 0,boundary_level = 0,bool_operate = "and",
+        )
+        response = DmBlockData.block_constrain_to_dmc_file("model.dmf",params,"constrain.dmc")
+        print(f"块约束保存到约束结果dmc文件结果: {response}")
+        ```
+        """
+        json_param = json.dumps(constrain_json_param.to_dict(), ensure_ascii=False)
+        raw_response = Dm.BlockConstrainToDmcFile(block_model_file,json_param,constrain_result_file)
+        return raw_response

dimine_python_sdk/lib/prospecting/drill_db.py

@@ -0,0 +1,333 @@
+import json
+import DmPyBindInterface as Dm
+from typing import Dict, Any, Union
+from dimine_python_sdk.lib.prospecting.models import SampleLengthCombineParam,\
+ StepCombineParam, HighGradeProcessParam
+from dimine_python_sdk.lib.types.entity import DmDataTable
+from pathlib import Path
+
+class DrillFunctionWrapper:
+    """
+    二次封装钻孔相关函数，提供更Python化的接口
+    """
+    @staticmethod
+    def sample_length_combine(params: SampleLengthCombineParam) -> dict:
+        """
+        样长组合功能的二次封装
+        :param params: Python字典，包含样长组合所需的参数
+        :return: 处理结果，成功返回{"state": "ok", "message": "..."}，失败抛出异常
+
+        example:
+        ```python
+        params = SampleLengthCombineParam(
+        )
+        result = DrillFunctionWrapper.sample_length_combine(params)
+        ```
+        """
+        # 将Python字典序列化为JSON字符串
+        json_param = json.dumps(params.to_dict(), ensure_ascii=False)
+        raw_response = Dm.SampleLengthCombine(json_param)
+        # 3. 解析返回的JSON字符串为Python字典
+        response = json.loads(raw_response)
+        # 4. 错误处理：如果失败，抛出异常
+        if response["state"] == "failed":
+            raise RuntimeError(f"样长组合失败: {response['message']}")
+        return response
+
+    @staticmethod
+    def step_combine(params: StepCombineParam) -> dict:
+        """
+        台阶组合功能的二次封装
+        :param params: Python字典，包含台阶组合所需的参数
+        :return: 处理结果，成功返回{"state": "ok", "message": "..."}，失败抛出异常
+
+        example:
+        ```python
+        params = StepCombineParam(
+        )
+        result = DrillFunctionWrapper.step_combine(params)
+        ```
+        """
+        json_param = json.dumps(params.to_dict(), ensure_ascii=False)
+        raw_response = Dm.StepCombine(json_param)
+        response = json.loads(raw_response)
+        if response["state"] == "failed":
+            raise RuntimeError(f"台阶组合失败: {response['message']}")
+        return response
+
+    @staticmethod
+    def extra_high_grade_process(params: HighGradeProcessParam) -> dict:
+        """
+        特高品位处理功能的二次封装
+        :param params: Python字典，包含台阶组合所需的参数
+        :return: 处理结果，成功返回{"state": "ok", "message": "..."}，失败抛出异常
+
+        example:
+        ```python
+        params = HighGradeProcessParam(
+        )
+        result = DrillFunctionWrapper.extra_high_grade_process(params)
+        ```
+        """
+        json_param = json.dumps(params.to_dict(), ensure_ascii=False)
+        raw_response = Dm.ExtraHighGradeProcess(json_param)
+        response = json.loads(raw_response)
+        if response["state"] == "failed":
+            raise RuntimeError(f"特高品位处理失败: {response['message']}")
+        return response
+
+class DrillDBManager:
+    """
+    二次封装 CDrillDBManager 类，提供 Python 化的钻孔数据库管理接口
+    """
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生CDrillDBManager对象创建封装实例
+        :param obj: 原生CDrillDBManager对象（bind11封装后）
+        :return: CDrillDBManager实例
+        """
+        instance = cls.__new__(cls)
+        instance._manager = obj
+        return instance
+
+    def get_drill_count(self) -> int:
+        """
+        获取钻孔数量
+        :return: 钻孔数量
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        print("钻孔数量:", drill_manager.get_drill_count())
+        ```
+        """
+        return self._manager.GetDrillCount()
+
+    def get_total_length(self) -> float:
+        """
+        获取钻孔总长度
+        :return: 钻孔总长度
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        print("钻孔总长度:", drill_manager.get_total_length())
+        ```
+        """
+        return self._manager.GetTotalLength()
+
+    def get_base_table(self, table_mark: str) -> DmDataTable:
+        """
+        获取基础表
+        :param table_mark: 表标识（例如 "collar", "survey", "lithology"）
+        :return: 基础表数据（DmDataTable实例）
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        collar_table = drill_manager.get_base_table("collar")
+        ```
+        """
+        cpp_result = self._manager.GetBaseTable(table_mark)
+        return DmDataTable._from_obj(cpp_result)
+
+    def get_added_table(self, table_mark: str) -> DmDataTable:
+        """
+        获取附加表
+        :param table_mark: 表标识（例如 "collar", "survey", "lithology"）
+        :return: 附加表数据（DmDataTable实例）
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        survey_table = drill_manager.get_added_table("survey")
+        ```
+        """
+        cpp_result = self._manager.GetAddedTable(table_mark)
+        return DmDataTable._from_obj(cpp_result)
+
+    def get_added_table_count(self) -> int:
+        """
+        获取附加表数量
+        :return: 附加表数量
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        print("附加表数量:", drill_manager.get_added_table_count())
+        ```
+        """
+        return self._manager.GetAddedTableCount()
+
+    def get_collar_table_def(self) -> Dict[str, Any]:
+        """
+        获取孔口表结构定义
+        :return: 孔口表结构定义（字典）
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        collar_def = drill_manager.get_collar_table_def()
+        print("孔口表字段数:", collar_def)
+        ```
+        """
+        return self._manager.GetCollarTableDefine()
+
+    def get_survey_table_def(self) -> Dict[str, Any]:
+        """
+        获取测斜表结构定义
+        :return: 测斜表结构定义（字典）
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        survey_def = drill_manager.get_survey_table_def()
+        print("测斜表字段数:",survey_def)
+        ```
+        """
+        return self._manager.GetSurveryTableDefine()
+
+    def get_lithology_table_def(self) -> Dict[str, Any]:
+        """
+        获取岩性表结构定义
+        :return: 岩性表结构定义（字典）
+
+        example:
+        ```python
+        drill_manager = drill_db.get_drill_db_manager()
+        lithology_def = drill_manager.get_lithology_table_def()
+        print("岩性表字段数:", lithology_def)
+        ```
+        """
+        return self._manager.GetLithologyTableDefine()
+
+class DmGeoDrillData:
+    """
+    二次封装 CGeoDrillDataNew (dmGeoDrillData) 类
+    """
+    def __init__(self):
+        # 初始化底层对象
+        self._geo_drill = Dm.dmGeoDrillData()
+
+    def load(self, file_path: Union[str, Path]) -> bool:
+        """
+        加载钻孔数据库文件
+        :param file_path: DMF 文件路径（自动处理编码转换）
+        :raises RuntimeError: 加载失败时抛出异常
+
+        :return: 是否成功加载
+
+        example:
+        ```python
+        drill_db = DmGeoDrillData()
+        success = drill_db.load("model.dmf")
+        if success:
+            print("成功加载钻孔数据库")
+        ```
+        """
+        result = self._geo_drill.Load(file_path)
+        if not result:
+            raise RuntimeError(f"加载钻孔数据库失败: {file_path}")
+        return result
+
+    def save(self, file_path: Union[str, Path]) -> bool:
+        """
+        保存钻孔数据库到文件
+        :param file_path: 保存路径（自动处理编码转换）
+        :raises RuntimeError: 保存失败时抛出异常
+        :return: 是否成功保存
+
+        example:
+        ```python
+        drill_db = DmGeoDrillData()
+        success = drill_db.load("model.dmf")
+        if success:
+            print("成功加载钻孔数据库")
+            success = drill_db.save("model.dmf")
+            if success:
+                print("成功保存钻孔数据库")
+        ```
+        """
+        result = self._geo_drill.Save(file_path)
+        if not result:
+            raise RuntimeError(f"保存钻孔数据库失败: {file_path}")
+        return result
+
+    def get_drill_db_manager(self) -> DrillDBManager:
+        """
+        获取钻孔数据库管理器实例
+        :return: DrillDBManager实例
+
+        example:
+        ```python
+        drill_db = DmGeoDrillData()
+        success = drill_db.load("model.dmf")
+        if success:
+            print("成功加载钻孔数据库")
+            db_manager = drill_db.get_drill_db_manager()
+            print(f"钻孔数量: {db_manager.get_drill_count()}")
+        ```
+        """
+        db_manager = self._geo_drill.GetDrillDBManager()
+        if not db_manager:
+            raise RuntimeError("钻孔数据库管理器获取失败")
+        return DrillDBManager._from_obj(db_manager)
+
+    def get_collar_table(self) -> DmDataTable:
+        """获取钻孔孔口表 (Collar Table)
+        :return: 孔口表数据（DmDataTable实例）
+
+        example:
+        ```python
+        drill_db = DmGeoDrillData()
+        success = drill_db.load("model.dmf")
+        if success:
+            print("成功加载钻孔数据库")
+            collar_table = drill_db.get_collar_table()
+            print(f"孔口表字段数: {collar_table.get_field_count()}")
+        ```
+        """
+        if not self._geo_drill:
+            raise RuntimeError("数据库未加载")
+        cpp_result = self._geo_drill.GetCollarTable()
+        return DmDataTable._from_obj(cpp_result)
+
+    def get_survey_table(self) -> DmDataTable:
+        """获取钻孔测斜表 (Survey Table)
+        :return: 测斜表数据（DmDataTable实例）
+
+        example:
+        ```python
+        drill_db = DmGeoDrillData()
+        success = drill_db.load("model.dmf")
+        if success:
+            print("成功加载钻孔数据库")
+            survey_table = drill_db.get_survey_table()
+            print(f"测斜表字段数: {survey_table.get_field_count()}")
+        ```
+        """
+        if not self._geo_drill:
+            raise RuntimeError("数据库未加载")
+        cpp_result = self._geo_drill.GetSurveyTable()
+        return DmDataTable._from_obj(cpp_result)
+
+    def get_lithology_table(self) -> DmDataTable:
+        """获取钻孔岩性表 (Lithology Table)
+        :return: 岩性表数据（DmDataTable实例）
+
+        example:
+        ```python
+        drill_db = DmGeoDrillData()
+        success = drill_db.load("model.dmf")
+        if success:
+            print("成功加载钻孔数据库")
+            lithology_table = drill_db.get_lithology_table()
+            print(f"岩性表字段数: {lithology_table.get_field_count()}")
+        ```
+        """
+        if not self._geo_drill:
+            raise RuntimeError("数据库未加载")
+        cpp_result = self._geo_drill.GetLithologyTable()
+        return DmDataTable._from_obj(cpp_result)