feat: initial commit

.gitignore

@@ -0,0 +1,4 @@
+.gradio/
+.DS_Store
+__pycache__/
+.venv

Dockerfile

@@ -0,0 +1,25 @@
+FROM openscad/openscad:trixie.2026-01-19 AS base
+
+WORKDIR /app
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+COPY requirements.txt /app/
+
+RUN apt-get update \
+    && apt-get -y install python3 python3-pip \
+    && pip install -r requirements.txt --break-system-packages
+
+FROM base AS developer
+
+ENV GRADIO_WATCH_DIRS="/app/src"
+
+CMD ["python3", "src/app.py"]
+
+
+FROM base AS executor
+
+WORKDIR /app
+
+COPY src/app.py src/3mf2mmuv3.py src/input.scad.j2 src/png23mf.py /app/
+
+CMD ["python3", "app.py"]

LICENSE.md

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

Makefile

@@ -0,0 +1,16 @@
+.PHONY: all .venv install clean
+
+all: install
+
+.venv:
+	@if [ ! -d .venv ]; then \
+		python3 -m venv .venv; \
+	fi
+
+install: .venv
+
+
+	.venv/bin/pip install -r requirements.txt
+
+clean:
+	rm -rf .venv

README.md

@@ -0,0 +1,33 @@
+# PNG to 3MF converter
+
+Simple python app with Gradio UI that allows to create a multicolor 3mf file
+suitable for 3d printing using Prusa/Orca-family slicers.
+
+<video width="640" height="360" controls>
+  <source src="docs/demo.mp4" type="video/mp4">
+  Your browser does not support the video tag. See "docs/demo.mp4"
+</video>
+
+## Local development
+
+```sh
+docker compose up --build
+```
+
+### [Optional] code linting in IDE
+
+Install virtualenv for IDE to resolve dependencies.
+
+```sh
+make install
+```
+
+## Production build
+
+```sh
+TARGET=executor docker compose up --build
+```
+
+## Usage
+
+Navigate the page: http://localhost:7860

docker-compose.yml

@@ -0,0 +1,9 @@
+services:
+  app:
+    build:
+      context: .
+      target: "${TARGET:-developer}"
+    volumes:
+      - "${PWD:-./}:/${TARGET:-app}"
+    ports:
+      - "7860:7860"

requirements.txt

@@ -0,0 +1,4 @@
+gradio==6.9.0
+ruff==0.15.6
+scipy==1.17.1
+jinja2==3.1.6

ruff.toml

@@ -0,0 +1 @@
+line-length = 79

src/.gitignore

@@ -0,0 +1 @@
+tmp/

src/3mf2mmuv3.py

