reverse3d 0.4.0__py3-none-any.whl

reverse3d/rendering/_blender_job.py

@@ -0,0 +1,284 @@
+"""Headless render job executed *inside* Blender's embedded Python.
+
+Invoked by :mod:`reverse3d.rendering.blender_render` as::
+
+    blender --background --factory-startup --disable-autoexec \
+            --python-exit-code 1 --python _blender_job.py -- job.json
+
+This file must not import reverse3d (Blender ships its own interpreter). It only
+reads a JSON job written by the launcher, so no code or expression coming from
+users/agents is ever evaluated here. Compatible with Blender 3.6 LTS → 4.x.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import sys
+import traceback
+from pathlib import Path
+
+import bpy
+from mathutils import Vector
+
+RESULT_MARKER = "REVERSE3D_RESULT "
+
+
+def _read_job() -> dict:
+    argv = sys.argv
+    if "--" not in argv:
+        raise SystemExit("Missing job file argument")
+    job_path = Path(argv[argv.index("--") + 1])
+    return json.loads(job_path.read_text(encoding="utf-8"))
+
+
+def _hex_to_rgba(value: str, alpha: float = 1.0) -> tuple[float, float, float, float]:
+    value = value.lstrip("#")
+    r, g, b = (int(value[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
+
+    # Convert sRGB to linear for Blender's scene-referred colour inputs.
+    def lin(c: float) -> float:
+        return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4
+
+    return lin(r), lin(g), lin(b), alpha
+
+
+def _call_first(*candidates: tuple[str, str], **kwargs: object) -> None:
+    """Call the first operator that exists (operators were renamed in 4.x)."""
+    last_error: Exception | None = None
+    for module, name in candidates:
+        try:
+            getattr(getattr(bpy.ops, module), name)(**kwargs)
+            return
+        except (AttributeError, RuntimeError) as exc:
+            last_error = exc
+    raise RuntimeError(f"No importer available: {last_error}")
+
+
+def import_mesh(path: str) -> bpy.types.Object:
+    ext = Path(path).suffix.lower()
+    before = set(bpy.data.objects)
+    if ext == ".obj":
+        _call_first(("wm", "obj_import"), ("import_scene", "obj"), filepath=path)
+    elif ext == ".stl":
+        _call_first(("wm", "stl_import"), ("import_mesh", "stl"), filepath=path)
+    elif ext == ".ply":
+        _call_first(("wm", "ply_import"), ("import_mesh", "ply"), filepath=path)
+    elif ext in {".glb", ".gltf"}:
+        _call_first(("import_scene", "gltf"), filepath=path)
+    else:
+        raise ValueError(f"Unsupported format for Blender: {ext}")
+
+    meshes = [o for o in bpy.data.objects if o not in before and o.type == "MESH"]
+    if not meshes:
+        raise RuntimeError("Imported file contains no mesh objects")
+    bpy.ops.object.select_all(action="DESELECT")
+    for obj in meshes:
+        obj.select_set(True)
+    bpy.context.view_layer.objects.active = meshes[0]
+    if len(meshes) > 1:
+        bpy.ops.object.join()
+    obj = bpy.context.view_layer.objects.active
+    bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
+    return obj
+
+
+def normalize(obj: bpy.types.Object, ground: bool) -> tuple[float, float]:
+    """Center the object and scale its largest dimension to 2 units.
+
+    Returns the bounding-sphere radius and the height of the object's centre
+    (non-zero when it rests on the ground), which is where the camera aims.
+    """
+    corners = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
+    lo = Vector((min(c.x for c in corners), min(c.y for c in corners), min(c.z for c in corners)))
+    hi = Vector((max(c.x for c in corners), max(c.y for c in corners), max(c.z for c in corners)))
+    size = max((hi - lo).x, (hi - lo).y, (hi - lo).z) or 1.0
+    scale = 2.0 / size
+    center = (lo + hi) / 2
+    obj.location = -center * scale
+    if ground:
+        obj.location.z = -lo.z * scale
+    obj.scale = (scale, scale, scale)
+    bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
+    center_z = (hi.z - lo.z) * scale / 2 if ground else 0.0
+    return ((hi - lo) * scale).length / 2, center_z
+
+
+def shade(obj: bpy.types.Object, mode: str) -> None:
+    if mode == "flat":
+        bpy.ops.object.shade_flat()
+        return
+    if mode == "smooth":
+        bpy.ops.object.shade_smooth()
+        return
+    try:  # Blender >= 4.1
+        bpy.ops.object.shade_smooth_by_angle(angle=math.radians(30))
+    except (AttributeError, RuntimeError, TypeError):
+        bpy.ops.object.shade_smooth()
+        if hasattr(obj.data, "use_auto_smooth"):  # Blender <= 4.0
+            obj.data.use_auto_smooth = True
+            obj.data.auto_smooth_angle = math.radians(30)
+
+
+def make_material(obj: bpy.types.Object, job: dict) -> None:
+    mat = bpy.data.materials.new("reverse3d_material")
+    mat.use_nodes = True
+    bsdf = mat.node_tree.nodes.get("Principled BSDF")
+    bsdf.inputs["Base Color"].default_value = _hex_to_rgba(job["color"])
+    bsdf.inputs["Metallic"].default_value = float(job["metallic"])
+    bsdf.inputs["Roughness"].default_value = float(job["roughness"])
+    attrs = getattr(obj.data, "color_attributes", None)
+    if job.get("vertex_colors", True) and attrs is not None and len(attrs) > 0:
+        node = mat.node_tree.nodes.new("ShaderNodeVertexColor")
+        node.layer_name = attrs[0].name
+        mat.node_tree.links.new(node.outputs["Color"], bsdf.inputs["Base Color"])
+    obj.data.materials.clear()
+    obj.data.materials.append(mat)
+
+
+def add_light(name: str, location: tuple[float, float, float], energy: float, size: float) -> None:
+    data = bpy.data.lights.new(name, type="AREA")
+    data.energy = energy
+    data.size = size
+    light = bpy.data.objects.new(name, data)
+    bpy.context.collection.objects.link(light)
+    light.location = location
+    direction = Vector((0, 0, 0.5)) - light.location
+    light.rotation_euler = direction.to_track_quat("-Z", "Y").to_euler()
+
+
+def setup_world(job: dict) -> None:
+    world = bpy.data.worlds.new("reverse3d_world")
+    bpy.context.scene.world = world
+    world.use_nodes = True
+    bg = world.node_tree.nodes.get("Background")
+    bg.inputs["Color"].default_value = _hex_to_rgba(job["background"])
+    bg.inputs["Strength"].default_value = 0.6
+
+
+def setup_camera(radius: float, center_z: float, job: dict) -> bpy.types.Object:
+    rig = bpy.data.objects.new("reverse3d_rig", None)
+    bpy.context.collection.objects.link(rig)
+    rig.location = (0, 0, center_z)
+
+    cam_data = bpy.data.cameras.new("reverse3d_camera")
+    cam_data.lens = 50
+    cam = bpy.data.objects.new("reverse3d_camera", cam_data)
+    bpy.context.collection.objects.link(cam)
+    # camera.angle is the FOV of the longer image side; fit the sphere in the shorter one.
+    width, height = int(job["width"]), int(job["height"])
+    fov = cam_data.angle
+    if width != height:
+        fov = 2 * math.atan(math.tan(fov / 2) * min(width, height) / max(width, height))
+    distance = radius / math.sin(fov / 2) * 1.1
+    elev, azim = math.radians(job["elevation_deg"]), math.radians(job["azimuth_deg"])
+    # Parented with an identity parent-inverse: this location is relative to the rig.
+    cam.location = (
+        distance * math.cos(elev) * math.sin(azim),
+        -distance * math.cos(elev) * math.cos(azim),
+        distance * math.sin(elev),
+    )
+    cam.parent = rig
+    track = cam.constraints.new(type="TRACK_TO")
+    track.target = rig
+    track.track_axis = "TRACK_NEGATIVE_Z"
+    track.up_axis = "UP_Y"
+    bpy.context.scene.camera = cam
+    cam_data.clip_end = distance * 10
+    return rig
+
+
+def setup_ground(job: dict) -> None:
+    if not job["ground"] or job["engine"] != "cycles":
+        return
+    bpy.ops.mesh.primitive_plane_add(size=50, location=(0, 0, 0))
+    plane = bpy.context.active_object
+    plane.is_shadow_catcher = True
+
+
+def setup_render(job: dict) -> None:
+    scene = bpy.context.scene
+    engines = {item.identifier for item in scene.render.bl_rna.properties["engine"].enum_items}
+    if job["engine"] == "cycles":
+        scene.render.engine = "CYCLES"
+        scene.cycles.samples = int(job["samples"])
+        if job["device"] == "gpu":
+            try:
+                prefs = bpy.context.preferences.addons["cycles"].preferences
+                for backend in ("OPTIX", "CUDA", "HIP", "METAL", "ONEAPI"):
+                    try:
+                        prefs.compute_device_type = backend
+                        prefs.get_devices()
+                        if any(d.type == backend for d in prefs.devices):
+                            for d in prefs.devices:
+                                d.use = True
+                            scene.cycles.device = "GPU"
+                            break
+                    except TypeError:
+                        continue
+            except KeyError:
+                pass
+    elif job["engine"] == "eevee":
+        scene.render.engine = (
+            "BLENDER_EEVEE_NEXT" if "BLENDER_EEVEE_NEXT" in engines else "BLENDER_EEVEE"
+        )
+        scene.eevee.taa_render_samples = int(job["samples"])
+    else:
+        scene.render.engine = "BLENDER_WORKBENCH"
+
+    scene.render.resolution_x = int(job["width"])
+    scene.render.resolution_y = int(job["height"])
+    scene.render.resolution_percentage = 100
+    scene.render.film_transparent = bool(job["transparent"])
+    scene.render.image_settings.file_format = "PNG"
+    scene.render.image_settings.color_mode = "RGBA" if job["transparent"] else "RGB"
+    for transform in ("AgX", "Filmic", "Standard"):
+        try:
+            scene.view_settings.view_transform = transform
+            break
+        except TypeError:
+            continue
+
+
+def main() -> None:
+    job = _read_job()
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    obj = import_mesh(job["mesh"])
+    radius, center_z = normalize(obj, job["ground"])
+    shade(obj, job["shading"])
+    make_material(obj, job)
+    setup_world(job)
+    r = max(radius, 0.1)
+    add_light("key", (r * 3, -r * 3, r * 4), 800 * r * r, r * 2)
+    add_light("fill", (-r * 4, -r * 2, r * 2), 300 * r * r, r * 3)
+    add_light("rim", (0, r * 4, r * 3), 500 * r * r, r * 2)
+    rig = setup_camera(radius, center_z, job)
+    setup_ground(job)
+    setup_render(job)
+
+    output = Path(job["output"])
+    files: list[str] = []
+    frames = int(job["turntable_frames"])
+    if frames <= 0:
+        bpy.context.scene.render.filepath = str(output)
+        bpy.ops.render.render(write_still=True)
+        files.append(str(output))
+    else:
+        for i in range(frames):
+            rig.rotation_euler.z = 2 * math.pi * i / frames
+            path = output.with_name(f"{output.stem}_{i:04d}{output.suffix}")
+            bpy.context.scene.render.filepath = str(path)
+            bpy.ops.render.render(write_still=True)
+            files.append(str(path))
+
+    print(
+        RESULT_MARKER + json.dumps({"files": files, "blender": bpy.app.version_string}), flush=True
+    )
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        traceback.print_exc()
+        sys.exit(1)

reverse3d/rendering/blender_render.py

@@ -0,0 +1,215 @@
+"""Automated headless rendering with Blender (preferred) or PyVista (fallback).
+
+Security model of the Blender launcher:
+
+* Render parameters are validated here and passed to a **static** script
+  (:mod:`reverse3d.rendering._blender_job`) through a JSON file. No Python
+  source is generated from user/agent input, so there is nothing to inject.
+* Blender runs with ``--factory-startup`` (ignores user add-ons and startup
+  scripts) and ``--disable-autoexec`` (never runs scripts embedded in .blend
+  files), under the hard timeout and scrubbed environment of
+  :func:`reverse3d.security.run_command`.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import tempfile
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Literal
+
+from reverse3d.config import Settings
+from reverse3d.errors import DependencyMissingError, InputValidationError, ProcessingError
+from reverse3d.mesh_io import load_mesh, save_mesh
+from reverse3d.security import (
+    MESH_EXTENSIONS,
+    prepare_output_file,
+    resolve_executable,
+    run_command,
+    validate_input_file,
+)
+
+logger = logging.getLogger(__name__)
+
+RenderEngine = Literal["cycles", "eevee", "workbench"]
+Backend = Literal["auto", "blender", "pyvista"]
+
+_HEX_COLOR = re.compile(r"^#[0-9a-fA-F]{6}$")
+_JOB_SCRIPT = Path(__file__).with_name("_blender_job.py")
+_RESULT_MARKER = "REVERSE3D_RESULT "
+_BLENDER_NATIVE = {".obj", ".stl", ".ply", ".glb", ".gltf"}
+
+
+@dataclass
+class RenderOptions:
+    """Validated render parameters (shared by the Blender and PyVista backends)."""
+
+    width: int = 1600
+    height: int = 1200
+    engine: RenderEngine = "cycles"
+    device: Literal["cpu", "gpu"] = "cpu"
+    samples: int = 64
+    color: str = "#9aa4b2"
+    metallic: float = 0.0
+    roughness: float = 0.45
+    background: str = "#f4f5f7"
+    transparent: bool = False
+    elevation_deg: float = 25.0
+    azimuth_deg: float = 35.0
+    turntable_frames: int = 0
+    ground: bool = True
+    shading: Literal["auto", "smooth", "flat"] = "auto"
+    vertex_colors: bool = True
+
+    def validate(self) -> None:
+        checks = [
+            (64 <= self.width <= 8192, "width must be in [64, 8192]"),
+            (64 <= self.height <= 8192, "height must be in [64, 8192]"),
+            (
+                self.engine in ("cycles", "eevee", "workbench"),
+                "engine must be cycles, eevee or workbench",
+            ),
+            (self.device in ("cpu", "gpu"), "device must be cpu or gpu"),
+            (1 <= self.samples <= 4096, "samples must be in [1, 4096]"),
+            (bool(_HEX_COLOR.match(self.color)), "color must be #RRGGBB"),
+            (bool(_HEX_COLOR.match(self.background)), "background must be #RRGGBB"),
+            (0 <= self.metallic <= 1, "metallic must be in [0, 1]"),
+            (0 <= self.roughness <= 1, "roughness must be in [0, 1]"),
+            (-89 <= self.elevation_deg <= 89, "elevation_deg must be in [-89, 89]"),
+            (0 <= self.azimuth_deg <= 360, "azimuth_deg must be in [0, 360]"),
+            (0 <= self.turntable_frames <= 360, "turntable_frames must be in [0, 360]"),
+            (self.shading in ("auto", "smooth", "flat"), "shading must be auto, smooth or flat"),
+        ]
+        for ok, message in checks:
+            if not ok:
+                raise InputValidationError(message)
+
+
+@dataclass
+class RenderResult:
+    """Paths of the rendered images and the backend that produced them."""
+
+    backend: str
+    files: list[str] = field(default_factory=list)
+    renderer_version: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+def _expected_outputs(out: Path, frames: int) -> list[Path]:
+    if frames <= 0:
+        return [out]
+    return [out.with_name(f"{out.stem}_{i:04d}{out.suffix}") for i in range(frames)]
+
+
+def _check_outputs_free(out: Path, frames: int, overwrite: bool) -> None:
+    if overwrite:
+        return
+    for path in _expected_outputs(out, frames):
+        if path.exists():
+            raise InputValidationError(
+                f"Output file already exists: {path.name}", hint="Pass overwrite=true."
+            )
+
+
+def render_with_blender(
+    mesh_path: str | Path,
+    output_path: str | Path,
+    settings: Settings,
+    options: RenderOptions | None = None,
+    *,
+    blender_executable: Path | None = None,
+    overwrite: bool = False,
+) -> RenderResult:
+    """Render ``mesh_path`` to PNG with Blender in background mode.
+
+    With ``turntable_frames > 0`` the files are ``<stem>_0000.png ...``.
+
+    Raises:
+        DependencyMissingError: Blender not found.
+        ExternalToolError: Blender failed or timed out.
+    """
+    options = options or RenderOptions()
+    options.validate()
+    src = validate_input_file(
+        mesh_path, allowed_extensions=MESH_EXTENSIONS, max_bytes=settings.max_input_bytes
+    )
+    out = prepare_output_file(output_path, allowed_extensions={".png"}, overwrite=True)
+    _check_outputs_free(out, options.turntable_frames, overwrite)
+    blender = blender_executable or resolve_executable(
+        ["blender", "blender.exe"], settings.blender_path, tool="blender"
+    )
+
+    with tempfile.TemporaryDirectory(prefix="reverse3d_render_") as tmp:
+        tmp_dir = Path(tmp)
+        mesh_for_blender = src
+        if src.suffix.lower() not in _BLENDER_NATIVE:
+            # Blender has no importer for e.g. .off: convert through trimesh first.
+            mesh_for_blender = save_mesh(load_mesh(src, settings), tmp_dir / "mesh.ply")
+        job = {**asdict(options), "mesh": str(mesh_for_blender), "output": str(out)}
+        job_file = tmp_dir / "job.json"
+        job_file.write_text(json.dumps(job), encoding="utf-8")
+
+        proc = run_command(
+            blender,
+            [
+                "--background",
+                "--factory-startup",
+                "--disable-autoexec",
+                "--python-exit-code",
+                "1",
+                "--python",
+                str(_JOB_SCRIPT),
+                "--",
+                str(job_file),
+            ],
+            timeout_s=settings.subprocess_timeout_s,
+            tool="blender",
+        )
+
+    payload: dict[str, object] = {}
+    for line in (proc.stdout or "").splitlines():
+        if line.startswith(_RESULT_MARKER):
+            try:
+                payload = json.loads(line[len(_RESULT_MARKER) :])
+            except json.JSONDecodeError:
+                payload = {}
+    files = [str(p) for p in _expected_outputs(out, options.turntable_frames) if p.exists()]
+    if not files:
+        raise ProcessingError("Blender finished but produced no image.")
+    version = payload.get("blender")
+    logger.info("Blender rendered %d image(s)", len(files))
+    return RenderResult(
+        backend="blender", files=files, renderer_version=str(version) if version else None
+    )
+
+
+def render_mesh(
+    mesh_path: str | Path,
+    output_path: str | Path,
+    settings: Settings,
+    options: RenderOptions | None = None,
+    *,
+    backend: Backend = "auto",
+    overwrite: bool = False,
+) -> RenderResult:
+    """Render with the requested backend. ``auto`` uses Blender when available
+    and falls back to PyVista (``[render]`` extra) otherwise."""
+    if backend not in ("auto", "blender", "pyvista"):
+        raise InputValidationError("backend must be auto, blender or pyvista")
+    if backend in ("auto", "blender"):
+        try:
+            return render_with_blender(
+                mesh_path, output_path, settings, options, overwrite=overwrite
+            )
+        except DependencyMissingError:
+            if backend == "blender":
+                raise
+            logger.info("Blender not available, falling back to PyVista")
+    from reverse3d.rendering.preview import render_with_pyvista
+
+    return render_with_pyvista(mesh_path, output_path, settings, options, overwrite=overwrite)

