slice3d 0.1.0__py3-none-any.whl

slice3d/__init__.py

@@ -0,0 +1,46 @@
+"""slice3d: 3Dモデルを一定間隔でスライスして断面を出力するライブラリ。
+
+最小の使用例::
+
+    import slice3d
+
+    mesh = slice3d.load_mesh("model.stl")
+    for s in slice3d.iter_slices(mesh, axis="z", thickness=1.0):
+        if not s.is_empty:
+            slice3d.save_section(s.path_2d, f"out/{s.index:04d}.svg")
+
+または一括処理::
+
+    import slice3d
+
+    slice3d.slice_file("model.stl", "out", axis="z", thickness=1.0, fmt="svg")
+"""
+
+from .core import (
+    AXES,
+    Slice,
+    compute_heights,
+    iter_slices,
+    load_mesh,
+    polylines,
+    print_volume,
+    save_section,
+    slice_file,
+    slice_mesh,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AXES",
+    "Slice",
+    "compute_heights",
+    "iter_slices",
+    "load_mesh",
+    "polylines",
+    "print_volume",
+    "save_section",
+    "slice_file",
+    "slice_mesh",
+    "__version__",
+]

slice3d/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

slice3d/cli.py

@@ -0,0 +1,58 @@
+"""slice3d のコマンドラインインターフェース。"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .core import AXES, load_mesh, compute_heights, iter_slices, save_section
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="slice3d",
+        description="3Dモデルを一定幅でスライスして断面を出力する",
+    )
+    parser.add_argument("model", type=Path, help="入力3Dモデルファイル (STL/OBJ/PLY/GLBなど)")
+    parser.add_argument("--axis", choices=tuple(AXES), default="z", help="スライスする軸 (既定: z)")
+    parser.add_argument("--thickness", type=float, default=1.0, help="スライス間隔 [モデル単位] (既定: 1.0)")
+    parser.add_argument("--start", type=float, default=None, help="開始位置 (既定: モデルの最小値)")
+    parser.add_argument("--end", type=float, default=None, help="終了位置 (既定: モデルの最大値)")
+    parser.add_argument("--outdir", type=Path, default=Path("slices"), help="出力先ディレクトリ (既定: ./slices)")
+    parser.add_argument(
+        "--format",
+        choices=("svg", "dxf", "png", "csv"),
+        default="svg",
+        help="断面の出力形式 (既定: svg)",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+
+    mesh = load_mesh(args.model)
+    if not mesh.is_watertight:
+        print(f"警告: メッシュが閉じていません (is_watertight=False)。断面が欠ける場合があります: {args.model}")
+
+    heights = compute_heights(mesh, args.axis, args.thickness, args.start, args.end)
+    print(f"{len(heights)} 枚の断面を axis={args.axis}, thickness={args.thickness} で生成します")
+
+    args.outdir.mkdir(parents=True, exist_ok=True)
+    stem = args.model.stem
+
+    n_ok = 0
+    for s in iter_slices(mesh, axis=args.axis, thickness=args.thickness, start=args.start, end=args.end):
+        if s.is_empty:
+            print(f"  [{s.index:04d}] {args.axis}={s.position:.4f}: 交差なし (スキップ)")
+            continue
+        outpath = args.outdir / f"{stem}_{args.axis}{s.index:04d}_{s.position:.4f}.{args.format}"
+        save_section(s.path_2d, outpath, args.format)
+        print(f"  [{s.index:04d}] {args.axis}={s.position:.4f}: {outpath.name}")
+        n_ok += 1
+
+    print(f"完了: {n_ok}/{len(heights)} 断面を {args.outdir} に出力しました")
+
+
+if __name__ == "__main__":
+    main()

slice3d/core.py

@@ -0,0 +1,247 @@
+"""3Dメッシュを一定間隔でスライスし、断面(2Dパス)を得るためのコア機能。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator
+
+import numpy as np
+import trimesh
+
+__all__ = [
+    "AXES",
+    "Slice",
+    "load_mesh",
+    "compute_heights",
+    "iter_slices",
+    "slice_mesh",
+    "save_section",
+    "slice_file",
+    "print_volume",
+    "polylines",
+]
+
+AXES = {"x": 0, "y": 1, "z": 2}
+
+
+@dataclass(frozen=True)
+class Slice:
+    """1枚の断面を表す。"""
+
+    index: int
+    axis: str
+    position: float
+    path_2d: "trimesh.path.Path2D | None"
+    # 断面のワールド座標での点列(Nx3配列のリスト)。png保存時に実寸スケールを
+    # 揃えるために使う(path_2d はtrimeshが断面ごとに選ぶローカル2D座標系のため、
+    # 複数断面間でスケールが揃わない)。
+    polylines_3d: list = field(default_factory=list)
+
+    @property
+    def is_empty(self) -> bool:
+        return self.path_2d is None
+
+
+def load_mesh(path: str | Path) -> trimesh.Trimesh:
+    """3Dモデルファイルを読み込み、単一の Trimesh として返す。
+
+    STL / OBJ / PLY / GLB / GLTF など、trimesh が対応する形式を扱える。
+    """
+    mesh = trimesh.load(path, force="mesh")
+    if not isinstance(mesh, trimesh.Trimesh):
+        raise TypeError(f"単一のメッシュとして読み込めませんでした: {path}")
+    return mesh
+
+
+def compute_heights(
+    mesh: trimesh.Trimesh,
+    axis: str,
+    thickness: float,
+    start: float | None = None,
+    end: float | None = None,
+) -> np.ndarray:
+    """指定した軸に沿って、一定間隔(thickness)でスライスする位置の配列を計算する。"""
+    if axis not in AXES:
+        raise ValueError(f"axis は {list(AXES)} のいずれかである必要があります: {axis!r}")
+    if thickness <= 0:
+        raise ValueError("thickness は正の値である必要があります")
+
+    axis_idx = AXES[axis]
+    bounds_min, bounds_max = mesh.bounds[:, axis_idx]
+    lo = bounds_min if start is None else start
+    hi = bounds_max if end is None else end
+    if hi <= lo:
+        raise ValueError(f"終了位置は開始位置より大きい必要があります (start={lo}, end={hi})")
+
+    n = int(np.floor((hi - lo) / thickness)) + 1
+    return lo + np.arange(n) * thickness
+
+
+def iter_slices(
+    mesh: trimesh.Trimesh,
+    axis: str = "z",
+    thickness: float = 1.0,
+    start: float | None = None,
+    end: float | None = None,
+) -> Iterator[Slice]:
+    """メッシュを一定間隔でスライスし、Sliceオブジェクトを1枚ずつ生成する。
+
+    交差しない位置では ``path_2d=None`` の Slice を返す(呼び出し側でスキップ判定できる)。
+    """
+    axis_idx = AXES[axis]
+    heights = compute_heights(mesh, axis, thickness, start, end)
+
+    normal = np.zeros(3)
+    normal[axis_idx] = 1.0
+    origin = mesh.bounds[0].copy()
+
+    for i, h in enumerate(heights):
+        plane_origin = origin.copy()
+        plane_origin[axis_idx] = h
+        section = mesh.section(plane_origin=plane_origin, plane_normal=normal)
+        if section is None:
+            yield Slice(index=i, axis=axis, position=float(h), path_2d=None)
+            continue
+        path_2d, _transform = section.to_2D()
+        yield Slice(
+            index=i,
+            axis=axis,
+            position=float(h),
+            path_2d=path_2d,
+            polylines_3d=polylines(section),
+        )
+
+
+def slice_mesh(
+    mesh: trimesh.Trimesh,
+    axis: str = "z",
+    thickness: float = 1.0,
+    start: float | None = None,
+    end: float | None = None,
+) -> list[Slice]:
+    """iter_slices の結果をリストとして返す。"""
+    return list(iter_slices(mesh, axis=axis, thickness=thickness, start=start, end=end))
+
+
+def polylines(path) -> list[np.ndarray]:
+    """Path2D/Path3D の全エンティティを点列(Nx2 または Nx3 配列)のリストとして取り出す。
+
+    ``path.discrete`` は閉じたループしか返さないため、非watertightなメッシュの
+    断面のように閉じていない(開いた)線が含まれていると取りこぼしてしまう。
+    この関数は entity 単位で ``entity.discrete(path.vertices)`` を呼ぶことで、
+    開いた線も含めてすべての線分を取得する。
+    """
+    return [entity.discrete(path.vertices) for entity in path.entities]
+
+
+def save_section(
+    path_2d: "trimesh.path.Path2D",
+    outpath: str | Path,
+    fmt: str | None = None,
+    *,
+    polylines_3d: "list[np.ndarray] | None" = None,
+    axis: str | None = None,
+    bounds: "np.ndarray | None" = None,
+) -> Path:
+    """1枚の断面 (Path2D) をファイルへ保存する。
+
+    fmt: "svg" | "dxf" | "png" | "csv"。省略時は outpath の拡張子から判定する。
+
+    fmt="png" で保存する場合は、``polylines_3d``(ワールド座標の点列。
+    ``Slice.polylines_3d`` を渡す)、``axis``、``bounds``(``mesh.bounds``)を
+    指定すると、画像の表示範囲をモデル全体のバウンディングボックスに固定できる。
+    これらを省略すると各断面の内容だけに自動フィットして保存されるため、
+    断面ごとに画像の縮尺(見た目の大きさ)がバラバラになってしまう点に注意。
+    """
+    outpath = Path(outpath)
+    fmt = (fmt or outpath.suffix.lstrip(".")).lower()
+
+    if fmt in ("svg", "dxf"):
+        data = path_2d.export(file_type=fmt)
+        if isinstance(data, str):
+            outpath.write_text(data)
+        else:
+            outpath.write_bytes(data)
+    elif fmt == "png":
+        import matplotlib.pyplot as plt
+
+        fig, ax = plt.subplots()
+        if polylines_3d is not None and axis is not None and bounds is not None:
+            # ワールド座標をそのまま2軸に投影し、表示範囲をモデル全体のバウンディング
+            # ボックスに固定する。これにより、断面の大きさに関わらずどの画像も
+            # 元モデルに対する実際の縮尺(比率)を保って保存される。
+            axis_idx = AXES[axis]
+            other = [i for i in range(3) if i != axis_idx]
+            for polyline in polylines_3d:
+                ax.plot(polyline[:, other[0]], polyline[:, other[1]], "-k")
+            ax.set_xlim(bounds[0, other[0]], bounds[1, other[0]])
+            ax.set_ylim(bounds[0, other[1]], bounds[1, other[1]])
+            ax.set_aspect("equal")
+            ax.axis("off")
+            fig.savefig(outpath, dpi=150)
+        else:
+            # 従来どおり: 断面の内容だけに自動フィットする(スケールは断面ごとに異なる)。
+            for polyline in polylines(path_2d):
+                ax.plot(polyline[:, 0], polyline[:, 1], "-k")
+            ax.set_aspect("equal")
+            ax.axis("off")
+            fig.savefig(outpath, bbox_inches="tight", dpi=150)
+        plt.close(fig)
+    elif fmt == "csv":
+        lines = ["polyline_id,x,y"]
+        for i, polyline in enumerate(polylines(path_2d)):
+            for x, y in polyline:
+                lines.append(f"{i},{x},{y}")
+        outpath.write_text("\n".join(lines))
+    else:
+        raise ValueError(f"未対応の出力形式です: {fmt!r} (対応形式: svg, dxf, png, csv)")
+
+    return outpath
+
+
+def print_volume(mesh: trimesh.Trimesh) -> float:
+    """メッシュの体積を標準出力に表示し、その値を返す。
+
+    メッシュが水密(watertight)でない場合、体積の計算結果が不正確になりうるため警告を表示する。
+    """
+    if not mesh.is_watertight:
+        print("警告: メッシュが水密でないため、体積の計算結果は不正確な可能性があります")
+
+    volume = float(mesh.volume)
+    print(f"体積: {volume}")
+    return volume
+
+
+def slice_file(
+    model_path: str | Path,
+    outdir: str | Path,
+    axis: str = "z",
+    thickness: float = 1.0,
+    start: float | None = None,
+    end: float | None = None,
+    fmt: str = "svg",
+) -> list[Path]:
+    """3Dモデルファイルを読み込み、スライスして outdir へ一括出力する。
+
+    戻り値は書き出したファイルパスのリスト(交差しないスライスはスキップされる)。
+    """
+    model_path = Path(model_path)
+    outdir = Path(outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    mesh = load_mesh(model_path)
+    stem = model_path.stem
+
+    written: list[Path] = []
+    for s in iter_slices(mesh, axis=axis, thickness=thickness, start=start, end=end):
+        if s.is_empty:
+            continue
+        outpath = outdir / f"{stem}_{axis}{s.index:04d}_{s.position:.4f}.{fmt}"
+        written.append(
+            save_section(
+                s.path_2d, outpath, fmt,
+                polylines_3d=s.polylines_3d, axis=axis, bounds=mesh.bounds,
+            )
+        )
+    return written

slice3d/gui.py

@@ -0,0 +1,471 @@
+"""3Dモデルの断面・体積を確認するGUIビューア。
+
+専用ウィンドウを開き、3D表示でモデル全体と現在の切断位置を確認しながら、
+スライダーで断面を切り替えられる。軸(x/y/z)とスライス間隔(thickness)はウィンドウ上で変更できる。
+
+使い方::
+
+    slice3d-gui model.stl
+    slice3d-gui model.stl --axis x --thickness 0.01
+    slice3d-gui model.glb              # glTF/GLBは仕様上メートル単位なので自動で"m"表示
+    slice3d-gui model.stl --units mm   # STLなど単位不明な形式は明示的に指定
+
+matplotlib が必要 (``pip install "slice3d[gui]"``)。
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+from pathlib import Path
+
+import numpy as np
+import trimesh
+import matplotlib.pyplot as plt
+from matplotlib.widgets import Button, RadioButtons, Slider, TextBox
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+
+from . import core
+
+
+def _pick_cjk_font() -> str | None:
+    """環境にインストールされているCJK対応フォントを1つ選ぶ(文字化け防止用)。"""
+    import matplotlib.font_manager as fm
+
+    available = {f.name for f in fm.fontManager.ttflist}
+    for candidate in ("Hiragino Sans", "Yu Gothic", "Meiryo", "Noto Sans CJK JP", "IPAexGothic"):
+        if candidate in available:
+            return candidate
+    return None
+
+
+_cjk_font = _pick_cjk_font()
+if _cjk_font:
+    plt.rcParams["font.family"] = [_cjk_font, "DejaVu Sans"]
+plt.rcParams["axes.unicode_minus"] = False
+
+# 3Dプレビューが重くならないよう、面数がこれを超えたらメッシュを簡略化して表示する。
+# mplot3dは面数に比例して回転・再描画が遅くなるため、数千面程度に抑えるとスムーズに動く。
+# (スライス計算自体は元メッシュの精度で行われ、この簡略化は3D表示にのみ影響する)
+_MAX_PREVIEW_FACES = 4_000
+
+# glTF/GLBは仕様上メートル単位と定められているため、既定値として表示に使う。
+# STL/OBJ/PLYなどは単位の情報を持たないファイル形式なので、既定は単位なし(空文字)。
+_UNITS_BY_EXTENSION = {".glb": "m", ".gltf": "m"}
+
+_AXIS_NAMES = ("x", "y", "z")
+_FORMATS = ("svg", "png", "dxf", "csv")
+
+
+def _default_units(model_path: Path) -> str:
+    return _UNITS_BY_EXTENSION.get(model_path.suffix.lower(), "")
+
+
+def _nice_thickness(extent: float, target_slices: int = 30) -> float:
+    """extentを約target_slices分割する、キリの良いthickness値(1/2/5 x 10^n)を選ぶ。"""
+    raw = extent / target_slices
+    if raw <= 0:
+        return max(raw, 1e-9)
+    magnitude = 10 ** math.floor(math.log10(raw))
+    for m in (1, 2, 5, 10):
+        candidate = m * magnitude
+        if candidate >= raw:
+            return candidate
+    return 10 * magnitude
+
+
+class SliceViewer:
+    """3D表示 + スライダーで断面を切り替えながら確認するmatplotlibウィンドウ。"""
+
+    def __init__(
+        self,
+        model_path: str | Path,
+        axis: str = "z",
+        thickness: float | None = None,
+        max_preview_faces: int = _MAX_PREVIEW_FACES,
+        units: str | None = None,
+        fmt: str = "svg",
+    ):
+        self.model_path = Path(model_path)
+        self.mesh = core.load_mesh(self.model_path)
+        self.axis = axis
+        self.volume = float(self.mesh.volume)
+        self.max_preview_faces = max_preview_faces
+        self.units = _default_units(self.model_path) if units is None else units
+        if fmt not in _FORMATS:
+            raise ValueError(f"fmt は {list(_FORMATS)} のいずれかである必要があります: {fmt!r}")
+        self.format = fmt
+        self._format_buttons: dict[str, Button] = {}
+
+        if thickness is None:
+            extent = self.mesh.extents[core.AXES[axis]]
+            thickness = _nice_thickness(extent)
+        self.thickness = thickness
+
+        self.heights = None
+        self.slider = None
+        self._plane_artist = None
+        self._curve_lines: list = []
+
+        self._build_ui()
+        self._recompute_slices()
+
+    # ---- 表示用フォーマット ----
+    # 有効数字3桁に丸める(生の浮動小数点をそのまま出すと桁数が多すぎて読みにくいため)。
+    def _fmt_length(self, value: float) -> str:
+        suffix = f" {self.units}" if self.units else ""
+        return f"{value:.3g}{suffix}"
+
+    def _fmt_volume(self, value: float) -> str:
+        suffix = f" {self.units}³" if self.units else ""
+        return f"{value:.3g}{suffix}"
+
+    # ---- データ ----
+    def _recompute_slices(self) -> None:
+        self.heights = core.compute_heights(self.mesh, self.axis, self.thickness)
+        self._rebuild_slider()
+
+    def _section_at(self, index: int):
+        """指定インデックスの断面を計算する。(path_2d, discrete_3d) を返す。
+
+        path_2d は2D平面上のPath2D(交差なしならNone)、discrete_3d は
+        3Dプレビュー用のポリライン(Nx3配列)のリスト。
+
+        polylines()(core.pyのentityベースの抽出)を使うことで、非watertightな
+        メッシュの断面のように閉じていない(開いた)線も欠落なく拾う。
+        ``section.discrete`` は閉じたループしか返さないため使わない。
+        """
+        axis_idx = core.AXES[self.axis]
+        normal = [0.0, 0.0, 0.0]
+        normal[axis_idx] = 1.0
+        origin = self.mesh.bounds[0].copy()
+        origin[axis_idx] = self.heights[index]
+        section = self.mesh.section(plane_origin=origin, plane_normal=normal)
+        if section is None:
+            return None, []
+        path_2d, _transform = section.to_2D()
+        return path_2d, core.polylines(section)
+
+    def _plane_corners(self, index: int) -> np.ndarray:
+        axis_idx = core.AXES[self.axis]
+        h = self.heights[index]
+        other = [i for i in range(3) if i != axis_idx]
+        b = self.mesh.bounds
+        lo0, hi0 = b[0, other[0]], b[1, other[0]]
+        lo1, hi1 = b[0, other[1]], b[1, other[1]]
+        corners = np.zeros((4, 3))
+        for k, (a, c) in enumerate(((lo0, lo1), (hi0, lo1), (hi0, hi1), (lo0, hi1))):
+            corners[k, axis_idx] = h
+            corners[k, other[0]] = a
+            corners[k, other[1]] = c
+        return corners
+
+    # ---- UI構築 ----
+    def _build_ui(self) -> None:
+        self.fig = plt.figure(figsize=(11, 9))
+        try:
+            self.fig.canvas.manager.set_window_title(f"slice3d viewer - {self.model_path.name}")
+        except AttributeError:
+            pass
+
+        self.ax_3d = self.fig.add_axes((0.03, 0.34, 0.45, 0.55), projection="3d")
+        self._draw_static_mesh()
+
+        self.ax_section = self.fig.add_axes((0.55, 0.34, 0.43, 0.55))
+        self.ax_section.set_aspect("equal")
+        self.ax_section.set_title("Cross-section (view along slicing axis)", fontsize=10)
+
+        watertight_note = "" if self.mesh.is_watertight else "  (non-watertight: volume is approximate)"
+        self.fig.text(
+            0.02, 0.975,
+            f"{self.model_path.name}   volume = {self._fmt_volume(self.volume)}{watertight_note}",
+            fontsize=10, va="top",
+        )
+        self.pos_text = self.fig.text(0.02, 0.95, "", fontsize=10, va="top")
+        self.fig.text(
+            0.03, 0.92, "Full model (red = current slice plane)", fontsize=10, va="top"
+        )
+
+        # ラジオボタンは既定だと丸のサイズ・クリック領域が小さく押しづらいため、
+        # 専用エリアを広めに取った上で radio_props/label_props でマーカーと
+        # フォントを拡大している。
+        ax_radio = self.fig.add_axes((0.01, 0.02, 0.13, 0.27))
+        ax_radio.set_title("Axis", fontsize=11)
+        self.radio = RadioButtons(
+            ax_radio,
+            ("x", "y", "z"),
+            active="xyz".index(self.axis),
+            radio_props={"s": 160},
+            label_props={"fontsize": [14, 14, 14]},
+        )
+        self.radio.on_clicked(self._on_axis_change)
+
+        self.ax_slider = self.fig.add_axes((0.19, 0.25, 0.71, 0.05))
+        # スライダーのつまみも既定サイズだと掴みづらいので大きくする
+        # (トラック自体はどこをクリックしてもその位置へ移動できる)。
+        self._slider_handle_style = {"size": 18}
+
+        thickness_label = f"Thickness ({self.units})  " if self.units else "Thickness  "
+        ax_thickness = self.fig.add_axes((0.19, 0.16, 0.18, 0.06))
+        self.thickness_box = TextBox(ax_thickness, thickness_label, initial=f"{self.thickness:g}")
+        self.thickness_box.text_disp.set_fontsize(12)
+        self.thickness_box.label.set_fontsize(11)
+        self.thickness_box.on_submit(self._on_thickness_submit)
+
+        ax_save_current = self.fig.add_axes((0.62, 0.16, 0.28, 0.06))
+        self.save_current_button = Button(ax_save_current, "")
+        self.save_current_button.label.set_fontsize(11)
+        self.save_current_button.on_clicked(self._on_save)
+
+        self.fig.text(0.19, 0.10, "Format:", fontsize=10, va="center")
+        format_x = (0.30, 0.44, 0.58, 0.72)
+        format_width = 0.13
+        for x, fmt in zip(format_x, _FORMATS):
+            ax_fmt = self.fig.add_axes((x, 0.075, format_width, 0.05))
+            button = Button(ax_fmt, fmt.upper())
+            button.label.set_fontsize(10)
+            button.on_clicked(lambda event, f=fmt: self._on_format_change(f))
+            self._format_buttons[fmt] = button
+
+        ax_save_all = self.fig.add_axes((0.19, 0.005, 0.81, 0.06))
+        self.save_all_button = Button(ax_save_all, "")
+        self.save_all_button.label.set_fontsize(11)
+        self.save_all_button.on_clicked(self._on_save_all)
+
+        self._refresh_format_buttons()
+
+    def _preview_mesh(self):
+        """3D表示専用の軽量化されたメッシュを返す(スライス計算には使わない)。"""
+        mesh = self.mesh
+        if len(mesh.faces) <= self.max_preview_faces:
+            return mesh
+        try:
+            return mesh.simplify_quadric_decimation(face_count=self.max_preview_faces)
+        except Exception:
+            # fast_simplification が無い環境などへのフォールバック: 単純間引き。
+            # 形状の見え方は粗くなるが、表示が固まるよりはよい。
+            step = math.ceil(len(mesh.faces) / self.max_preview_faces)
+            faces = mesh.faces[::step]
+            return trimesh.Trimesh(vertices=mesh.vertices, faces=faces, process=False)
+
+    def _draw_static_mesh(self) -> None:
+        """モデル全体を半透明の3Dサーフェスとして一度だけ描画する(スライス操作では再描画しない)。"""
+        preview = self._preview_mesh()
+        tri = preview.vertices[preview.faces]
+
+        surface = Poly3DCollection(tri, alpha=0.25, facecolor="lightsteelblue", edgecolor="none")
+        self.ax_3d.add_collection3d(surface)
+
+        b = self.mesh.bounds
+        self.ax_3d.set_xlim(b[0, 0], b[1, 0])
+        self.ax_3d.set_ylim(b[0, 1], b[1, 1])
+        self.ax_3d.set_zlim(b[0, 2], b[1, 2])
+        extents = np.maximum(self.mesh.extents, 1e-9)
+        self.ax_3d.set_box_aspect(tuple(extents))
+        self.ax_3d.set_xlabel("x", fontsize=8)
+        self.ax_3d.set_ylabel("y", fontsize=8)
+        self.ax_3d.set_zlabel("z", fontsize=8)
+
+    def _update_3d_highlight(self, index: int, discrete_3d) -> None:
+        if self._plane_artist is not None:
+            self._plane_artist.remove()
+            self._plane_artist = None
+        for line in self._curve_lines:
+            line.remove()
+        self._curve_lines = []
+
+        corners = self._plane_corners(index)
+        plane = Poly3DCollection([corners], alpha=0.15, facecolor="tomato", edgecolor="none")
+        self.ax_3d.add_collection3d(plane)
+        self._plane_artist = plane
+
+        for polyline in discrete_3d:
+            (line,) = self.ax_3d.plot(
+                polyline[:, 0], polyline[:, 1], polyline[:, 2], color="red", linewidth=2
+            )
+            self._curve_lines.append(line)
+
+    def _rebuild_slider(self) -> None:
+        n = len(self.heights)
+        current = 0 if self.slider is None else min(int(self.slider.val), n - 1)
+        self.ax_slider.clear()
+        self.slider = Slider(
+            self.ax_slider,
+            "slice",
+            0,
+            max(n - 1, 0),
+            valinit=current,
+            valstep=1,
+            handle_style=self._slider_handle_style,
+        )
+        self.slider.label.set_fontsize(11)
+        self.slider.on_changed(lambda val: self._show_index(int(val)))
+        self._show_index(current)
+
+    # ---- コールバック ----
+    def _on_axis_change(self, label: str) -> None:
+        self.axis = label
+        self.thickness = _nice_thickness(self.mesh.extents[core.AXES[label]])
+        self.thickness_box.set_val(f"{self.thickness:g}")
+        self._recompute_slices()
+        self._refresh_format_buttons()  # Save Allボタンのラベルに軸名が含まれるため更新
+        self.fig.canvas.draw_idle()
+
+    def _on_thickness_submit(self, text: str) -> None:
+        try:
+            thickness = float(text)
+        except ValueError:
+            return
+        if thickness <= 0:
+            return
+        self.thickness = thickness
+        self._recompute_slices()
+        self.fig.canvas.draw_idle()
+
+    def _on_format_change(self, fmt: str) -> None:
+        self.format = fmt
+        self._refresh_format_buttons()
+        self.fig.canvas.draw_idle()
+
+    def _refresh_format_buttons(self) -> None:
+        """選択中のフォーマットのボタンをハイライトし、保存ボタンのラベルを更新する。"""
+        for fmt, button in self._format_buttons.items():
+            selected = fmt == self.format
+            button.color = "lightblue" if selected else "0.85"
+            button.hovercolor = "skyblue" if selected else "0.95"
+            button.ax.set_facecolor(button.color)
+        self.save_current_button.label.set_text(f"Save Current Slice ({self.format.upper()})")
+        self.save_all_button.label.set_text(f"Save All Slices Along {self.axis.upper()}-Axis ({self.format.upper()})")
+
+    def _outdir(self) -> Path:
+        outdir = self.model_path.parent / "slices_gui"
+        outdir.mkdir(exist_ok=True)
+        return outdir
+
+    def _on_save(self, event) -> None:
+        index = int(self.slider.val)
+        path_2d, discrete_3d = self._section_at(index)
+        if path_2d is None:
+            print("Cannot save: no intersection at this slice position")
+            return
+        outdir = self._outdir()
+        outpath = outdir / f"{self.model_path.stem}_{self.axis}{index:04d}_{self.heights[index]:.4f}.{self.format}"
+        # polylines_3d/axis/bounds を渡すことで、保存画像(png)の表示範囲を
+        # モデル全体のバウンディングボックスに固定する(断面ごとに縮尺がバラつかない)。
+        core.save_section(
+            path_2d, outpath, self.format,
+            polylines_3d=discrete_3d, axis=self.axis, bounds=self.mesh.bounds,
+        )
+        print(f"Saved: {outpath}")
+
+    def _on_save_all(self, event) -> None:
+        """現在の軸・thickness設定で全スライスを一括保存する(交差しない位置はスキップ)。"""
+        outdir = self._outdir()
+        written = core.slice_file(
+            self.model_path,
+            outdir,
+            axis=self.axis,
+            thickness=self.thickness,
+            fmt=self.format,
+        )
+        print(
+            f"Saved {len(written)}/{len(self.heights)} slices "
+            f"(axis={self.axis}, thickness={self._fmt_length(self.thickness)}, format={self.format}) to {outdir}"
+        )
+
+    # ---- 描画 ----
+    def _show_index(self, index: int) -> None:
+        index = max(0, min(index, len(self.heights) - 1))
+        position = self.heights[index]
+        path_2d, discrete_3d = self._section_at(index)
+
+        self._update_3d_highlight(index, discrete_3d)
+
+        # 断面図は3Dハイライトと同じワールド座標(discrete_3d)をそのまま2軸に投影して描く。
+        # path_2d(trimeshが断面ごとに独自に選ぶローカル2D座標系)を使うと、断面の形だけで
+        # 自動スケーリングされてしまい、小さな断片がパネルいっぱいに拡大されて3D表示と
+        # 対応が取れなくなる(特にthin方向の軸でスライスすると顕著)。
+        # ここではモデル全体のバウンディングボックスに表示範囲を固定し、常に同じ縮尺で見せる。
+        axis_idx = core.AXES[self.axis]
+        other = [i for i in range(3) if i != axis_idx]
+        xlabel, ylabel = _AXIS_NAMES[other[0]], _AXIS_NAMES[other[1]]
+
+        self.ax_section.clear()
+        self.ax_section.set_aspect("equal")
+        self.ax_section.set_title("Cross-section (view along slicing axis)", fontsize=10)
+        self.ax_section.set_xlabel(xlabel, fontsize=9)
+        self.ax_section.set_ylabel(ylabel, fontsize=9)
+        b = self.mesh.bounds
+        self.ax_section.set_xlim(b[0, other[0]], b[1, other[0]])
+        self.ax_section.set_ylim(b[0, other[1]], b[1, other[1]])
+        if not discrete_3d:
+            self.ax_section.text(
+                0.5, 0.5, "No intersection", ha="center", va="center", transform=self.ax_section.transAxes
+            )
+        else:
+            for polyline in discrete_3d:
+                self.ax_section.plot(polyline[:, other[0]], polyline[:, other[1]], "-k")
+
+        self.pos_text.set_text(
+            f"axis={self.axis}  thickness={self._fmt_length(self.thickness)}  "
+            f"slice={index + 1}/{len(self.heights)}  position={self._fmt_length(position)}"
+        )
+        self.fig.canvas.draw_idle()
+
+    def show(self) -> None:
+        plt.show()
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="slice3d-gui", description="Interactive GUI viewer for a 3D model's volume and slices"
+    )
+    parser.add_argument("model", type=Path, help="input 3D model file (STL/OBJ/PLY/GLB, etc.)")
+    parser.add_argument("--axis", choices=tuple(core.AXES), default="z", help="initial slicing axis")
+    parser.add_argument(
+        "--thickness",
+        type=float,
+        default=None,
+        help='initial slice spacing (a.k.a. "slice thickness"); '
+        "default: a round number giving roughly 30 slices across the model",
+    )
+    parser.add_argument(
+        "--units",
+        type=str,
+        default=None,
+        help='length unit label to display next to values, e.g. "m" or "mm". '
+        'Defaults to "m" for glTF/GLB files (meters by spec) and no unit otherwise; '
+        'pass --units "" to force no unit label.',
+    )
+    parser.add_argument(
+        "--max-preview-faces",
+        type=int,
+        default=_MAX_PREVIEW_FACES,
+        help=f"max face count for the 3D preview mesh (default: {_MAX_PREVIEW_FACES}); "
+        "lower this if the 3D view feels slow",
+    )
+    parser.add_argument(
+        "--format",
+        choices=_FORMATS,
+        default="svg",
+        help="initial export format for the Save buttons (default: svg); "
+        "can also be changed in the window",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+    viewer = SliceViewer(
+        args.model,
+        axis=args.axis,
+        thickness=args.thickness,
+        max_preview_faces=args.max_preview_faces,
+        units=args.units,
+        fmt=args.format,
+    )
+    viewer.show()
+
+
+if __name__ == "__main__":
+    main()

slice3d-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.5
+Name: slice3d
+Version: 0.1.0
+Summary: 3Dモデルを一定間隔でスライスして断面(輪郭)を出力するライブラリ/CLI
+Project-URL: Homepage, https://github.com/Hanibuchi/slice-3d
+Project-URL: Issues, https://github.com/Hanibuchi/slice-3d/issues
+Author-email: hanibuchi <hanitech8686@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3d,cad,cross-section,mesh,slicing,stl,trimesh
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Requires-Dist: networkx>=3.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: shapely>=2.0
+Requires-Dist: trimesh>=4.0.0
+Provides-Extra: dev
+Requires-Dist: fast-simplification>=0.1.7; extra == 'dev'
+Requires-Dist: matplotlib!=3.11.*,>=3.8; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: gui
+Requires-Dist: fast-simplification>=0.1.7; extra == 'gui'
+Requires-Dist: matplotlib!=3.11.*,>=3.8; extra == 'gui'
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7; extra == 'viz'
+Description-Content-Type: text/markdown
+
+# slice3d
+
+3Dモデル(STL / OBJ / PLY / GLB / GLTF など)を一定間隔でスライスし、断面(輪郭)を SVG / DXF / PNG / CSV として出力するPythonライブラリ・CLIです。[trimesh](https://github.com/mikedh/trimesh) をベースにしています。
+
+アンモナイトの化石モデルをX軸方向にスライスした例:
+
+![スライス一覧](docs/assets/ammonite_slices_grid.png)
+
+中心付近の断面(渦巻き状の房室がきれいに現れる):
+
+![中心断面](docs/assets/ammonite_center_slice.png)
+
+## インストール
+
+```bash
+pip install slice3d
+
+# PNG出力を使う場合(matplotlibが必要)
+pip install "slice3d[viz]"
+```
+
+開発時はこのリポジトリを editable インストールしてください。
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## CLIとして使う
+
+```bash
+slice3d model.stl --axis z --thickness 2.0 --outdir slices --format svg
+```
+
+| オプション | 説明 | 既定値 |
+| --- | --- | --- |
+| `--axis {x,y,z}` | スライスする軸 | `z` |
+| `--thickness` | スライス間隔(モデル単位) | `1.0` |
+| `--start` / `--end` | スライス範囲(省略時はモデルのバウンディングボックス全体) | なし |
+| `--outdir` | 出力先ディレクトリ | `./slices` |
+| `--format {svg,dxf,png,csv}` | 断面の出力形式 | `svg` |
+
+PNG出力(CLI/`slice_file`/GUIいずれも共通)は、断面ごとの内容に自動フィットするのではなく、元モデル全体のバウンディングボックスを基準に表示範囲を固定して保存する。そのため、同じスライス処理で出力した画像はすべて同じピクセルサイズ・同じ縮尺になり、小さな断面ほど小さく、大きな断面ほど大きく写る(元モデルに対する実際の大きさの比率がそのまま画像に反映される)。
+
+交差しない位置のスライスは自動的にスキップされます。
+
+## GUIビューア
+
+体積・スライス位置を確認しながら、軸やスライス間隔(thickness)をその場で変更できる専用ウィンドウを開きます。
+
+```bash
+pip install "slice3d[gui]"
+slice3d-gui model.stl
+slice3d-gui model.stl --axis x --thickness 0.01
+slice3d-gui model.glb              # glTF/GLBは仕様上メートル単位なので自動で"m"表示
+slice3d-gui model.stl --units mm   # STLなど単位不明な形式は明示的に指定
+slice3d-gui model.stl --format png # Save系ボタンの初期フォーマット(既定: svg)
+```
+
+![GUIビューア](docs/assets/gui_screenshot.png)
+
+ウィンドウ内の表示は(体積・軸・数値など)すべて英語で統一しています。
+
+- ウィンドウ上部にモデル名・体積(`mesh.volume`、非watertightなら近似値である旨も表示)
+- 左側にモデル全体を半透明の3D表示。現在の切断位置を赤い平面と断面の輪郭線で重ねて表示するので、どこをどの向きで切っているか一目で分かる
+- 右側にその断面(切断面を真上から見た2D形状)をリアルタイム表示
+- スライダーでスライス位置(index / position)を切り替え
+- `Axis` ラジオボタンでスライス軸を切り替え(切り替え時はthicknessが軸の全長に応じてキリの良い値(1/2/5 × 10ⁿ、約30分割相当)に自動再設定される)
+- `Thickness` テキストボックスで間隔を指定して Enter → 断面数が再計算される
+- 体積・thickness・positionの表示には単位が付く。glTF/GLB(`.glb` / `.gltf`)は仕様上メートル単位と定められているため自動で`m`が付き、STL/OBJ/PLYなど単位情報を持たない形式は既定で単位なし
+  - `--units`(例: `mm`, `cm`)で表示単位を明示指定できる。`--units ""` で単位表示を消すことも可能
+- `Format` ボタン(SVG/PNG/DXF/CSV)で保存形式を選択。選択中の形式はハイライトされ、Saveボタンのラベルにも反映される
+- `Save Current Slice` ボタンで現在表示中の断面を1枚保存
+- `Save All Slices Along <軸>-Axis` ボタンで、現在の軸・thickness設定のまま全断面を一括保存(交差しない位置は自動的にスキップ)
+- 保存先はどちらも `<モデルと同じディレクトリ>/slices_gui/`
+
+## ライブラリとして使う
+
+```python
+import slice3d
+
+# 一括処理: モデルを読み込んでスライスし、ディレクトリへ書き出す
+written = slice3d.slice_file("model.stl", "out", axis="z", thickness=1.0, fmt="svg")
+
+# 細かく制御したい場合
+mesh = slice3d.load_mesh("model.stl")
+for s in slice3d.iter_slices(mesh, axis="z", thickness=1.0):
+    if s.is_empty:
+        continue
+    print(s.index, s.position, len(s.path_2d.discrete))
+    slice3d.save_section(s.path_2d, f"out/{s.index:04d}.svg")
+```
+
+### API
+
+- `slice3d.load_mesh(path)` — 3Dモデルを読み込み `trimesh.Trimesh` を返す
+- `slice3d.compute_heights(mesh, axis, thickness, start=None, end=None)` — スライス位置の配列を計算
+- `slice3d.iter_slices(mesh, axis="z", thickness=1.0, start=None, end=None)` — `Slice` を1枚ずつ生成するイテレータ
+- `slice3d.slice_mesh(...)` — `iter_slices` の結果をリストで取得
+- `slice3d.save_section(path_2d, outpath, fmt=None)` — 1枚の断面を保存(`fmt` 省略時は拡張子から推定)
+- `slice3d.print_volume(mesh)` — メッシュの体積を標準出力に表示し、その値を返す
+- `slice3d.slice_file(model_path, outdir, axis="z", thickness=1.0, start=None, end=None, fmt="svg")` — 読み込み〜保存までを一括実行
+
+`Slice` は `index`, `axis`, `position`, `path_2d`(`trimesh.path.Path2D | None`), `is_empty` を持つデータクラスです。
+
+## サンプル
+
+```bash
+python examples/slice_ammonite.py
+```
+
+`examples/ammonite.glb` をX軸方向にスライスし、`examples/output/` にPNGを出力します。
+
+## 開発
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## ライセンス
+
+MIT License. [LICENSE](LICENSE) を参照してください。

slice3d-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+slice3d/__init__.py,sha256=A7eBDOPPl7Q4fu6DsCwU1jdShb9ZJ6RvFOK67AH7nnw,889
+slice3d/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+slice3d/cli.py,sha256=SSQFM88Pfj1VPMlCdDgmf-Cu5OooSERvjIUSKjndAr4,2552
+slice3d/core.py,sha256=OCGcoucoRnGGzaVG9vGJ2viu-ie3aTF0kpNFdd9zOuA,8998
+slice3d/gui.py,sha256=x__81vNleECdsB9fHZLwJor8-EaApIkkkjXoia7yD5Y,19700
+slice3d-0.1.0.dist-info/METADATA,sha256=S_u710N4b3KBLagn1LIJN8MFE2i3Q62qIqFuReMawpQ,7757
+slice3d-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+slice3d-0.1.0.dist-info/entry_points.txt,sha256=k08GJgfEHWTQlWQU767X3pOY5QIgeNhQQoyCvSMjuLU,76
+slice3d-0.1.0.dist-info/licenses/LICENSE,sha256=NCdIQCSLUrkKbtgHzg4Sg45n-dSns0YGb5zHHNciVmo,1066
+slice3d-0.1.0.dist-info/RECORD,,

slice3d-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

slice3d-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+slice3d = slice3d.cli:main
+slice3d-gui = slice3d.gui:main

slice3d-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hanibuchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.