slicerbridge 0.2.0__py3-none-any.whl

slicerbridge/__init__.py

@@ -0,0 +1,3 @@
+"""SlicerBridge: any multicolor 3MF project in, a ready file for every multicolor printer out."""
+
+__version__ = "0.2.0"

slicerbridge/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

slicerbridge/_vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendored third-party code; see THIRD_PARTY_NOTICES.md."""

slicerbridge/_vendor/panda2prusa/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph (CupsOhJoe)
+
+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.

slicerbridge/_vendor/panda2prusa/VENDORED.md

@@ -0,0 +1,13 @@
+# Panda2Prusa (vendored)
+
+From https://github.com/liutang/Panda2Prusa at commit
+`b6cd13143fb5ea29b9111a11bd329c7e25f25b8d` (2026-10-20), MIT License (LICENSE here).
+
+Only the library modules are copied, unmodified: `__init__`, `ns`, `paint`,
+`transform`, `reader`, `convert`, `writer`, `settings`, `autobrim`, `prusa`.
+The web app, GUI and CLI are left out.
+
+Vendored rather than installed because that commit's `pyproject.toml` can't be
+built by pip (`keywords` and `classifiers` sit under
+`[project.optional-dependencies]`). To update: copy the same modules from a
+newer commit, update the hash above, and run the full test suite.

slicerbridge/_vendor/panda2prusa/__init__.py

@@ -0,0 +1,7 @@
+"""panda2prusa - convert Bambu Studio / OrcaSlicer 3mf files to PrusaSlicer-compatible 3mf."""
+
+from .convert import convert_file, ConversionResult
+from .reader import read_bambu_3mf, BambuProject
+
+__all__ = ["convert_file", "ConversionResult", "read_bambu_3mf", "BambuProject"]
+__version__ = "1.0.0"

slicerbridge/_vendor/panda2prusa/autobrim.py

@@ -0,0 +1,149 @@
+"""Approximate Bambu Studio / OrcaSlicer's automatic brim width for PrusaSlicer.
+
+Bambu's "Auto" brim type picks a brim width per object from how likely it is to tip
+over (tall and slender, printed fast) or to warp (a large footprint in a shrinking
+material). PrusaSlicer has no such mode, so the width is computed here with Orca's
+formula (``configBrimWidthByVolumeGroups`` in Brim.cpp) and written as an outer brim.
+
+Differences from Orca: the footprint is a cut of the mesh at half the first layer
+height, not the sliced first layer after elephant foot compensation, and the whole
+object is one group, where Orca computes a width per group of touching parts.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional
+
+# Orca's MaterialType table: filament type -> (adhesion coefficient, thermal length).
+_MATERIALS = {
+    "ABS": (1, 100), "ABS-CF": (1, 100), "ABS-GF": (1, 100), "ASA": (1, 100), "ASA-CF": (1, 100),
+    "ASA-GF": (1, 100), "ASA-AERO": (1, 100), "BVOH": (1, 200), "CoPE": (1, 200), "EVA": (1, 200),
+    "FLEX": (0.5, 1000), "HIPS": (1, 200), "PA": (1, 100), "PA-CF": (1, 100), "PA-GF": (1, 100),
+    "PA6": (1, 100), "PA6-CF": (1, 100), "PA6-GF": (1, 100), "PA11": (1, 100), "PA11-CF": (1, 100),
+    "PA11-GF": (1, 100), "PA12": (1, 100), "PA12-CF": (1, 100), "PA12-GF": (1, 100),
+    "PAHT": (1, 200), "PAHT-CF": (1, 200), "PAHT-GF": (1, 200), "PC": (1, 40), "PC-ABS": (1, 80),
+    "PC-CF": (1, 80), "PC-PBT": (1, 40), "PCL": (1, 200), "PCTG": (2, 200), "PE": (1, 200),
+    "PE-CF": (1, 200), "PE-GF": (1, 200), "PEI-1010": (1, 200), "PEI-1010-CF": (1, 200),
+    "PEI-1010-GF": (1, 200), "PEI-9085": (1, 200), "PEI-9085-CF": (1, 200), "PEI-9085-GF": (1, 200),
+    "PEEK": (1, 200), "PEEK-CF": (1, 200), "PEEK-GF": (1, 200), "PEKK": (1, 200), "PEKK-CF": (1, 200),
+    "PES": (1, 200), "PET": (2, 100), "PET-CF": (2, 100), "PET-GF": (2, 100), "PETG": (2, 100),
+    "PETG-CF": (1, 100), "PETG-GF": (1, 100), "PHA": (1, 200), "PI": (1, 200), "PLA": (1, 200),
+    "PLA-AERO": (1, 200), "PLA-CF": (1, 200), "POM": (1, 200), "PP": (1, 200), "PP-CF": (1, 200),
+    "PP-GF": (1, 200), "PPA-CF": (1, 200), "PPA-GF": (1, 200), "PPS": (1, 200), "PPS-CF": (1, 200),
+    "PPSU": (1, 200), "PSU": (1, 200), "PVA": (1, 200), "PVB": (1, 200), "PVDF": (1, 200),
+    "SBS": (1, 200), "TPI": (1, 200), "TPU": (0.5, 1000),
+}
+_DEFAULT_MATERIAL = (1.0, 200.0)
+
+# Speeds whose maximum feeds the tipping estimate (Orca's Model::findMaxSpeed).
+SPEED_KEYS = ("inner_wall_speed", "outer_wall_speed", "sparse_infill_speed",
+              "internal_solid_infill_speed", "top_surface_speed", "support_speed")
+
+
+def material(filament_type: Optional[str]) -> tuple[float, float]:
+    """(adhesion coefficient, thermal length in mm) of a filament type."""
+    return _MATERIALS.get(filament_type or "", _DEFAULT_MATERIAL)
+
+
+@dataclass
+class Footprint:
+    """Area properties of a horizontal cut through an object, in mm."""
+
+    area: float = 0.0
+    perimeter: float = 0.0
+    ixx: float = 0.0  # second moment of area about the horizontal axis through the centroid
+    iyy: float = 0.0  # ... about the vertical axis through the centroid
+    width_x: float = 0.0
+    width_y: float = 0.0
+
+
+class FootprintBuilder:
+    """Accumulates a cut at height ``z`` from triangles, without joining the outlines.
+
+    Each triangle that crosses the plane adds one edge of the cut, oriented so the
+    material is on its left (from the triangle's outward normal). Area, first and second
+    moments are sums over edges (Green's theorem), so holes subtract on their own.
+    """
+
+    def __init__(self, z: float):
+        self.z = z
+        self.a = self.sx = self.sy = self.sxx = self.syy = self.length = 0.0
+        self.min_x = self.min_y = math.inf
+        self.max_x = self.max_y = -math.inf
+
+    def add_triangle(self, p1, p2, p3) -> None:
+        """Add a triangle with outward-facing counter-clockwise vertices (x, y, z)."""
+        z = self.z
+        pts = []
+        for a, b in ((p1, p2), (p2, p3), (p3, p1)):
+            if (a[2] < z) != (b[2] < z):
+                t = (z - a[2]) / (b[2] - a[2])
+                pts.append((a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])))
+        if len(pts) != 2:
+            return
+        (xa, ya), (xb, yb) = pts
+        # Outward normal's horizontal part; the edge runs along (-ny, nx).
+        ux, uy, uz = p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]
+        vx, vy, vz = p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]
+        nx, ny = uy * vz - uz * vy, uz * vx - ux * vz
+        if (xb - xa) * -ny + (yb - ya) * nx < 0:
+            xa, ya, xb, yb = xb, yb, xa, ya
+        cross = xa * yb - xb * ya
+        self.a += cross
+        self.sx += (xa + xb) * cross
+        self.sy += (ya + yb) * cross
+        self.sxx += (xa * xa + xa * xb + xb * xb) * cross
+        self.syy += (ya * ya + ya * yb + yb * yb) * cross
+        self.length += math.hypot(xb - xa, yb - ya)
+        self.min_x, self.max_x = min(self.min_x, xa, xb), max(self.max_x, xa, xb)
+        self.min_y, self.max_y = min(self.min_y, ya, yb), max(self.max_y, ya, yb)
+
+    def result(self) -> Optional[Footprint]:
+        area = self.a / 2
+        if area <= 1e-9:
+            return None
+        cx, cy = self.sx / (6 * area), self.sy / (6 * area)
+        return Footprint(
+            area=area,
+            perimeter=self.length,
+            ixx=self.syy / 12 - area * cy * cy,
+            iyy=self.sxx / 12 - area * cx * cx,
+            width_x=self.max_x - self.min_x,
+            width_y=self.max_y - self.min_y,
+        )
+
+
+def brim_width(
+    footprint: Footprint,
+    height: float,
+    max_speed: float,
+    adhesion: float,
+    thermal_length_ref: float,
+    line_spacing: float,
+) -> float:
+    """Orca's automatic brim width in mm (0 for no brim), rounded to whole brim lines."""
+    fp = footprint
+    if fp.ixx <= 0 or fp.iyy <= 0:
+        return 0.0
+    thermal_length = math.hypot(fp.width_x, fp.width_y)
+    height_to_area = max(height / fp.ixx * fp.width_y, height / fp.iyy * fp.width_x) * height / 1920
+    raw = adhesion * min(
+        max(height_to_area * max_speed, thermal_length * 8.0 / thermal_length_ref * min(height, 30.0) / 30.0),
+        18.0,
+        1.5 * thermal_length,
+    )
+    if raw < 5 and raw < 1.5 * thermal_length:
+        raw = 0.0  # small brims are omitted
+    raw = min(raw, 18.0)
+
+    def lines(w: float) -> float:
+        return math.floor(w / line_spacing / 2) * line_spacing * 2 if line_spacing > 0 else w
+
+    width = lines(raw)
+    # A tall, thin part (area / perimeter under 1.1 mm) without a brim gets 5 mm.
+    if width < 5 and height > 10 and width < line_spacing and fp.area / fp.perimeter < 1.1:
+        width += lines(5.0)
+    # Never wider than the footprint itself.
+    return lines(min(width, max(fp.width_x, fp.width_y)))