@@ -0,0 +1,153 @@
+#!/bin/env python3
+"""
+Convert a standard 3mf generated by OpenSCAD with color information
+to a MMU‑painted 3mf that PrusaSlicer expects
+"""
+
+import argparse
+import logging
+import zipfile
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+# Mapping from extruder index to paint color code used by PrusaSlicer / BambuStudio
+PAINT_COLOR_MAP = [
+    None,
+    "8",
+    "0C",
+    "1C",
+    "2C",
+    "3C",
+    "4C",
+    "5C",
+    "6C",
+    "7C",
+    "8C",
+    "9C",
+    "AC",
+    "BC",
+    "CC",
+    "DC",
+]
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--loglevel",
+        type=str,
+        choices=["INFO", "DEBUG", "WARN", "ERROR"],
+        default="INFO",
+        help="Logging Level",
+    )
+    parser.add_argument(
+        "--force",
+        default=False,
+        action="store_true",
+        help="Force overwriting the output file",
+    )
+    parser.add_argument("openscad_3mf", help="OpenSCAD 3MF input")
+    parser.add_argument("prusaslicer_3mf", help="PrusaSlicer 3MF output")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        format="%(asctime)s %(levelname)8s %(message)s", level=args.loglevel
+    )
+
+    # register the namespaces we care about
+    namespaces = {
+        "xml": "http://www.w3.org/XML/1998/namespace",
+        "": "http://schemas.microsoft.com/3dmanufacturing/core/2015/02",
+        "p": "http://schemas.microsoft.com/3dmanufacturing/production/2015/06",
+        "slic3rpe": "http://schemas.slic3r.org/3mf/2017/06",
+    }
+    for k, v in namespaces.items():
+        ET.register_namespace(k, v)
+
+    os3mf = Path(args.openscad_3mf)
+    ps3mf = Path(args.prusaslicer_3mf)
+
+    if not os3mf.exists():
+        logging.error(f"The input file {os3mf} doesn't exist")
+        exit(1)
+
+    if ps3mf.exists() and not args.force:
+        logging.error(
+            f"The output file {ps3mf} exists and will not be overwritten without --force"
+        )
+        exit(1)
+
+    with zipfile.ZipFile(
+        ps3mf, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9
+    ) as pszip:
+        with zipfile.ZipFile(os3mf, "r") as oszip:
+            # copy the files from the openscad 3mf to the prusaslicer 3mf
+            for file in [
+                x for x in oszip.infolist() if x.filename != "3D/3dmodel.model"
+            ]:
+                logging.info(f"Copying file {file}")
+                pszip.writestr(file, oszip.open(file).read())
+
+            model_raw = oszip.read("3D/3dmodel.model")
+
+            logging.info("Updating 3dmodel.model")
+            # Parse the XML
+            model_root = ET.fromstring(str(model_raw, encoding="utf-8"))
+
+            # Remove any existing Application metadata and set to PrusaSlicer
+            for meta in list(model_root.findall("metadata")):
+                if meta.get("name") == "Application":
+                    model_root.remove(meta)
+            # Add Application metadata
+            app_meta = ET.Element(
+                "metadata", {"name": "Application", "preserve": "1"}
+            )
+            app_meta.text = "PrusaSlicer"
+            model_root.append(app_meta)
+
+            # add slic3rpe metadata
+            for k, v in {
+                "slic3rpe:Version3mf": "1",
+                "slic3rpe:MmPaintingVersion": "1",
+                "BambuStudio:3mfVersion": "1",
+            }.items():
+                e = ET.Element("metadata", {"name": k})
+                e.text = v
+                model_root.append(e)
+
+            # Set color attributes on triangles
+            for t in model_root.findall(
+                "resources/object/mesh/triangles/triangle", namespaces
+            ):
+                p1_value = t.get("p1")
+                if not p1_value or p1_value == "0":
+                    continue
+                try:
+                    p1_index = int(p1_value)
+                except ValueError:
+                    logging.warning(
+                        f"Triangle has non‑integer p1 value: {p1_value}"
+                    )
+                    continue
+                if p1_index < len(PAINT_COLOR_MAP):
+                    color_code = PAINT_COLOR_MAP[p1_index]
+                else:
+                    logging.warning(
+                        f"Material number {p1_index} is greater than supported extruders"
+                    )
+                    color_code = None
+                if color_code:
+                    t.set("slic3rpe:mmu_segmentation", color_code)
+                    t.set("paint_color", color_code)
+
+            model_text = str(
+                ET.tostring(
+                    model_root, encoding="utf-8", xml_declaration=True
+                ),
+                encoding="utf-8",
+            )
+            pszip.writestr("3D/3dmodel.model", model_text)
+
+
+if __name__ == "__main__":
+    main()

