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

dimine_python_sdk/docs/reference/lib/io/file_conversion.md

@@ -0,0 +1,3 @@
+# file_conversion
+
+::: dimine_python_sdk.lib.io.file_conversion

dimine_python_sdk/docs/reference/lib/io/models.md

@@ -0,0 +1,3 @@
+# models
+
+::: dimine_python_sdk.lib.io.models

dimine_python_sdk/docs/reference/lib/io/project_plotting.md

@@ -0,0 +1,3 @@
+# project_plotting
+
+::: dimine_python_sdk.lib.io.project_plotting

dimine_python_sdk/docs/reference/lib/prospecting/block_data.md

@@ -0,0 +1,3 @@
+# block_data
+
+::: dimine_python_sdk.lib.prospecting.block_data

dimine_python_sdk/docs/reference/lib/prospecting/drill_db.md

@@ -0,0 +1,3 @@
+# drill_db
+
+::: dimine_python_sdk.lib.prospecting.drill_db

dimine_python_sdk/docs/reference/lib/prospecting/models.md

@@ -0,0 +1,3 @@
+# models
+
+::: dimine_python_sdk.lib.prospecting.models

dimine_python_sdk/docs/reference/lib/prospecting/valuation.md

@@ -0,0 +1,3 @@
+# valuation
+
+::: dimine_python_sdk.lib.prospecting.valuation

dimine_python_sdk/docs/reference/lib/types/entity.md

@@ -0,0 +1,3 @@
+# entity
+
+::: dimine_python_sdk.lib.types.entity

dimine_python_sdk/docs/reference/lib/types/line.md

@@ -0,0 +1,3 @@
+# line
+
+::: dimine_python_sdk.lib.types.line

dimine_python_sdk/docs/reference/lib/types/point.md

@@ -0,0 +1,3 @@
+# point
+
+::: dimine_python_sdk.lib.types.point

dimine_python_sdk/docs/reference/logger.md

@@ -0,0 +1,3 @@
+# logger
+
+::: dimine_python_sdk.logger

dimine_python_sdk/docs/reference/models/conn.md

@@ -0,0 +1,3 @@
+# conn
+
+::: dimine_python_sdk.models.conn

dimine_python_sdk/docs/reference/models/errors.md

@@ -0,0 +1,3 @@
+# errors
+
+::: dimine_python_sdk.models.errors

dimine_python_sdk/docs/reference/models/types.md

@@ -0,0 +1,3 @@
+# types
+
+::: dimine_python_sdk.models.types

dimine_python_sdk/docs/summary.md

@@ -0,0 +1,6 @@
+* [首页](index.md)
+* [快速开始](quickstart.md)
+* [操作指南](guides/)
+* [API 参考](reference/SUMMARY.md)
+* [示例](examples/)
+  

dimine_python_sdk/lib/__init__.py

@@ -0,0 +1,20 @@
+import os
+from pathlib import Path
+import sys
+from dimine_python_sdk.logger import logger
+
+DM_PYD_NAME = "DmPyBindInterface.pyd"
+
+__DIMINE_HOME__ = os.environ.get("DIMINE_HOME", None)        # DIMINE 软件安装路径
+if __DIMINE_HOME__ and (Path(__DIMINE_HOME__)/DM_PYD_NAME).exists():
+    sys.path.append(__DIMINE_HOME__)
+else:
+    logger.error("DIMINE_HOME not found or DmPyBindInterface.pyd not found in DIMINE_HOME")
+
+def set_dimine_home(dimine_home: str):
+    if dimine_home and (Path(dimine_home)/DM_PYD_NAME).exists():
+        os.environ["DIMINE_HOME"] = dimine_home
+        logger.info(f"set DIMINE_HOME to {dimine_home}")
+        __DIMINE_HOME__ = dimine_home
+    else:
+        raise Exception(f"dimine_home not found: {dimine_home} or DmPyBindInterface.pyd not found in dimine_home")

dimine_python_sdk/lib/algorithm/__init__.py

@@ -0,0 +1 @@
+from dimine_python_sdk.lib.algorithm.model_func import *

