stlbench 0.2.0__py3-none-any.whl

stlbench/__init__.py

@@ -0,0 +1,3 @@
+"""STL preparation toolkit for resin 3D printing: scale, layout, fill, autopack, info."""
+
+__version__ = "0.2.0"

stlbench/__main__.py

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

stlbench/cli.py

@@ -0,0 +1,275 @@
+"""Typer CLI: ``stlbench`` / ``python -m stlbench``."""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from stlbench.config.loader import load_app_settings
+from stlbench.pipeline.run_autopack import AutopackRunArgs, run_autopack
+from stlbench.pipeline.run_fill import FillRunArgs, run_fill
+from stlbench.pipeline.run_info import InfoRunArgs, run_info
+from stlbench.pipeline.run_layout import LayoutRunArgs, run_layout
+from stlbench.pipeline.run_scale import ScaleRunArgs, run_scale
+
+app = typer.Typer(
+    no_args_is_help=True,
+    help="STL preparation for resin 3D printing: scale, layout, fill, autopack, info.",
+)
+
+
+def _parse_printer_opt(value: str | None) -> tuple[float, float, float] | None:
+    if value is None or not str(value).strip():
+        return None
+    parts = re.split(r"[\s,xX]+", str(value).strip())
+    nums = [float(p) for p in parts if p]
+    if len(nums) != 3:
+        raise typer.BadParameter("Нужно ровно три числа: Px Py Pz или Px,Py,Pz.")
+    return nums[0], nums[1], nums[2]
+
+
+@app.command("scale")
+def cmd_scale(
+    input_dir: Annotated[
+        Path,
+        typer.Option("--input", "-i", exists=True, file_okay=False, dir_okay=True),
+    ],
+    output_dir: Annotated[Path, typer.Option("--output", "-o")],
+    config: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", exists=True, dir_okay=False, file_okay=True),
+    ] = None,
+    printer: Annotated[
+        str | None,
+        typer.Option(
+            "--printer",
+            "-p",
+            help="Три числа: например 153.36,77.76,165",
+        ),
+    ] = None,
+    margin: Annotated[float | None, typer.Option("--margin")] = None,
+    supports_scale: Annotated[float | None, typer.Option("--supports-scale")] = None,
+    method: Annotated[str | None, typer.Option("--method")] = None,
+    orientation: Annotated[str | None, typer.Option("--orientation")] = None,
+    rotation_samples: Annotated[int | None, typer.Option("--rotation-samples")] = None,
+    no_upscale: Annotated[bool, typer.Option("--no-upscale")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    recursive: Annotated[bool, typer.Option("--recursive")] = False,
+    suffix: Annotated[str, typer.Option("--suffix", show_default=False)] = "",
+    no_packing_report: Annotated[bool, typer.Option("--no-packing-report")] = False,
+    hollow: Annotated[bool | None, typer.Option("--hollow/--no-hollow")] = None,
+) -> None:
+    st = load_app_settings(config) if config else None
+    pr = _parse_printer_opt(printer)
+    raise typer.Exit(
+        run_scale(
+            ScaleRunArgs(
+                input_dir=input_dir,
+                output_dir=output_dir,
+                config_path=config,
+                settings=st,
+                printer_xyz=pr,
+                margin=margin,
+                supports_scale=supports_scale,
+                method=method,
+                orientation=orientation,
+                rotation_samples=rotation_samples,
+                no_upscale=no_upscale,
+                dry_run=dry_run,
+                recursive=recursive,
+                suffix=suffix,
+                no_packing_report=no_packing_report,
+                hollow_override=hollow,
+            )
+        )
+    )
+
+
+@app.command("layout")
+def cmd_layout(
+    input_dir: Annotated[
+        Path,
+        typer.Option("--input", "-i", exists=True, file_okay=False, dir_okay=True),
+    ],
+    output_dir: Annotated[Path, typer.Option("--output", "-o")],
+    config: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", exists=True, dir_okay=False, file_okay=True),
+    ] = None,
+    printer: Annotated[
+        str | None,
+        typer.Option("-p", "--printer", help="Px,Py,Pz"),
+    ] = None,
+    gap_mm: Annotated[float | None, typer.Option("--gap-mm")] = None,
+    algorithm: Annotated[str | None, typer.Option("--algorithm")] = None,
+    recursive: Annotated[bool, typer.Option("--recursive")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+) -> None:
+    pr = _parse_printer_opt(printer)
+    raise typer.Exit(
+        run_layout(
+            LayoutRunArgs(
+                input_dir=input_dir,
+                output_dir=output_dir,
+                config_path=config,
+                printer_xyz=pr,
+                gap_mm=gap_mm,
+                algorithm=algorithm,
+                recursive=recursive,
+                dry_run=dry_run,
+            )
+        )
+    )
+
+
+@app.command("fill")
+def cmd_fill(
+    input_file: Annotated[
+        Path,
+        typer.Option("--input", "-i", exists=True, help="Single STL file or directory with one STL"),
+    ],
+    output_dir: Annotated[Path, typer.Option("--output", "-o")],
+    config: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", exists=True, dir_okay=False, file_okay=True),
+    ] = None,
+    printer: Annotated[
+        str | None,
+        typer.Option("-p", "--printer", help="Px,Py,Pz"),
+    ] = None,
+    gap_mm: Annotated[float | None, typer.Option("--gap-mm")] = None,
+    scale: Annotated[bool, typer.Option("--scale/--no-scale")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+) -> None:
+    pr = _parse_printer_opt(printer)
+    raise typer.Exit(
+        run_fill(
+            FillRunArgs(
+                input_file=input_file,
+                output_dir=output_dir,
+                config_path=config,
+                printer_xyz=pr,
+                gap_mm=gap_mm,
+                scale=scale,
+                dry_run=dry_run,
+            )
+        )
+    )
+
+
+@app.command("autopack")
+def cmd_autopack(
+    input_dir: Annotated[
+        Path,
+        typer.Option("--input", "-i", exists=True, file_okay=False, dir_okay=True),
+    ],
+    output_dir: Annotated[Path, typer.Option("--output", "-o")],
+    config: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", exists=True, dir_okay=False, file_okay=True),
+    ] = None,
+    printer: Annotated[
+        str | None,
+        typer.Option("-p", "--printer", help="Px,Py,Pz"),
+    ] = None,
+    gap_mm: Annotated[float | None, typer.Option("--gap-mm")] = None,
+    margin: Annotated[float | None, typer.Option("--margin")] = None,
+    supports_scale: Annotated[float | None, typer.Option("--supports-scale")] = None,
+    recursive: Annotated[bool, typer.Option("--recursive")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+) -> None:
+    pr = _parse_printer_opt(printer)
+    raise typer.Exit(
+        run_autopack(
+            AutopackRunArgs(
+                input_dir=input_dir,
+                output_dir=output_dir,
+                config_path=config,
+                printer_xyz=pr,
+                gap_mm=gap_mm,
+                margin=margin,
+                supports_scale=supports_scale,
+                dry_run=dry_run,
+                recursive=recursive,
+            )
+        )
+    )
+
+
+@app.command("info")
+def cmd_info(
+    input_dir: Annotated[
+        Path,
+        typer.Option("--input", "-i", exists=True, file_okay=False, dir_okay=True),
+    ],
+    config: Annotated[
+        Path | None,
+        typer.Option("--config", "-c", exists=True, dir_okay=False, file_okay=True),
+    ] = None,
+    printer: Annotated[
+        str | None,
+        typer.Option("-p", "--printer", help="Px,Py,Pz"),
+    ] = None,
+    recursive: Annotated[bool, typer.Option("--recursive")] = False,
+) -> None:
+    pr = _parse_printer_opt(printer)
+    raise typer.Exit(
+        run_info(
+            InfoRunArgs(
+                input_dir=input_dir,
+                config_path=config,
+                printer_xyz=pr,
+                recursive=recursive,
+            )
+        )
+    )
+
+
+@app.command("hollow")
+def cmd_hollow_info() -> None:
+    typer.echo("Configure [hollow] section in TOML and run: stlbench scale ... --hollow")
+
+
+@app.command("supports")
+def cmd_supports_info() -> None:
+    typer.echo(
+        "Supports are not generated by stlbench. Open exported STL in Lychee, Chitubox or another slicer."
+    )
+
+
+_KNOWN_COMMANDS = frozenset(
+    {"scale", "layout", "fill", "autopack", "info", "hollow", "supports", "-h", "--help"}
+)
+
+
+def launch() -> None:
+    if len(sys.argv) > 1 and sys.argv[1] not in _KNOWN_COMMANDS:
+        sys.argv.insert(1, "scale")
+    app()
+
+
+def main(argv: list[str] | None = None) -> int:
+    old = sys.argv
+    try:
+        if argv is not None:
+            sys.argv = [old[0]] + list(argv)
+        try:
+            launch()
+            return 0
+        except SystemExit as e:
+            code = e.code
+            if code is None:
+                return 0
+            if isinstance(code, int):
+                return code
+            return 1
+    finally:
+        sys.argv = old
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stlbench/config/__init__.py