src/app.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+
+import shutil
+import tempfile
+from pathlib import Path
+
+import gradio as gr
+
+from png23mf import (
+    calculate_zoom_value,
+    generate_3mf_file,
+    overlay_images_core,
+    update_height_from_width,
+    update_width_from_height,
+)
+
+temp_dir = Path(tempfile.gettempdir())
+
+
+def overlay_images(
+    base_img,
+    overlay_img,
+    x,
+    y,
+    rot,
+    zoom,
+    indexed_colors,
+    base_thickness,
+    overlay_thickness,
+    width,
+    height,
+    use_common_colors,
+    morph_size,
+    resolution,
+):
+    base_rgb, masks, mask_colors = overlay_images_core(
+        base_img,
+        overlay_img,
+        x,
+        y,
+        rot,
+        zoom,
+        indexed_colors,
+        base_thickness,
+        overlay_thickness,
+        width,
+        height,
+        use_common_colors,
+        morph_size,
+        resolution,
+    )
+    if base_rgb is None:
+        return None, None, None, None, gr.update(interactive=False)
+    return base_rgb, masks, masks, mask_colors, gr.update(interactive=True)
+
+
+def update_slider_ranges(base_img, overlay_img, resolution):
+    if base_img is None:
+        if overlay_img is not None:
+            w, h = overlay_img.size
+        else:
+            w, h = resolution, resolution
+    else:
+        w, h = base_img.size
+    max_dim = resolution
+    if max(w, h) > max_dim:
+        scale_factor = max_dim / max(w, h)
+        w = int(w * scale_factor)
+        h = int(h * scale_factor)
+    default_width = round(100, 2)
+    default_height = round(default_width * h / w, 2)
+    if overlay_img is not None:
+        zoom_val = calculate_zoom_value(base_img, overlay_img, 1.0, resolution)
+    else:
+        zoom_val = 1.0
+    return (
+        gr.update(minimum=-w, maximum=w, step=1, value=0),
+        gr.update(minimum=-h, maximum=h, step=1, value=0),
+        gr.update(maximum=180, step=1, value=0),
+        gr.update(maximum=10.0, step=0.01, value=zoom_val),
+        gr.update(value=4),
+        gr.update(value=default_width),
+        gr.update(value=default_height),
+    )
+
+
+def get_user_dir(req: gr.Request) -> str:
+    """Create a unique directory for the user session."""
+    session_hash = (
+        str(req.session_hash) if req.session_hash is not None else "unknown"
+    )
+    user_dir = temp_dir / session_hash
+    user_dir.mkdir(parents=True, exist_ok=True)
+    return str(user_dir)
+
+
+def delete_user_dir(req: gr.Request) -> None:
+    """Delete the user directory when the session ends."""
+    session_hash = (
+        str(req.session_hash) if req.session_hash is not None else "unknown"
+    )
+    user_dir = temp_dir / session_hash
+    if user_dir.exists():
+        shutil.rmtree(user_dir)
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(value="# PNG to scad/3mf")
+    gr.Markdown(
+        value="**Tip:** The base image must be black and white. "
+        "Black is treated as transparent and White will be extruded."
+    )
+    with gr.Row():
+        with gr.Column():
+            with gr.Row():
+                base_img = gr.Image(
+                    label="Base Image",
+                    type="pil",
+                    image_mode="RGB",
+                )
+                overlay_img = gr.Image(
+                    label="Overlay Image",
+                    type="pil",
+                    image_mode="RGBA",
+                )
+            with gr.Column():
+                x_slider = gr.Slider(
+                    label="X (px)",
+                    minimum=-500,
+                    maximum=500,
+                    step=1,
+                    value=0,
+                    interactive=False,
+                    info="Overlay image X coordinate relative to base",
+                )
+                y_slider = gr.Slider(
+                    label="Y (px)",
+                    minimum=-500,
+                    maximum=500,
+                    step=1,
+                    value=0,
+                    interactive=False,
+                    info="Overlay image Y coordinate relative to base",
+                )
+                rot_slider = gr.Slider(
+                    label="Rotation (°)",
+                    minimum=-180,
+                    maximum=180,
+                    step=1,
+                    value=0,
+                    interactive=False,
+                    info="Rotate overlay image",
+                )
+                zoom_slider = gr.Slider(
+                    label="Zoom",
+                    minimum=0.01,
+                    maximum=10.0,
+                    step=0.01,
+                    value=1.0,
+                    interactive=False,
+                    info="Make overlay image bigger or smaller",
+                )
+                indexed_slider = gr.Slider(
+                    label="Indexed Colors",
+                    minimum=2,
+                    maximum=255,
+                    step=1,
+                    value=4,
+                    info="Overlay image colors will be quantized",
+                )
+                use_common_colors_checkbox = gr.Checkbox(
+                    label="Use most common colors for quantization",
+                    value=True,
+                    interactive=True,
+                    info="Best for the logo's.",
+                )
+                morphology_slider = gr.Slider(
+                    label="Morphology Size",
+                    minimum=1,
+                    maximum=20,
+                    step=1,
+                    value=1,
+                    info=(
+                        "Size of morphological opening/closing "
+                        "to remove small features"
+                    ),
+                )
+                resolution_dropdown = gr.Dropdown(
+                    label="Resolution (px)",
+                    choices=[512, 1024, 2048],
+                    value=512,
+                    interactive=True,
+                )
+
+        with gr.Column():
+            out = gr.Image(label="Result")
+            mask_gallery = gr.Gallery(label="Masks")
+            base_thickness = gr.Number(
+                label="Base Thickness (mm)", minimum=0, step=0.1, value=1.0
+            )
+            overlay_thickness = gr.Number(
+                label="Overlay Thickness (mm)", minimum=0, step=0.1, value=0.5
+            )
+            width_slider = gr.Number(
+                label="Width (mm)",
+                minimum=0,
+                step=0.01,
+                value=100,
+                interactive=True,
+            )
+            height_slider = gr.Number(
+                label="Height (mm)",
+                minimum=0,
+                step=0.01,
+                value=100,
+                interactive=True,
+            )
+            use_aspect_ratio = gr.Checkbox(
+                label="Use image aspect ratio (base/overlay)",
+                value=True,
+                interactive=True,
+            )
+            height_slider.input(
+                fn=update_width_from_height,
+                inputs=[
+                    height_slider,
+                    width_slider,
+                    use_aspect_ratio,
+                    base_img,
+                    overlay_img,
+                ],
+                outputs=[width_slider],
+            )
+            width_slider.input(
+                fn=update_height_from_width,
+                inputs=[
+                    width_slider,
+                    height_slider,
+                    use_aspect_ratio,
+                    base_img,
+                    overlay_img,
+                ],
+                outputs=[height_slider],
+            )
+            masks_state = gr.State()
+            mask_colors_state = gr.State()
+
+            generate_button = gr.Button("Generate scad/3mf", interactive=False)
+            scad_file = gr.File(label="SCAD/3mf output")
+
+            masks_state.change(
+                fn=lambda masks: gr.update(interactive=bool(masks)),
+                inputs=[masks_state],
+                outputs=[generate_button],
+            )
+
+    base_img.change(
+        fn=update_slider_ranges,
+        inputs=[base_img, overlay_img, resolution_dropdown],
+        outputs=[
+            x_slider,
+            y_slider,
+            rot_slider,
+            zoom_slider,
+            indexed_slider,
+            width_slider,
+            height_slider,
+        ],
+    )
+
+    base_img.change(
+        fn=lambda img: (
+            gr.update(interactive=True),
+            gr.update(interactive=True),
+            gr.update(interactive=True),
+        ),
+        inputs=base_img,
+        outputs=[width_slider, height_slider, use_aspect_ratio],
+    )
+
+    overlay_img.change(
+        fn=lambda img, base, current_zoom, res: (
+            gr.update(interactive=bool(img)),
+            gr.update(interactive=bool(img)),
+            gr.update(interactive=bool(img)),
+            gr.update(
+                interactive=bool(img),
+                value=calculate_zoom_value(base, img, current_zoom, res)
+                if img
+                else current_zoom,
+            ),
+        ),
+        inputs=[overlay_img, base_img, zoom_slider, resolution_dropdown],
+        outputs=[x_slider, y_slider, rot_slider, zoom_slider],
+    )
+
+    overlay_img.change(
+        fn=update_height_from_width,
+        inputs=[
+            width_slider,
+            height_slider,
+            use_aspect_ratio,
+            base_img,
+            overlay_img,
+        ],
+        outputs=[height_slider],
+    )
+
+    for comp in [
+        x_slider,
+        y_slider,
+        rot_slider,
+        zoom_slider,
+        indexed_slider,
+        use_common_colors_checkbox,
+        base_img,
+        overlay_img,
+        morphology_slider,
+        resolution_dropdown,
+    ]:
+        comp.change(
+            fn=overlay_images,
+            inputs=[
+                base_img,
+                overlay_img,
+                x_slider,
+                y_slider,
+                rot_slider,
+                zoom_slider,
+                indexed_slider,
+                base_thickness,
+                overlay_thickness,
+                width_slider,
+                height_slider,
+                use_common_colors_checkbox,
+                morphology_slider,
+                resolution_dropdown,
+            ],
+            outputs=[
+                out,
+                mask_gallery,
+                masks_state,
+                mask_colors_state,
+                generate_button,
+            ],
+        )
+
+    resolution_dropdown.change(
+        fn=update_slider_ranges,
+        inputs=[base_img, overlay_img, resolution_dropdown],
+        outputs=[
+            x_slider,
+            y_slider,
+            rot_slider,
+            zoom_slider,
+            indexed_slider,
+            width_slider,
+            height_slider,
+        ],
+    )
+
+    # Hidden component to hold the user directory path
+    user_dir = gr.Text(visible=False)
+
+    # Set the user directory when the app loads
+    demo.load(get_user_dir, outputs=user_dir)
+
+    generate_button.click(
+        fn=generate_3mf_file,
+        inputs=[
+            base_img,
+            masks_state,
+            mask_colors_state,
+            width_slider,
+            height_slider,
+            base_thickness,
+            overlay_thickness,
+            resolution_dropdown,
+            user_dir,
+        ],
+        outputs=[scad_file],
+    )
+
+    # Delete the user directory when the session ends
+    demo.unload(delete_user_dir)
+
+if __name__ == "__main__":
+    demo.launch(share=False, server_name="0.0.0.0")