slicerbridge/_vendor/panda2prusa/convert.py

@@ -0,0 +1,168 @@
+"""High-level conversion orchestration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from . import ns
+from .paint import used_states, PaintError
+from .prusa import PrusaProject, is_prusa_3mf, read_prusa_3mf, remap_prusa_3mf
+from .reader import read_bambu_3mf
+from .writer import write_prusa_3mf, WriteStats
+
+
+@dataclass
+class ConversionResult:
+    input_path: str
+    output_path: str
+    stats: WriteStats
+    producer: str
+    plates_available: list
+    source: str = "bambu"  # "prusa" when the input was remapped rather than converted
+
+
+def used_filaments(project) -> list[int]:
+    """Sorted 1-based filament slots a project actually uses.
+
+    Union of object/part extruder assignments and every state referenced by
+    paint data. Bambu leaves unassigned objects on filament 1.
+    """
+    if isinstance(project, PrusaProject):
+        return list(project.used)
+    used: set[int] = set()
+    for so in project.settings_objects.values():
+        for ext in [so.extruder, *(p.extruder for p in so.parts)]:
+            if ext:
+                try:
+                    used.add(int(ext))
+                except ValueError:
+                    pass
+    codes: set[str] = set()
+    for tree in [project.root_tree, *project.object_trees.values()]:
+        for tri in tree.getroot().iter(ns.q(ns.CORE, "triangle")):
+            code = tri.get("paint_color")
+            if code:
+                codes.add(code)
+    for code in codes:
+        try:
+            used |= used_states(code)
+        except PaintError:
+            pass
+    used.discard(0)
+    if not used and (project.build_items or codes):
+        used.add(1)  # something is printed and it defaults to filament 1
+    return sorted(used)
+
+
+def suggest_extruder_map(used: list[int]) -> dict[int, int]:
+    """Compact sparse filament slots to sequential extruders 1..K."""
+    return {old: i for i, old in enumerate(sorted(used), start=1)}
+
+
+def default_extruder_map(project) -> dict[int, int]:
+    """The mapping to offer first: Bambu slots compacted, Prusa tools left where they are."""
+    used = used_filaments(project)
+    if project.source == "prusa":
+        return {f: f for f in used}
+    return suggest_extruder_map(used)
+
+
+def needs_mapping(project) -> bool:
+    """Whether there is a filament mapping worth asking about.
+
+    A Bambu project with one filament on slot 1 needs no decision; in a Prusa project
+    even a single filament may be wanted on a different tool head.
+    """
+    used = used_filaments(project)
+    return bool(used) and (project.source == "prusa" or used != [1])
+
+
+def filament_noun(project) -> str:
+    """What a filament slot of this project is called, e.g. 'Bambu filament'."""
+    return "Tool" if project.source == "prusa" else "Bambu filament"
+
+
+def output_suffix(source: str) -> str:
+    return "_remapped" if source == "prusa" else "_prusa"
+
+
+def painted_triangles(project) -> int:
+    if isinstance(project, PrusaProject):
+        return project.painted
+    return sum(
+        1
+        for tree in [project.root_tree, *project.object_trees.values()]
+        for tri in tree.getroot().iter(ns.q(ns.CORE, "triangle"))
+        if "paint_color" in tri.attrib
+    )
+
+
+def structure(project) -> tuple[int, int]:
+    """(model parts, build items) of a project."""
+    if isinstance(project, PrusaProject):
+        return project.objects, project.build_items
+    return len(project.object_trees) + 1, len(project.build_items)
+
+
+def filament_label(project, slot: int) -> str:
+    """Human-readable description of a filament slot, e.g. '3 (PLA #8E2929)'."""
+    bits = []
+    if 0 < slot <= len(project.filament_types):
+        bits.append(project.filament_types[slot - 1])
+    if 0 < slot <= len(project.filament_colors):
+        bits.append(project.filament_colors[slot - 1])
+    return f"{slot} ({' '.join(bits)})" if bits else str(slot)
+
+
+def convert_file(
+    input_path: str,
+    output_path: str,
+    plates: Optional[list] = None,
+    extruder_map: Optional[dict] = None,
+    compact_extruders: bool = True,
+) -> ConversionResult:
+    """Convert a Bambu/Orca .3mf at ``input_path`` to a Prusa .3mf at ``output_path``.
+
+    ``plates`` optionally restricts output to the given 1-based plate numbers.
+    ``extruder_map`` explicitly maps Bambu filament slots to Prusa extruders
+    (``{}`` keeps the original numbering); when None and ``compact_extruders`` is
+    true, sparse slots are compacted to sequential extruders automatically.
+
+    A PrusaSlicer .3mf is accepted too: it is copied with its tools remapped by
+    ``extruder_map`` (filament settings follow), and is never compacted or split by
+    plate.
+    """
+    if is_prusa_3mf(input_path):
+        prusa = read_prusa_3mf(input_path)
+        stats = remap_prusa_3mf(prusa, output_path, extruder_map)
+        return ConversionResult(
+            input_path=input_path,
+            output_path=output_path,
+            stats=stats,
+            producer=prusa.producer,
+            plates_available=[],
+            source="prusa",
+        )
+    project = read_bambu_3mf(input_path)
+    stats = write_prusa_3mf(
+        project,
+        output_path,
+        plates=plates,
+        extruder_map=extruder_map,
+        compact_extruders=compact_extruders,
+    )
+    return ConversionResult(
+        input_path=input_path,
+        output_path=output_path,
+        stats=stats,
+        producer=project.producer,
+        plates_available=project.plate_ids,
+    )
+
+
+def describe(input_path: str):
+    """Read a project for inspection (used by --info and interactive prompts)."""
+    if is_prusa_3mf(input_path):
+        return read_prusa_3mf(input_path)
+    return read_bambu_3mf(input_path)

slicerbridge/_vendor/panda2prusa/ns.py

@@ -0,0 +1,26 @@
+"""3MF namespace URIs and qualified-name helpers."""
+
+CORE = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02"
+PRODUCTION = "http://schemas.microsoft.com/3dmanufacturing/production/2015/06"
+MATERIAL = "http://schemas.microsoft.com/3dmanufacturing/material/2015/02"
+BAMBU = "http://schemas.bambulab.com/package/2021"
+SLIC3RPE = "http://schemas.slic3r.org/3mf/2017/06"
+
+RELS = "http://schemas.openxmlformats.org/package/2006/relationships"
+CONTENT_TYPES = "http://schemas.openxmlformats.org/package/2006/content-types"
+
+# Relationship type used to point at the primary 3D model part.
+REL_TYPE_STARTPART = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"
+REL_TYPE_THUMBNAIL = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail"
+
+
+def q(uri: str, tag: str) -> str:
+    """Clark-notation qualified name, e.g. q(CORE, 'object') -> '{...}object'."""
+    return f"{{{uri}}}{tag}"
+
+
+def localname(tag) -> str:
+    """Return the local part of a possibly-namespaced tag."""
+    if not isinstance(tag, str):
+        return ""
+    return tag.rsplit("}", 1)[-1]

slicerbridge/_vendor/panda2prusa/paint.py

@@ -0,0 +1,104 @@
+"""Decode / re-encode triangle paint RLE strings (TriangleSelector serialization).
+
+Bambu Studio's ``paint_color`` and PrusaSlicer's ``slic3rpe:mmu_segmentation`` share
+this format (Bambu forked PrusaSlicer's TriangleSelector). The hex string is a
+bitstream read nibble-by-nibble from the END of the string, bits LSB-first within
+each nibble. Node grammar::
+
+    node := split:2 ( state:2 [ext:4 if state==0b11, value ext+3]   -- leaf
+                    | special_side:2 node{split+1} )                -- split
+
+State 0 is "use the volume's extruder"; state N paints extruder N. Remapping paint
+to different extruder numbers therefore requires rewriting leaf states in the
+bitstream — the strings cannot be value-preserved when extruders are renumbered.
+"""
+
+from __future__ import annotations
+
+
+class PaintError(ValueError):
+    pass
+
+
+def _bits_of(code: str) -> list[int]:
+    bits: list[int] = []
+    for ch in reversed(code):
+        try:
+            n = int(ch, 16)
+        except ValueError:
+            raise PaintError(f"non-hex character {ch!r} in paint string")
+        bits.extend((n >> i) & 1 for i in range(4))
+    return bits
+
+
+def _string_of(bits: list[int]) -> str:
+    while len(bits) % 4:
+        bits.append(0)
+    chars = []
+    for i in range(0, len(bits), 4):
+        nibble = bits[i] | bits[i + 1] << 1 | bits[i + 2] << 2 | bits[i + 3] << 3
+        chars.append("0123456789ABCDEF"[nibble])
+    return "".join(reversed(chars))
+
+
+def _transform(code: str, map_fn) -> str:
+    bits = _bits_of(code)
+    out: list[int] = []
+    pos = 0
+
+    def take(k: int) -> int:
+        nonlocal pos
+        if pos + k > len(bits):
+            raise PaintError("truncated paint bitstream")
+        v = sum(bits[pos + i] << i for i in range(k))
+        pos += k
+        return v
+
+    def emit(v: int, k: int) -> None:
+        out.extend((v >> i) & 1 for i in range(k))
+
+    def node() -> None:
+        split = take(2)
+        emit(split, 2)
+        if split == 0:
+            s = take(2)
+            if s == 0b11:
+                s = take(4) + 3
+            s = map_fn(s)
+            if s < 0 or s > 18:
+                raise PaintError(f"state {s} out of range for TriangleSelector encoding")
+            if s <= 2:
+                emit(s, 2)
+            else:
+                emit(0b11, 2)
+                emit(s - 3, 4)
+        else:
+            emit(take(2), 2)  # special side index
+            for _ in range(split + 1):
+                node()
+
+    node()
+    if any(bits[pos:]) and len(bits) - pos >= 4:
+        raise PaintError("leftover data bits after root node")
+    return _string_of(out)
+
+
+def transform_states(code: str, mapping: dict[int, int]) -> str:
+    """Rewrite every leaf state through ``mapping`` (states absent stay unchanged).
+
+    With an identity mapping this round-trips byte-for-byte (modulo zero padding,
+    which producers already emit as zeros).
+    """
+    return _transform(code, lambda s: mapping.get(s, s))
+
+
+def used_states(code: str) -> set[int]:
+    """Return the set of leaf states referenced by one paint string."""
+    states: set[int] = set()
+
+    def spy(s: int) -> int:
+        states.add(s)
+        return s
+
+    _transform(code, spy)
+    return states