dimine-python-sdk 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

dimine_python_sdk/__init__.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Any
 
 DOCS_PATH = Path(__file__).parent / "docs"
-__VERSION__ = "0.2.6"  # 由 build.bat 中的 generate_version.py 自动更新
+__VERSION__ = "0.2.7"  # 由 build.bat 中的 generate_version.py 自动更新
 
 
 _LAZY_IMPORTS: dict[str, Any] = {}

dimine_python_sdk/lib/blasting/__init__.py

@@ -0,0 +1,98 @@
+"""露天爆破设计模块：布孔 → 装药 → 起爆网络 → 分析 → 数据输出(DMO)
+
+纯 Python 业务域，不依赖 DmPyBindInterface（DMO 输出复用 :mod:`lib.io.dmo_file`）。
+Excel 报告（爆破设计说明书）由 skill 技能生成，不在此模块内。
+"""
+
+from dimine_python_sdk.lib.blasting.api import BlastError, run_full_design
+from dimine_python_sdk.lib.blasting.analysis import (
+    animate_blast,
+    blast_bounds,
+    flyrock_range,
+    plot_isochrones,
+    plot_time_histogram,
+    throw_direction,
+)
+from dimine_python_sdk.lib.blasting.charge_design import design_charge
+from dimine_python_sdk.lib.blasting.errors import (
+    BlastAnalysisError,
+    BlastChargeError,
+    BlastLayoutError,
+    BlastNetworkError,
+    BlastReportError,
+)
+from dimine_python_sdk.lib.blasting.explosive_db import (
+    ExplosiveDB,
+    ExplosiveDBError,
+    ExplosiveDBFormatError,
+    ExplosiveDBPathError,
+    explosive_db_conn,
+    explosivedb_path,
+)
+from dimine_python_sdk.lib.blasting.hole_layout import layout_holes
+from dimine_python_sdk.lib.blasting.models import (
+    AdjustRule,
+    BlastRegion,
+    BlastType,
+    ChargeMode,
+    ChargeParams,
+    ChargeResult,
+    ChargeSegment,
+    ConnectionType,
+    DetonatorType,
+    ElevationMode,
+    ElevationSpec,
+    Explosive,
+    FlyrockParams,
+    Hole,
+    HoleLayoutParams,
+    LayoutPattern,
+    NetworkParams,
+    NetworkResult,
+)
+from dimine_python_sdk.lib.blasting.network import build_network
+from dimine_python_sdk.lib.blasting.report import generate_dmo
+
+__all__ = [
+    "BlastError",
+    "BlastLayoutError",
+    "BlastChargeError",
+    "BlastNetworkError",
+    "BlastAnalysisError",
+    "BlastReportError",
+    "ExplosiveDBError",
+    "ExplosiveDBPathError",
+    "ExplosiveDBFormatError",
+    "explosivedb_path",
+    "ExplosiveDB",
+    "explosive_db_conn",
+    "LayoutPattern",
+    "ChargeMode",
+    "AdjustRule",
+    "DetonatorType",
+    "ConnectionType",
+    "BlastType",
+    "ElevationMode",
+    "ElevationSpec",
+    "BlastRegion",
+    "HoleLayoutParams",
+    "Hole",
+    "Explosive",
+    "ChargeSegment",
+    "ChargeParams",
+    "ChargeResult",
+    "NetworkParams",
+    "NetworkResult",
+    "FlyrockParams",
+    "layout_holes",
+    "design_charge",
+    "build_network",
+    "throw_direction",
+    "blast_bounds",
+    "flyrock_range",
+    "plot_isochrones",
+    "plot_time_histogram",
+    "animate_blast",
+    "generate_dmo",
+    "run_full_design",
+]

dimine_python_sdk/lib/blasting/analysis.py