dimine_python_sdk/lib/algorithm/model_func.py

@@ -0,0 +1,219 @@
+import DmPyBindInterface as Dm
+
+from dimine_python_sdk.lib.types import DmDPoint, DmPolyData
+
+
+class ThModelFunc:
+    """
+    模型工具函数 Python 二次封装类
+    底层直接调用源扩展接口，提供静态工具方法
+    """
+
+    @staticmethod
+    def distance(point_a: DmDPoint, point_b: DmDPoint) -> float:
+        """
+        计算两点间距离
+        :param point_a: 点A对象
+        :param point_b: 点B对象
+        :return: 两点间距离（浮点数）
+
+        example:
+        ```python
+        point_a = DmDPoint(0, 0, 0)
+        point_b = DmDPoint(1, 1, 1)
+        distance = ThModelFunc.distance(point_a, point_b)
+        print(distance)  # 输出: 1.7320508075688772
+        ```
+        """
+        return Dm.thModelFunc.Distance(point_a._obj, point_b._obj)
+
+    @staticmethod
+    def calculate_min_rectangle_2d(point_set: list[DmDPoint],d_bounds: list[float]) -> list[DmDPoint]:
+        """
+        计算点集的最小外接矩形
+        :param point_set: 点集列表
+        :param d_bounds: 包围盒
+        :return: 最小外接矩形的4个角点列表
+
+        example:
+        ```python
+        point_set = [DmDPoint(0, 0, 0), DmDPoint(1, 0, 0), DmDPoint(0, 1, 0), DmDPoint(1, 1, 0)]
+        d_bounds = [0, 1, 0, 1, 0, 1]
+        min_rect = ThModelFunc.calculate_min_rectangle_2d(point_set, d_bounds)
+        print(min_rect)  # 输出: [DmDPoint(0, 0, 0), DmDPoint(1, 0, 0), DmDPoint(0, 1, 0), DmDPoint(1, 1, 0)]
+        ```
+        """
+        cpp_points = [p._obj for p in point_set]
+        cpp_result = Dm.thModelFunc.CalcultateMinRectangle2D(cpp_points,d_bounds)
+        return [DmDPoint._from_obj(p) for p in cpp_result]
+
+    @staticmethod
+    def cross(vector1: DmDPoint, vector2: DmDPoint) -> DmDPoint:
+        """
+        计算两个向量的叉积
+        :param vector1: 向量1
+        :param vector2: 向量2
+        :return: 叉积结果向量
+
+        example:
+        ```python
+        vector1 = DmDPoint(1, 0, 0)
+        vector2 = DmDPoint(0, 1, 0)
+        cross_product = ThModelFunc.cross(vector1, vector2)
+        print(cross_product)  # 输出: DmDPoint(0, 0, 1)
+        ```
+        """
+        cpp_result = Dm.thModelFunc.Cross(vector1._obj, vector2._obj)
+        return DmDPoint._from_obj(cpp_result)
+
+    @staticmethod
+    def compute_bounds(point_set: list[DmDPoint]) -> list[float]:
+        """
+        计算点集的边界范围
+        :param point_set: 点集列表
+        :return: 边界参数列表（6个值）
+
+        example:
+        ```python
+        point_set = [DmDPoint(0, 0, 0), DmDPoint(1, 0, 0), DmDPoint(0, 1, 0), DmDPoint(1, 1, 0)]
+        bounds = ThModelFunc.compute_bounds(point_set)
+        print(bounds)  # 输出: [0.0, 1.0, 0.0, 1.0, 0.0, 1.0]
+        ```
+        """
+        cpp_points = [p._obj for p in point_set]
+        return Dm.thModelFunc.ComputeBounds(cpp_points)
+
+    @staticmethod
+    def cut_model_data(input_data: DmPolyData, origin: DmDPoint, normal: DmDPoint,output_data: DmPolyData,num:int = 1,dist:float = 0) -> int:
+        """
+        裁剪模型数据
+        :param input_data: 输入模型数据
+        :param origin: 裁剪平面原点
+        :param normal: 裁剪平面法向量
+        :param output_data: 返回值
+        :param num: 切面个数
+        :param dist: 切面距离
+        :return: 1成功 0失败
+
+        example:
+        ```python
+        input_data = DmPolyData()
+        origin = DmDPoint(0, 0, 0)
+        normal = DmDPoint(0, 0, 1)
+        output_data = DmPolyData()
+        result = ThModelFunc.cut_model_data(input_data, origin, normal,output_data)
+        print(result)  # 输出: 1
+        ```
+        """
+        result = Dm.thModelFunc.CutModelData(input_data._obj, origin._obj, normal._obj,output_data._obj, num, dist)
+        if result != 1:
+            raise ValueError(f"模型切割失败，底层返回结果码：{result}")
+        return result
+
+    @staticmethod
+    def project_point_on_plane(origin: DmDPoint, normal: DmDPoint, point: DmDPoint) -> int:
+        """
+        将点投影到平面上
+        :param origin: 平面原点
+        :param normal: 平面法向量
+        :param point: 待投影点
+        :return: 1成功,0失败
+
+        example:
+        ```python
+        origin = DmDPoint(0, 0, 0)
+        normal = DmDPoint(0, 0, 1)
+        point = DmDPoint(1, 1, 1)
+        result = ThModelFunc.project_point_on_plane(origin, normal, point)
+        print(result)  # 输出: 1
+        ```
+        """
+        print(point._obj)
+        result = Dm.thModelFunc.ProjectPointsOnPlane(origin._obj, normal._obj, point._obj)
+        print(point._obj)
+        if result != 1:
+            raise ValueError(f"投影失败，底层返回结果码：{result}")
+        return result
+
+    @staticmethod
+    def line_x_polyline(start: DmDPoint, end: DmDPoint, point_set: list[DmDPoint], tolerance: float) -> list[DmDPoint]:
+        """
+        计算线段与多段线的交点
+        :param start: 线段起点
+        :param end: 线段终点
+        :param point_set: 多段线点集
+        :param tolerance: 容差
+        :return: 交点列表
+
+        example:
+        ```python
+        start = DmDPoint(0, 0, 0)
+        end = DmDPoint(1, 1, 1)
+        point_set = [DmDPoint(0, 0, 0), DmDPoint(1, 0, 0), DmDPoint(0, 1, 0), DmDPoint(1, 1, 0)]
+        tolerance = 0.01
+        intersections = ThModelFunc.line_x_polyline(start, end, point_set, tolerance)
+        print(intersections)  # 输出: [DmDPoint(0.5, 0.5, 0.0)]
+        ```
+        """
+        cpp_points = [p._obj for p in point_set]
+        cpp_result = Dm.thModelFunc.LineXPolyline(start._obj, end._obj, cpp_points, tolerance)
+        return [DmDPoint._from_obj(p) for p in cpp_result]
+
+    @staticmethod
+    def compute_normal(point_set: list[DmDPoint]) -> DmDPoint:
+        """
+        计算点集的法向量
+        :param point_set: 点集列表
+        :return: 法向量
+
+        example:
+        ```python
+        point_set = [DmDPoint(0, 0, 0), DmDPoint(1, 0, 0), DmDPoint(0, 1, 0)]
+        normal = ThModelFunc.compute_normal(point_set)
+        print(normal)  # 输出: DmDPoint(0.0, 0.0, 1.0)
+        ```
+        """
+        cpp_points = [p._obj for p in point_set]
+        cpp_result = Dm.thModelFunc.ComputeNormal(cpp_points)
+        return DmDPoint._from_obj(cpp_result)
+
+class TwModelFunc:
+    """点集处理工具类（Python风格二次封装）"""
+    @staticmethod
+    def sort_points(base_point: DmDPoint,points: list[DmDPoint]) -> list[DmDPoint]:
+        """
+        根据点集和基点的距离按从小到大进行排列，并清除重复点
+        :param base_point: 基准点，计算距离的中心
+        :param points: 待排序的点集列表
+        :return: 排序并去重后的点集
+
+        example:
+        ```python
+        base_point = DmDPoint(0, 0, 0)
+        points = [DmDPoint(1, 0, 0), DmDPoint(0, 1, 0), DmDPoint(0, 0, 1)]
+        sorted_points = TwModelFunc.sort_points(base_point, points)
+        print(sorted_points)  # 输出: [DmDPoint(0.0, 0.0, 1.0), DmDPoint(0.0, 1.0, 0.0), DmDPoint(1.0, 0.0, 0.0)]
+        ```
+        """
+        cpp_points = [p._obj for p in points]
+        sorted_points = Dm.PointSetSort(base_point._obj, cpp_points)
+        return [DmDPoint._from_obj(p) for p in sorted_points]
+
+    @staticmethod
+    def calculate_theat_phi_psi(vector: DmDPoint,use_radians: bool = True) -> dict:
+        """
+        这里的倾角定义为与 xy 平面的夹角
+        计算向量的方位角、倾角和长度
+        :param vector: 输入向量
+        :param use_radians: 是否返回弧度（默认返回角度）
+        :return: 包含 'azimuth', 'dip'的字典
+
+        example:
+        ```python
+        vector = DmDPoint(1, 1, 1)
+        result = TwModelFunc.calculate_theat_phi_psi(vector,False)
+        print(result)  # 输出: {'azimuth': 45.0, 'dip': 35.264389682754654}
+        ```
+        """
+        result = Dm.twModelFunc.CalculateTheatPhiPsi(vector._obj, use_radians)
+        return result