@@ -0,0 +1,4 @@
+from stlbench.config.loader import AppConfig, load_app_settings, load_config
+from stlbench.config.schema import AppSettings
+
+__all__ = ["AppConfig", "AppSettings", "load_app_settings", "load_config"]

stlbench/config/loader.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import cast
+
+import tomli
+
+from stlbench.config.schema import AppSettings
+
+
+def load_app_settings(path: Path) -> AppSettings:
+    if not path.is_file():
+        raise FileNotFoundError(f"Config not found: {path}")
+    with path.open("rb") as f:
+        raw = tomli.load(f)
+    printer = raw.get("printer") or {}
+    if "width_mm" not in printer:
+        raise ValueError("config [printer] must define width_mm, depth_mm, height_mm.")
+    data = {
+        "printer": printer,
+        "scaling": raw.get("scaling") or {},
+        "orientation": raw.get("orientation") or {},
+        "packing": raw.get("packing") or {},
+        "hollow": raw.get("hollow") or {},
+        "supports": raw.get("supports") or {},
+    }
+    return cast(AppSettings, AppSettings.model_validate(data))
+
+
+# Backward-compatible flat view for legacy code paths
+class AppConfig:
+    """Плоский доступ к полям (совместимость со старым API)."""
+
+    def __init__(self, s: AppSettings) -> None:
+        self._s = s
+
+    @property
+    def printer_name(self) -> str:
+        return self._s.printer.name
+
+    @property
+    def width_mm(self) -> float:
+        return self._s.printer.width_mm
+
+    @property
+    def depth_mm(self) -> float:
+        return self._s.printer.depth_mm
+
+    @property
+    def height_mm(self) -> float:
+        return self._s.printer.height_mm
+
+    @property
+    def bed_margin(self) -> float:
+        return self._s.scaling.bed_margin
+
+    @property
+    def supports_scale(self) -> float:
+        return self._s.scaling.supports_scale
+
+    @property
+    def orientation_mode(self) -> str:
+        return self._s.orientation.mode
+
+    @property
+    def orientation_samples(self) -> int:
+        return self._s.orientation.samples
+
+    @property
+    def orientation_seed(self) -> int:
+        return self._s.orientation.seed
+
+    @property
+    def packing_report(self) -> bool:
+        return self._s.packing.report
+
+    @property
+    def settings(self) -> AppSettings:
+        return self._s
+
+
+def load_config(path: Path) -> AppConfig:
+    return AppConfig(load_app_settings(path))