@@ -0,0 +1,239 @@
+"""露天爆破设计 —— 爆破设计分析
+
+六项分析：爆破模拟动画、等时线、抛掷方向、起爆时间-孔数柱状图、
+飞石范围、爆破范围。
+
+对外主入口：
+  - ``plot_isochrones`` / ``plot_time_histogram`` / ``animate_blast``
+  - ``throw_direction`` / ``flyrock_range`` / ``blast_bounds``
+"""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Dict, List
+
+import numpy as np
+
+from dimine_python_sdk.lib.blasting.errors import BlastAnalysisError
+from dimine_python_sdk.lib.blasting.models import (
+    BlastRegion,
+    BlastType,
+    FlyrockParams,
+    Hole,
+)
+
+__all__ = [
+    "plot_isochrones",
+    "plot_time_histogram",
+    "animate_blast",
+    "throw_direction",
+    "flyrock_range",
+    "blast_bounds",
+]
+
+
+def _setup_cjk():
+    """配置 matplotlib：无界面后端 + 中文字体（避免中文显示为方块）。"""
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    plt.rcParams["font.sans-serif"] = [
+        "Microsoft YaHei", "SimHei", "SimSun", "Arial Unicode MS", "DejaVu Sans",
+    ]
+    plt.rcParams["axes.unicode_minus"] = False
+    return plt
+
+
+def _front_unit(region: BlastRegion) -> np.ndarray:
+    az = math.radians(region.front_azimuth)
+    return np.array([math.sin(az), math.cos(az)])
+
+
+def throw_direction(region: BlastRegion) -> Dict[str, object]:
+    """抛掷方向 = 前排方向（自由面朝向）单位矢量。"""
+    f = _front_unit(region)
+    return {
+        "azimuth": region.front_azimuth,
+        "vector": [float(f[0]), float(f[1])],
+        "note": "岩石抛掷方向 = 前排方向（自由面朝向）",
+    }
+
+
+def blast_bounds(holes: List[Hole]) -> Dict[str, float]:
+    """爆破范围 = 所有炮孔的最小外接盒（含孔口/孔底）。"""
+    if not holes:
+        return {}
+    xs = [h.mouth_x for h in holes] + [h.bottom_x for h in holes]
+    ys = [h.mouth_y for h in holes] + [h.bottom_y for h in holes]
+    zs = [h.mouth_z for h in holes] + [h.bottom_z for h in holes]
+    return {
+        "X最小": min(xs), "X最大": max(xs),
+        "Y最小": min(ys), "Y最大": max(ys),
+        "Z最小": min(zs), "Z最大": max(zs),
+        "炮孔数": len(holes),
+    }
+
+
+def flyrock_range(params: FlyrockParams) -> Dict[str, object]:
+    """飞石安全距离（GB 6722-2014）。
+
+    理论值 R = Kf·n·W；规范下限：深孔 ≥200m，浅孔/二次破碎 ≥300m；
+    下坡方向增大 50%。最终影响范围 = max(理论值, 规范下限)（下坡再 ×1.5）。
+    """
+    theory = params.Kf * params.n * params.W
+    floor = 300.0 if params.blast_type == BlastType.SHALLOW_HOLE else 200.0
+    base = max(theory, floor)
+    result = base * 1.5 if params.downhill else base
+    return {
+        "影响范围": round(result, 2),
+        "理论值": round(theory, 2),
+        "规范下限值": floor,
+        "爆破类型": params.blast_type.value,
+        "下坡方向": params.downhill,
+    }
+
+
+def plot_isochrones(
+    holes: List[Hole],
+    delays: Dict[str, int],
+    interval: float,
+    output_path: str,
+    title: str = "起爆等时线",
+    contour: bool = True,
+) -> str:
+    """等时线：按起爆时间着色炮孔，并叠加等高线式的等时线曲线。
+
+    等高线通过 Delaunay 三角剖分对起爆时间场插值后绘制（``tricontour``），
+    把同一时刻起爆的炮孔连成等时线曲线；曲线过密时自动加倍间隔，最多 20 条。
+    """
+    if not holes:
+        raise BlastAnalysisError("无炮孔数据，无法绘制等时线")
+    plt = _setup_cjk()
+
+    xs = np.array([h.mouth_x for h in holes], dtype=float)
+    ys = np.array([h.mouth_y for h in holes], dtype=float)
+    ts = np.array([delays.get(h.number, 0) for h in holes], dtype=float)
+    tmin, tmax = ts.min(), ts.max()
+
+    fig, ax = plt.subplots(figsize=(9, 7))
+    sc = ax.scatter(xs, ys, c=ts, cmap="viridis", edgecolors="k", s=55, zorder=3)
+    for h in holes:
+        d = delays.get(h.number, 0)
+        ax.annotate(f"{h.number}\n{d}ms", (h.mouth_x, h.mouth_y), fontsize=5,
+                    ha="center", textcoords="offset points", xytext=(0, 6), zorder=4)
+
+    # 等时线曲线（等高线式）
+    if contour and len(holes) >= 3:
+        try:
+            step = float(interval)
+            while True:
+                levels = np.arange(
+                    math.floor(tmin / step) * step, tmax + step, step
+                )
+                levels = levels[(levels > tmin) & (levels < tmax)]
+                if len(levels) <= 20 or step >= (tmax - tmin):
+                    break
+                step *= 2.0
+            if len(levels) == 0:
+                levels = np.array([tmin])
+            cs = ax.tricontour(xs, ys, ts, levels=levels, colors="black",
+                               linewidths=0.7, alpha=0.6, zorder=2)
+            ax.clabel(cs, fmt="%.0f ms", fontsize=6, inline=True)
+        except Exception:
+            # 三角剖分失败（点数不足 / 共线 / 值无变化）时静默跳过等时线
+            pass
+
+    fig.colorbar(sc, ax=ax, label="起爆时间 (ms)")
+    ax.set_aspect("equal", adjustable="datalim")
+    ax.set_title(title)
+    ax.set_xlabel("X"); ax.set_ylabel("Y")
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=150)
+    plt.close(fig)
+    return output_path
+
+
+def plot_time_histogram(
+    delays: Dict[str, int],
+    output_path: str,
+    bin_width: float = 10.0,
+    title: str = "起爆时间-爆破孔数量",
+) -> str:
+    """起爆时间-孔数柱状图：预警同时起爆孔过多。"""
+    if not delays:
+        raise BlastAnalysisError("无延时数据可绘制柱状图")
+    plt = _setup_cjk()
+
+    ts = list(delays.values())
+    tmin, tmax = min(ts), max(ts)
+    bins = np.arange(math.floor(tmin / bin_width) * bin_width,
+                     math.ceil(tmax / bin_width) * bin_width + bin_width, bin_width)
+
+    fig, ax = plt.subplots(figsize=(8, 4))
+    ax.hist(ts, bins=bins, edgecolor="black", color="steelblue")
+    ax.set_xlabel("起爆时间 (ms)")
+    ax.set_ylabel("同时起爆炮孔数")
+    ax.set_title(title)
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=150)
+    plt.close(fig)
+    return output_path
+
+
+def animate_blast(
+    holes: List[Hole],
+    delays: Dict[str, int],
+    output_path: str,
+    frame_interval: float = 10.0,
+) -> str:
+    """爆破模拟动画：整个网络的延时波前传播（GIF）。
+
+    依次点亮「已起爆」的炮孔，展示波前由起爆孔向全网传播。
+    """
+    if not holes:
+        raise BlastAnalysisError("无炮孔数据，无法生成爆破模拟动画")
+    plt = _setup_cjk()
+    from matplotlib.animation import FuncAnimation
+
+    xs = [h.mouth_x for h in holes]
+    ys = [h.mouth_y for h in holes]
+    ts = np.array([delays.get(h.number, 0) for h in holes])
+    tmax = int(ts.max()) if len(ts) else 0
+    frames = np.arange(0, tmax + frame_interval, frame_interval)
+
+    fig, ax = plt.subplots(figsize=(7, 6))
+    ax.set_aspect("equal", adjustable="datalim")
+    fired = ax.scatter([], [], c="red", s=70, label="已起爆")
+    unfired = ax.scatter(xs, ys, c="lightgray", s=40, label="未起爆")
+    # 标注每孔累积延时（编号 + 延时 ms）
+    for h in holes:
+        d = delays.get(h.number, 0)
+        ax.annotate(f"{h.number}\n{d}ms", (h.mouth_x, h.mouth_y), fontsize=5,
+                    ha="center", textcoords="offset points", xytext=(0, 6))
+    ax.legend(loc="upper right", fontsize=7)
+    title = ax.set_title("")
+
+    def init():
+        fired.set_offsets(np.empty((0, 2)))
+        return (fired,)
+
+    def update(t):
+        mask = ts <= t
+        pts = np.column_stack([np.array(xs)[mask], np.array(ys)[mask]])
+        fired.set_offsets(pts)
+        title.set_text(f"爆破波前传播  t={t:.0f} ms")
+        return (fired, title)
+
+    anim = FuncAnimation(fig, update, frames=frames, init_func=init, blit=True)
+    try:
+        anim.save(output_path, writer="pillow", fps=5, dpi=100)
+    except Exception:
+        # pillow 缺失时退化为帧序列
+        output_path = str(Path(output_path).with_suffix(".gif"))
+        anim.save(output_path, writer="pillow", fps=5, dpi=100)
+    plt.close(fig)
+    return output_path

