flkit 0.1.0__py3-none-any.whl

flkit/alg/collierydb.py

@@ -0,0 +1,1217 @@
+import json
+from pathlib import Path
+import shutil
+import pandas as pd
+import numpy as np
+import pyvista as pv
+import flkit.alg as alg
+import flkit.typr as typr
+from flkit.alg.in_tin import is_point_in_triangles
+from flkit.alg.point_in_polygon import PointInPolygon
+from flkit.alg.rotated_rect import RotatedRect
+from flkit.model.engine import engine
+from flkit.utils import FileDB, getvar
+
+import datetime
+import tkinter.messagebox as messagebox
+
+from flkit.utils.c_grid import Grid3D
+from flkit.utils.utils import send_f
+
+COAL_FACE_FMT = "=id"
+COAL_VOXEL_FMT = "=i"
+STRATUM_FACE_FMT = "=d"
+STRATUM_VOXEL_FMT = "=i"
+BOUDN_FMT = "=i"
+FAULTAGE_FMT = "=iii"
+MASHGAS_FMT = "=d"
+
+
+# region 计算点是否在断层内
+def comp_in_fault(range, distance, in_fault):
+    if not in_fault:
+        return 0
+    if distance > range * 10:
+        return 0
+    return 1
+
+
+# endregion 计算点是否在断层内
+
+
+# region 颜色映射
+def get_colors(name: str):
+    """获取颜色列表"""
+    color_map = getvar(
+        "colliery",
+        "color_map",
+        {
+            "地表": "red",
+            "松散": "blue",
+            "砂岩层": "green",
+            "松散层2": "green",
+            "二1煤": "orange",
+        },
+    )
+    return color_map.get(name, "red")
+
+
+# endregion 颜色映射
+
+
+# region 当前时间
+def now() -> datetime.datetime:
+    return datetime.datetime.now().isoformat()
+
+
+# endregion 当前时间
+
+
+# region 煤矿数据库元数据
+class CollieryMeta:
+    def __init__(
+        self,
+        name: str,  # 名称
+        create_at: None,  # 创建时间
+        creator: str,  # 创建人
+        bound: False,  # 边界
+        blocks: False,  # 块
+        voxel: False,  # 体素参数
+        mashgas: False,  #  瓦斯
+        tunnels: False,  # 巷道
+        faultage: False,  # 断层
+        stratum: False,  #  地层
+        volume: False,  #  地质体
+        coal: False,  #  底抽巷煤层
+    ):
+        self.name = name
+        self.create_at = create_at if create_at else now()
+        self.creator = creator
+        self.bound = bound
+        self.blocks = blocks
+        if not voxel:
+            voxel = {"mode": "", "params": {}, "gen": False}
+        self.voxel = voxel
+        self.mashgas = mashgas
+        if not tunnels:
+            tunnels = {"names": [], "gen": False}
+        self.tunnels = tunnels
+        if not faultage:
+            faultage = {"names": [], "gen": False}
+        self.faultage = faultage
+        if not stratum:
+            stratum = {"names": [], "gen": False}
+        self.stratum = stratum
+        if not volume:
+            volume = {"names": [], "gen": False}
+        self.volume = volume
+        if not coal:
+            coal = {"names": [], "gen": False}
+        self.coal = coal
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "create_at": self.create_at,
+            "creator": self.creator,
+            "bound": self.bound,
+            "blocks": self.blocks,
+            "voxel": self.voxel,
+            "mashgas": self.mashgas,
+            "tunnels": self.tunnels,
+            "faultage": self.faultage,
+            "stratum": self.stratum,
+            "volume": self.volume,
+            "coal": self.coal,
+        }
+
+    def save(self, path: Path):
+        path.write_text(
+            json.dumps(self.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+
+    @staticmethod
+    def init(base: Path) -> "CollieryMeta":
+        config_path = base / "meta.json"
+        # 如果不存在侧初始化meta文件
+        if not config_path.exists():
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            meta = CollieryMeta(
+                base.stem,
+                None,
+                None,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+                False,
+            )
+            meta.save(config_path)
+            return meta
+        # 从文件中加载meta
+        data = json.loads(config_path.read_text(encoding="utf-8"))
+        return CollieryMeta(**data)
+
+
+# endregion 煤矿数据库元数据
+
+
+# region 煤矿数据库
+class CollieryDB:
+    def __init__(self, name: str, auto_init: bool = True):
+        self.name = name
+        self.base = Path(typr.getenv("JSON_DB_DIR", ".json_db")) / self.name
+        if not self.base.exists():
+            if auto_init:
+                self.base.mkdir(parents=True, exist_ok=True)
+            else:
+                raise ValueError(f"煤矿 {self.name} 不存在")
+        self.meta = CollieryMeta.init(self.base)
+
+    # region 边界
+    def set_bound(self, path: Path):
+        """
+        设置煤矿边界
+
+        bound文件结构：
+        [
+            {
+                "x": 12,
+                "y": 34,
+            },
+            {
+                "x": 45,
+                "y": 6,
+            },
+            {
+                "x": 12,
+                "y": 34,
+            }
+        ]
+        """
+        data = pd.read_excel(path, sheet_name="info")
+        if "x" not in data.columns or "y" not in data.columns:
+            raise ValueError(f"Excel 文件 {path} 中必须包含 x, y 列")
+        data = data[["x", "y"]].values
+        if not np.array_equal(data[0], data[-1]):
+            raise ValueError(f"Excel 文件 {path} 中首尾坐标不一致，不是封闭区域")
+        np.save(self.base / "bound.npy", np.array(data))
+        self.meta.bound = False
+        self.meta.save(self.base / "meta.json")
+
+    def comp_bound(self):
+        """
+        计算煤矿边界
+        """
+        grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+        data = np.load(self.base / "bound.npy")
+        ppn = PointInPolygon(data)
+        file_db = FileDB(self.base / "voxel" / "bound" / "bound.cube", BOUDN_FMT)("wb")
+        up_in = False
+        up_index = [None, None]
+        total = grid3d.sum()
+        for idx, index, point in grid3d.enumerate():
+            if idx % 1000000 == 0:
+                print(f"已处理 {idx} 个点，共 {total} 个点 进度 {idx / total:.2%}")
+            if index[0] != up_index[0] or index[1] != up_index[1]:
+                up_index = index
+                up_in = ppn.is_inside(point)
+            file_db.append([int(up_in)])
+        self.meta.bound = True
+        self.meta.save(self.base / "meta.json")
+
+    # endregion 边界
+
+    # region 块段
+    def set_blocks(self, path: Path):
+        raise ValueError("尚未实现设置块功能")
+
+    # endregion 块
+
+    # region 体素
+    def set_voxel(
+        self,
+        mode: str,
+        z_min: float,
+        z_max: float,
+        x_min: float = None,
+        x_max: float = None,
+        y_min: float = None,
+        y_max: float = None,
+        x_step: float = None,
+        y_step: float = None,
+        z_step: float = None,
+        from_bound: bool = False,
+    ):
+        voxel_path = self.base / "voxel"
+        # 统一检查边界文件是否存在，避免后续重复判断
+        bound_exists = (self.base / "bound.npy").exists()
+        if from_bound:
+            if not bound_exists:
+                raise ValueError("未设置煤矿边界，无法依照边界生成范围")
+            bound = np.load(self.base / "bound.npy")
+            x_min, x_max = np.min(bound[:, 0]), np.max(bound[:, 0])
+            y_min, y_max = np.min(bound[:, 1]), np.max(bound[:, 1])
+
+        if mode == "signed":
+            # 提前检查边界是否存在，避免后续重复判断
+            if not bound_exists:
+                raise ValueError("未设置煤矿边界，无法生成体素")
+            if None in [
+                x_min,
+                x_max,
+                y_min,
+                y_max,
+                z_min,
+                z_max,
+                x_step,
+                y_step,
+                z_step,
+            ]:
+                raise ValueError("signed 模式下必须提供所有参数")
+            if x_min >= x_max or y_min >= y_max or z_min >= z_max:
+                raise ValueError("体素参数中，最小坐标必须小于最大坐标")
+            if x_step <= 0 or y_step <= 0 or z_step <= 0:
+                raise ValueError("体素参数中，步长必须大于0")
+            # 检查目录是否存在前，先确保不会误删
+            if voxel_path.exists():
+                raise ValueError(
+                    f"voxel 目录 {voxel_path} 已存在，为防止数据丢失，已拒绝操作"
+                )
+            voxel_path.mkdir(parents=True, exist_ok=True)
+            self.meta.voxel["mode"] = mode
+            self.meta.voxel["params"] = {
+                "x_min": x_min,
+                "x_max": x_max,
+                "y_min": y_min,
+                "y_max": y_max,
+                "z_min": z_min,
+                "z_max": z_max,
+                "x_step": x_step,
+                "y_step": y_step,
+                "z_step": z_step,
+            }
+            self.meta.voxel["gen"] = False
+            self.meta.save(self.base / "meta.json")
+        elif mode == "auto":
+            if None in [x_min, x_max, y_min, y_max, z_min, z_max]:
+                raise ValueError("auto 模式下必须提供所有参数")
+            if voxel_path.exists():
+                raise ValueError(
+                    f"voxel 目录 {voxel_path} 已存在，为防止数据丢失，已拒绝操作"
+                )
+            voxel_path.mkdir(parents=True, exist_ok=True)
+            # 此处可预留自动体素生成逻辑
+            raise ValueError("auto 模式下未实现自动体素生成功能")
+        else:
+            raise ValueError(f"不支持的体素生成模式: {mode}")
+
+    def show_one_voxel(
+        self,
+        typ: str = "bound",
+        opacity: float = 1,
+        edge_color: str = "black",
+        cmap: str = "viridis",
+        line_width: float = 0.5,
+        show_edges: bool = False,
+        show_scalar_bar: bool = False,
+        scalar_bar_args: dict = None,
+        bound: bool = True,
+    ):
+        dtype = np.int32
+        if typ == "stratum":
+
+            def l_map(values: list):
+                if values[0] == 0:
+                    return False, 0
+                # if values[0] != 3:
+                #     return False, 0
+                return True, values[0]  # 使用整数标签而不是字符串
+
+            file_path = self.base / "voxel" / "stratum" / "stratum.cube"
+            fmt = STRATUM_VOXEL_FMT
+        elif typ == "mashgas":
+
+            def l_map(values: list):
+                # 检查是否为NaN值，如果是则跳过
+                if np.isnan(values[0]):
+                    return False, 0
+                return True, values[0]
+
+            file_path = self.base / "voxel" / "mashgas" / "mashgas.cube"
+            fmt = MASHGAS_FMT
+            cmap = "cool"
+        elif typ == "coal":
+
+            def l_map(values: list):
+                if values[0] == 0:
+                    return False, 0
+                return True, values[0]
+
+            file_path = self.base / "voxel" / "coal" / "coal.cube"
+            fmt = COAL_VOXEL_FMT
+        elif typ == "faultage":
+
+            def l_map(values: list):
+                if values[0] == 0:
+                    return False, 0
+                return True, values[-1]
+
+            file_path = self.base / "voxel" / "faultage" / "faultage.cube"
+            fmt = FAULTAGE_FMT
+        else:
+            raise ValueError(f"不支持的体素类型: {typ}")
+
+        grid = Grid3D.from_step(**self.meta.voxel["params"])
+        bound_db = FileDB(self.base / "voxel" / "bound" / "bound.cube", "=i")("rb")
+        file_db = FileDB(file_path, fmt)("rb")
+        nx = int((grid.info.x_max - grid.info.x_min) // grid.info.x_step)
+        ny = int((grid.info.y_max - grid.info.y_min) // grid.info.y_step)
+        nz = int((grid.info.z_max - grid.info.z_min) // grid.info.z_step)
+        cell_nx, cell_ny, cell_nz = nx - 1, ny - 1, nz - 1
+        cell_label_ids = np.zeros((cell_nx, cell_ny, cell_nz), dtype=dtype)
+        vtk = engine()
+        sum_voxel = 0
+        for idx, index, point in grid.enumerate():
+            if idx % 1000000 == 0:
+                send_f(
+                    f"结构进度: {idx}/{grid.sum()} ({idx / (grid.sum()) * 100:.2f}%)"
+                )
+            if bound:
+                in_bound = bound_db.search(idx)[0] == 1
+                if not in_bound:
+                    continue
+            values = file_db.search(idx)
+            visible, label = l_map(values)
+            if not visible:
+                continue
+            x_i, y_i, z_i = index
+            if 0 <= x_i < cell_nx and 0 <= y_i < cell_ny and 0 <= z_i < cell_nz:
+                cell_label_ids[x_i, y_i, z_i] = label
+                sum_voxel += 1
+
+        if sum_voxel == 0:
+            send_f("没有可见体素")
+            return
+        else:
+            send_f(f"共发现 {sum_voxel} 个可见体素")
+
+        volume = pv.ImageData(
+            dimensions=(nx, ny, nz),
+            spacing=(grid.info.x_step, grid.info.y_step, grid.info.z_step),
+            origin=(grid.info.x_min, grid.info.y_min, grid.info.z_min),
+        )
+        volume.cell_data["label_id"] = cell_label_ids.flatten(order="F")
+        filtered_volume = volume.threshold(0.5, scalars="label_id")
+        vtk.add_mesh(
+            filtered_volume,
+            cmap=cmap,
+            show_edges=show_edges,
+            edge_color=edge_color,
+            line_width=line_width,
+            opacity=opacity,
+            interpolate_before_map=False,
+            show_scalar_bar=show_scalar_bar,
+            scalar_bar_args=scalar_bar_args
+            or {
+                "title": "地质结构",
+                "position_x": 0.02,
+                "position_y": 0.1,
+            },
+        )
+        send_f("体素可视化完成")
+
+    def show_voxel(
+        self,
+        opacity: float = 1,
+        edge_color: str = "black",
+        cmap: str = "viridis",
+        att_cmap: str = "cool",
+        line_width: float = 0.5,
+        show_edges: bool = False,
+        show_scalar_bar: bool = False,
+        scalar_bar_args: dict = None,
+        bound: bool = True,
+    ):
+        bound_db = FileDB(self.base / "voxel" / "bound" / "bound.cube", BOUDN_FMT)("rb")
+        stratum_db = FileDB(
+            self.base / "voxel" / "stratum" / "stratum.cube", STRATUM_VOXEL_FMT
+        )("rb")
+        coal_db = FileDB(self.base / "voxel" / "coal" / "coal.cube", COAL_VOXEL_FMT)(
+            "rb"
+        )
+        mashgas_db = FileDB(
+            self.base / "voxel" / "mashgas" / "mashgas.cube", MASHGAS_FMT
+        )("rb")
+        faultage_db = FileDB(
+            self.base / "voxel" / "faultage" / "faultage.cube", FAULTAGE_FMT
+        )("rb")
+        grid = Grid3D.from_step(**self.meta.voxel["params"])
+        nx = int((grid.info.x_max - grid.info.x_min) // grid.info.x_step)
+        ny = int((grid.info.y_max - grid.info.y_min) // grid.info.y_step)
+        nz = int((grid.info.z_max - grid.info.z_min) // grid.info.z_step)
+        cell_nx, cell_ny, cell_nz = nx - 1, ny - 1, nz - 1
+        cell_label_ids = np.zeros((cell_nx, cell_ny, cell_nz), dtype=np.float64)
+        cell_label_ids2 = np.zeros((cell_nx, cell_ny, cell_nz), dtype=np.float64)
+        cell_idx = np.zeros((cell_nx, cell_ny, cell_nz), dtype=np.int32)
+
+        all_labels = []
+        voxel_labels = (
+            self.meta.stratum["names"]
+            + self.meta.coal["names"]
+            + self.meta.faultage["names"]
+        )
+        print(voxel_labels)
+        labels = {
+            "x": [],
+            "y": [],
+            "z": [],
+            "stratum": [],
+            "coal": [],
+            "mashgas": [],
+            "faultage": [],
+            "voxel": [],
+        }
+        vtk = engine()
+        label_idx = 0
+        for idx, index, point in grid.enumerate():
+            if bound:
+                in_bound = bound_db.search(idx)[0] == 1
+                if not in_bound:
+                    continue
+            stratum_val = stratum_db.search(idx)
+            if stratum_val[0] == 0:
+                continue
+            coal_val = coal_db.search(idx)
+            mashgas_val = mashgas_db.search(idx)
+            faultage_val = faultage_db.search(idx)
+            labels["x"].append(point[0])
+            labels["y"].append(point[1])
+            labels["z"].append(point[2])
+            stratum_idx = (
+                voxel_labels.index(self.meta.stratum["names"][stratum_val[0] - 1]) + 1
+            )
+            faultage_idx = (
+                voxel_labels.index(self.meta.faultage["names"][faultage_val[-1] - 1])
+                + 1
+            )
+            voxel_l = stratum_idx
+            all_labels.append(
+                {
+                    "地层名称": voxel_labels[stratum_idx],
+                    "工作面采区": (
+                        self.meta.coal["names"][coal_val[0] - 1]
+                        if coal_val[0] != 0
+                        else "无"
+                    ).replace("gzm", "4103工作面"),
+                    "断层编号": (
+                        self.meta.faultage["names"][faultage_val[-1] - 1]
+                        if faultage_val[-1] != 0
+                        else "无"
+                    ).replace("id_7", "23-1"),
+                    "瓦斯含量": mashgas_val[0],
+                }
+            )
+            label_idx += 1
+            voxel_l2 = 0
+            if coal_val[0] != 0:
+                voxel_l = (
+                    voxel_labels.index(self.meta.coal["names"][coal_val[0] - 1]) + 1
+                )
+                voxel_l2 = 0
+            if "砂岩层" in voxel_labels[stratum_idx - 1]:
+                voxel_l = 0
+                voxel_l2 = mashgas_val[0]
+            if faultage_val[0] == 1:
+                voxel_l = faultage_idx
+                voxel_l2 = 0
+            x_i, y_i, z_i = index
+            if 0 <= x_i < cell_nx and 0 <= y_i < cell_ny and 0 <= z_i < cell_nz:
+                cell_label_ids[x_i, y_i, z_i] = voxel_l
+                cell_label_ids2[x_i, y_i, z_i] = voxel_l2
+                cell_idx[x_i, y_i, z_i] = label_idx
+            if idx % 1000000 == 0:
+                send_f(
+                    f"结构进度: {idx}/{grid.sum()} ({idx / (grid.sum()) * 100:.2f}%)"
+                )
+        volume = pv.ImageData(
+            dimensions=(nx, ny, nz),
+            spacing=(grid.info.x_step, grid.info.y_step, grid.info.z_step),
+            origin=(grid.info.x_min, grid.info.y_min, grid.info.z_min),
+        )
+        volume.cell_data["label_id"] = cell_label_ids.flatten(order="F")
+        volume.cell_data["label_idx"] = cell_idx.flatten(order="F")
+        filtered_volume = volume.threshold(0.5, scalars="label_id")
+        volume2 = pv.ImageData(
+            dimensions=(nx, ny, nz),
+            spacing=(grid.info.x_step, grid.info.y_step, grid.info.z_step),
+            origin=(grid.info.x_min, grid.info.y_min, grid.info.z_min),
+        )
+        volume2.cell_data["label_id"] = cell_label_ids2.flatten(order="F")
+        volume2.cell_data["label_idx"] = cell_idx.flatten(order="F")
+        filtered_volume2 = volume2.threshold(0.5, scalars="label_id")
+        print(f"共有体素：{filtered_volume2.n_cells}")
+
+        def pick_callback(point):
+            """鼠标点击回调：显示被点击位置最近体素的信息"""
+            print("=" * 50)
+            print("🔍 体素点击事件触发")
+            print(f"📍 点击坐标: ({point[0]:.2f}, {point[1]:.2f}, {point[2]:.2f})")
+
+            try:
+                # 在第一个体素中查找最近的单元
+                cell_id = filtered_volume.find_closest_cell(point)
+                if cell_id is None or cell_id < 0 or cell_id >= filtered_volume.n_cells:
+                    print("❌ 未找到有效体素")
+                    print("=" * 50)
+                    return
+
+                label_id = int(filtered_volume.cell_data["label_id"][cell_id])
+                label_idx = int(filtered_volume.cell_data["label_idx"][cell_id])
+                label_info = all_labels[label_idx]
+                print(f"✅ 最近体素ID: {cell_id}，label_id = {label_id}")
+                print(f"📋 标签信息: {label_info}")
+
+                # 尝试使用 messagebox，如果失败则只用 print
+                try:
+                    import tkinter as tk
+
+                    root = tk.Tk()
+                    root.withdraw()  # 隐藏主窗口
+                    # 将标签信息格式化为更易读的字符串
+                    formatted_labels = []
+                    for key, val in label_info.items():
+                        if isinstance(val, (int, float)) and not isinstance(val, bool):
+                            formatted_labels.append(f"{key}: {val:.2f}")
+                        else:
+                            formatted_labels.append(f"{key}: {val}")
+                    label_str = "\n".join(formatted_labels)
+
+                    messagebox.showinfo(
+                        "体素信息",
+                        f"体素ID: {cell_id}\nlabel_id: {voxel_labels[label_id - 1]}\n标签信息:\n{label_str}\n坐标: ({point[0]:.2f}, {point[1]:.2f}, {point[2]:.2f})",
+                    )
+                    root.destroy()
+                except Exception as e:
+                    print(f"⚠️  消息框显示失败: {e}")
+                    print(
+                        f"📋 体素信息: ID={cell_id}, label_id={label_id}, 标签={label_info}"
+                    )
+            except Exception as e:
+                print(f"❌ 获取体素信息失败: {e}")
+            print("=" * 50)
+
+        vtk.add_mesh(
+            filtered_volume,
+            cmap=cmap,
+            show_edges=show_edges,
+            edge_color=edge_color,
+            line_width=line_width,
+            opacity=opacity,
+            interpolate_before_map=False,
+            show_scalar_bar=show_scalar_bar,
+            scalar_bar_args=scalar_bar_args
+            or {
+                "title": "地质结构",
+                "position_x": 0.06,
+                "position_y": 0.2,
+            },
+            pickable=True,
+        )
+        vtk.add_mesh(
+            filtered_volume2,
+            cmap=att_cmap,
+            show_edges=show_edges,
+            edge_color=edge_color,
+            line_width=line_width,
+            opacity=opacity,
+            interpolate_before_map=False,
+            show_scalar_bar=show_scalar_bar,
+            scalar_bar_args=scalar_bar_args
+            or {
+                "title": "瓦斯结构",
+                "position_x": 0.06,
+                "position_y": 0.1,
+            },
+            pickable=True,
+        )
+        # 启用点击拾取功能
+        vtk.enable_point_picking(callback=pick_callback, show_message=True)
+        send_f("体素可视化完成")
+
+    # endregion 体素
+
+    # region  瓦斯
+    def set_mashgas(self, path: Path):
+        data = pd.read_excel(path, sheet_name="info")
+        if (
+            "x" not in data.columns
+            or "y" not in data.columns
+            or "z" not in data.columns
+        ):
+            raise ValueError(f"Excel 文件 {path} 中必须包含 x, y, z 列")
+        # 以numpy数组的形式保存，保存为npy文件
+        data = data[["x", "y", "z", "value"]].values
+        np.save(self.base / "mashgas.npy", data)
+        self.meta.mashgas = False
+        self.meta.save(self.base / "meta.json")
+
+    def comp_mashgas(self, func: str = "idw"):
+        max_value = 0
+        grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+        data = np.load(self.base / "mashgas.npy")  # (N,4) [x,y,z,value]
+        interp = alg.inter.make_interpolator(func, dim=3).fit(data)
+        db = FileDB(self.base / "voxel" / "mashgas" / "mashgas.cube", MASHGAS_FMT)(
+            "w+b"
+        )
+        total = grid3d.sum()
+        for idx, index, point in grid3d.enumerate():
+            if idx % 1000000 == 0:
+                print(f"处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+            val = interp.predict(np.array(point))
+            max_value = max(max_value, abs(val))
+            db.append([val])
+        self.meta.mashgas = True
+        self.meta.save(self.base / "meta.json")
+
+    # endregion  mashgas
+
+    # region 巷道
+    def set_tunnels(self, path: Path):
+        raise ValueError("尚未实现设置巷道功能")
+
+    # endregion 巷道
+
+    # region 断层
+    def set_faultage(self, path: Path):
+        path_obj = self.base / "faultage.npy"
+
+        data = pd.read_excel(path, sheet_name="info")
+        if (
+            "x1" not in data.columns
+            or "y1" not in data.columns
+            or "z1" not in data.columns
+            or "x2" not in data.columns
+            or "y2" not in data.columns
+            or "z2" not in data.columns
+            or "x3" not in data.columns
+            or "y3" not in data.columns
+            or "z3" not in data.columns
+            or "gc" not in data.columns
+            or "lx" not in data.columns
+            or "range" not in data.columns
+            or "dcbh" not in data.columns
+        ):
+            raise ValueError(
+                f"Excel 文件 {path} 中必须包含 x1, y1, z1, x2, y2, z2, x3, y3, z3, gc, lx, range, dcbh 列"
+            )
+        data = data[
+            [
+                "x1",
+                "y1",
+                "z1",
+                "x2",
+                "y2",
+                "z2",
+                "x3",
+                "y3",
+                "z3",
+                "gc",
+                "lx",
+                "range",
+                "dcbh",
+            ]
+        ].values
+        if path_obj.exists():
+            old_data = np.load(self.base / "faultage.npy", allow_pickle=True)
+            data = np.vstack((old_data, data))
+        np.save(path_obj, data)
+        zkbhs = np.unique(data[:, -1])
+        self.meta.faultage["names"] = list(zkbhs)
+        self.meta.faultage["gen"] = False
+        self.meta.save(self.base / "meta.json")
+
+    def comp_faultage(self):
+        grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+        voxel_faultage_dir = self.base / "voxel"
+        voxel_faultage_dir.mkdir(parents=True, exist_ok=True)
+        file_db = FileDB(
+            self.base / "voxel" / "faultage" / "faultage.cube", FAULTAGE_FMT
+        )("w+b")
+        total = grid3d.sum()
+        if not (self.base / "faultage.npy").exists():
+            raise ValueError(f"断层数据文件不存在: {self.base / 'faultage.npy'}")
+        faultage_data = np.load(self.base / "faultage.npy", allow_pickle=True)
+
+        if faultage_data.size == 0:
+            raise ValueError("没有找到任何断层数据文件")
+        tins = faultage_data[:, :9].reshape(-1, 3, 3)
+
+        for idx, _, point in grid3d.enumerate():
+            if idx % 1000000 == 0:
+                print(f"处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+            is_inside, triangle_idx = is_point_in_triangles(
+                point, tins, faultage_data[:, -2]
+            )
+            file_db.append(
+                [
+                    is_inside,
+                    1,
+                    self.meta.faultage["names"].index(faultage_data[triangle_idx, -1])
+                    + 1
+                    if is_inside
+                    else 0,
+                ]
+            )
+        self.meta.faultage["gen"] = True
+        self.meta.save(self.base / "meta.json")
+
+    # endregion 断层
+
+    # region 地层
+    def set_stratum(self, names: list, path: Path):
+        if path.suffix != "":
+            raise ValueError(f"路径 {path} 必须是目录")
+        stratum_path = self.base / "voxel" / "stratum"
+        if stratum_path.exists():
+            shutil.rmtree(stratum_path)
+        stratum_path.mkdir(parents=True, exist_ok=True)
+        for name in names:
+            name_path = path / f"{name}.xlsx"
+            if not name_path.exists():
+                raise ValueError(f"找不到文件 {name_path}")
+            # 读取Excel文件，检查是否包含 x, y, z 列
+            data = pd.read_excel(name_path, sheet_name="info")
+            if (
+                "x" not in data.columns
+                or "y" not in data.columns
+                or "z" not in data.columns
+            ):
+                raise ValueError(f"Excel 文件 {name_path} 中必须包含 x, y, z 列")
+            # 以numpy数组的形式保存，保存为npy文件
+            data = data[["x", "y", "z"]].values
+            np.save(stratum_path / f"{name}.npy", data)
+        self.meta.stratum["names"] = names
+        self.meta.save(self.base / "meta.json")
+
+    def comp_stratum(self, func: str = "idw"):
+        self.face_stratum(func)
+        print("完成面层插值")
+        self.class_stratum()
+        print("完成地层分类")
+
+    def face_stratum(self, func: str = "idw"):
+        grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+        grid = grid3d.to_2d()
+        for name in self.meta.stratum["names"]:
+            data = np.load(self.base / "stratum" / f"{name}.npy")  # (N,3) [x,y,z]
+            interp = alg.inter.make_interpolator(func, dim=2).fit(data)
+            db = FileDB(
+                self.base / "voxel" / "stratum" / f"{name}.bin", STRATUM_FACE_FMT
+            )("w+b")
+            total = grid.sum()
+            for idx, _, p in grid.enumerate():
+                if idx % 100000 == 0:
+                    print(f"{name} 处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+                z = interp.predict([np.array(p[:2])])[0]
+                db.append([z])
+
+    def class_stratum(self):
+        grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+        grid = grid3d.to_2d()
+        stratums = self.meta.stratum["names"]
+        dbs = [
+            FileDB(self.base / "voxel" / "stratum" / f"{name}.bin", STRATUM_FACE_FMT)
+            for name in stratums
+        ]
+        for db in dbs:
+            db("r+b")
+        total = grid3d.sum()
+        file_db = FileDB(
+            self.base / "voxel" / "stratum" / "stratum.cube", STRATUM_VOXEL_FMT
+        )
+        file_db("w+b")
+        up_lays = []
+        up_index = [None, None]
+        for idx, index, point in grid3d.enumerate():
+            if idx % 1000000 == 0:
+                print(f"处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+            z = point[2]
+
+            # 检查是否需要更新缓存（当x,y坐标发生变化时）
+            if up_index[0] != index[0] or up_index[1] != index[1]:
+                # 新的(x,y)位置，更新缓存
+                up_index[0] = index[0]
+                up_index[1] = index[1]
+                idx2d = grid.get_idx(index)
+
+                # 一次性查询所有地层数据并缓存到up_lays
+                up_lays = []
+                for lay_idx in range(len(stratums)):
+                    up_lays.append(dbs[lay_idx].search(idx2d)[0])
+
+            # 使用缓存的数据进行地层分类
+            label = 0
+            for lay_idx in range(1, len(stratums)):
+                up_val = up_lays[lay_idx - 1]
+                down_val = up_lays[lay_idx]
+                if down_val < z <= up_val:
+                    label = lay_idx
+                    break
+            file_db.append([label])
+        self.meta.stratum["gen"] = True
+        self.meta.save(self.base / "meta.json")
+
+    def show_stratum(self, names: str = "*"):
+        if names == "*":
+            names = self.meta.stratum["names"]
+            grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+            grid = grid3d.to_2d()
+            vtk = engine()
+            for name in names:
+                filedb = FileDB(
+                    self.base / "voxel" / "stratum" / f"{name}.bin", STRATUM_FACE_FMT
+                )
+                filedb("r+b")
+                total = grid.sum()
+                layers_grid = []
+                for idx, index, point in grid.enumerate():
+                    if idx % 1000000 == 0:
+                        print(f"{name} 处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+                    pre_v = filedb.search(idx)[0]
+                    layers_grid.append((point[0], point[1], pre_v))
+                layers_grid_array = np.array(layers_grid)
+                points = np.column_stack(
+                    (
+                        layers_grid_array[:, 0],
+                        layers_grid_array[:, 1],
+                        layers_grid_array[:, 2],
+                    )
+                )
+                surface = pv.PolyData(points).delaunay_2d()
+                vtk.add_mesh(surface, scalars=points[:, 2], color=get_colors(name))
+
+            input("按任意键继续")
+        else:
+            for name in names.split(","):
+                data = np.load(self.base / "stratum" / f"{name}.npy")
+                send_f(f"已展示地层数据 - {name} ({data.shape[0]} 个点)")
+
+    # endregion 地层
+
+    # region 地质体
+    def set_volume(self, path: Path):
+        raise ValueError("尚未实现设置地质体功能")
+
+    # endregion 地质体
+
+    # region 煤体
+    def set_coal(self, path: Path, name: str):
+        # 确保coal目录存在
+        coal_dir = self.base / "coal"
+        coal_dir.mkdir(parents=True, exist_ok=True)
+
+        path_obj = coal_dir / f"{name}.npy"
+        if path_obj.exists():
+            raise ValueError(f"煤体名称 {name} 已存在")
+        data = pd.read_excel(path, sheet_name="info")
+        if (
+            "x1" not in data.columns
+            or "y1" not in data.columns
+            or "z1" not in data.columns
+            or "x2" not in data.columns
+            or "y2" not in data.columns
+            or "z2" not in data.columns
+        ):
+            raise ValueError(f"Excel 文件 {path} 中必须包含 x1, y1, z1, x2, y2, z2 列")
+        # 以numpy数组的形式保存，保存为npy文件
+        data = data[["x1", "y1", "z1", "x2", "y2", "z2"]].values
+        np.save(path_obj, data)
+        self.meta.coal["names"].append(name)
+
+    def comp_coal(self, func: str = "idw", auto_bound: bool = True):
+        self.face_coal(func, auto_bound)
+        send_f("煤体分类完成")
+        self.class_coal(auto_bound)
+        send_f("煤体分类完成")
+
+    def face_coal(self, func: str = "idw", auto_bound: bool = True):
+        # 确保voxel/coal目录存在
+        voxel_coal_dir = self.base / "voxel" / "coal"
+        voxel_coal_dir.mkdir(parents=True, exist_ok=True)
+
+        coals = self.meta.coal["names"]
+        if not coals:
+            raise ValueError("未设置煤体")
+        for coal in coals:
+            grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+            grid = grid3d.to_2d()
+            file_db_up = FileDB(
+                self.base / "voxel" / "coal" / f"{coal}_up.bin", COAL_FACE_FMT
+            )("w+b")
+            file_db_down = FileDB(
+                self.base / "voxel" / "coal" / f"{coal}_down.bin", COAL_FACE_FMT
+            )("w+b")
+            total = grid.sum()
+            data = np.load(
+                self.base / "coal" / f"{coal}.npy"
+            )  # shape: (N, 6) [x1,y1,z1,x2,y2,z2]
+
+            # 分离顶板和底板数据
+            top_data = data[:, [0, 1, 2]]  # [x1, y1, z1] - 顶板数据
+            bottom_data = data[:, [3, 4, 5]]  # [x2, y2, z2] - 底板数据
+
+            if auto_bound:
+                # 使用xy坐标范围计算边界框（使用顶板数据的xy坐标）
+                rotate_rect = RotatedRect(bottom_data[:, :2])
+
+            # 分别训练顶板和底板的插值器
+            # IDW2D和Kriging2D的fit方法期望(N,3)数组[x,y,z]
+            interp_up = alg.inter.make_interpolator(func, dim=2).fit(top_data)
+            interp_down = alg.inter.make_interpolator(func, dim=2).fit(bottom_data)
+
+            if auto_bound:
+                box, _ = rotate_rect.min_bounding_rect()
+            vi_voxel = 0
+            for idx, index, point in grid.enumerate():
+                if idx % 1000000 == 0:
+                    print(f"处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+                is_coal = False
+                up_val = 0
+                down_val = 0
+                if auto_bound:
+                    if rotate_rect.in_box(np.array(point[:2]).astype(np.float32), box):
+                        is_coal = True
+                        vi_voxel += 1
+                        up_val = interp_up.predict(np.array(point[:2]))
+                        down_val = interp_down.predict(np.array(point[:2]))
+                else:
+                    is_coal = True
+                    vi_voxel += 1
+                    up_val = interp_up.predict(np.array(point[:2]))
+                    down_val = interp_down.predict(np.array(point[:2]))
+                file_db_up.append([int(is_coal), up_val])
+                file_db_down.append([int(is_coal), down_val])
+
+    def class_coal(self, auto_bound: bool = True):
+        coals = self.meta.coal["names"]
+        if not coals:
+            raise ValueError("未设置煤体")
+        grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+        grid = grid3d.to_2d()
+        coal_obj = []
+        for coal in coals:
+            # 只读取之前face_coal生成的数据，不写入
+            up_db = FileDB(
+                self.base / "voxel" / "coal" / f"{coal}_up.bin", COAL_FACE_FMT
+            )("rb")
+            down_db = FileDB(
+                self.base / "voxel" / "coal" / f"{coal}_down.bin", COAL_FACE_FMT
+            )("rb")
+            data = np.load(
+                self.base / "coal" / f"{coal}.npy"
+            )  # shape: (N, 6) [x1,y1,z1,x2,y2,z2]
+
+            # 分离顶板和底板数据
+            top_data = data[:, [0, 1, 2]]  # [x1, y1, z1] - 顶板数据
+            bottom_data = data[:, [3, 4, 5]]  # [x2, y2, z2] - 底板数据
+            if auto_bound:
+                # 使用xy坐标范围计算边界框（使用顶板数据的xy坐标）
+                rotate_rect = RotatedRect(bottom_data[:, :2])
+                box, _ = rotate_rect.min_bounding_rect()
+                print(box)
+            else:
+                rotate_rect = None
+                box = None
+            coal_obj.append(
+                {
+                    "name": coal,
+                    "up_db": up_db,
+                    "down_db": down_db,
+                    "box": box,
+                    "rotate_rect": rotate_rect,
+                }
+            )
+        db_3d = FileDB(self.base / "voxel" / "coal" / "coal.cube", COAL_VOXEL_FMT)(
+            "w+b"
+        )
+        total = grid3d.sum()
+        up_index = [None, None]
+        up_coal_valuse = []
+        up_sum = 0
+        for idx, index, point in grid3d.enumerate():
+            if idx % 1000000 == 0:
+                print(f"处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+            if index[0] != up_index[0] or index[1] != up_index[1]:
+                up_index = index
+                up_coal_valuse = []
+                for coal in coal_obj:
+                    idx2d = grid.get_idx(index)
+                    up_in, up_val_up = coal["up_db"].search(idx2d)
+                    _, up_val_down = coal["down_db"].search(idx2d)
+                    up_coal_valuse.append(
+                        {
+                            "name": coal["name"],
+                            "up_val_up": up_val_up,
+                            "up_val_down": up_val_down,
+                        }
+                    )
+            coal_idx = 0
+            for idx, coal in enumerate(up_coal_valuse):
+                if auto_bound:
+                    if coal_obj[idx]["rotate_rect"].in_box(
+                        np.array(point[:2]).astype(np.float32), coal_obj[idx]["box"]
+                    ):
+                        if (
+                            up_in == 1
+                            and coal["up_val_down"] <= point[2] <= coal["up_val_up"]
+                        ):
+                            coal_idx = self.meta.coal["names"].index(coal["name"]) + 1
+                            up_sum += 1
+                else:
+                    if (
+                        up_in == 1
+                        and coal["up_val_down"] <= point[2] <= coal["up_val_up"]
+                    ):
+                        coal_idx = self.meta.coal["names"].index(coal["name"]) + 1
+                        up_sum += 1
+            db_3d.append([coal_idx])
+        if up_sum == 0:
+            raise ValueError("未找到任何煤体")
+        self.meta.coal["gen"] = True
+        self.meta.save(self.base / "meta.json")
+
+    def show_coal(self, names: str = "*"):
+        if names == "*":
+            names = self.meta.coal["names"]
+            grid3d = Grid3D.from_step(**self.meta.voxel["params"])
+            grid = grid3d.to_2d()
+            vtk = engine()
+            for name in names:
+                filedb_up = FileDB(
+                    self.base / "voxel" / "coal" / f"{name}_up.bin", COAL_FACE_FMT
+                )
+                filedb_down = FileDB(
+                    self.base / "voxel" / "coal" / f"{name}_down.bin", COAL_FACE_FMT
+                )
+                filedb_up("r+b")
+                filedb_down("r+b")
+                data = np.load(self.base / "coal" / f"{name}.npy")
+                bottom_data = data[:, [3, 4, 5]]
+                rotate_rect = RotatedRect(bottom_data[:, :2])
+                box, _ = rotate_rect.min_bounding_rect()
+                total = grid.sum()
+                layers_up = []
+                layers_down = []
+                for idx, index, point in grid.enumerate():
+                    if idx % 1000000 == 0:
+                        print(f"{name} 处理体素 {idx}/{total} 进度 {idx / total:.2%}")
+                    if rotate_rect.in_box(np.array(point[:2]), box):
+                        _, pre_v_up = filedb_up.search(idx)
+                        _, pre_v_down = filedb_down.search(idx)
+                        layers_up.append((point[0], point[1], pre_v_up))
+                        layers_down.append((point[0], point[1], pre_v_down))
+                layers_up_array = np.array(layers_up)
+                layers_down_array = np.array(layers_down)
+                points_up = np.column_stack(
+                    (
+                        layers_up_array[:, 0],
+                        layers_up_array[:, 1],
+                        layers_up_array[:, 2],
+                    )
+                )
+                points_down = np.column_stack(
+                    (
+                        layers_down_array[:, 0],
+                        layers_down_array[:, 1],
+                        layers_down_array[:, 2],
+                    )
+                )
+                surface_up = pv.PolyData(points_up).delaunay_2d()
+                vtk.add_mesh(
+                    surface_up, scalars=points_up[:, 2], color=get_colors(name)
+                )
+                surface_down = pv.PolyData(points_down).delaunay_2d()
+                vtk.add_mesh(
+                    surface_down, scalars=points_down[:, 2], color=get_colors(name)
+                )
+            input("按任意键继续")
+        else:
+            for name in names.split(","):
+                data = np.load(self.base / "stratum" / f"{name}.npy")
+
+    # endregion 煤体分类
+
+    # region 体素
+    def comp_voxel(self):
+        all_cube = {}
+        if self.meta.bound:
+            all_cube["bound"] = FileDB(self.base / "voxel" / "stratum.cube", "=i")(
+                "r+b"
+            )
+        if self.meta.blocks:
+            raise ValueError("未实现")
+        if self.meta.mashgas:
+            all_cube["mashgas"] = FileDB(
+                self.base / "voxel" / "mashgas" / "mashgas.cube", "=i"
+            )("r+b")
+        if self.meta.tunnels:
+            raise ValueError("未实现")
+        if self.meta.faultage["gen"]:
+            all_cube["faultage"] = []
+            faultages = list((self.base / "faultage").glob("*.npy"))
+            for faultage in faultages:
+                all_cube["faultage"].append(
+                    FileDB(
+                        self.base / "voxel" / "faultage" / f"{faultage.stem}.cube", "=i"
+                    )("r+b")
+                )
+        if self.meta.stratum["gen"]:
+            all_cube["stratum"] = FileDB(self.base / "voxel" / "stratum.cube", "=i")(
+                "r+b"
+            )
+        if self.meta.volume:
+            raise ValueError("未实现")
+        if self.meta.coal["gen"]:
+            all_cube["coal"] = FileDB(self.base / "voxel" / "coal.cube", "=i")("r+b")
+        self.meta.voxel["gen"] = True
+        self.meta.save(self.base / "meta.json")
+
+    # endregion 体素
+
+    # region 删除
+    def delete(self):
+        # 删除所有数据
+        shutil.rmtree(self.base)
+
+    # endregion 删除
+
+    # region 清空模型
+    def clearm(self):
+        # 清空模型
+        shutil.rmtree(self.base / "voxel")
+
+    # endregion 清空模型
+
+    # region 判断是否是新数据库
+    def is_new(self) -> bool:
+        return not self.base.exists()
+
+    # endregion 新数据库
+
+
+# endregion 煤矿数据库
+
+
+# region 所有数据库
+def all_db():
+    base = Path(typr.getenv("JSON_DB_DIR", ".json_db"))
+    # 返回数据库名列表
+    return [db.name for db in base.iterdir() if db.is_dir()]
+
+
+# endregion 所有数据库