dimine_python_sdk/lib/io/__init__.py

@@ -0,0 +1,2 @@
+from dimine_python_sdk.lib.io.file_conversion import *
+from dimine_python_sdk.lib.io.project_plotting import *

dimine_python_sdk/lib/io/file_conversion.py

@@ -0,0 +1,143 @@
+import DmPyBindInterface as Dm
+from pathlib import Path
+from typing import Union
+
+class FileConverter:
+    """
+    文件格式转换工具类，支持AutoCAD、Surpac、MicroMine、DataMine、MapGIS与DMF格式互转
+    """
+
+    @staticmethod
+    def cad_to_dmf(cad_file: Union[str, Path], dmf_file: Union[str, Path]) -> bool:
+        """
+        AutoCAD文件转DMF格式
+        :param cad_file: 输入AutoCAD文件路径
+        :param dmf_file: 输出DMF文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.cad_to_dmf("input.dwg", "output.dmf")
+        ```
+        """
+        return Dm.dmIO_CADToDmf(str(cad_file), str(dmf_file))
+
+    @staticmethod
+    def dmf_to_cad(dmf_file: Union[str, Path], cad_file: Union[str, Path]) -> bool:
+        """
+        DMF文件转AutoCAD格式
+        :param dmf_file: 输入DMF文件路径
+        :param cad_file: 输出AutoCAD文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.dmf_to_cad("input.dmf", "output.dwg")
+        ```
+        """
+        return Dm.dmIO_DmfToCAD(str(dmf_file), str(cad_file))
+
+    @staticmethod
+    def surpac_to_dmf(surpac_file: Union[str, Path], dmf_file: Union[str, Path]) -> bool:
+        """
+        Surpac文件转DMF格式
+        :param surpac_file: 输入Surpac文件路径
+        :param dmf_file: 输出DMF文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.surpac_to_dmf("input.sur", "output.dmf")
+        ```
+        """
+        return Dm.dmIO_SurpacToDmf(str(surpac_file), str(dmf_file))
+
+    @staticmethod
+    def dmf_to_surpac(dmf_file: Union[str, Path], surpac_file: Union[str, Path]) -> bool:
+        """
+        DMF文件转Surpac格式
+        :param dmf_file: 输入DMF文件路径
+        :param surpac_file: 输出Surpac文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.dmf_to_surpac("input.dmf", "output.sur")
+        ```
+        """
+        return Dm.dmIO_DmfToSurpac(str(dmf_file), str(surpac_file))
+
+    @staticmethod
+    def micromine_to_dmf(micromine_file: Union[str, Path], dmf_file: Union[str, Path]) -> bool:
+        """
+        MicroMine文件转DMF格式
+        :param micromine_file: 输入MicroMine文件路径
+        :param dmf_file: 输出DMF文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.micromine_to_dmf("input.mic", "output.dmf")
+        ```
+        """
+        return Dm.dmIO_MicroMineToDmf(str(micromine_file), str(dmf_file))
+
+    @staticmethod
+    def dmf_to_micromine(dmf_file: Union[str, Path], micromine_file: Union[str, Path]) -> bool:
+        """
+        DMF文件转MicroMine格式
+        :param dmf_file: 输入DMF文件路径
+        :param micromine_file: 输出MicroMine文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.dmf_to_micromine("input.dmf", "output.mic")
+        ```
+        """
+        return Dm.dmIO_DmfToMicroMine(str(dmf_file), str(micromine_file))
+
+    @staticmethod
+    def datamine_to_dmf(datamine_file: Union[str, Path], dmf_file: Union[str, Path]) -> bool:
+        """
+        DataMine文件转DMF格式
+        :param datamine_file: 输入DataMine文件路径
+        :param dmf_file: 输出DMF文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.datamine_to_dmf("input.dat", "output.dmf")
+        ```
+        """
+        return Dm.dmIO_DataMineToDmf(str(datamine_file), str(dmf_file))
+
+    @staticmethod
+    def mapgis_to_dmf(mapgis_file: Union[str, Path], dmf_file: Union[str, Path]) -> bool:
+        """
+        MapGIS文件转DMF格式
+        :param mapgis_file: 输入MapGIS文件路径
+        :param dmf_file: 输出DMF文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.mapgis_to_dmf("input.map", "output.dmf")
+        ```
+        """
+        return Dm.dmIO_MapGisToDmf(str(mapgis_file), str(dmf_file))
+
+    @staticmethod
+    def dmf_to_mapgis(dmf_file: Union[str, Path], mapgis_file: Union[str, Path]) -> bool:
+        """
+        DMF文件转MapGIS格式
+        :param dmf_file: 输入DMF文件路径
+        :param mapgis_file: 输出MapGIS文件路径
+        :return: 是否转换成功
+
+        example:
+        ```python
+        FileConverter.dmf_to_mapgis("input.dmf", "output.map")
+        ```
+        """
+        return Dm.dmIO_DmfToMapGis(str(dmf_file), str(mapgis_file))