dimine_python_sdk/lib/blasting/api.py

@@ -0,0 +1,136 @@
+"""露天爆破设计 —— 端到端编排（业务层）
+
+一键跑通 ①→⑥：布孔 → 装药 → 起爆网络连线 → 起爆孔 → 分析 → 数据输出(DMO)。
+
+对外主入口：``run_full_design(...)``
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from dimine_python_sdk.lib.blasting.analysis import (
+    animate_blast,
+    blast_bounds,
+    flyrock_range,
+    plot_isochrones,
+    plot_time_histogram,
+    throw_direction,
+)
+from dimine_python_sdk.lib.blasting.charge_design import design_charge
+from dimine_python_sdk.lib.blasting.errors import BlastError
+from dimine_python_sdk.lib.blasting.hole_layout import layout_holes
+from dimine_python_sdk.lib.blasting.models import (
+    BlastRegion,
+    ChargeParams,
+    Explosive,
+    FlyrockParams,
+    HoleLayoutParams,
+    NetworkParams,
+)
+from dimine_python_sdk.lib.blasting.network import build_network
+from dimine_python_sdk.lib.blasting.report import generate_dmo
+
+__all__ = ["BlastError", "run_full_design"]
+
+logger = logging.getLogger(__name__)
+
+
+def run_full_design(
+    region: BlastRegion,
+    layout_params: Optional[HoleLayoutParams] = None,
+    charge_params: Optional[ChargeParams] = None,
+    explosives: Optional[List[Explosive]] = None,
+    network_params: Optional[NetworkParams] = None,
+    flyrock_params: Optional[FlyrockParams] = None,
+    burden: float = 4.0,
+    output_dir: str = "blasting_output",
+) -> Dict[str, object]:
+    """执行完整露天爆破设计流程，返回各产物路径与摘要。
+
+    Args:
+        region: 爆区（多边形 + 前排方向 + 标高策略）
+        layout_params: 布孔参数，缺省用默认值
+        charge_params: 装药参数，缺省用默认值
+        explosives: 炸药信息库，缺省用乳化炸药默认库
+        network_params: 起爆网络参数，缺省用默认值
+        flyrock_params: 飞石参数（None 时不计算飞石范围）
+        burden: 最小抵抗线 W（m）
+        output_dir: 产物输出目录
+
+    Returns:
+        摘要字典（含各产物路径、爆破范围、抛掷方向、飞石范围、单段最大药量）
+
+    Raises:
+        BlastError: 任一步骤失败（细分 BlastLayoutError / BlastChargeError 等）
+    """
+    layout_params = layout_params or HoleLayoutParams()
+    charge_params = charge_params or ChargeParams()
+    network_params = network_params or NetworkParams()
+    explosives = explosives or [
+        Explosive(name="乳化炸药", line_density=5.0, unit_price=8.0),
+    ]
+
+    out = Path(output_dir)
+    analysis_dir = out / "analysis"
+    analysis_dir.mkdir(parents=True, exist_ok=True)
+
+    # ① 布孔
+    holes = layout_holes(region, layout_params)
+    if not holes:
+        raise BlastError("布孔结果为空，检查爆区多边形与安全距离参数")
+    logger.info("布孔完成：%d 个炮孔", len(holes))
+
+    # ③ 装药
+    charges = design_charge(holes, charge_params, explosives, burden)
+    logger.info("装药完成：%d 个孔", len(charges))
+
+    # ④ 起爆网络连线
+    network = build_network(holes, network_params,
+                            init_delay=layout_params.init_delay, charge_results=charges)
+    logger.info("起爆网络完成：%d 条连线，起爆孔 %s", len(network.edges), network.initiating_hole)
+
+    # ⑤ 设置起爆孔（标记）
+    for h in holes:
+        h.is_initiating = (h.number == network.initiating_hole)
+
+    # ⑥ 分析
+    iso_path = str(analysis_dir / "等时线.png")
+    hist_path = str(analysis_dir / "起爆时间-孔数柱状图.png")
+    anim_path = str(analysis_dir / "爆破模拟动画.gif")
+    plot_isochrones(holes, network.delays, layout_params.isochrone_interval, iso_path)
+    plot_time_histogram(network.delays, hist_path)
+    try:
+        animate_blast(holes, network.delays, anim_path)
+    except Exception as exc:  # pillow 缺失等
+        logger.warning("动画生成失败，跳过: %s", exc)
+        anim_path = ""
+
+    throw = throw_direction(region)
+    bounds = blast_bounds(holes)
+    flyrock = flyrock_range(flyrock_params) if flyrock_params else None
+
+    # ⑦ 数据输出：DMO 炮孔数据库（Excel 报告由 skill 技能生成，lib 不负责）
+    dmo_out = generate_dmo(holes, charges, network, region, str(out / "炮孔数据库.dmo"))
+
+    summary = {
+        "爆区": region.name,
+        "炮孔数": len(holes),
+        "连线数": len(network.edges),
+        "起爆孔": network.initiating_hole,
+        "爆破范围": bounds,
+        "抛掷方向": throw,
+        "飞石范围": flyrock,
+        "单段最大药量": max(network.segment_charges.values(), default=0.0),
+        "输出": {
+            "dmo": dmo_out,
+            "等时线": iso_path,
+            "柱状图": hist_path,
+            "动画": anim_path,
+        },
+    }
+    (out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    return summary

dimine_python_sdk/lib/blasting/charge_design.py

@@ -0,0 +1,186 @@
+"""露天爆破设计 —— 装药设计
+
+对每个炮孔按公式计算装药量、装药长度、填塞长度、分段结构，并做
+填塞长度 / 孔深守恒 / 分段装药校验。
+
+对外主入口：``design_charge(holes, params, explosives, burden) -> list[ChargeResult]``
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from dimine_python_sdk.lib.blasting.errors import BlastChargeError
+from dimine_python_sdk.lib.blasting.models import (
+    AdjustRule,
+    ChargeMode,
+    ChargeParams,
+    ChargeResult,
+    ChargeSegment,
+    Explosive,
+    Hole,
+)
+
+__all__ = ["design_charge"]
+
+_FILL_EXPLOSIVE = "炸药"
+_FILL_STEMMING = "填塞物"
+_FILL_SPACER = "间隔器"
+_FILL_PRIMER = "起爆药包"
+
+
+def _min_stemming(params: ChargeParams, burden: float, diameter_m: float) -> float:
+    """最小填塞长度 = max(最小堵塞长度, 0.7W, 20d, 4.5m)。"""
+    return max(params.min_stemming, 0.7 * burden, 20.0 * diameter_m, 4.5)
+
+
+def _segment_count(hole: Hole, params: ChargeParams) -> int:
+    """分段数：显式指定优先；否则间隔装药按孔深自动 2~3 段，连续装药 1 段。"""
+    if params.segments is not None:
+        return max(1, int(params.segments))
+    if params.template == "连续装药":
+        return 1
+    # 间隔装药：孔深 > 8m 分段，>15m 分 3 段
+    if hole.depth > 15.0:
+        return 3
+    if hole.depth > 8.0:
+        return 2
+    return 1
+
+
+def design_charge(
+    holes: List[Hole],
+    params: ChargeParams,
+    explosives: List[Explosive],
+    burden: float,
+) -> List[ChargeResult]:
+    """对每个炮孔做装药设计。
+
+    Args:
+        holes: 布孔结果
+        params: 装药参数
+        explosives: 炸药信息库（非空，第一个为计算主炸药）
+        burden: 最小抵抗线 W（m）
+
+    Returns:
+        每孔的装药结果（装药结构/装药量/填塞长度/间隔长度/单耗面积/警告）
+    """
+    if not explosives:
+        raise BlastChargeError("炸药信息库为空，请先提供炸药名称/线装药密度/单价")
+    primary = explosives[0]
+
+    results: List[ChargeResult] = []
+    for hole in holes:
+        a = hole.hole_spacing
+        b = hole.row_spacing
+        H = hole.bench_height  # 台阶高度 = 孔深 − 超深
+        is_front = hole.row == 0
+        diameter_m = hole.diameter / 1000.0  # mm -> m
+
+        # 单耗面积与装药量
+        if is_front:
+            area = a * burden  # 前排负担面积 a·W
+            charge_weight = params.specific_charge * a * burden * H
+        else:
+            area = a * b  # 后排负担面积 a·b
+            charge_weight = params.k * params.specific_charge * a * b * H
+
+        charge_length = charge_weight / primary.line_density
+        n_seg = _segment_count(hole, params)
+        spacer_total = params.spacer_length * (n_seg - 1) if n_seg > 1 else 0.0
+
+        warnings: List[str] = []
+
+        # 最小填塞（规范下限）
+        min_stem = _min_stemming(params, burden, diameter_m)
+        if params.charge_mode == ChargeMode.STEMMING_SPACER:
+            # 优先填塞和间隔器：进一步提高填塞下限
+            min_stem = max(min_stem, params.min_stemming + params.spacer_length)
+
+        # 可装药长度 = 孔深 − 最小填塞 − 间隔总长度；装药超限则截断
+        max_charge = hole.depth - min_stem - spacer_total
+        if max_charge < 0.0:
+            warnings.append(
+                f"孔深 {hole.depth:.2f}m 不足以容纳最小填塞 {min_stem:.2f}m + 间隔 {spacer_total:.2f}m"
+            )
+            max_charge = 0.0
+        if charge_length > max_charge + 0.2:
+            warnings.append(
+                f"装药长度 {charge_length:.2f}m 超过可装药长度 {max_charge:.2f}m，已截断"
+            )
+            charge_length = max(0.0, max_charge)
+            charge_weight = charge_length * primary.line_density
+
+        # 填塞长度 = 孔深 − 装药长度 − 间隔总长度（填满整个炮孔）
+        stemming = hole.depth - charge_length - spacer_total
+
+        # 构建分段结构（自孔口→孔底）
+        segments = _build_segments(
+            hole, params, charge_length, charge_weight, stemming, n_seg, primary
+        )
+
+        results.append(ChargeResult(
+            hole_number=hole.number,
+            depth=hole.depth,
+            charge_length=sum(s.length for s in segments if s.fill_type == _FILL_EXPLOSIVE),
+            charge_weight=sum(s.weight for s in segments if s.fill_type == _FILL_EXPLOSIVE),
+            stemming_length=sum(s.length for s in segments if s.fill_type == _FILL_STEMMING),
+            spacer_length=sum(s.length for s in segments if s.fill_type == _FILL_SPACER),
+            segments=segments,
+            specific_charge_area=area,
+            warnings=warnings,
+        ))
+
+    return results
+
+
+def _build_segments(
+    hole: Hole,
+    params: ChargeParams,
+    charge_length: float,
+    charge_weight: float,
+    stemming: float,
+    n_seg: int,
+    explosive: Explosive,
+) -> List[ChargeSegment]:
+    """构建自孔口→孔底的分段结构。
+
+    调整规则：
+      - 优先孔口装药（正向起爆）：炸药靠孔口，填塞靠孔底
+      - 优先孔底装药（反向起爆）：填塞靠孔口，炸药靠孔底
+      - 按比例：填塞在孔口，炸药在中间（常规）
+
+    默认（按比例）结构：孔口[填塞] → [炸药]*(间隔) → 孔底
+    """
+    segments: List[ChargeSegment] = []
+
+    def add_explosive_segments() -> List[ChargeSegment]:
+        """生成 n_seg 段炸药（相邻段间插间隔器）。"""
+        segs: List[ChargeSegment] = []
+        per_len = charge_length / n_seg
+        per_w = charge_weight / n_seg
+        for i in range(n_seg):
+            segs.append(ChargeSegment(
+                fill_type=_FILL_EXPLOSIVE, length=per_len, weight=per_w, delay=0
+            ))
+            if i < n_seg - 1:
+                segs.append(ChargeSegment(
+                    fill_type=_FILL_SPACER, length=params.spacer_length, weight=0.0, delay=0
+                ))
+        return segs
+
+    stem_seg = ChargeSegment(
+        fill_type=_FILL_STEMMING, length=stemming, weight=0.0, delay=0
+    )
+    charge_segs = add_explosive_segments()
+
+    if params.adjust_rule == AdjustRule.BOTTOM_FIRST:
+        # 反向起爆：填塞在孔口，炸药靠孔底（常规结构已是填塞在上、炸药在下）
+        segments.extend([stem_seg] + charge_segs)
+    elif params.adjust_rule == AdjustRule.MOUTH_FIRST:
+        # 正向起爆：炸药靠孔口，填塞靠孔底
+        segments.extend(charge_segs + [stem_seg])
+    else:
+        segments.extend([stem_seg] + charge_segs)
+
+    return segments