stlbench/config/schema.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class PrinterSection(BaseModel):
+    name: str = ""
+    width_mm: float = Field(gt=0)
+    depth_mm: float = Field(gt=0)
+    height_mm: float = Field(gt=0)
+
+
+class ScalingSection(BaseModel):
+    bed_margin: float = Field(default=0.0, ge=0.0, lt=1.0)
+    supports_scale: float = Field(default=1.0, gt=0.0)
+
+
+class OrientationSection(BaseModel):
+    mode: Literal["axis", "free"] = "axis"
+    samples: int = Field(default=2048, ge=1)
+    seed: int = 0
+
+
+class PackingSection(BaseModel):
+    report: bool = True
+    algorithm: Literal["shelf", "rectpack"] = "rectpack"
+    gap_mm: float = Field(default=2.0, ge=0.0)
+
+
+class HollowSection(BaseModel):
+    enabled: bool = False
+    backend: Literal["none", "open3d_voxel"] = "none"
+    wall_thickness_mm: float = Field(default=2.0, gt=0.0)
+    voxel_mm: float = Field(default=0.5, gt=0.0)
+
+
+class SupportsSection(BaseModel):
+    """
+    Заглушка для совместимости TOML. Генерации опор в пакете нет — только слайсер.
+    """
+
+    enabled: bool = False
+    backend: Literal["none", "external"] = "none"
+    external_command_template: str = ""
+
+    @field_validator("external_command_template", mode="before")
+    @classmethod
+    def _empty_str(cls, v: object) -> str:
+        if v is None:
+            return ""
+        return str(v)
+
+
+class AppSettings(BaseModel):
+    printer: PrinterSection
+    scaling: ScalingSection = Field(default_factory=ScalingSection)
+    orientation: OrientationSection = Field(default_factory=OrientationSection)
+    packing: PackingSection = Field(default_factory=PackingSection)
+    hollow: HollowSection = Field(default_factory=HollowSection)
+    supports: SupportsSection = Field(default_factory=SupportsSection)