reverse3d/rendering/preview.py

@@ -0,0 +1,80 @@
+"""Lightweight offscreen renderer based on PyVista/VTK (``[render]`` extra).
+
+Used when Blender is not installed. Quality is lower (no path tracing) but it
+needs no external binary and is fast enough for previews in agent loops.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from reverse3d.config import Settings
+from reverse3d.errors import DependencyMissingError
+from reverse3d.mesh_io import load_mesh
+from reverse3d.rendering.blender_render import (
+    RenderOptions,
+    RenderResult,
+    _check_outputs_free,
+    _expected_outputs,
+)
+from reverse3d.security import prepare_output_file
+
+logger = logging.getLogger(__name__)
+
+
+def _require_pyvista() -> Any:
+    try:
+        import pyvista as pv
+    except ImportError as exc:
+        raise DependencyMissingError(
+            "Neither Blender nor PyVista is available for rendering.",
+            hint='Install Blender (and add it to PATH) or: pip install "reverse3d[render]"',
+        ) from exc
+    return pv
+
+
+def render_with_pyvista(
+    mesh_path: str | Path,
+    output_path: str | Path,
+    settings: Settings,
+    options: RenderOptions | None = None,
+    *,
+    overwrite: bool = False,
+) -> RenderResult:
+    """Render ``mesh_path`` offscreen with PyVista. Supports turntables."""
+    options = options or RenderOptions()
+    options.validate()
+    pv = _require_pyvista()
+    mesh = load_mesh(mesh_path, settings)
+    out = prepare_output_file(output_path, allowed_extensions={".png"}, overwrite=True)
+    _check_outputs_free(out, options.turntable_frames, overwrite)
+
+    plotter = pv.Plotter(off_screen=True, window_size=(options.width, options.height))
+    plotter.set_background(options.background)
+    plotter.add_mesh(
+        pv.wrap(mesh),
+        color=options.color,
+        smooth_shading=options.shading != "flat",
+        pbr=True,
+        metallic=options.metallic,
+        roughness=options.roughness,
+    )
+    if options.ground:
+        plotter.enable_shadows()
+    targets = _expected_outputs(out, options.turntable_frames)
+    step = 360.0 / max(len(targets), 1)
+    plotter.camera_position = "iso"
+    plotter.camera.azimuth = options.azimuth_deg
+    plotter.camera.elevation = options.elevation_deg
+    plotter.reset_camera()
+    files: list[str] = []
+    for index, target in enumerate(targets):
+        if index:
+            plotter.camera.azimuth = options.azimuth_deg + step * index
+        plotter.screenshot(str(target), transparent_background=options.transparent)
+        files.append(str(target))
+    plotter.close()
+    logger.info("PyVista rendered %d image(s)", len(files))
+    return RenderResult(backend="pyvista", files=files, renderer_version=pv.__version__)

reverse3d/reverse_eng/__init__.py

@@ -0,0 +1,33 @@
+"""Reverse engineering: mesh repair, measurement, primitive fitting and CAD export."""
+
+from reverse3d.reverse_eng.geometry_fit import (
+    FitReport,
+    PrimitiveFit,
+    detect_primitives,
+    fit_primitives_file,
+)
+from reverse3d.reverse_eng.measure import MeshStats, compute_stats, measure_mesh_file
+from reverse3d.reverse_eng.mesh_cleaner import (
+    CleanOptions,
+    CleanReport,
+    clean_mesh,
+    clean_mesh_file,
+)
+from reverse3d.reverse_eng.parametric import export_parametric, generate_cadquery, generate_openscad
+
+__all__ = [
+    "CleanOptions",
+    "CleanReport",
+    "FitReport",
+    "MeshStats",
+    "PrimitiveFit",
+    "clean_mesh",
+    "clean_mesh_file",
+    "compute_stats",
+    "detect_primitives",
+    "export_parametric",
+    "fit_primitives_file",
+    "generate_cadquery",
+    "generate_openscad",
+    "measure_mesh_file",
+]