src/input.scad.j2

@@ -0,0 +1,28 @@
+{% if include_base %}
+module base() {
+    scale([{{ scale_x }}, {{ scale_y }}, {{ scale_z }}]) {
+        color({{ base_color }}) linear_extrude(height = 100) projection(cut = true) {
+            surface(file="{{ base_rel_path }}", center=false);
+        }
+    }
+}
+{% endif %}
+
+module masks() {
+    scale([{{ scale_x }}, {{ scale_y }}, {{ overlay_scale_z }}]) {
+{% for mask_path, mask_color in mask_paths_and_colors %}
+        color({{ mask_color }}) linear_extrude(height = 100) projection(cut = true) {
+            surface(file="{{ mask_path }}", center=false);
+        }
+{% endfor %}
+    }
+}
+
+{% if include_base %}
+difference() {
+    base();
+    masks();
+}
+{% endif %}
+
+masks();

src/png23mf.py

@@ -0,0 +1,471 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import random
+import shutil
+import string
+import subprocess
+import tempfile
+import zipfile
+from pathlib import Path
+
+import jinja2
+import numpy as np
+from PIL import Image
+from scipy import ndimage
+
+
+def generate_scad_file(
+    base_img,
+    width_mm,
+    height_mm,
+    base_thickness_mm,
+    overlay_thickness_mm,
+    resolution,
+    masks,
+    mask_colors,
+):
+    include_base = base_img is not None
+    tmp_dir = tempfile.mkdtemp(prefix="scad_")
+    # Base image handling
+    if include_base:
+        base = base_img.convert("RGBA")
+        w_base, h_base = base.size
+        if max(w_base, h_base) > resolution:
+            scale_factor = resolution / max(w_base, h_base)
+            new_w_base = int(w_base * scale_factor)
+            new_h_base = int(h_base * scale_factor)
+            base = base.resize(
+                (new_w_base, new_h_base), Image.Resampling.BICUBIC
+            )
+            w_base, h_base = base.size
+        base_path = Path(tmp_dir) / "base.png"
+        base.save(base_path)
+        scale_x = width_mm / w_base if w_base != 0 else 1.0
+        scale_y = height_mm / h_base if h_base != 0 else 1.0
+        scale_z = base_thickness_mm / 100.0 if base_thickness_mm != 0 else 1.0
+        base_rel_path = base_path.name
+        base_color = [0.0, 0.0, 0.0]  # placeholder, will be set below
+    else:
+        # No base image: use overlay size for scaling
+        if masks:
+            w_overlay, h_overlay = masks[0].size
+            scale_x = width_mm / w_overlay if w_overlay != 0 else 1.0
+            scale_y = height_mm / h_overlay if h_overlay != 0 else 1.0
+        else:
+            scale_x = 1.0
+            scale_y = 1.0
+        scale_z = 1.0
+        base_rel_path = ""
+        base_color = [0.0, 0.0, 0.0]
+    overlay_scale_z = (
+        overlay_thickness_mm / 100.0 if overlay_thickness_mm != 0 else 1.0
+    )
+    # Save masks
+    mask_paths = []
+    for idx, mask_img in enumerate(masks):
+        mask_path = Path(tmp_dir) / f"mask_{idx}.png"
+        mask_img = mask_img.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
+        mask_path.parent.mkdir(parents=True, exist_ok=True)
+        mask_img.save(mask_path)
+        mask_paths.append(mask_path)
+    # Load template
+    template_path = os.path.join(os.path.dirname(__file__), "input.scad.j2")
+    with open(template_path, "r") as f:
+        template_text = f.read()
+    template = jinja2.Template(template_text)
+    mask_paths_and_colors = [
+        (mask_path.name, mask_color)
+        for mask_path, mask_color in zip(mask_paths, mask_colors)
+    ]
+    if include_base:
+        mask_color_ints = set(
+            (int(r * 255), int(g * 255), int(b * 255))
+            for r, g, b in mask_colors
+        )
+        max_attempts = 1000
+        for _ in range(max_attempts):
+            r = random.randint(0, 255)
+            g = random.randint(0, 255)
+            b = random.randint(0, 255)
+            if (r, g, b) not in mask_color_ints:
+                break
+        else:
+            r, g, b = 0, 0, 0
+        base_color = [r / 255.0, g / 255.0, b / 255.0]
+    rendered_scad = template.render(
+        scale_x=scale_x,
+        scale_y=scale_y,
+        scale_z=scale_z,
+        base_rel_path=base_rel_path,
+        overlay_scale_z=overlay_scale_z,
+        mask_paths_and_colors=mask_paths_and_colors,
+        base_color=base_color,
+        include_base=include_base,
+    )
+    scad_path = Path(tmp_dir) / "model.scad"
+    with open(scad_path, "w") as f:
+        f.write(rendered_scad)
+    return str(scad_path)
+
+
+def extract_masks(overlay_image, morph_size=1):
+    overlay_rgba = overlay_image.convert("RGBA")
+    overlay_np = np.array(overlay_rgba)
+    alpha_mask = overlay_np[..., 3] != 0
+    flat = overlay_np.reshape(-1, 4)
+    unique_colors = np.unique(flat, axis=0)
+    unique_colors = unique_colors[unique_colors[:, 3] != 0]
+    masks = []
+    mask_colors = []
+    selem = np.ones((int(morph_size), int(morph_size)), dtype=bool)
+    for color in unique_colors:
+        mask_array = (
+            np.all(overlay_np[..., :3] == color[:3], axis=-1) & alpha_mask
+        )
+        opened = ndimage.binary_opening(mask_array, structure=selem)
+        closed = ndimage.binary_closing(opened, structure=selem)
+        mask_image = Image.fromarray((closed.astype(np.uint8) * 255), mode="L")
+        masks.append(mask_image)
+        r = int(color[0]) / 255.0
+        g = int(color[1]) / 255.0
+        b = int(color[2]) / 255.0
+        mask_colors.append([r, g, b])
+    return masks, mask_colors
+
+
+def calculate_zoom_value(base_img, overlay_img, current_zoom, resolution):
+    if base_img is None or overlay_img is None:
+        return current_zoom
+    base = base_img.convert("RGBA")
+    w_base, h_base = base.size
+    if max(w_base, h_base) > resolution:
+        scale_factor = resolution / max(w_base, h_base)
+        w_base = int(w_base * scale_factor)
+        h_base = int(h_base * scale_factor)
+    base_longer = max(w_base, h_base)
+    w_overlay, h_overlay = overlay_img.size
+    overlay_longer = max(w_overlay, h_overlay)
+    if overlay_longer > base_longer:
+        zoom = round(base_longer / overlay_longer, 2)
+        zoom = max(0.01, min(10.0, zoom))
+        return zoom
+    else:
+        return current_zoom
+
+
+def get_most_common_colors(overlay_img, num_colors):
+    rgba = overlay_img.convert("RGBA")
+    arr = np.array(rgba)
+    alpha_mask = arr[..., 3] > 0
+    rgb_pixels = arr[alpha_mask][:, :3]
+    if rgb_pixels.size == 0:
+        return [(0, 0, 0)] * num_colors
+    unique_colors, counts = np.unique(rgb_pixels, axis=0, return_counts=True)
+    sorted_indices = np.argsort(-counts)
+    sorted_colors = unique_colors[sorted_indices]
+    top_colors = sorted_colors[:num_colors]
+    return [tuple(color) for color in top_colors]
+
+
+def create_palette_image(colors):
+    palette = [0] * 768
+    for i, color in enumerate(colors):
+        if i >= 256:
+            break
+        palette[i * 3] = color[0]
+        palette[i * 3 + 1] = color[1]
+        palette[i * 3 + 2] = color[2]
+    last_color = colors[-1]
+    for i in range(len(colors), 256):
+        palette[i * 3] = last_color[0]
+        palette[i * 3 + 1] = last_color[1]
+        palette[i * 3 + 2] = last_color[2]
+    palette_img = Image.new("P", (1, 1))
+    palette_img.putpalette(palette)
+    return palette_img
+
+
+def overlay_images_core(
+    base_img,
+    overlay_img,
+    x,
+    y,
+    rot,
+    zoom,
+    indexed_colors,
+    base_thickness,
+    overlay_thickness,
+    width,
+    height,
+    use_common_colors,
+    morph_size,
+    resolution,
+):
+    if overlay_img is None:
+        return None, None, None
+    width = round(width, 2)
+    height = round(height, 2)
+    if base_img is None:
+        base = overlay_img.convert("RGBA")
+        x, y = 0, 0
+    else:
+        base = base_img.convert("RGBA")
+        w_base, h_base = base.size
+        max_dim = resolution
+        if max(w_base, h_base) > max_dim:
+            scale_factor = max_dim / max(w_base, h_base)
+            new_w_base = int(w_base * scale_factor)
+            new_h_base = int(h_base * scale_factor)
+            base = base.resize(
+                (new_w_base, new_h_base), Image.Resampling.BICUBIC
+            )
+    overlay = overlay_img.convert("RGBA")
+    w, h = overlay.size
+    overlay = overlay.resize(
+        (int(w * zoom), int(h * zoom)), Image.Resampling.NEAREST
+    )
+    overlay = overlay.rotate(rot, expand=True)
+    alpha = overlay.split()[3]
+    rgb = overlay.convert("RGB")
+    if use_common_colors:
+        common_colors = get_most_common_colors(overlay_img, indexed_colors)
+        palette_img = create_palette_image(common_colors)
+        rgb_quant = rgb.quantize(palette=palette_img, dither=0).convert("RGB")
+    else:
+        rgb_quant = rgb.quantize(colors=indexed_colors).convert("RGB")
+    alpha = overlay.split()[3].point(lambda p: 255 if p > 0 else 0)
+    overlay = Image.merge("RGBA", (*rgb_quant.split(), alpha))
+    if base_img is not None:
+        base.paste(overlay, (int(x), int(y)), overlay)
+    overlay_on_transparent = Image.new("RGBA", base.size, (0, 0, 0, 0))
+    overlay_on_transparent.paste(overlay, (int(x), int(y)), overlay)
+    masks, mask_colors = extract_masks(overlay_on_transparent, morph_size)
+    return (
+        base.convert("RGB"),
+        masks,
+        mask_colors,
+    )
+
+
+def update_width_from_height(
+    height,
+    width,
+    use_aspect_ratio,
+    base_img,
+    overlay_img,
+):
+    if use_aspect_ratio:
+        if base_img is not None:
+            w_base, h_base = base_img.size
+        elif overlay_img is not None:
+            w_base, h_base = overlay_img.size
+        else:
+            return width
+        new_width = round(height * w_base / h_base, 2)
+        if abs(new_width - width) > 1e-6:
+            return new_width
+    return width
+
+
+def update_height_from_width(
+    width,
+    height,
+    use_aspect_ratio,
+    base_img,
+    overlay_img,
+):
+    if use_aspect_ratio:
+        if base_img is not None:
+            w_base, h_base = base_img.size
+        elif overlay_img is not None:
+            w_base, h_base = overlay_img.size
+        else:
+            return height
+        new_height = round(width * h_base / w_base, 2)
+        if abs(new_height - height) > 1e-6:
+            return new_height
+    return height
+
+
+def generate_3mf_file(
+    base_img,
+    masks,
+    mask_colors,
+    width,
+    height,
+    base_thickness,
+    overlay_thickness,
+    resolution,
+    user_dir=None,
+):
+    if not masks or not mask_colors:
+        return None
+    scad_path = generate_scad_file(
+        base_img,
+        width,
+        height,
+        base_thickness,
+        overlay_thickness,
+        resolution,
+        masks,
+        mask_colors,
+    )
+    if not scad_path:
+        return None
+    scad_path_obj = Path(scad_path)
+    openscad_model_3mf = scad_path_obj.with_name("openscad_model.3mf")
+    subprocess.run(
+        ["openscad", "-o", str(openscad_model_3mf), str(scad_path_obj)],
+        check=True,
+    )
+    converted_model_3mf = openscad_model_3mf.with_name("converted_model.3mf")
+    script_path = Path(__file__).parent / "3mf2mmuv3.py"
+    subprocess.run(
+        [
+            "python3",
+            str(script_path),
+            str(openscad_model_3mf),
+            str(converted_model_3mf),
+            "--force",
+        ],
+        check=True,
+    )
+    temp_dir = scad_path_obj.parent
+    mask_paths = sorted(Path(temp_dir).glob("mask_*.png"))
+    random_string = "".join(
+        random.choices(string.ascii_letters + string.digits, k=6)
+    )
+    if user_dir is not None:
+        zip_dir = Path(user_dir)
+        zip_dir.mkdir(parents=True, exist_ok=True)
+        zip_path = zip_dir / f"model_{random_string}.zip"
+    else:
+        zip_path = Path(tempfile.gettempdir()) / f"model_{random_string}.zip"
+    with zipfile.ZipFile(
+        zip_path, "w", zipfile.ZIP_DEFLATED, compresslevel=9
+    ) as zf:
+        zf.write(scad_path_obj, arcname=scad_path_obj.name)
+        zf.write(openscad_model_3mf, arcname=openscad_model_3mf.name)
+        zf.write(converted_model_3mf, arcname=converted_model_3mf.name)
+        for mask_path in mask_paths:
+            zf.write(mask_path, arcname=mask_path.name)
+        if base_img is not None:
+            base_img_path = Path(temp_dir) / "base.png"
+            zf.write(base_img_path, arcname=base_img_path.name)
+    shutil.rmtree(temp_dir)
+    return str(zip_path)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate 3MF from base and overlay images."
+    )
+    parser.add_argument("base_image", help="Path to base image (PNG)")
+    parser.add_argument("overlay_image", help="Path to overlay image (PNG)")
+    parser.add_argument(
+        "-o", "--output", default=None, help="Output zip file path (optional)"
+    )
+    parser.add_argument(
+        "--width", type=float, default=100.0, help="Width in mm"
+    )
+    parser.add_argument(
+        "--height", type=float, default=100.0, help="Height in mm"
+    )
+    parser.add_argument(
+        "--base-thickness",
+        type=float,
+        default=1.0,
+        help="Base thickness in mm",
+    )
+    parser.add_argument(
+        "--overlay-thickness",
+        type=float,
+        default=0.5,
+        help="Overlay thickness in mm",
+    )
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        choices=[512, 1024, 2048],
+        default=512,
+        help="Resolution in pixels",
+    )
+    parser.add_argument(
+        "--morph-size",
+        type=int,
+        default=1,
+        help="Morphology size for mask extraction",
+    )
+    # New arguments that mirror the Gradio UI
+    parser.add_argument("--x", type=int, default=0, help="X offset (px)")
+    parser.add_argument("--y", type=int, default=0, help="Y offset (px)")
+    parser.add_argument(
+        "--rot", type=int, default=0, help="Rotation (degrees)"
+    )
+    parser.add_argument("--zoom", type=float, default=1.0, help="Zoom factor")
+    parser.add_argument(
+        "--indexed-colors",
+        type=int,
+        default=4,
+        help="Number of colors for quantization",
+    )
+    parser.add_argument(
+        "--use-common-colors",
+        action="store_true",
+        default=True,
+        help="Use most common colors for quantization",
+    )
+    args = parser.parse_args()
+
+    # Load images
+    base_img = Image.open(args.base_image).convert("RGBA")
+    overlay_img = Image.open(args.overlay_image).convert("RGBA")
+
+    # Generate masks and mask colors using overlay images core logic
+    _, masks, mask_colors = overlay_images_core(
+        base_img,
+        overlay_img,
+        args.x,
+        args.y,
+        args.rot,
+        args.zoom,
+        args.indexed_colors,
+        args.base_thickness,
+        args.overlay_thickness,
+        args.width,
+        args.height,
+        args.use_common_colors,
+        args.morph_size,
+        args.resolution,
+    )
+
+    if not masks or not mask_colors:
+        print("Failed to generate masks from overlay image.")
+        return
+
+    zip_path = generate_3mf_file(
+        base_img,
+        masks,
+        mask_colors,
+        args.width,
+        args.height,
+        args.base_thickness,
+        args.overlay_thickness,
+        args.resolution,
+    )
+
+    if zip_path is None:
+        print("Failed to generate 3MF zip.")
+        return
+
+    if args.output:
+        shutil.move(zip_path, args.output)
+        print(f"Generated zip file: {args.output}")
+    else:
+        print(f"Generated zip file: {zip_path}")
+
+
+if __name__ == "__main__":
+    main()