stlbench/core/__init__.py

@@ -0,0 +1,31 @@
+"""Core scaling and orientation math."""
+
+from stlbench.core.fit import (
+    Method,
+    PartScaleReport,
+    aabb_edge_lengths,
+    compute_global_scale,
+    limiting_part_index,
+    printer_dims_with_margin,
+    s_max_for_part_conservative,
+    s_max_for_part_sorted,
+)
+from stlbench.core.orientation import (
+    best_aabb_extents_for_conservative_fit,
+    best_aabb_extents_for_sorted_fit,
+    mesh_vertices_for_orientation,
+)
+
+__all__ = [
+    "Method",
+    "PartScaleReport",
+    "aabb_edge_lengths",
+    "compute_global_scale",
+    "limiting_part_index",
+    "printer_dims_with_margin",
+    "s_max_for_part_conservative",
+    "s_max_for_part_sorted",
+    "best_aabb_extents_for_conservative_fit",
+    "best_aabb_extents_for_sorted_fit",
+    "mesh_vertices_for_orientation",
+]

stlbench/core/fit.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+
+Method = Literal["sorted", "conservative"]
+
+
+def printer_dims_with_margin(
+    px: float, py: float, pz: float, margin: float
+) -> tuple[float, float, float]:
+    if margin < 0 or margin >= 1:
+        raise ValueError("margin must be in [0, 1).")
+    f = 1.0 - margin
+    return px * f, py * f, pz * f
+
+
+def aabb_edge_lengths(bounds: np.ndarray) -> tuple[float, float, float]:
+    """bounds: (2, 3) min/max corners."""
+    if bounds.shape != (2, 3):
+        raise ValueError("bounds must have shape (2, 3).")
+    d = bounds[1] - bounds[0]
+    return float(d[0]), float(d[1]), float(d[2])
+
+
+def _require_positive_dims(dims: tuple[float, float, float], label: str) -> None:
+    if any(x <= 0 for x in dims):
+        raise ValueError(f"{label}: all AABB edge lengths must be positive, got {dims}.")
+
+
+def s_max_for_part_sorted(
+    p_sorted: tuple[float, float, float], d_sorted: tuple[float, float, float]
+) -> float:
+    _require_positive_dims(d_sorted, "Part")
+    p1, p2, p3 = p_sorted
+    d1, d2, d3 = d_sorted
+    return min(p1 / d1, p2 / d2, p3 / d3)
+
+
+def s_max_for_part_conservative(p_min: float, dx: float, dy: float, dz: float) -> float:
+    dmax = max(dx, dy, dz)
+    if dmax <= 0:
+        raise ValueError(f"Part max dimension must be positive, got {dmax}.")
+    return p_min / dmax
+
+
+@dataclass(frozen=True)
+class PartScaleReport:
+    name: str
+    dx: float
+    dy: float
+    dz: float
+    s_limit: float
+    limiting_axis: str | None
+    file_dx: float | None = None
+    file_dy: float | None = None
+    file_dz: float | None = None
+
+
+def compute_global_scale(
+    printer_xyz: tuple[float, float, float],
+    parts_dims: list[tuple[float, float, float]],
+    part_names: list[str],
+    method: Method,
+    file_dims: list[tuple[float, float, float]] | None = None,
+) -> tuple[float, list[PartScaleReport]]:
+    if len(parts_dims) != len(part_names):
+        raise ValueError("parts_dims and part_names length mismatch.")
+    if not parts_dims:
+        raise ValueError("No parts to scale.")
+    if file_dims is not None and len(file_dims) != len(parts_dims):
+        raise ValueError("file_dims length must match parts_dims.")
+
+    px, py, pz = printer_xyz
+    if min(px, py, pz) <= 0:
+        raise ValueError("Printer dimensions must be positive.")
+
+    reports: list[PartScaleReport] = []
+    limits: list[float] = []
+
+    if method == "sorted":
+        p_sorted = tuple(sorted((px, py, pz)))
+        for i, (name, dims) in enumerate(zip(part_names, parts_dims, strict=True)):
+            _require_positive_dims(dims, name)
+            d_sorted = tuple(sorted(dims))
+            s1 = p_sorted[0] / d_sorted[0]
+            s2 = p_sorted[1] / d_sorted[1]
+            s3 = p_sorted[2] / d_sorted[2]
+            s_lim = min(s1, s2, s3)
+            limits.append(s_lim)
+            if s_lim == s1:
+                axis = "shortest_part_vs_shortest_printer"
+            elif s_lim == s2:
+                axis = "mid_part_vs_mid_printer"
+            else:
+                axis = "longest_part_vs_longest_printer"
+            fx = fy = fz = None
+            if file_dims is not None:
+                fx, fy, fz = file_dims[i]
+            reports.append(
+                PartScaleReport(
+                    name=name,
+                    dx=dims[0],
+                    dy=dims[1],
+                    dz=dims[2],
+                    s_limit=s_lim,
+                    limiting_axis=axis,
+                    file_dx=fx,
+                    file_dy=fy,
+                    file_dz=fz,
+                )
+            )
+    elif method == "conservative":
+        p_min = min(px, py, pz)
+        for i, (name, dims) in enumerate(zip(part_names, parts_dims, strict=True)):
+            s_lim = s_max_for_part_conservative(p_min, *dims)
+            limits.append(s_lim)
+            fx = fy = fz = None
+            if file_dims is not None:
+                fx, fy, fz = file_dims[i]
+            reports.append(
+                PartScaleReport(
+                    name=name,
+                    dx=dims[0],
+                    dy=dims[1],
+                    dz=dims[2],
+                    s_limit=s_lim,
+                    limiting_axis="max_extent_vs_min_printer",
+                    file_dx=fx,
+                    file_dy=fy,
+                    file_dz=fz,
+                )
+            )
+    else:
+        raise ValueError(f"Unknown method: {method}")
+
+    s_max = min(limits)
+    return s_max, reports
+
+
+def limiting_part_index(reports: list[PartScaleReport], s_max: float) -> int:
+    eps = 1e-12
+    for i, r in enumerate(reports):
+        if r.s_limit <= s_max + eps:
+            return i
+    return 0