dimine_python_sdk/lib/io/models.py

@@ -0,0 +1,180 @@
+from dataclasses import dataclass,field
+from typing import Optional, Dict, Any,List
+
+@dataclass
+class LayoutParam:
+    """
+    包含原点坐标、法向量、坐标轴、厚度等核心布局参数
+    """
+    # 原点坐标
+    origin_x: float  # 原点X坐标
+    origin_y: float  # 原点Y坐标
+    origin_z: float  # 原点Z坐标
+
+    # 法向量
+    normal_x: float  # 法向量X分量
+    normal_y: float  # 法向量Y分量
+    normal_z: float  # 法向量Z分量
+
+    # X轴向量
+    x_axis_x: float  # X轴向量X分量
+    x_axis_y: float  # X轴向量Y分量
+    x_axis_z: float  # X轴向量Z分量
+
+    # Y轴向量
+    y_axis_x: float  # Y轴向量X分量
+    y_axis_y: float  # Y轴向量Y分量
+    y_axis_z: float  # Y轴向量Z分量
+
+    # 厚度参数
+    forward_thickness: float  # 正向厚度
+    reverse_thickness: float  # 反向厚度
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典，便于JSON序列化"""
+        return {
+            "origin_x": self.origin_x,
+            "origin_y": self.origin_y,
+            "origin_z": self.origin_z,
+            "normal_x": self.normal_x,
+            "normal_y": self.normal_y,
+            "normal_z": self.normal_z,
+            "x_axis_x": self.x_axis_x,
+            "x_axis_y": self.x_axis_y,
+            "x_axis_z": self.x_axis_z,
+            "y_axis_x": self.y_axis_x,
+            "y_axis_y": self.y_axis_y,
+            "y_axis_z": self.y_axis_z,
+            "forward_thickness": self.forward_thickness,
+            "reverse_thickness": self.reverse_thickness
+        }
+
+@dataclass
+class BlockHatch:
+    angle:float
+    block_name:str
+    color:int
+    ratio:float
+
+@dataclass
+class PatternHatch:
+    angle:float
+    backcolor:int
+    color:int
+    pattern_name:str
+    ratio:float
+
+
+@dataclass
+class ProjectHatchItem:
+    """单个项目的 Hatch 参数"""
+    annotation_property: str
+    annotation_style: str
+    block_hatch: BlockHatch
+    pattern_hatch: PatternHatch
+    color: int = 0
+    line_style: str = "Continuous"
+    line_style_ratio: float = 1.0
+    line_weight: int = 6
+    name: str = ""
+    output_mode: int = 2
+
+
+@dataclass
+class PlotProjectParam:
+    """项目参数集合"""
+    enable: bool
+    file_project_param: List[ProjectHatchItem] = field(default_factory=list)
+    type: int = 0
+
+
+@dataclass
+class PlotBlockParam:
+    """块参数"""
+    display_mode: int
+    enable: bool
+    shrinkage_coefficient: float
+
+@dataclass
+class AnnotatinoStyleParam:
+    annotation_position: float = 0.0
+    style_bottom: str = ""
+    style_left: str = ""
+    style_right: str = ""
+    style_top: str = ""
+    text_size: float = 0.5
+
+@dataclass
+class PlotDrillParam:
+    """钻孔参数"""
+    AnnotatinoStyle: AnnotatinoStyleParam
+    annotation_collar_triangle: bool = False
+    annotation_cutting_point_circle: bool = False
+    annotation_drill_name: bool = False
+    annotation_hole_bottom_line: bool = False
+    annotation_position: float = 0.0
+    annotation_text_height: float = 0.0
+    collar_triangle_ratio: float = 0.0
+    cutting_into_point: bool = False
+    cutting_point_circle: float = 0.0
+    draw_sample_tray: bool = False
+    enable: bool = True
+    gram_per_ton_field_set: str = ""
+    have_intersetion_projection_track: bool = False
+    hole_bottom_line_length: float = 0.0
+    is_multiple_table: bool = False
+    negative_thickness: float = 20.0
+    no_intersetion_projection_track: bool = False
+    other_field_set: str = ""
+    output_drill_section: bool = False
+    output_param_table: bool = False
+    output_sample_info_table: bool = False
+    percentage_field_set: str = ""
+    positive_thickness: float = 20.0
+    reserve_drill_track_outside_layout: bool = False
+    sample_tray_content: str = ""
+    sample_tray_interval: float = 0.0
+    sample_tray_text_height: float = 0.0
+    sample_tray_width: float = 0.0
+
+@dataclass
+class PlotGirdParam:
+    """网格参数"""
+    check_x: bool
+    check_y: bool
+    check_z: bool
+    color: int
+    enable: bool
+    mode: int
+    separated: bool
+    text_height: float
+    x: float = 50.0
+    y: float = 50.0
+    z: float = 50.0
+    transverse: bool = False
+
+@dataclass
+class SetupParams:
+    """主配置参数类"""
+    current: bool
+    name: str
+    plot_block_param: PlotBlockParam
+    plot_drill_param: PlotDrillParam
+    plot_gird_param: PlotGirdParam
+    plot_hatch_param: Dict[str, Any] = field(default_factory=lambda: {"enable": False})
+    plot_project_param: PlotProjectParam = field(default_factory=PlotProjectParam)
+    uuid: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为嵌套字典，支持JSON序列化"""
+        def dc_to_dict(obj):
+            if isinstance(obj, (int, float, str, bool)):
+                return obj
+            elif hasattr(obj, '__dataclass_fields__'):
+                return {k: dc_to_dict(getattr(obj, k)) for k in obj.__dataclass_fields__}
+            elif isinstance(obj, list):
+                return [dc_to_dict(item) for item in obj]
+            elif isinstance(obj, dict):
+                return {k: dc_to_dict(v) for k, v in obj.items()}
+            return obj
+        return dc_to_dict(self)