upload script for load dataset sample into blender

load_dataset_sample.py

@@ -0,0 +1,2708 @@
+import bpy
+import json
+import math
+import re
+import numpy as np
+import bmesh
+from pathlib import Path
+from mathutils import Vector
+from mathutils.bvhtree import BVHTree
+from mathutils.geometry import barycentric_transform
+import random
+import time
+import sys
+import argparse
+
+IMAGE_PREFIX = "dens_"
+VGROUP_PREFIX = "len_"
+
+ANIMALLIFT_ROOT = Path("path/to/AnimalLift")
+
+REGIONS = [
+    "face", "ear", "neck", "body", "leg", "tail"
+]
+
+CURVE_REGION_MAP = {
+    "face_fur": "face",
+    "ear_fur": "ear",
+    "body_fur": "body",
+    "leg_fur": "leg",
+    "neck_fur": "neck",
+    "neck": "neck",
+    "mouse_fur": "face",
+    "tail_fur": "tail",
+}
+
+IGNORE_NAME_KEYWORDS = ["undercoat"]
+
+MOUSE_LENGTH_VALUE = 0.05
+
+BASE_PART_RESOLUTION = 512
+SAMPLES_PER_STRAND = 32
+ATLAS_TILE_PADDING = 0.02
+
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp", ".exr"}
+
+META_ROOT = ANIMALLIFT_ROOT / "meta"
+HDR_DIR = META_ROOT / "render_elements" / "hdr"
+HDR_IMAGE_EXTS = {".hdr", ".exr"}
+
+UNDERHAIR_MASK_PATH = META_ROOT / "used_version_obj" / "part_masks" / "merged.png"
+UNDERHAIR_LENGTH = 0.005
+UNDERHAIR_INTERP_DENSITY = 500000.0
+UNDERHAIR_MASK_GROUP = "underhair_mask"
+
+
+def log(msg: str):
+    print(f"[hair-load] {msg}")
+
+
+def natural_key(path: Path):
+    parts = re.split(r"(\d+)", path.stem.lower())
+    key = []
+    for p in parts:
+        if p.isdigit():
+            key.append(int(p))
+        else:
+            key.append(p)
+    key.append(path.suffix.lower())
+    return key
+
+
+def is_hidden_or_metadata_name(name: str) -> bool:
+    """Return True for hidden files and common macOS metadata entries."""
+    return (
+        not name
+        or name.startswith(".")
+        or name.startswith("._")
+        or name in {".DS_Store", "Thumbs.db"}
+    )
+
+
+def is_usable_file(path: Path) -> bool:
+    """Accept only real, visible files."""
+    path = Path(path)
+    return path.is_file() and not is_hidden_or_metadata_name(path.name)
+
+
+def is_usable_directory(path: Path) -> bool:
+    """Accept only real, visible directories."""
+    path = Path(path)
+    return path.is_dir() and not is_hidden_or_metadata_name(path.name)
+
+
+def require_usable_file(path, description: str = "File") -> Path:
+    """Resolve and validate an explicitly supplied file path."""
+    path = Path(path).expanduser().resolve()
+    if not is_usable_file(path):
+        raise FileNotFoundError(
+            f"{description} is missing, hidden, or a macOS metadata file: {path}"
+        )
+    return path
+
+
+# Backward-compatible alias used by older helper functions.
+is_usable_dataset_file = is_usable_file
+
+
+
+def pick_random_hdr_image(hdr_dir: str, rng_seed: int = None):
+    hdr_dir = Path(hdr_dir).resolve()
+    if not is_usable_directory(hdr_dir):
+        raise FileNotFoundError(
+            f"HDR directory is missing or hidden: {hdr_dir}"
+        )
+
+    hdr_files = sorted(
+        [
+            path
+            for path in hdr_dir.iterdir()
+            if is_usable_file(path)
+            and path.suffix.lower() in HDR_IMAGE_EXTS
+        ],
+        key=natural_key,
+    )
+
+    rejected = sorted(
+        [
+            path.name
+            for path in hdr_dir.iterdir()
+            if path.suffix.lower() in HDR_IMAGE_EXTS
+            and not is_usable_file(path)
+        ]
+    )
+    if rejected:
+        log(f"Ignored hidden HDR metadata files: {rejected}")
+
+    if not hdr_files:
+        raise FileNotFoundError(
+            f"No usable HDR/EXR files found in: {hdr_dir}"
+        )
+
+    rng = random.Random(rng_seed)
+    chosen = rng.choice(hdr_files)
+    log(f"Randomly selected HDR: {chosen.name}")
+    return chosen
+
+def list_hair_files(hair_dir: Path):
+    """Prefer .pt files exactly as the training dataset does."""
+    pt_files = sorted(
+        [p for p in hair_dir.glob("*.pt") if is_usable_file(p)],
+        key=natural_key,
+    )
+    if pt_files:
+        return pt_files
+
+    return sorted(
+        [p for p in hair_dir.glob("*.npz") if is_usable_file(p)],
+        key=natural_key,
+    )
+
+
+def select_hair_map_for_obj(obj_path: Path, dataset_dir: Path):
+    """
+    Match the training dataset's auxiliary-file rule.
+
+    - Prefer hair_maps_single_512_uvlocal.
+    - Prefer .pt over .npz.
+    - If there is one hair file, reuse it for every shape.
+    - Otherwise pair hair and shape files by natural-sort index.
+    """
+    hair_dir_candidates = [
+        dataset_dir / "hair_maps_single_512_uvlocal",
+        dataset_dir / "hair_maps_curl",
+        dataset_dir / "hair_maps",
+    ]
+
+    shapes_dir = dataset_dir / "shapes"
+    shape_files = sorted(
+        [p for p in shapes_dir.glob("*.obj") if is_usable_file(p)],
+        key=natural_key,
+    )
+
+    try:
+        shape_index = next(
+            index
+            for index, path in enumerate(shape_files)
+            if path.resolve() == obj_path.resolve()
+        )
+    except StopIteration as exc:
+        raise FileNotFoundError(
+            f"OBJ file is not present in the dataset shapes directory: {obj_path}"
+        ) from exc
+
+    checked = []
+    for hair_dir in hair_dir_candidates:
+        checked.append(str(hair_dir))
+        hair_files = list_hair_files(hair_dir)
+        if not hair_files:
+            continue
+
+        same_stem = [
+            path for path in hair_files
+            if path.stem == obj_path.stem
+        ]
+        if same_stem:
+            return same_stem[0]
+
+        if len(hair_files) == 1:
+            return hair_files[0]
+
+        if shape_index < len(hair_files):
+            return hair_files[shape_index]
+
+        raise IndexError(
+            f"Hair index out of range for {obj_path.name}: "
+            f"shapes={len(shape_files)}, hair_files={len(hair_files)}, "
+            f"shape_index={shape_index}, hair_dir={hair_dir}"
+        )
+
+    raise FileNotFoundError(
+        "Could not find a compatible .pt or .npz hair map in:\n  "
+        + "\n  ".join(checked)
+    )
+
+
+def resolve_paths_from_obj(obj_path: str):
+    obj_path = Path(obj_path).expanduser().resolve()
+    if not is_usable_file(obj_path):
+        raise FileNotFoundError(
+            f"OBJ file is missing or is a hidden/macOS metadata file: {obj_path}"
+        )
+    if obj_path.parent.name != "shapes":
+        raise ValueError(
+            "Expected an OBJ inside a dataset group 'shapes' directory, for example:\n"
+            "  /path/to/animallift/cat/dataset/<group>/shapes/<sample>.obj"
+        )
+
+    dataset_dir = obj_path.parent.parent
+    hair_map_path = select_hair_map_for_obj(obj_path, dataset_dir)
+
+    return {
+        "dataset_dir": dataset_dir,
+        "datasets_root": dataset_dir.parent,
+        "sample_name": obj_path.stem,
+        "textures_dir": dataset_dir / "textures",
+        "hair_map": hair_map_path,
+        "hair_meta": META_ROOT / "hair_map_meta_uvanchor.npz",
+        "hair_map_curl_out": hair_map_path,
+        "mesh_normal": META_ROOT / "render_elements" / "Normal.png",
+        "mesh_roughness": META_ROOT / "render_elements" / "Roughness.png",
+        "hdr_dir": HDR_DIR,
+    }
+
+
+def discover_dataset_case(
+    root: Path,
+    species: str = "cat",
+    group_name: str = None,
+    sample_index: int = 0,
+):
+    """
+    Discover a real case from:
+      <root>/<species>/dataset/<group>/shapes/*.obj
+
+    The group must also contain textures and a compatible hair-map directory.
+    """
+    root = Path(root).expanduser().resolve()
+    species_root = root / species / "dataset"
+    if not species_root.is_dir():
+        raise FileNotFoundError(f"Species dataset directory not found: {species_root}")
+
+    if group_name:
+        explicit_group = species_root / group_name
+        if not is_usable_directory(explicit_group):
+            raise FileNotFoundError(
+                f"Requested dataset group not found: {explicit_group}"
+            )
+        group_dirs = [explicit_group]
+    else:
+        group_dirs = sorted(
+            [
+                path
+                for path in species_root.iterdir()
+                if is_usable_directory(path)
+            ],
+            key=natural_key,
+        )
+
+    failures = []
+    for group_dir in group_dirs:
+        shapes_dir = group_dir / "shapes"
+        textures_dir = group_dir / "textures"
+        if not shapes_dir.is_dir() or not textures_dir.is_dir():
+            failures.append(f"{group_dir}: missing shapes or textures")
+            continue
+
+        shape_files = sorted(
+            [p for p in shapes_dir.glob("*.obj") if is_usable_file(p)],
+            key=natural_key,
+        )
+        texture_files = sorted(
+            [
+                p for p in textures_dir.iterdir()
+                if is_usable_file(p) and p.suffix.lower() in IMAGE_EXTS
+            ],
+            key=natural_key,
+        )
+        if not shape_files or not texture_files:
+            failures.append(f"{group_dir}: empty shapes or textures")
+            continue
+
+        usable_count = min(len(shape_files), len(texture_files))
+        if sample_index < 0 or sample_index >= usable_count:
+            failures.append(
+                f"{group_dir}: sample_index={sample_index} outside 0..{usable_count - 1}"
+            )
+            continue
+
+        obj_path = shape_files[sample_index]
+        try:
+            hair_path = select_hair_map_for_obj(obj_path, group_dir)
+        except Exception as exc:
+            failures.append(f"{group_dir}: {exc}")
+            continue
+
+        deformed_candidate = group_dir / "deformed_shapes" / obj_path.name
+        deformed_path = (
+            deformed_candidate
+            if is_usable_file(deformed_candidate)
+            else None
+        )
+
+        log(f"Using dataset group: {group_dir.name}")
+        log(f"Selected OBJ: {obj_path.name}")
+        log(f"Selected hair map: {hair_path.name}")
+        if deformed_path is None:
+            log("No matching deformed shape found; using the original mesh")
+        else:
+            log(f"Selected deformed shape: {deformed_path.name}")
+
+        return obj_path, deformed_path
+
+    detail = "\n".join(f"  - {item}" for item in failures[:20])
+    raise RuntimeError(
+        f"No usable visualization case found under {species_root}.\n{detail}"
+    )
+
+
+
+def load_global_hair_meta(meta_path: str):
+    meta_path = require_usable_file(
+        meta_path,
+        "Global hair metadata",
+    )
+
+    data = np.load(str(meta_path), allow_pickle=True)
+
+    required_keys = [
+        "group_names",
+        "guide_group_id_map",
+        "uv_face_index_map",
+        "uv_bary_map",
+    ]
+    for key in required_keys:
+        if key not in data:
+            raise KeyError(f"Missing key '{key}' in global hair meta: {meta_path}")
+
+    group_names = [str(n) for n in data["group_names"]]
+    guide_group_id_map = data["guide_group_id_map"].astype(np.int32)
+    uv_face_index_map = data["uv_face_index_map"].astype(np.int32)
+    uv_bary_map = data["uv_bary_map"].astype(np.float32)
+
+    log(f"Loaded global hair meta: {meta_path}")
+    log(f"  Groups: {group_names}")
+    log(f"  guide_group_id_map shape: {guide_group_id_map.shape}")
+    log(f"  uv_face_index_map shape: {uv_face_index_map.shape}")
+    log(f"  uv_bary_map shape: {uv_bary_map.shape}")
+
+    return group_names, guide_group_id_map, uv_face_index_map, uv_bary_map
+
+
+def import_obj_as_mesh(obj_path: str, object_name: str = None):
+    obj_path = str(require_usable_file(obj_path, "OBJ file"))
+
+    bpy.ops.object.select_all(action='DESELECT')
+    if hasattr(bpy.ops.wm, "obj_import"):
+        bpy.ops.wm.obj_import(filepath=obj_path)
+    else:
+        bpy.ops.import_scene.obj(filepath=obj_path)
+
+    imported_meshes = [o for o in bpy.context.selected_objects if o.type == 'MESH']
+    if not imported_meshes:
+        raise Exception(f"No mesh imported from {obj_path}")
+
+    mesh_obj = imported_meshes[0]
+    if object_name:
+        mesh_obj.name = object_name
+        mesh_obj.data.name = object_name
+
+    bpy.ops.object.select_all(action='DESELECT')
+    mesh_obj.select_set(True)
+    bpy.context.view_layer.objects.active = mesh_obj
+    bpy.ops.object.shade_smooth()
+
+    log(f"Imported mesh: {mesh_obj.name} ({len(mesh_obj.data.vertices)} verts, smooth shading)")
+    return mesh_obj
+
+
+def apply_deformed_shape_directly(mesh_obj, deformed_obj_path: str):
+    """Overwrite base mesh vertex positions with deformed OBJ vertex positions.
+
+    This avoids shape keys entirely so the base mesh IS the deformed shape,
+    and all curves bound to its surface will follow naturally.
+    """
+    deformed_obj_path = str(
+        require_usable_file(deformed_obj_path, "Deformed OBJ file")
+    )
+
+    bpy.ops.object.select_all(action='DESELECT')
+    if hasattr(bpy.ops.wm, "obj_import"):
+        bpy.ops.wm.obj_import(filepath=deformed_obj_path)
+    else:
+        bpy.ops.import_scene.obj(filepath=deformed_obj_path)
+
+    imported_meshes = [o for o in bpy.context.selected_objects if o.type == 'MESH']
+    if not imported_meshes:
+        raise Exception(f"No mesh imported from {deformed_obj_path}")
+    imported = imported_meshes[0]
+
+    if len(mesh_obj.data.vertices) != len(imported.data.vertices):
+        bpy.data.objects.remove(imported, do_unlink=True)
+        raise Exception(
+            f"Vertex count mismatch! Target: {len(mesh_obj.data.vertices)}, "
+            f"Imported: {len(imported.data.vertices)}"
+        )
+
+    for i, v in enumerate(imported.data.vertices):
+        mesh_obj.data.vertices[i].co = v.co
+
+    bpy.data.objects.remove(imported, do_unlink=True)
+    mesh_obj.data.update()
+
+    log(f"Applied deformed shape directly to '{mesh_obj.name}' from {deformed_obj_path}")
+
+
+def import_obj_as_shape_key(target, obj_path: str, shape_key_name: str):
+    obj_path = str(require_usable_file(obj_path, "Shape-key OBJ file"))
+
+    bpy.ops.object.select_all(action='DESELECT')
+    if hasattr(bpy.ops.wm, "obj_import"):
+        bpy.ops.wm.obj_import(filepath=obj_path)
+    else:
+        bpy.ops.import_scene.obj(filepath=obj_path)
+
+    imported_meshes = [o for o in bpy.context.selected_objects if o.type == 'MESH']
+    if not imported_meshes:
+        raise Exception(f"No imported mesh found from {obj_path}")
+    imported = imported_meshes[0]
+
+    try:
+        if len(target.data.vertices) != len(imported.data.vertices):
+            raise Exception(
+                f"Vertex count mismatch! Target: {len(target.data.vertices)}, "
+                f"Imported: {len(imported.data.vertices)}"
+            )
+
+        if not target.data.shape_keys:
+            target.shape_key_add(name="Basis")
+
+        old = target.data.shape_keys.key_blocks.get(shape_key_name)
+        if old is not None:
+            bpy.context.view_layer.objects.active = target
+            target.active_shape_key_index = list(target.data.shape_keys.key_blocks).index(old)
+            bpy.ops.object.shape_key_remove(all=False)
+
+        sk = target.shape_key_add(name=shape_key_name, from_mix=False)
+        for i, v in enumerate(imported.data.vertices):
+            sk.data[i].co = v.co
+
+        sk.value = 1.0
+        target.active_shape_key_index = list(target.data.shape_keys.key_blocks).index(sk)
+
+        log(f"Shape key created and enabled: {shape_key_name}")
+        return sk
+    finally:
+        bpy.data.objects.remove(imported, do_unlink=True)
+
+
+def resolve_corresponding_deformed_shape_path(source_obj_path: str, deformed_obj_path: str = None):
+    if deformed_obj_path is not None:
+        p = Path(deformed_obj_path).resolve()
+    else:
+        source_obj_path = Path(source_obj_path).resolve()
+        dataset_dir = source_obj_path.parent.parent
+        p = dataset_dir / "deformed_shapes" / source_obj_path.name
+
+    if not is_usable_file(p):
+        raise FileNotFoundError(
+            f"Deformed shape OBJ is missing or hidden: {p}"
+        )
+    return p
+
+
+def open_image_simple(image_path: str, non_color: bool = True):
+    image_path = str(require_usable_file(image_path, "Image file"))
+    img = bpy.data.images.load(filepath=image_path, check_existing=True)
+    img.colorspace_settings.name = 'Non-Color' if non_color else 'sRGB'
+    img.pixels[:]
+    return img
+
+
+def open_image_color(image_path: str):
+    return open_image_simple(image_path, non_color=False)
+
+def is_green_rgb(rgb, green_threshold=0.45, green_margin=0.08):
+    r, g, b = float(rgb[0]), float(rgb[1]), float(rgb[2])
+    return (
+        g >= green_threshold and
+        g > r + green_margin and
+        g > b + green_margin
+    )
+
+
+def remove_green_screen_from_image(
+    src_image_path: str,
+    out_image_path: str = None,
+    green_threshold: float = 0.45,
+    green_margin: float = 0.08,
+    rng_seed: int = None,
+):
+    """
+    Replace green pixels with randomly sampled non-green colors from the same image.
+    Returns the output image path.
+    """
+    src_image_path = require_usable_file(
+        src_image_path,
+        "Texture image",
+    )
+
+    img = bpy.data.images.load(filepath=str(src_image_path), check_existing=False)
+    width, height = img.size
+
+    pixel_count = width * height * 4
+    pixels = np.empty(pixel_count, dtype=np.float32)
+    img.pixels.foreach_get(pixels)
+    pixels = pixels.reshape((height, width, 4))
+
+    rgb = pixels[:, :, :3]
+    alpha = pixels[:, :, 3:4]
+
+    green_mask = (
+        (rgb[:, :, 1] >= green_threshold) &
+        (rgb[:, :, 1] > rgb[:, :, 0] + green_margin) &
+        (rgb[:, :, 1] > rgb[:, :, 2] + green_margin)
+    )
+
+    non_green_coords = np.argwhere(~green_mask)
+    green_coords = np.argwhere(green_mask)
+
+    if len(green_coords) == 0:
+        log(f"No green pixels detected in texture: {src_image_path.name}")
+        return src_image_path
+
+    if len(non_green_coords) == 0:
+        log(f"[WARN] Texture has no non-green pixels to sample from: {src_image_path.name}")
+        return src_image_path
+
+    rng = np.random.default_rng(rng_seed)
+
+    sampled_ids = rng.integers(0, len(non_green_coords), size=len(green_coords))
+    sampled_coords = non_green_coords[sampled_ids]
+
+    replacement_colors = rgb[sampled_coords[:, 0], sampled_coords[:, 1]]
+    rgb[green_coords[:, 0], green_coords[:, 1]] = replacement_colors
+
+    out_pixels = np.concatenate([rgb, alpha], axis=2).astype(np.float32).reshape(-1)
+
+    if out_image_path is None:
+        out_image_path = src_image_path.parent / f"{src_image_path.stem}_nogreen.png"
+    else:
+        out_image_path = Path(out_image_path).resolve()
+
+    out_image_path.parent.mkdir(parents=True, exist_ok=True)
+
+    out_img = bpy.data.images.new(
+        name=f"{src_image_path.stem}_nogreen",
+        width=width,
+        height=height,
+        alpha=True,
+        float_buffer=False,
+    )
+    out_img.colorspace_settings.name = 'sRGB'
+    out_img.filepath_raw = str(out_image_path)
+    out_img.file_format = 'PNG'
+    out_img.pixels.foreach_set(out_pixels.tolist())
+    out_img.save()
+
+    try:
+        bpy.data.images.remove(img)
+    except Exception:
+        pass
+
+    log(f"Saved green-removed texture: {out_image_path}")
+    return out_image_path
+
+
+def resolve_render_output_path(obj_path: str, render_filename: str = None):
+    obj_path = Path(obj_path).resolve()
+    dataset_dir = obj_path.parent.parent
+    render_dir = dataset_dir / "render_images"
+    render_dir.mkdir(parents=True, exist_ok=True)
+
+    if render_filename is None:
+        render_filename = f"{obj_path.stem}.png"
+
+    return render_dir / render_filename
+
+
+def render_and_save_image(output_path: str):
+    output_path = Path(output_path).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    scene = bpy.context.scene
+    scene.render.image_settings.file_format = 'PNG'
+    scene.render.image_settings.color_mode = 'RGBA'
+    scene.render.filepath = str(output_path)
+
+    bpy.ops.render.render(write_still=True)
+    log(f"Saved render image: {output_path}")
+
+
+def load_density_images(mesh_obj, density_dir: str):
+    density_images = {}
+    for region in REGIONS:
+        image_path = Path(density_dir) / f"{region}.png"
+        if not is_usable_file(image_path):
+            log(f"  [WARN] Density image not found: {image_path}")
+            continue
+        img = open_image_simple(str(image_path), non_color=True)
+        img.name = f"{IMAGE_PREFIX}{region}_{mesh_obj.name}"
+        density_images[region] = img
+    return density_images
+
+
+def create_vertex_group_from_image(obj, image_path: str, group_name: str, scale: float = 1.0):
+    mesh = obj.data
+    if not mesh.uv_layers:
+        raise Exception("Target mesh has no UVs")
+
+    img = open_image_simple(image_path, non_color=True)
+    width, height = img.size
+
+    pixel_count = width * height * 4
+    pixels_np = np.empty(pixel_count, dtype=np.float32)
+    img.pixels.foreach_get(pixels_np)
+    pixels_np = pixels_np.reshape((height, width, 4))
+
+    lum = (
+        0.2126 * pixels_np[:, :, 0]
+        + 0.7152 * pixels_np[:, :, 1]
+        + 0.0722 * pixels_np[:, :, 2]
+    )
+
+    total_loops = len(mesh.loops)
+    loop_uvs = np.empty(total_loops * 2, dtype=np.float32)
+    mesh.uv_layers.active.data.foreach_get("uv", loop_uvs)
+    loop_uvs = loop_uvs.reshape((total_loops, 2))
+
+    loop_verts = np.empty(total_loops, dtype=np.int32)
+    mesh.loops.foreach_get("vertex_index", loop_verts)
+
+    u = np.clip(loop_uvs[:, 0], 0.0, 1.0)
+    v = np.clip(loop_uvs[:, 1], 0.0, 1.0)
+    xi = (u * (width - 1)).astype(np.int32)
+    yi = (v * (height - 1)).astype(np.int32)
+    loop_weights = lum[yi, xi] * float(scale)
+
+    num_verts = len(mesh.vertices)
+    weight_sum = np.zeros(num_verts, dtype=np.float64)
+    weight_cnt = np.zeros(num_verts, dtype=np.int32)
+    np.add.at(weight_sum, loop_verts, loop_weights)
+    np.add.at(weight_cnt, loop_verts, 1)
+
+    mask = weight_cnt > 0
+    avg_weights = np.zeros(num_verts, dtype=np.float64)
+    avg_weights[mask] = weight_sum[mask] / weight_cnt[mask]
+
+    old_vg = obj.vertex_groups.get(group_name)
+    if old_vg is not None:
+        obj.vertex_groups.remove(old_vg)
+    vg = obj.vertex_groups.new(name=group_name)
+
+    indices = np.where(mask)[0]
+    for vid in indices:
+        vg.add([int(vid)], float(avg_weights[vid]), 'REPLACE')
+
+    return vg, img
+
+
+def load_hair_info(json_path):
+    json_path = Path(json_path).resolve()
+    if not is_usable_file(json_path):
+        raise FileNotFoundError(
+            f"hair_info.json is missing or hidden: {json_path}"
+        )
+    with open(json_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def get_region_length_scale(hair_info: dict, region: str) -> float:
+    params = hair_info.get("resolved_hair_params", {})
+    if region not in params:
+        raise KeyError(f"Region '{region}' not found in resolved_hair_params")
+    return float(params[region]["length"])
+
+
+def create_length_vertex_groups(mesh_obj, length_dir: str, hair_info: dict):
+    for region in REGIONS:
+        image_path = Path(length_dir) / f"{region}.png"
+        if not is_usable_file(image_path):
+            log(f"  [WARN] Length image not found: {image_path}")
+            continue
+        vg_name = f"{VGROUP_PREFIX}{region}"
+        scale = get_region_length_scale(hair_info, region)
+        vg, img = create_vertex_group_from_image(mesh_obj, str(image_path), vg_name, scale=scale)
+        img.name = f"lenimg_{region}_{mesh_obj.name}"
+        log(f"  Created vertex group: {vg.name}, scale={scale:.4f}")
+
+
+def ensure_triangulated_bmesh(mesh):
+    bm = bmesh.new()
+    bm.from_mesh(mesh)
+    bmesh.ops.triangulate(bm, faces=bm.faces[:])
+    bm.faces.ensure_lookup_table()
+    bm.verts.ensure_lookup_table()
+    return bm
+
+
+def get_evaluated_mesh(mesh_obj):
+    """Return the evaluated (deformed) mesh data, accounting for shape keys
+    and modifiers. Caller must call eval_obj.to_mesh_clear() when done if needed.
+    """
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    eval_obj = mesh_obj.evaluated_get(depsgraph)
+    eval_mesh = eval_obj.to_mesh()
+    return eval_obj, eval_mesh
+
+
+def compute_root_uvs(roots, mesh_obj):
+    mesh = mesh_obj.data
+    if not mesh.uv_layers.active:
+        raise RuntimeError("Mesh has no active UV layer")
+
+    # Use evaluated mesh so roots snap to deformed positions
+    eval_obj, eval_mesh = get_evaluated_mesh(mesh_obj)
+
+    bm = bmesh.new()
+    bm.from_mesh(eval_mesh)
+    bmesh.ops.triangulate(bm, faces=bm.faces[:])
+    bm.faces.ensure_lookup_table()
+    bm.verts.ensure_lookup_table()
+
+    # UV layer name comes from the original mesh
+    uv_layer = bm.loops.layers.uv.get(mesh.uv_layers.active.name)
+    if uv_layer is None:
+        bm.free()
+        eval_obj.to_mesh_clear()
+        raise RuntimeError("Could not access active UV layer")
+
+    bvh = BVHTree.FromBMesh(bm)
+    uvs = []
+
+    for root in roots:
+        hit = bvh.find_nearest(Vector(root))
+        if hit is None or hit[2] is None:
+            uvs.append((0.5, 0.5))
+            continue
+
+        location, normal, face_index, dist = hit
+        face = bm.faces[face_index]
+        if len(face.verts) != 3:
+            uvs.append((0.5, 0.5))
+            continue
+
+        v0, v1, v2 = [f.co for f in face.verts]
+        uv0 = face.loops[0][uv_layer].uv
+        uv1 = face.loops[1][uv_layer].uv
+        uv2 = face.loops[2][uv_layer].uv
+
+        uv = barycentric_transform(
+            location, v0, v1, v2,
+            uv0.to_3d(), uv1.to_3d(), uv2.to_3d()
+        )
+        uvs.append((float(uv.x), float(uv.y)))
+
+    bm.free()
+    eval_obj.to_mesh_clear()
+    return uvs
+
+
+def build_face_geom(mesh_obj):
+    """Build triangle face geometry from the evaluated (deformed) mesh."""
+    mesh = mesh_obj.data
+    if not mesh.uv_layers.active:
+        raise RuntimeError("Mesh has no active UV layer")
+
+    # Use evaluated mesh to pick up shape key / modifier deformations
+    eval_obj, eval_mesh = get_evaluated_mesh(mesh_obj)
+
+    bm = bmesh.new()
+    bm.from_mesh(eval_mesh)
+    bmesh.ops.triangulate(bm, faces=bm.faces[:])
+    bm.faces.ensure_lookup_table()
+    bm.verts.ensure_lookup_table()
+
+    uv_layer = bm.loops.layers.uv.get(mesh.uv_layers.active.name)
+    if uv_layer is None:
+        bm.free()
+        eval_obj.to_mesh_clear()
+        raise RuntimeError("Could not access active UV layer")
+
+    num_faces = len(bm.faces)
+    face_pos = np.empty((num_faces, 3, 3), dtype=np.float32)
+    face_uvs = np.empty((num_faces, 3, 2), dtype=np.float32)
+
+    for fi, face in enumerate(bm.faces):
+        for vi in range(3):
+            co = face.verts[vi].co
+            uv = face.loops[vi][uv_layer].uv
+            face_pos[fi, vi] = (co.x, co.y, co.z)
+            face_uvs[fi, vi] = (uv.x, uv.y)
+
+    bm.free()
+    eval_obj.to_mesh_clear()
+    return face_pos, face_uvs
+
+
+def reconstruct_surface_points_and_frames(mesh_obj, uv_face_index_map, uv_bary_map):
+    face_pos, face_uvs = build_face_geom(mesh_obj)
+
+    height, width = uv_face_index_map.shape
+    roots = np.zeros((height, width, 3), dtype=np.float32)
+    Tu = np.zeros((height, width, 3), dtype=np.float32)
+    Tv = np.zeros((height, width, 3), dtype=np.float32)
+    N = np.zeros((height, width, 3), dtype=np.float32)
+
+    ys, xs = np.where(uv_face_index_map >= 0)
+    fids = uv_face_index_map[ys, xs].astype(np.int32)
+    bary = uv_bary_map[ys, xs].astype(np.float32)
+
+    p0 = face_pos[fids, 0]
+    p1 = face_pos[fids, 1]
+    p2 = face_pos[fids, 2]
+
+    uv0 = face_uvs[fids, 0]
+    uv1 = face_uvs[fids, 1]
+    uv2 = face_uvs[fids, 2]
+
+    roots_pts = (
+        bary[:, 0:1] * p0 +
+        bary[:, 1:2] * p1 +
+        bary[:, 2:3] * p2
+    )
+
+    dp1 = p1 - p0
+    dp2 = p2 - p0
+    duv1 = uv1 - uv0
+    duv2 = uv2 - uv0
+
+    det = duv1[:, 0] * duv2[:, 1] - duv1[:, 1] * duv2[:, 0]
+    safe = np.abs(det) > 1e-12
+    det_safe = det.copy()
+    det_safe[~safe] = 1.0
+
+    Tu_pts = np.empty_like(dp1)
+    Tv_pts = np.empty_like(dp1)
+
+    Tu_pts[:, 0] = (dp1[:, 0] * duv2[:, 1] - dp2[:, 0] * duv1[:, 1]) / det_safe
+    Tu_pts[:, 1] = (dp1[:, 1] * duv2[:, 1] - dp2[:, 1] * duv1[:, 1]) / det_safe
+    Tu_pts[:, 2] = (dp1[:, 2] * duv2[:, 1] - dp2[:, 2] * duv1[:, 1]) / det_safe
+
+    Tv_pts[:, 0] = (-dp1[:, 0] * duv2[:, 0] + dp2[:, 0] * duv1[:, 0]) / det_safe
+    Tv_pts[:, 1] = (-dp1[:, 1] * duv2[:, 0] + dp2[:, 1] * duv1[:, 0]) / det_safe
+    Tv_pts[:, 2] = (-dp1[:, 2] * duv2[:, 0] + dp2[:, 2] * duv1[:, 0]) / det_safe
+
+    N_pts = np.cross(dp1, dp2)
+
+    def normalize(v):
+        lens = np.linalg.norm(v, axis=1, keepdims=True)
+        lens[lens < 1e-12] = 1.0
+        return v / lens
+
+    Tu_pts = normalize(Tu_pts)
+    Tv_pts = normalize(Tv_pts)
+    N_pts = normalize(N_pts)
+
+    if np.any(~safe):
+        Tu_pts[~safe] = normalize(dp1[~safe])
+        Tv_pts[~safe] = normalize(np.cross(N_pts[~safe], Tu_pts[~safe]))
+        N_pts[~safe] = normalize(np.cross(Tu_pts[~safe], Tv_pts[~safe]))
+
+    roots[ys, xs] = roots_pts
+    Tu[ys, xs] = Tu_pts
+    Tv[ys, xs] = Tv_pts
+    N[ys, xs] = N_pts
+
+    return roots, Tu, Tv, N
+
+
+def load_quantized_hair_map(hair_map_path: str):
+    """
+    Load either the uploaded .pt cache format or the legacy .npz format.
+
+    Returns:
+      hair_q: [H, W, S-1, 3] float32
+      scale: [3] float32
+      samples: S
+      hair_mask: [H, W] bool
+    """
+    path = require_usable_file(hair_map_path, "Hair map")
+    suffix = path.suffix.lower()
+
+    if suffix == ".pt":
+        try:
+            import torch
+        except ImportError as exc:
+            raise ImportError(
+                "Reading uploaded .pt hair maps requires PyTorch in Blender's "
+                "Python environment. Install torch for the Blender Python version."
+            ) from exc
+
+        data = torch.load(str(path), map_location="cpu")
+        required = ["hair_q", "scale", "hair_mask"]
+        missing = [key for key in required if key not in data]
+        if missing:
+            raise KeyError(f"Missing keys {missing} in PT hair map: {path}")
+
+        hair_q = data["hair_q"].detach().cpu().numpy().astype(np.float32)
+        scale = data["scale"].detach().cpu().numpy().astype(np.float32)
+        hair_mask = data["hair_mask"].detach().cpu().numpy().astype(bool)
+        samples = int(hair_q.shape[2]) + 1
+        return hair_q, scale, samples, hair_mask
+
+    if suffix == ".npz":
+        data = np.load(str(path), allow_pickle=True)
+        required = ["hair_offsets_local_q", "offset_scale"]
+        missing = [key for key in required if key not in data]
+        if missing:
+            raise KeyError(f"Missing keys {missing} in NPZ hair map: {path}")
+
+        hair_q = data["hair_offsets_local_q"].astype(np.float32)
+        scale = data["offset_scale"].astype(np.float32)
+        samples = (
+            int(data["samples"])
+            if "samples" in data
+            else int(hair_q.shape[2]) + 1
+        )
+        hair_mask = np.abs(hair_q).sum(axis=(2, 3)) > 0
+        return hair_q, scale, samples, hair_mask
+
+    raise ValueError(f"Unsupported hair map extension: {path.suffix}")
+
+
+def decode_hair_map(hair_map_path: str, meta_path: str, mesh_obj):
+    hair_offsets_local_q, offset_scale, samples, hair_mask = (
+        load_quantized_hair_map(hair_map_path)
+    )
+
+    group_names, guide_group_id_map, uv_face_index_map, uv_bary_map = (
+        load_global_hair_meta(meta_path)
+    )
+
+    if samples < 1:
+        raise ValueError(f"Invalid samples={samples} in hair map")
+
+    height, width = guide_group_id_map.shape[:2]
+    if hair_offsets_local_q.shape[:2] != (height, width):
+        raise ValueError(
+            "Shape mismatch between hair map and global metadata: "
+            f"{hair_offsets_local_q.shape[:2]} vs {(height, width)}"
+        )
+    if hair_mask.shape[:2] != (height, width):
+        raise ValueError(
+            f"Hair mask shape mismatch: {hair_mask.shape[:2]} vs {(height, width)}"
+        )
+    if uv_face_index_map.shape[:2] != (height, width):
+        raise ValueError(
+            f"UV face map shape mismatch: {uv_face_index_map.shape[:2]} "
+            f"vs {(height, width)}"
+        )
+    if uv_bary_map.shape[:2] != (height, width):
+        raise ValueError(
+            f"UV barycentric map shape mismatch: {uv_bary_map.shape[:2]} "
+            f"vs {(height, width)}"
+        )
+
+    offsets_local = (
+        hair_offsets_local_q / 127.0
+    ) * offset_scale.reshape(1, 1, 1, 3)
+    strands_by_group = {name: [] for name in group_names}
+
+    roots_map, Tu_map, Tv_map, N_map = reconstruct_surface_points_and_frames(
+        mesh_obj,
+        uv_face_index_map,
+        uv_bary_map,
+    )
+
+    valid_map = (
+        (guide_group_id_map >= 0)
+        & hair_mask
+        & (uv_face_index_map >= 0)
+    )
+    ys, xs = np.where(valid_map)
+    gids = guide_group_id_map[ys, xs].astype(np.int32)
+
+    for y, x, gid in zip(ys, xs, gids):
+        gid = int(gid)
+        if gid < 0 or gid >= len(group_names):
+            continue
+
+        root = roots_map[y, x]
+        Tu = Tu_map[y, x]
+        Tv = Tv_map[y, x]
+        normal = N_map[y, x]
+
+        local = offsets_local[y, x]
+        world_offsets = (
+            local[:, 0:1] * Tu[None, :]
+            + local[:, 1:2] * Tv[None, :]
+            + local[:, 2:3] * normal[None, :]
+        )
+
+        strand = np.empty((samples, 3), dtype=np.float32)
+        strand[0] = root
+        if samples > 1:
+            strand[1:] = root[None, :] + world_offsets
+
+        strands_by_group[group_names[gid]].append(strand)
+
+    for group_name, strands in list(strands_by_group.items()):
+        if strands:
+            strands_by_group[group_name] = np.stack(strands, axis=0)
+        else:
+            strands_by_group[group_name] = np.zeros(
+                (0, samples, 3),
+                dtype=np.float32,
+            )
+
+    total_strands = sum(value.shape[0] for value in strands_by_group.values())
+    log(f"Decoded hair map: {hair_map_path}")
+    log(f"  Samples per strand: {samples}")
+    log(f"  Total guide strands: {total_strands}")
+
+    return group_names, strands_by_group, samples
+
+
+
+def sanitize_name(name):
+    out = []
+    for ch in str(name):
+        if ch.isalnum() or ch in "._-":
+            out.append(ch)
+        else:
+            out.append("_")
+    s = "".join(out).strip("_")
+    return s if s else "HairPart"
+
+
+def build_curve_object_from_strands(obj_name, strands, root_uvs, mesh_obj):
+    if len(strands) == 0:
+        return None
+
+    curve_data = bpy.data.curves.new(obj_name, type='CURVE')
+    curve_data.dimensions = '3D'
+
+    curve_obj = bpy.data.objects.new(obj_name, curve_data)
+    bpy.context.collection.objects.link(curve_obj)
+
+    curve_obj.parent = mesh_obj
+    curve_obj.location = (0, 0, 0)
+    curve_obj.rotation_euler = (0, 0, 0)
+    curve_obj.scale = (1, 1, 1)
+
+    for strand in strands:
+        spline = curve_data.splines.new('POLY')
+        spline.points.add(len(strand) - 1)
+        for i, p in enumerate(strand):
+            spline.points[i].co = (float(p[0]), float(p[1]), float(p[2]), 1.0)
+
+    if bpy.ops.object.mode_set.poll():
+        bpy.ops.object.mode_set(mode='OBJECT')
+
+    bpy.ops.object.select_all(action='DESELECT')
+    curve_obj.select_set(True)
+    bpy.context.view_layer.objects.active = curve_obj
+    bpy.ops.object.convert(target='CURVES')
+
+    curve_obj = bpy.context.view_layer.objects.active
+    curves = curve_obj.data
+
+    curves.surface = mesh_obj
+    curves.surface_uv_map = mesh_obj.data.uv_layers.active.name
+
+    if "surface_uv_coordinate" in curves.attributes:
+        uv_attr = curves.attributes["surface_uv_coordinate"]
+    else:
+        uv_attr = curves.attributes.new(
+            name="surface_uv_coordinate",
+            type='FLOAT2',
+            domain='CURVE'
+        )
+
+    for i in range(len(root_uvs)):
+        uv_attr.data[i].vector = (float(root_uvs[i][0]), float(root_uvs[i][1]))
+
+    log(f"  Created '{curve_obj.name}' with {len(strands)} guide strands")
+    return curve_obj
+
+
+def build_curve_object_from_strands_no_uv(obj_name, strands, mesh_obj):
+    if len(strands) == 0:
+        return None
+
+    curve_data = bpy.data.curves.new(obj_name, type='CURVE')
+    curve_data.dimensions = '3D'
+
+    curve_obj = bpy.data.objects.new(obj_name, curve_data)
+    bpy.context.collection.objects.link(curve_obj)
+
+    curve_obj.matrix_world = mesh_obj.matrix_world.copy()
+
+    for strand in strands:
+        spline = curve_data.splines.new('POLY')
+        spline.points.add(len(strand) - 1)
+        for i, p in enumerate(strand):
+            spline.points[i].co = (float(p[0]), float(p[1]), float(p[2]), 1.0)
+
+    if bpy.ops.object.mode_set.poll():
+        bpy.ops.object.mode_set(mode='OBJECT')
+
+    bpy.ops.object.select_all(action='DESELECT')
+    curve_obj.select_set(True)
+    bpy.context.view_layer.objects.active = curve_obj
+    bpy.ops.object.convert(target='CURVES')
+
+    curve_obj = bpy.context.view_layer.objects.active
+    curve_obj.matrix_world = mesh_obj.matrix_world.copy()
+    curve_obj.parent = mesh_obj
+    curve_obj.matrix_parent_inverse = mesh_obj.matrix_world.inverted()
+
+    curves = curve_obj.data
+    curves.surface = mesh_obj
+
+    log(f"  Created '{curve_obj.name}' with {len(strands)} guide strands (no UV attr)")
+    return curve_obj
+
+
+def describe_node_group_inputs(mod):
+    if getattr(mod, "node_group", None) is None:
+        return []
+    items = []
+    try:
+        for item in mod.node_group.interface.items_tree:
+            if getattr(item, "in_out", None) == 'INPUT':
+                items.append((item.name, item.identifier, getattr(item, "socket_type", "")))
+    except Exception:
+        pass
+    return items
+
+
+def get_node_input_identifier_by_name(mod, display_name):
+    for name, identifier, socket_type in describe_node_group_inputs(mod):
+        if name == display_name:
+            return identifier
+    return None
+
+
+def set_gn_input(mod, display_name, value):
+    identifier = get_node_input_identifier_by_name(mod, display_name)
+    if identifier is None:
+        log(f"    [WARN] GN input '{display_name}' not found on '{mod.name}'")
+        return False
+    try:
+        mod[identifier] = value
+        return True
+    except Exception as e:
+        log(f"    [WARN] Failed to set '{display_name}' on '{mod.name}': {e}")
+        return False
+
+
+def find_gn_input_identifier_contains(mod, keywords):
+    keywords = [k.lower() for k in keywords]
+    for name, identifier, socket_type in describe_node_group_inputs(mod):
+        lname = (name or "").lower()
+        if all(k in lname for k in keywords):
+            return identifier, name
+    return None, None
+
+
+def set_gn_input_by_keywords(mod, keywords, value):
+    identifier, display_name = find_gn_input_identifier_contains(mod, keywords)
+    if identifier is None:
+        log(f"    [WARN] No GN input matching keywords {keywords} on '{mod.name}'")
+        return False
+    try:
+        mod[identifier] = value
+        log(f"    + {mod.name} '{display_name}' = {value}")
+        return True
+    except Exception as e:
+        log(f"    [WARN] Failed setting '{display_name}' on '{mod.name}': {e}")
+        return False
+
+
+def debug_modifier_inputs(mod):
+    log(f"--- Modifier inputs for {mod.name} ---")
+    for name, identifier, socket_type in describe_node_group_inputs(mod):
+        log(f"    name='{name}' identifier='{identifier}' socket_type='{socket_type}'")
+
+
+def select_and_activate(obj):
+    bpy.ops.object.select_all(action='DESELECT')
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+
+
+def get_essentials_blend_path():
+    candidates = []
+
+    try:
+        local_root = Path(bpy.utils.resource_path('LOCAL'))
+        candidates.append(local_root / "datafiles" / "assets" / "geometry_nodes" / "procedural_hair_node_assets.blend")
+    except Exception:
+        pass
+
+    try:
+        system_root = Path(bpy.utils.resource_path('SYSTEM'))
+        candidates.append(system_root / "datafiles" / "assets" / "geometry_nodes" / "procedural_hair_node_assets.blend")
+    except Exception:
+        pass
+
+    try:
+        user_datafiles = Path(bpy.utils.user_resource('DATAFILES'))
+        candidates.append(user_datafiles / "assets" / "geometry_nodes" / "procedural_hair_node_assets.blend")
+    except Exception:
+        pass
+
+    for p in candidates:
+        if p.exists():
+            return p
+
+    raise FileNotFoundError(
+        "Could not locate procedural_hair_node_assets.blend in Blender datafiles."
+    )
+
+
+def ensure_node_group_loaded_from_blend(node_group_name, blend_path):
+    ng = bpy.data.node_groups.get(node_group_name)
+    if ng is not None:
+        return ng
+
+    blend_path = Path(blend_path)
+    if not blend_path.exists():
+        raise FileNotFoundError(f"Blend library not found: {blend_path}")
+
+    with bpy.data.libraries.load(str(blend_path), link=False) as (data_from, data_to):
+        if node_group_name not in data_from.node_groups:
+            raise RuntimeError(f"Node group '{node_group_name}' not found in {blend_path}")
+        data_to.node_groups = [node_group_name]
+
+    ng = bpy.data.node_groups.get(node_group_name)
+    if ng is None:
+        raise RuntimeError(f"Failed to append node group '{node_group_name}' from {blend_path}")
+    return ng
+
+
+def add_gn_modifier(curves_obj, node_group_name, modifier_name):
+    select_and_activate(curves_obj)
+
+    blend_path = get_essentials_blend_path()
+    node_group = ensure_node_group_loaded_from_blend(node_group_name, blend_path)
+
+    mod = curves_obj.modifiers.new(name=modifier_name, type='NODES')
+    mod.node_group = node_group
+    return mod
+
+
+def try_add_gn_modifier(curves_obj, node_group_names, modifier_name):
+    last_err = None
+    for ng_name in node_group_names:
+        try:
+            mod = add_gn_modifier(curves_obj, ng_name, modifier_name)
+            log(f"    + Loaded node group '{ng_name}' as '{modifier_name}'")
+            return mod
+        except Exception as e:
+            last_err = e
+    log(f"    [WARN] Could not load any of {node_group_names} for '{modifier_name}': {last_err}")
+    return None
+
+
+def add_custom_post_duplicate_modifier(curves_obj):
+    select_and_activate(curves_obj)
+
+    blend_path = get_essentials_blend_path()
+    noise_ng = ensure_node_group_loaded_from_blend("Hair Curves Noise", blend_path)
+    trim_ng = ensure_node_group_loaded_from_blend("Trim Hair Curves", blend_path)
+
+    bpy.ops.object.modifier_add(type='NODES')
+    mod = curves_obj.modifiers[-1]
+    mod.name = "Custom Post Duplicate Trim"
+
+    bpy.ops.node.new_geometry_node_group_assign()
+    ng = mod.node_group
+    ng.name = f"{curves_obj.name}_CustomPostDuplicateTrim"
+
+    nodes = ng.nodes
+    links = ng.links
+
+    group_in = None
+    group_out = None
+    for node in nodes:
+        if node.bl_idname == "NodeGroupInput":
+            group_in = node
+        elif node.bl_idname == "NodeGroupOutput":
+            group_out = node
+
+    if group_in is None or group_out is None:
+        raise RuntimeError("Failed to get default GN group input/output nodes")
+
+    for node in list(nodes):
+        if node not in {group_in, group_out}:
+            nodes.remove(node)
+
+    group_in.location = (-1000, 0)
+    group_out.location = (500, 0)
+
+    try:
+        id_node = nodes.new("GeometryNodeInputID")
+    except RuntimeError:
+        id_node = nodes.new("GeometryNodeInputIndex")
+    id_node.location = (-1000, -220)
+
+    random_value = nodes.new("FunctionNodeRandomValue")
+    random_value.location = (-760, -220)
+    random_value.data_type = 'BOOLEAN'
+    random_value.inputs["Probability"].default_value = 0.08
+    if "Seed" in random_value.inputs:
+        random_value.inputs["Seed"].default_value = 0
+
+    separate = nodes.new("GeometryNodeSeparateGeometry")
+    separate.location = (-520, 0)
+    separate.domain = 'CURVE'
+
+    noise = nodes.new("GeometryNodeGroup")
+    noise.location = (-220, -40)
+    noise.node_tree = noise_ng
+
+    trim = nodes.new("GeometryNodeGroup")
+    trim.location = (40, -40)
+    trim.node_tree = trim_ng
+
+    join = nodes.new("GeometryNodeJoinGeometry")
+    join.location = (260, 20)
+
+    if "Factor" in noise.inputs:
+        noise.inputs["Factor"].default_value = 1.0
+    if "Distance" in noise.inputs:
+        noise.inputs["Distance"].default_value = 0.002
+    if "Shape" in noise.inputs:
+        noise.inputs["Shape"].default_value = 0.5
+    if "Scale" in noise.inputs:
+        noise.inputs["Scale"].default_value = 1.0
+    if "Scale Along Length" in noise.inputs:
+        noise.inputs["Scale Along Length"].default_value = 1.0
+    if "Offset" in noise.inputs:
+        noise.inputs["Offset"].default_value = 0.0
+    if "Cumulative Offset" in noise.inputs:
+        noise.inputs["Cumulative Offset"].default_value = False
+    if "Seed" in noise.inputs:
+        noise.inputs["Seed"].default_value = 0
+
+    if "Mask" in trim.inputs:
+        trim.inputs["Mask"].default_value = 1.0
+    if "Random Offset" in trim.inputs:
+        trim.inputs["Random Offset"].default_value = 0.03
+    if "Pin at Parameter" in trim.inputs:
+        trim.inputs["Pin at Parameter"].default_value = 0.0
+    if "Seed" in trim.inputs:
+        trim.inputs["Seed"].default_value = 0
+    if "Replace Length" in trim.inputs:
+        trim.inputs["Replace Length"].default_value = False
+
+    if "ID" in random_value.inputs:
+        if "ID" in id_node.outputs:
+            links.new(id_node.outputs["ID"], random_value.inputs["ID"])
+        else:
+            links.new(id_node.outputs["Index"], random_value.inputs["ID"])
+
+    links.new(group_in.outputs["Geometry"], separate.inputs["Geometry"])
+    links.new(random_value.outputs["Value"], separate.inputs["Selection"])
+
+    links.new(separate.outputs["Selection"], noise.inputs["Geometry"])
+    links.new(noise.outputs["Geometry"], trim.inputs["Geometry"])
+
+    links.new(separate.outputs["Inverted"], join.inputs["Geometry"])
+    links.new(trim.outputs["Geometry"], join.inputs["Geometry"])
+    links.new(join.outputs["Geometry"], group_out.inputs["Geometry"])
+
+    log(f"    + Custom Post Duplicate Trim on {curves_obj.name}")
+    return mod
+
+
+def setup_modifiers(curves_obj, group_name, mesh_obj, hair_info):
+    is_mouse = group_name == "mouse_fur"
+    is_face = group_name == "face_fur"
+    is_ear = group_name == "ear_fur"
+
+    profile_mod = add_gn_modifier(curves_obj, "Set Hair Curve Profile", "Set Hair Curve Profile")
+    set_gn_input(profile_mod, "Radius", 0.00012)
+    log("    + Set Hair Curve Profile (radius=0.0001)")
+
+    add_custom_post_duplicate_modifier(curves_obj)
+
+    if (not is_mouse) and (not is_face):
+        if(not is_ear):
+            mod = add_gn_modifier(curves_obj, "Duplicate Hair Curves", "Duplicate Hair Curves")
+            set_gn_input(mod, "Amount", 8)
+            set_gn_input(mod, "Radius", 0.007)
+            set_gn_input(mod, "Distribution Shape", 1.0)
+            log("    + Duplicate Hair Curves (radius=0.005, distribution_shape=1.0)")
+
+        frizz_mod = try_add_gn_modifier(
+            curves_obj,
+            ["Frizz Hair Curves", "Hair Curves Frizz"],
+            "Frizz Hair Curves"
+        )
+        if frizz_mod is not None:
+            set_gn_input(frizz_mod, "Factor", 0.7)
+            set_gn_input(frizz_mod, "Distance", 0.001)
+            set_gn_input(frizz_mod, "Shape", 0.01)
+            log("    + Frizz Hair Curves (factor=0.7, distance=0.001, shape=0.01)")
+    else:
+        log("    + Skip Duplicate Hair Curves for mouse_fur/face")
+
+    if is_face or is_ear:
+        mod = add_gn_modifier(curves_obj, "Duplicate Hair Curves", "Duplicate Hair Curves")
+        set_gn_input(mod, "Amount", 3)
+        set_gn_input(mod, "Radius", 0.005)
+        set_gn_input(mod, "Distribution Shape", 1.0)
+
+
+
+def delete_default_cube():
+    cube = bpy.data.objects.get("Cube")
+    if cube is None:
+        return
+
+    bpy.ops.object.select_all(action='DESELECT')
+    cube.select_set(True)
+    bpy.context.view_layer.objects.active = cube
+    bpy.ops.object.delete()
+
+    log("Deleted default Cube")
+
+
+def clear_material_slots(obj):
+    if not hasattr(obj.data, "materials"):
+        return
+    obj.data.materials.clear()
+
+
+def assign_material(obj, material):
+    if not hasattr(obj.data, "materials"):
+        return
+    obj.data.materials.clear()
+    obj.data.materials.append(material)
+    if hasattr(obj, "active_material"):
+        obj.active_material = material
+
+
+def extract_numeric_suffix(name: str):
+    m = re.search(r"(\d+)$", name)
+    return int(m.group(1)) if m else None
+
+
+def natural_key(path: Path):
+    parts = re.split(r"(\d+)", path.stem.lower())
+    key = []
+    for p in parts:
+        if p.isdigit():
+            key.append(int(p))
+        else:
+            key.append(p)
+    key.append(path.suffix.lower())
+    return key
+
+
+def find_texture_for_obj(obj_path: str, textures_dir: str):
+    """
+    Match a shape OBJ to a texture by natural-sort index.
+
+    This mirrors the dataset auxiliary-file rule after excluding hidden and
+    macOS resource-fork files. For a group with five real shapes and five
+    textures, only those five files participate in pairing.
+    """
+    obj_path = Path(obj_path).expanduser().resolve()
+    textures_dir = Path(textures_dir).expanduser().resolve()
+    shapes_dir = obj_path.parent.resolve()
+
+    if not shapes_dir.is_dir():
+        raise FileNotFoundError(f"Shapes directory not found: {shapes_dir}")
+    if not textures_dir.is_dir():
+        raise FileNotFoundError(f"Textures directory not found: {textures_dir}")
+    if not is_usable_file(obj_path):
+        raise FileNotFoundError(
+            f"OBJ is missing or is a hidden/macOS metadata file: {obj_path}"
+        )
+
+    shape_files = sorted(
+        [
+            path
+            for path in shapes_dir.iterdir()
+            if is_usable_file(path)
+            and path.suffix.lower() == ".obj"
+        ],
+        key=natural_key,
+    )
+    texture_files = sorted(
+        [
+            path
+            for path in textures_dir.iterdir()
+            if is_usable_file(path)
+            and path.suffix.lower() in IMAGE_EXTS
+        ],
+        key=natural_key,
+    )
+
+    if not shape_files:
+        raise FileNotFoundError(f"No usable shape OBJ files found in: {shapes_dir}")
+    if not texture_files:
+        raise FileNotFoundError(f"No usable texture files found in: {textures_dir}")
+
+    try:
+        shape_index = next(
+            index
+            for index, path in enumerate(shape_files)
+            if path.resolve() == obj_path
+        )
+    except StopIteration as exc:
+        raise FileNotFoundError(
+            f"Could not find usable OBJ {obj_path.name} in: {shapes_dir}"
+        ) from exc
+
+    if len(texture_files) == 1:
+        chosen = texture_files[0]
+    elif shape_index < len(texture_files):
+        chosen = texture_files[shape_index]
+    else:
+        raise IndexError(
+            "Texture index out of range after hidden-file filtering. "
+            f"usable_shapes={len(shape_files)}, "
+            f"usable_textures={len(texture_files)}, "
+            f"shape_index={shape_index}, obj={obj_path.name}"
+        )
+
+    log(
+        "Texture matched by natural-sort index: "
+        f"shape[{shape_index}]={obj_path.name} -> {chosen.name}; "
+        f"usable_shapes={len(shape_files)}, "
+        f"usable_textures={len(texture_files)}"
+    )
+    return chosen
+
+
+def set_node_input_if_exists(node, input_name, value):
+    if input_name in node.inputs:
+        node.inputs[input_name].default_value = value
+
+
+def set_enum_attr_if_exists(node, attr_names, value):
+    for attr in attr_names:
+        if hasattr(node, attr):
+            try:
+                setattr(node, attr, value)
+                return True
+            except Exception:
+                pass
+    return False
+
+
+def create_mesh_material(mesh_obj, texture_path: str, normal_path: str, roughness_path: str, material_name="MeshMaterial"):
+    texture_path = Path(texture_path).resolve()
+    normal_path = Path(normal_path).resolve() if normal_path else None
+    roughness_path = Path(roughness_path).resolve() if roughness_path else None
+
+    if not is_usable_file(texture_path):
+        raise FileNotFoundError(
+            f"Mesh texture is missing or hidden: {texture_path}"
+        )
+
+    mat = bpy.data.materials.get(material_name)
+    if mat is None:
+        mat = bpy.data.materials.new(material_name)
+    mat.use_nodes = True
+
+    nt = mat.node_tree
+    nodes = nt.nodes
+    links = nt.links
+    nodes.clear()
+
+    out = nodes.new("ShaderNodeOutputMaterial")
+    out.location = (700, 0)
+
+    bsdf = nodes.new("ShaderNodeBsdfPrincipled")
+    bsdf.location = (350, 0)
+    set_node_input_if_exists(bsdf, "IOR", 1.5)
+
+    tex_color = nodes.new("ShaderNodeTexImage")
+    tex_color.location = (-450, 150)
+    tex_color.image = open_image_color(str(texture_path))
+    tex_color.interpolation = 'Linear'
+    tex_color.extension = 'REPEAT'
+
+    links.new(tex_color.outputs["Color"], bsdf.inputs["Base Color"])
+    if "Alpha" in tex_color.outputs and "Alpha" in bsdf.inputs:
+        links.new(tex_color.outputs["Alpha"], bsdf.inputs["Alpha"])
+
+    if roughness_path is not None and is_usable_file(roughness_path):
+        tex_rough = nodes.new("ShaderNodeTexImage")
+        tex_rough.location = (-450, -50)
+        tex_rough.image = open_image_simple(str(roughness_path), non_color=True)
+        tex_rough.interpolation = 'Linear'
+        tex_rough.extension = 'REPEAT'
+        links.new(tex_rough.outputs["Color"], bsdf.inputs["Roughness"])
+    else:
+        set_node_input_if_exists(bsdf, "Roughness", 0.5)
+        log("Roughness map not found; using constant roughness=0.5")
+
+    if normal_path is not None and is_usable_file(normal_path):
+        tex_normal = nodes.new("ShaderNodeTexImage")
+        tex_normal.location = (-450, -250)
+        tex_normal.image = open_image_simple(str(normal_path), non_color=True)
+        tex_normal.interpolation = 'Linear'
+        tex_normal.extension = 'REPEAT'
+
+        normal_map = nodes.new("ShaderNodeNormalMap")
+        normal_map.location = (-100, -250)
+        set_node_input_if_exists(normal_map, "Strength", 1.0)
+        links.new(tex_normal.outputs["Color"], normal_map.inputs["Color"])
+        links.new(normal_map.outputs["Normal"], bsdf.inputs["Normal"])
+    else:
+        log("Normal map not found; using mesh normals")
+
+    links.new(bsdf.outputs["BSDF"], out.inputs["Surface"])
+
+    try:
+        mat.blend_method = 'HASHED'
+    except Exception:
+        pass
+    try:
+        mat.shadow_method = 'HASHED'
+    except Exception:
+        pass
+
+    assign_material(mesh_obj, mat)
+    log(f"Assigned mesh material: {mat.name}")
+    return mat
+
+
+def create_hair_material(texture_path: str, material_name="HairMaterial"):
+    texture_path = require_usable_file(
+        texture_path,
+        "Hair texture",
+    )
+
+    mat = bpy.data.materials.get(material_name)
+    if mat is None:
+        mat = bpy.data.materials.new(material_name)
+    mat.use_nodes = True
+
+    nt = mat.node_tree
+    nodes = nt.nodes
+    links = nt.links
+    nodes.clear()
+
+    tex_mesh = nodes.new("ShaderNodeTexImage")
+    tex_mesh.location = (-900, 200)
+    tex_mesh.image = open_image_color(str(texture_path))
+    tex_mesh.interpolation = 'Linear'
+    tex_mesh.extension = 'REPEAT'
+
+    tex_hair = nodes.new("ShaderNodeTexImage")
+    tex_hair.location = (-900, -200)
+    tex_hair.image = open_image_color(str(texture_path))
+    tex_hair.interpolation = 'Linear'
+    tex_hair.extension = 'REPEAT'
+
+    bsdf = nodes.new("ShaderNodeBsdfPrincipled")
+    bsdf.location = (-500, 180)
+    set_node_input_if_exists(bsdf, "IOR", 1.5)
+    set_node_input_if_exists(bsdf, "Roughness", 0.5)
+    set_node_input_if_exists(bsdf, "Alpha", 1.0)
+
+    hair_bsdf = nodes.new("ShaderNodeBsdfHairPrincipled")
+    hair_bsdf.location = (-500, -220)
+
+    set_enum_attr_if_exists(hair_bsdf, ["model", "distribution"], 'CHIANG')
+    set_enum_attr_if_exists(hair_bsdf, ["parametrization"], 'COLOR')
+
+    set_node_input_if_exists(hair_bsdf, "Roughness", 0.4)
+    set_node_input_if_exists(hair_bsdf, "Radial Roughness", 0.6)
+    set_node_input_if_exists(hair_bsdf, "Coat", 0.0)
+    set_node_input_if_exists(hair_bsdf, "IOR", 1.5)
+    set_node_input_if_exists(hair_bsdf, "Offset", math.radians(3.0))
+    set_node_input_if_exists(hair_bsdf, "Random Roughness", 0.25)
+
+    mix_main = nodes.new("ShaderNodeMixShader")
+    mix_main.location = (-120, 20)
+    if "Fac" in mix_main.inputs:
+        mix_main.inputs["Fac"].default_value = 0.6
+
+    transparent = nodes.new("ShaderNodeBsdfTransparent")
+    transparent.location = (-120, -260)
+
+    light_path = nodes.new("ShaderNodeLightPath")
+    light_path.location = (-360, 320)
+
+    mix_shadow = nodes.new("ShaderNodeMixShader")
+    mix_shadow.location = (180, 50)
+
+    out = nodes.new("ShaderNodeOutputMaterial")
+    out.location = (420, 50)
+
+    links.new(tex_mesh.outputs["Color"], bsdf.inputs["Base Color"])
+    links.new(tex_hair.outputs["Color"], hair_bsdf.inputs["Color"])
+    links.new(bsdf.outputs["BSDF"], mix_main.inputs[1])
+    links.new(hair_bsdf.outputs["BSDF"], mix_main.inputs[2])
+    links.new(light_path.outputs["Is Shadow Ray"], mix_shadow.inputs["Fac"])
+    links.new(mix_main.outputs["Shader"], mix_shadow.inputs[1])
+    links.new(transparent.outputs["BSDF"], mix_shadow.inputs[2])
+    links.new(mix_shadow.outputs["Shader"], out.inputs["Surface"])
+
+    try:
+        mat.blend_method = 'HASHED'
+    except Exception:
+        pass
+    try:
+        mat.shadow_method = 'HASHED'
+    except Exception:
+        pass
+    try:
+        mat.use_backface_culling = False
+    except Exception:
+        pass
+
+    log(f"Created hair material: {mat.name}")
+    return mat
+
+
+def setup_cycles_render(scene):
+    scene.render.engine = 'CYCLES'
+    scene.cycles.samples = 64
+    try:
+        scene.cycles.device = 'GPU'
+    except Exception:
+        pass
+    try:
+        scene.render.film_transparent = True
+    except Exception:
+        pass
+
+    try:
+        scene.view_layers["ViewLayer"].cycles.use_denoising = False
+    except Exception:
+        pass
+
+    log("Set render engine to Cycles")
+
+
+def setup_world_hdr(hdr_path: str):
+    hdr_path = require_usable_file(hdr_path, "HDR image")
+
+    scene = bpy.context.scene
+    world = scene.world
+    if world is None:
+        world = bpy.data.worlds.new("World")
+        scene.world = world
+
+    world.use_nodes = True
+    nt = world.node_tree
+    nodes = nt.nodes
+    links = nt.links
+    nodes.clear()
+
+    tex_coord = nodes.new("ShaderNodeTexCoord")
+    tex_coord.location = (-900, 0)
+
+    mapping = nodes.new("ShaderNodeMapping")
+    mapping.location = (-700, 0)
+
+    env_tex = nodes.new("ShaderNodeTexEnvironment")
+    env_tex.location = (-500, 0)
+    env_tex.image = bpy.data.images.load(filepath=str(hdr_path), check_existing=True)
+
+    background = nodes.new("ShaderNodeBackground")
+    background.location = (-220, 0)
+    background.inputs["Strength"].default_value = random.uniform(0.4, 0.6)
+
+    world_out = nodes.new("ShaderNodeOutputWorld")
+    world_out.location = (300, 0)
+
+    links.new(tex_coord.outputs["Generated"], mapping.inputs["Vector"])
+    links.new(mapping.outputs["Vector"], env_tex.inputs["Vector"])
+    links.new(env_tex.outputs["Color"], background.inputs["Color"])
+    links.new(background.outputs["Background"], world_out.inputs["Surface"])
+
+    scene.render.film_transparent = True
+    log(f"Set HDR world lighting: {hdr_path}")
+
+def compute_mesh_bbox_center_and_radius(mesh_obj):
+    """Compute the world-space bounding box center and enclosing sphere radius."""
+    bbox_corners = [mesh_obj.matrix_world @ Vector(c) for c in mesh_obj.bound_box]
+    bbox_min = Vector((
+        min(c.x for c in bbox_corners),
+        min(c.y for c in bbox_corners),
+        min(c.z for c in bbox_corners),
+    ))
+    bbox_max = Vector((
+        max(c.x for c in bbox_corners),
+        max(c.y for c in bbox_corners),
+        max(c.z for c in bbox_corners),
+    ))
+    center = (bbox_min + bbox_max) / 2.0
+    radius = (bbox_max - bbox_min).length / 2.0
+    return center, radius
+
+
+def ensure_camera(mesh_obj=None, h_range=(-20, 20), v_range=(10, 30), render_size=1024, padding=0.9):
+    """Create/reuse a camera with random orbit around the mesh.
+
+    Args:
+        mesh_obj: The target mesh. If None, falls back to a fixed position.
+        h_range: (min_deg, max_deg) horizontal rotation range around the object.
+                 0 = front (+X axis looking at center), negative = left, positive = right.
+        v_range: (min_deg, max_deg) vertical elevation range.
+                 0 = horizon level, 45 = looking down at 45 degrees.
+        render_size: Output image resolution (square).
+        padding: Multiplier on the camera distance to ensure the whole mesh
+                 (including hair) fits in frame. >1.0 adds margin.
+    """
+    cam_obj = bpy.data.objects.get("RenderCamera")
+    if cam_obj is None or cam_obj.type != 'CAMERA':
+        cam_data = bpy.data.cameras.new("RenderCamera")
+        cam_obj = bpy.data.objects.new("RenderCamera", cam_data)
+        bpy.context.collection.objects.link(cam_obj)
+
+    scene = bpy.context.scene
+    scene.camera = cam_obj
+
+    # Set render resolution to 512x512
+    scene.render.resolution_x = render_size
+    scene.render.resolution_y = render_size
+    scene.render.resolution_percentage = 100
+
+    if mesh_obj is None:
+        # Fallback: fixed position
+        cam_obj.location = (2.0, 0.0, 0.0)
+        cam_obj.rotation_euler = (
+            math.radians(90.0),
+            math.radians(0.0),
+            math.radians(90.0),
+        )
+        log("Set camera at fixed fallback position (no mesh provided)")
+        return cam_obj
+
+    # Compute mesh bounding sphere
+    center, radius = compute_mesh_bbox_center_and_radius(mesh_obj)
+    if radius < 1e-6:
+        radius = 1.0
+
+    # Random angles
+    h_deg = random.uniform(h_range[0], h_range[1])
+    v_deg = random.uniform(v_range[0], v_range[1])
+    h_rad = math.radians(h_deg)
+    v_rad = math.radians(v_deg)
+
+    # Compute camera distance so the bounding sphere fits in the FOV
+    cam_data = cam_obj.data
+    cam_data.sensor_fit = 'AUTO'
+    # cam_data.angle = 75
+    # cam_data.fov = 75
+    cam_data.lens = 75
+
+    print(cam_data.angle)
+    fov = cam_data.angle  # full horizontal FOV in radians
+    half_fov = fov / 2.0
+
+    # Distance from center so the sphere of size (radius * padding) fits
+    distance = (radius * padding) / math.sin(half_fov)
+    if distance < 0.01:
+        distance = 2.0
+
+    # Spherical coordinates -> cartesian offset from center
+    # h_rad=0 means looking from +X toward center (front view)
+    # v_rad=0 means at horizon level, v_rad>0 means elevated (looking down)
+    cam_x = center.x + distance * math.cos(v_rad) * math.cos(h_rad)
+    cam_y = center.y + distance * math.cos(v_rad) * math.sin(h_rad)
+    cam_z = center.z + distance * math.sin(v_rad)
+
+    cam_obj.location = (cam_x, cam_y, cam_z)
+
+    # Point camera at center using a track-to constraint (most robust)
+    # Remove any existing track-to constraint first
+    for c in list(cam_obj.constraints):
+        if c.type == 'TRACK_TO':
+            cam_obj.constraints.remove(c)
+
+    # Create an empty at the mesh center as the track target
+    target_empty = bpy.data.objects.get("CameraTarget")
+    if target_empty is None:
+        target_empty = bpy.data.objects.new("CameraTarget", None)
+        bpy.context.collection.objects.link(target_empty)
+    target_empty.location = center
+    target_empty.empty_display_size = 0.01
+    target_empty.hide_viewport = True
+    target_empty.hide_render = True
+
+    constraint = cam_obj.constraints.new(type='TRACK_TO')
+    constraint.target = target_empty
+    constraint.track_axis = 'TRACK_NEGATIVE_Z'
+    constraint.up_axis = 'UP_Y'
+
+    # Force update so the constraint takes effect
+    bpy.context.view_layer.update()
+
+    log(
+        f"Camera: h={h_deg:.1f}° v={v_deg:.1f}° dist={distance:.3f} "
+        f"center=({center.x:.3f},{center.y:.3f},{center.z:.3f}) "
+        f"render={render_size}x{render_size}"
+    )
+    return cam_obj
+
+
+def sample_image_luminance_at_uv(img, uv, pixels_np=None):
+    width, height = img.size
+
+    if pixels_np is None:
+        pixel_count = width * height * 4
+        pixels_np = np.empty(pixel_count, dtype=np.float32)
+        img.pixels.foreach_get(pixels_np)
+        pixels_np = pixels_np.reshape((height, width, 4))
+
+    u = float(np.clip(uv[0], 0.0, 1.0))
+    v = float(np.clip(uv[1], 0.0, 1.0))
+    xi = int(u * (width - 1))
+    yi = int(v * (height - 1))
+
+    rgba = pixels_np[yi, xi]
+    lum = 0.2126 * rgba[0] + 0.7152 * rgba[1] + 0.0722 * rgba[2]
+    return float(lum)
+
+
+def remove_curve_uv_attributes(curves_obj):
+    curves = curves_obj.data
+
+    try:
+        curves.surface_uv_map = ""
+    except Exception:
+        pass
+
+    for attr_name in ["surface_uv_coordinate", "uv_map", "UVMap", "UV", "map1"]:
+        attr = curves.attributes.get(attr_name)
+        if attr is not None:
+            try:
+                curves.attributes.remove(attr)
+                log(f"  Removed curve attribute: {attr_name}")
+            except Exception as e:
+                log(f"  [WARN] Failed removing curve attribute '{attr_name}': {e}")
+
+
+def create_underhair_guides_from_mesh(mesh_obj, mask_image_path, strand_length=0.01, threshold=0.05):
+    """Create underhair guide strands using the evaluated (deformed) mesh."""
+    mesh = mesh_obj.data
+    if not mesh.uv_layers.active:
+        raise RuntimeError("Mesh has no active UV layer; underhair mask sampling requires UVs.")
+
+    mask_img = open_image_simple(str(mask_image_path), non_color=True)
+    width, height = mask_img.size
+
+    pixel_count = width * height * 4
+    pixels_np = np.empty(pixel_count, dtype=np.float32)
+    mask_img.pixels.foreach_get(pixels_np)
+    pixels_np = pixels_np.reshape((height, width, 4))
+
+    # Use evaluated mesh for vertex positions and normals
+    eval_obj, eval_mesh = get_evaluated_mesh(mesh_obj)
+
+    total_loops = len(eval_mesh.loops)
+    loop_uvs = np.empty(total_loops * 2, dtype=np.float32)
+    eval_mesh.uv_layers.active.data.foreach_get("uv", loop_uvs)
+    loop_uvs = loop_uvs.reshape((total_loops, 2))
+
+    loop_verts = np.empty(total_loops, dtype=np.int32)
+    eval_mesh.loops.foreach_get("vertex_index", loop_verts)
+
+    num_verts = len(eval_mesh.vertices)
+    uv_sum = np.zeros((num_verts, 2), dtype=np.float64)
+    uv_cnt = np.zeros(num_verts, dtype=np.int32)
+
+    np.add.at(uv_sum[:, 0], loop_verts, loop_uvs[:, 0])
+    np.add.at(uv_sum[:, 1], loop_verts, loop_uvs[:, 1])
+    np.add.at(uv_cnt, loop_verts, 1)
+
+    valid = uv_cnt > 0
+    avg_uv = np.zeros((num_verts, 2), dtype=np.float64)
+    avg_uv[valid] = uv_sum[valid] / uv_cnt[valid][:, None]
+
+    strands = []
+    weights = np.zeros(num_verts, dtype=np.float32)
+
+    for vid in range(num_verts):
+        if not valid[vid]:
+            continue
+
+        uv = avg_uv[vid]
+        w = sample_image_luminance_at_uv(mask_img, uv, pixels_np=pixels_np)
+        weights[vid] = w
+
+        if w <= threshold:
+            continue
+
+        root = eval_mesh.vertices[vid].co.copy()
+        normal = eval_mesh.vertices[vid].normal.normalized()
+        tip = root + normal * float(strand_length)
+
+        strand = np.stack([
+            np.array((root.x, root.y, root.z), dtype=np.float32),
+            np.array((tip.x, tip.y, tip.z), dtype=np.float32),
+        ], axis=0)
+        strands.append(strand)
+
+    eval_obj.to_mesh_clear()
+
+    old_vg = mesh_obj.vertex_groups.get(UNDERHAIR_MASK_GROUP)
+    if old_vg is not None:
+        mesh_obj.vertex_groups.remove(old_vg)
+    vg = mesh_obj.vertex_groups.new(name=UNDERHAIR_MASK_GROUP)
+
+    for vid, w in enumerate(weights):
+        if w > 0.0:
+            vg.add([vid], float(w), 'REPLACE')
+
+    log(f"Created underhair guides: {len(strands)} strands")
+    return strands, vg, mask_img
+
+
+def setup_underhair_modifiers(curves_obj, mesh_obj, mask_img, trim_length=0.01):
+    profile_mod = add_gn_modifier(curves_obj, "Set Hair Curve Profile", "UnderHair Profile")
+    set_gn_input(profile_mod, "Radius", 0.0001)
+    log("    + UnderHair Profile (radius=0.0001)")
+
+    interp_mod = add_gn_modifier(curves_obj, "Interpolate Hair Curves", "UnderHair Interpolate")
+
+    try:
+        interp_mod["Input_2"] = mesh_obj
+        log(f"    + UnderHair Interpolate Input_2 = {mesh_obj.name}")
+    except Exception as e:
+        log(f"    [WARN] Failed setting UnderHair Interpolate Input_2: {e}")
+
+    set_gn_input(interp_mod, "Surface", mesh_obj)
+    set_gn_input(interp_mod, "Surface Object", mesh_obj)
+    set_gn_input(interp_mod, "Mesh", mesh_obj)
+
+    density_set = False
+    density_set |= set_gn_input(interp_mod, "Surface Density", UNDERHAIR_INTERP_DENSITY)
+    density_set |= set_gn_input(interp_mod, "Density", UNDERHAIR_INTERP_DENSITY)
+    density_set |= set_gn_input_by_keywords(interp_mod, ["density"], UNDERHAIR_INTERP_DENSITY)
+    density_set |= set_gn_input_by_keywords(interp_mod, ["surface", "density"], UNDERHAIR_INTERP_DENSITY)
+
+    if not density_set:
+        log("    [WARN] Could not find interpolation density socket; value may remain default")
+
+    set_gn_input(interp_mod, "Interpolation Quality", 6)
+    set_gn_input(interp_mod, "Variation Level", 0.15)
+    set_gn_input(interp_mod, "Guide Mask", 0.0)
+    set_gn_input(interp_mod, "Use Guide Mask", False)
+
+    interp_tex_id = get_node_input_identifier_by_name(interp_mod, "Mask Texture")
+    if interp_tex_id is not None:
+        try:
+            interp_mod[interp_tex_id] = mask_img
+            log("    + UnderHair Interpolate mask texture = merged.png")
+        except Exception as e:
+            log(f"    [WARN] Failed to assign interpolate mask texture: {e}")
+
+    log("    + UnderHair Interpolate configured")
+
+    noise_mod = add_gn_modifier(curves_obj, "Hair Curves Noise", "UnderHair Noise")
+    set_gn_input(noise_mod, "Factor", 1.0)
+    set_gn_input(noise_mod, "Distance", 0.0015)
+    set_gn_input(noise_mod, "Shape", 0.5)
+    set_gn_input(noise_mod, "Scale", 18.0)
+    set_gn_input(noise_mod, "Scale Along Length", 1.0)
+    set_gn_input(noise_mod, "Offset", 0.0)
+    set_gn_input(noise_mod, "Cumulative Offset", False)
+    set_gn_input(noise_mod, "Seed", 0)
+    log("    + UnderHair Noise")
+
+    frizz_mod = try_add_gn_modifier(
+        curves_obj,
+        ["Frizz Hair Curves", "Hair Curves Frizz"],
+        "UnderHair Frizz"
+    )
+    if frizz_mod is not None:
+        set_gn_input(frizz_mod, "Amount", 0.6)
+        set_gn_input(frizz_mod, "Radius", 0.001)
+        set_gn_input(frizz_mod, "Frequency", 12.0)
+        set_gn_input(frizz_mod, "Seed", 0)
+        set_gn_input(frizz_mod, "Mask", 1.0)
+
+        frizz_tex_id = get_node_input_identifier_by_name(frizz_mod, "Mask Texture")
+        if frizz_tex_id is not None:
+            try:
+                frizz_mod[frizz_tex_id] = mask_img
+                log("    + UnderHair Frizz mask texture = merged.png")
+            except Exception as e:
+                log(f"    [WARN] Failed to assign frizz mask texture: {e}")
+
+        log("    + UnderHair Frizz")
+
+    trim_mod = add_gn_modifier(curves_obj, "Trim Hair Curves", "UnderHair Trim")
+    set_gn_input(trim_mod, "Mask", 1.0)
+    set_gn_input(trim_mod, "Random Offset", 0.0)
+    set_gn_input(trim_mod, "Pin at Parameter", 0.0)
+    set_gn_input(trim_mod, "Replace Length", True)
+    set_gn_input(trim_mod, "Length", float(trim_length))
+
+    trim_tex_id = get_node_input_identifier_by_name(trim_mod, "Mask Texture")
+    if trim_tex_id is not None:
+        try:
+            trim_mod[trim_tex_id] = mask_img
+            log("    + UnderHair Trim mask texture = merged.png")
+        except Exception as e:
+            log(f"    [WARN] Failed to assign trim mask texture: {e}")
+
+    log(f"    + UnderHair Trim (length={trim_length})")
+
+
+def create_underhair_if_available(mesh_obj, mesh_material, mask_image_path):
+    mask_path = Path(mask_image_path).resolve()
+    if not mask_path.exists():
+        log(f"Underhair mask not found; skipping underhair: {mask_path}")
+        return None
+    return create_underhair_on_mesh(
+        mesh_obj=mesh_obj,
+        mesh_material=mesh_material,
+        mask_image_path=str(mask_path),
+    )
+
+
+def create_underhair_on_mesh(mesh_obj, mesh_material, mask_image_path):
+    log("Creating underhair from mesh surface...")
+
+    strands, mask_vg, mask_img = create_underhair_guides_from_mesh(
+        mesh_obj=mesh_obj,
+        mask_image_path=str(mask_image_path),
+        strand_length=UNDERHAIR_LENGTH,
+        threshold=0.05,
+    )
+
+    if len(strands) == 0:
+        log("  [WARN] No underhair strands created from mask.")
+        return None
+
+    underhair_obj = build_curve_object_from_strands_no_uv(
+        obj_name="underhair",
+        strands=strands,
+        mesh_obj=mesh_obj,
+    )
+    if underhair_obj is None:
+        return None
+
+    remove_curve_uv_attributes(underhair_obj)
+    assign_material(underhair_obj, mesh_material)
+
+    setup_underhair_modifiers(
+        curves_obj=underhair_obj,
+        mesh_obj=mesh_obj,
+        mask_img=mask_img,
+        trim_length=UNDERHAIR_LENGTH,
+    )
+
+    log("Underhair object created successfully")
+    return underhair_obj
+
+
+def get_child_hair_objects(surface_obj):
+    out = []
+    for obj in bpy.data.objects:
+        if obj.parent == surface_obj and obj.type in {'CURVES', 'MESH'}:
+            out.append(obj)
+    return out
+
+
+def ensure_curve_bound_to_surface(curves_obj, surface_obj):
+    if curves_obj.type != 'CURVES':
+        return
+    curves = curves_obj.data
+    curves.surface = surface_obj
+    if surface_obj.data.uv_layers.active is not None:
+        try:
+            curves.surface_uv_map = surface_obj.data.uv_layers.active.name
+        except Exception:
+            pass
+    curves_obj.parent = surface_obj
+    try:
+        curves_obj.matrix_parent_inverse = surface_obj.matrix_world.inverted()
+    except Exception:
+        pass
+
+
+def add_or_rebind_surface_deform(mesh_hair_obj, surface_obj, modifier_name="SurfaceDeformToBody"):
+    mod = mesh_hair_obj.modifiers.get(modifier_name)
+    if mod is None:
+        mod = mesh_hair_obj.modifiers.new(name=modifier_name, type='SURFACE_DEFORM')
+
+    mod.target = surface_obj
+    mod.falloff = 4.0
+
+    try:
+        bpy.ops.object.mode_set(mode='OBJECT')
+    except Exception:
+        pass
+
+    bpy.ops.object.select_all(action='DESELECT')
+    mesh_hair_obj.select_set(True)
+    bpy.context.view_layer.objects.active = mesh_hair_obj
+
+    try:
+        bpy.ops.object.surfacedeform_bind(modifier=mod.name)
+        log(f"Bound Surface Deform on '{mesh_hair_obj.name}' -> '{surface_obj.name}'")
+    except Exception as e:
+        log(f"[WARN] Failed to bind Surface Deform on '{mesh_hair_obj.name}': {e}")
+
+    return mod
+
+
+def apply_surface_deform_or_surface_bind_to_all_hair(surface_obj, hair_objects=None):
+    if hair_objects is None:
+        hair_objects = get_child_hair_objects(surface_obj)
+
+    for obj in hair_objects:
+        if obj.type == 'CURVES':
+            ensure_curve_bound_to_surface(obj, surface_obj)
+            log(f"Rebound curves surface for '{obj.name}'")
+        elif obj.type == 'MESH':
+            add_or_rebind_surface_deform(obj, surface_obj)
+
+    bpy.context.view_layer.update()
+    return hair_objects
+
+
+def refresh_hair_after_shape_change(surface_obj, hair_objects=None):
+    if hair_objects is None:
+        hair_objects = get_child_hair_objects(surface_obj)
+
+    for obj in hair_objects:
+        if obj.type == 'CURVES':
+            ensure_curve_bound_to_surface(obj, surface_obj)
+
+        for mod in obj.modifiers:
+            try:
+                mod.show_viewport = False
+                mod.show_viewport = True
+            except Exception:
+                pass
+
+        obj.update_tag()
+
+    surface_obj.update_tag()
+
+    # Force a full depsgraph evaluation so all curves re-snap
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    depsgraph.update()
+    bpy.context.view_layer.update()
+
+    log(f"Refreshed {len(hair_objects)} hair objects after shape change")
+
+
+def load_hair_scene(
+    obj_path: str,
+    mesh_object_name: str = "DeformedMesh",
+    save_blend_path: str = None,
+    render_filename: str = None,
+):
+    """Load mesh + hair without any deformation applied.
+    Hair is built on the base (undeformed) mesh geometry.
+    """
+    t_start = time.perf_counter()
+    paths = resolve_paths_from_obj(obj_path)
+    scene = bpy.context.scene
+
+    delete_default_cube()
+    setup_cycles_render(scene)
+    log("Selecting random HDR...")
+    hdr_path = pick_random_hdr_image(str(paths["hdr_dir"]))
+
+    log("Setting up world HDR...")
+    setup_world_hdr(str(hdr_path))
+
+    log("Importing mesh...")
+    mesh_obj = import_obj_as_mesh(obj_path, mesh_object_name)
+
+    if not mesh_obj.data.uv_layers:
+        raise RuntimeError("Imported mesh has no UV map. Texture assignment requires UVs.")
+
+    # # Set up camera after mesh is loaded so it can frame the object
+    # ensure_camera(mesh_obj)
+
+    log("Resolving dataset texture...")
+    raw_texture_path = find_texture_for_obj(obj_path, str(paths["textures_dir"]))
+    texture_path = remove_green_screen_from_image(
+        src_image_path=str(raw_texture_path),
+        out_image_path=str(Path(paths["dataset_dir"]) / "textures_processed" / f"{Path(raw_texture_path).stem}_nogreen.png"),
+        green_threshold=0.45,
+        green_margin=0.08,
+    )
+    log(f"Using processed texture: {texture_path}")
+
+    log("Creating mesh material...")
+    mesh_mat = create_mesh_material(
+        mesh_obj=mesh_obj,
+        texture_path=str(texture_path),
+        normal_path=str(paths["mesh_normal"]),
+        roughness_path=str(paths["mesh_roughness"]),
+        material_name=f"{mesh_object_name}_MeshMaterial",
+    )
+
+    log("Creating hair material...")
+    hair_mat = create_hair_material(
+        texture_path=str(texture_path),
+        material_name=f"{mesh_object_name}_HairMaterial",
+    )
+
+    log("Creating underhair...")
+    underhair_obj = create_underhair_if_available(
+        mesh_obj=mesh_obj,
+        mesh_material=mesh_mat,
+        mask_image_path=str(UNDERHAIR_MASK_PATH),
+    )
+
+    # Density and length maps are optional for this visualization pipeline.
+    # Strand positions and lengths are reconstructed directly from the hair map.
+    hair_info = {}
+
+    hair_map_path = str(paths["hair_map"])
+    log(f"Loading UV-local 512 hair map: {hair_map_path}")
+    log(f"Loading global hair meta: {paths['hair_meta']}")
+    group_names, strands_by_group, samples = decode_hair_map(
+        hair_map_path,
+        str(paths["hair_meta"]),
+        mesh_obj,
+    )
+    log(f"  Samples per strand: {samples}")
+
+    created_objects = []
+
+    for group_name in group_names:
+        if any(k in group_name.lower() for k in IGNORE_NAME_KEYWORDS):
+            log(f"  [SKIP] Group '{group_name}' ignored by keyword")
+            continue
+
+        strands = strands_by_group.get(group_name)
+        if strands is None or strands.shape[0] == 0:
+            log(f"  [SKIP] Group '{group_name}' has 0 strands")
+            continue
+
+        log(f"  Processing group: {group_name} ({strands.shape[0]} strands)")
+
+        roots = strands[:, 0, :]
+        root_uvs = compute_root_uvs(roots, mesh_obj)
+
+        curves_obj = build_curve_object_from_strands(
+            sanitize_name(group_name),
+            strands,
+            root_uvs,
+            mesh_obj,
+        )
+        if curves_obj is None:
+            continue
+
+        assign_material(curves_obj, hair_mat)
+
+        log(f"  Setting up modifiers for: {curves_obj.name}")
+        setup_modifiers(curves_obj, group_name, mesh_obj, hair_info)
+
+        created_objects.append(curves_obj)
+
+    if underhair_obj is not None:
+        created_objects.append(underhair_obj)
+
+    loaded_hair_map = str(paths["hair_map_curl_out"])
+    log(f"Loaded hair map from: {loaded_hair_map}")
+
+    if save_blend_path:
+        save_blend_path = str(Path(save_blend_path).resolve())
+        bpy.ops.wm.save_as_mainfile(filepath=save_blend_path)
+        log(f"Saved blend file: {save_blend_path}")
+
+    render_output_path = resolve_render_output_path(obj_path, render_filename=render_filename)
+
+
+    elapsed = time.perf_counter() - t_start
+    log(f"Done. Created {len(created_objects)} curve objects in {elapsed:.2f}s")
+    for obj in created_objects:
+        log(f"  {obj.name}")
+
+    return mesh_obj, created_objects
+
+
+def apply_deformed_shape_key_to_loaded_scene(
+    source_obj_path: str,
+    mesh_obj,
+    hair_objects,
+    deformed_obj_path: str = None,
+    shape_key_name: str = "DeformedShape",
+    shape_key_value: float = 1.0,
+):
+    """Legacy shape-key approach. Hair may not follow correctly for curves
+    objects unless the curves were built on the already-deformed mesh.
+    Prefer load_hair_scene_with_deformed_shape() which deforms first.
+    """
+    deformed_path = resolve_corresponding_deformed_shape_path(
+        source_obj_path,
+        deformed_obj_path=deformed_obj_path,
+    )
+    log(f"Using deformed shape OBJ: {deformed_path}")
+
+    log("Applying surface deform / surface binding to all hair before shape key...")
+    apply_surface_deform_or_surface_bind_to_all_hair(mesh_obj, hair_objects)
+
+    log("Creating shape key from deformed mesh...")
+    sk = import_obj_as_shape_key(mesh_obj, str(deformed_path), shape_key_name)
+    sk.value = float(shape_key_value)
+
+    log("Refreshing hair after shape key update...")
+    refresh_hair_after_shape_change(mesh_obj, hair_objects)
+
+    return sk
+
+
+def load_hair_scene_with_deformed_shape(
+    obj_path: str,
+    mesh_object_name: str = "DeformedMesh",
+    deformed_obj_path: str = None,
+    shape_key_name: str = "DeformedShape",
+    shape_key_value: float = 1.0,
+    save_blend_path: str = None,
+    use_shape_key: bool = False,
+    render_filename: str = None,
+):
+    """Load mesh, apply deformation FIRST, then build all hair on the
+    already-deformed geometry so that hair roots and strands match the
+    deformed surface.
+
+    Args:
+        use_shape_key: If True, use the legacy shape-key approach (hair is
+            built on the base mesh then shape key is applied afterward).
+            If False (default), the deformed vertex positions are written
+            directly into the base mesh before hair is created, so hair
+            is naturally placed on the deformed surface.
+    """
+    if use_shape_key:
+        # --- Legacy path: build hair on base mesh, then apply shape key ---
+        mesh_obj, created_objects = load_hair_scene(
+            obj_path=obj_path,
+            mesh_object_name=mesh_object_name,
+            save_blend_path=None,
+            render_filename=render_filename,
+        )
+
+        sk = apply_deformed_shape_key_to_loaded_scene(
+            source_obj_path=obj_path,
+            mesh_obj=mesh_obj,
+            hair_objects=created_objects,
+            deformed_obj_path=deformed_obj_path,
+            shape_key_name=shape_key_name,
+            shape_key_value=shape_key_value,
+        )
+
+        if save_blend_path:
+            save_blend_path = str(Path(save_blend_path).resolve())
+            bpy.ops.wm.save_as_mainfile(filepath=save_blend_path)
+            log(f"Saved blend file: {save_blend_path}")
+
+        return mesh_obj, created_objects, sk
+
+    # --- New path: deform mesh first, then build hair on deformed geometry ---
+    t_start = time.perf_counter()
+    paths = resolve_paths_from_obj(obj_path)
+    scene = bpy.context.scene
+
+    delete_default_cube()
+    setup_cycles_render(scene)
+    log("Selecting random HDR...")
+    hdr_path = pick_random_hdr_image(str(paths["hdr_dir"]))
+
+    log("Setting up world HDR...")
+    setup_world_hdr(str(hdr_path))
+
+    # Step 1: Import the base mesh
+    log("Importing base mesh...")
+    mesh_obj = import_obj_as_mesh(obj_path, mesh_object_name)
+
+    if not mesh_obj.data.uv_layers:
+        raise RuntimeError("Imported mesh has no UV map. Texture assignment requires UVs.")
+
+    # Step 2: Apply deformed vertex positions directly to the base mesh
+    if deformed_obj_path:
+        deformed_path = resolve_corresponding_deformed_shape_path(
+            obj_path,
+            deformed_obj_path=deformed_obj_path,
+        )
+        log(f"Applying deformed shape directly from: {deformed_path}")
+        apply_deformed_shape_directly(mesh_obj, str(deformed_path))
+        bpy.context.view_layer.update()
+    else:
+        log("No deformed OBJ supplied; using the original mesh geometry")
+
+    # # Set up camera after deformation so it frames the deformed mesh correctly
+    # ensure_camera(mesh_obj)
+
+    # Step 3: Set up materials
+    log("Resolving dataset texture...")
+    raw_texture_path = find_texture_for_obj(obj_path, str(paths["textures_dir"]))
+    texture_path = remove_green_screen_from_image(
+        src_image_path=str(raw_texture_path),
+        out_image_path=str(Path(paths["dataset_dir"]) / "textures_processed" / f"{Path(raw_texture_path).stem}_nogreen.png"),
+        green_threshold=0.45,
+        green_margin=0.08,
+    )
+    log(f"Using processed texture: {texture_path}")
+
+    log("Creating mesh material...")
+    mesh_mat = create_mesh_material(
+        mesh_obj=mesh_obj,
+        texture_path=str(texture_path),
+        normal_path=str(paths["mesh_normal"]),
+        roughness_path=str(paths["mesh_roughness"]),
+        material_name=f"{mesh_object_name}_MeshMaterial",
+    )
+
+    log("Creating hair material...")
+    hair_mat = create_hair_material(
+        texture_path=str(texture_path),
+        material_name=f"{mesh_object_name}_HairMaterial",
+    )
+
+    # Step 4: Create underhair (now on deformed mesh)
+    log("Creating underhair on deformed mesh...")
+    underhair_obj = create_underhair_if_available(
+        mesh_obj=mesh_obj,
+        mesh_material=mesh_mat,
+        mask_image_path=str(UNDERHAIR_MASK_PATH),
+    )
+
+    # Step 5: Load density/length maps
+    # Density and length maps are optional for this visualization pipeline.
+    # Strand positions and lengths are reconstructed directly from the hair map.
+    hair_info = {}
+
+    # Step 6: Decode hair map (reconstructs strand positions on deformed geometry)
+    hair_map_path = str(paths["hair_map"])
+    log(f"Loading UV-local 512 hair map: {hair_map_path}")
+    log(f"Loading global hair meta: {paths['hair_meta']}")
+    group_names, strands_by_group, samples = decode_hair_map(
+        hair_map_path,
+        str(paths["hair_meta"]),
+        mesh_obj,
+    )
+    log(f"  Samples per strand: {samples}")
+
+    # Step 7: Build hair curve objects on deformed mesh
+    created_objects = []
+
+    for group_name in group_names:
+        if any(k in group_name.lower() for k in IGNORE_NAME_KEYWORDS):
+            log(f"  [SKIP] Group '{group_name}' ignored by keyword")
+            continue
+
+        strands = strands_by_group.get(group_name)
+        if strands is None or strands.shape[0] == 0:
+            log(f"  [SKIP] Group '{group_name}' has 0 strands")
+            continue
+
+        log(f"  Processing group: {group_name} ({strands.shape[0]} strands)")
+
+        roots = strands[:, 0, :]
+        root_uvs = compute_root_uvs(roots, mesh_obj)
+
+        curves_obj = build_curve_object_from_strands(
+            sanitize_name(group_name),
+            strands,
+            root_uvs,
+            mesh_obj,
+        )
+        if curves_obj is None:
+            continue
+
+        assign_material(curves_obj, hair_mat)
+
+        log(f"  Setting up modifiers for: {curves_obj.name}")
+        setup_modifiers(curves_obj, group_name, mesh_obj, hair_info)
+
+        created_objects.append(curves_obj)
+
+    if underhair_obj is not None:
+        created_objects.append(underhair_obj)
+
+    loaded_hair_map = str(paths["hair_map_curl_out"])
+    log(f"Loaded hair map from: {loaded_hair_map}")
+
+    if save_blend_path:
+        save_blend_path = str(Path(save_blend_path).resolve())
+        bpy.ops.wm.save_as_mainfile(filepath=save_blend_path)
+        log(f"Saved blend file: {save_blend_path}")
+
+    render_output_path = resolve_render_output_path(obj_path, render_filename=render_filename)
+    # TODO
+    # render_and_save_image(str(render_output_path))
+
+    elapsed = time.perf_counter() - t_start
+    log(f"Done. Created {len(created_objects)} curve objects in {elapsed:.2f}s")
+    for obj in created_objects:
+        log(f"  {obj.name}")
+
+    # No shape key was created in this path, return None for sk
+    return mesh_obj, created_objects, None
+
+
+if __name__ == "__main__":
+    argv = sys.argv
+    user_args = argv[argv.index("--") + 1:] if "--" in argv else []
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--obj_path",
+        type=str,
+        default=None,
+        help=(
+            "OBJ inside <root>/<species>/dataset/<group>/shapes. "
+            "When omitted, a valid case is discovered automatically."
+        ),
+    )
+    parser.add_argument("--species", type=str, default="small_cat")
+    parser.add_argument(
+        "--group_name",
+        type=str,
+        default="groupA_different_breeds_buoumao",
+    )
+    parser.add_argument("--sample_index", type=int, default=3)
+    parser.add_argument("--mesh_object_name", type=str, default="DeformedMesh")
+    parser.add_argument(
+        "--deformed_obj_path",
+        type=str,
+        default=None,
+        help="Optional deformed OBJ. The original mesh is used when omitted.",
+    )
+    parser.add_argument("--shape_key_name", type=str, default="DeformedShape")
+    parser.add_argument("--shape_key_value", type=float, default=1.0)
+    parser.add_argument("--save_blend_path", type=str, default=None)
+    parser.add_argument("--render_filename", type=str, default=None)
+    parser.add_argument(
+        "--use_shape_key",
+        action="store_true",
+        default=False,
+        help="Use legacy shape-key approach instead of direct vertex overwrite",
+    )
+    args = parser.parse_args(user_args)
+
+    if args.obj_path is None:
+        discovered_obj, discovered_deformed = discover_dataset_case(
+            root=ANIMALLIFT_ROOT,
+            species=args.species,
+            group_name=args.group_name,
+            sample_index=args.sample_index,
+        )
+        args.obj_path = str(discovered_obj)
+        if args.deformed_obj_path is None and discovered_deformed is not None:
+            args.deformed_obj_path = str(discovered_deformed)
+
+    print(f"obj_path: {args.obj_path}")
+    print(f"mesh_object_name: {args.mesh_object_name}")
+    print(f"deformed_obj_path: {args.deformed_obj_path}")
+    print(f"shape_key_name: {args.shape_key_name}")
+    print(f"shape_key_value: {args.shape_key_value}")
+    print(f"save_blend_path: {args.save_blend_path}")
+    print(f"render_filename: {args.render_filename}")
+    print(f"use_shape_key: {args.use_shape_key}")
+
+    load_hair_scene_with_deformed_shape(
+        obj_path=args.obj_path,
+        mesh_object_name=args.mesh_object_name,
+        deformed_obj_path=args.deformed_obj_path,
+        shape_key_name=args.shape_key_name,
+        shape_key_value=args.shape_key_value,
+        save_blend_path=args.save_blend_path,
+        use_shape_key=args.use_shape_key,
+    )