Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,52 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/mesh_inpaint_processor.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val/images/01_0_818ac8b7e01b99f90b70.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val/images/03_0_49256f230cfc33e43100.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val/images/04_0_7b88252be613ce946fe4.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val/images/05_0_b250851f3c9169b00a69.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_crop/images/01_0_adea7798f8f45252a73c.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_crop/images/03_0_904944c01f3ae7bbd5f0.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_rot180/images/00_0_a606811f00914a368e75.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_rot180/images/01_0_4dded08813b724931309.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_rot180/images/02_0_ab41c15b1bb8525149c9.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_rot180/images/03_0_659fedbaf33a6c219944.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_rot180/images/04_0_b049d61d3085ba5f13ce.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_rot180/images/05_0_cc7d3bfcb29578a7e53d.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_scale/images/01_0_403bc0d6d88454fc8e84.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135527-ak3g766j/files/media/images/val_scale/images/03_0_ea5147228ff3b0d1b87a.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/train/examples/grid_0_661a5d74ca7dfd67e0b4.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val/images/01_0_2c96edd5ae4a47af8f53.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val/images/03_0_5e7b75cb7860a73cb9d1.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val/images/04_0_abb699ae435cf8b83003.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val/images/05_0_212056244411ef30fddf.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_crop/images/01_0_28ff21fc45bd9c10180a.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_crop/images/03_0_2b30a4f246fdc42315cc.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_rot180/images/00_0_c0472612a8a5d6d1d45a.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_rot180/images/01_0_25e541b74f270bb6fb37.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_rot180/images/02_0_d52eb7d14cbb426697f9.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_rot180/images/03_0_a3e9121765db9014f693.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_rot180/images/04_0_5c43ab551120d3156681.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_rot180/images/05_0_2bdfa81bfae10c494d15.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_scale/images/01_0_027e0601542d52d31398.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/files/media/images/val_scale/images/03_0_64a50028a9bbc978f275.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_135634-urqlwymz/run-urqlwymz.wandb filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/train/examples/grid_0_3e76f9aa156a193517c5.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val/images/00_0_7024f940af3f95bd447f.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val/images/01_0_85da5ed7facb325c1059.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val/images/02_0_5586337d302b720bd290.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val/images/03_0_d8179a4c647bd3e2936a.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val/images/04_0_c79975a8744557d039ea.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val/images/05_0_1bd6ec356b4f77ccd60b.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_crop/images/01_0_681e3f44716ca0c74ce5.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_crop/images/03_0_9bd579ebc1f440a1c78c.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_rot180/images/00_0_b0daad34dff08759d68e.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_rot180/images/01_0_dc0c32e37935a5371ce7.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_rot180/images/02_0_cd238a63711660b82256.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_rot180/images/03_0_18e54e8add02725ae043.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_rot180/images/04_0_bc02825b394e9c404d4d.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_rot180/images/05_0_28a6eacbf019405eb25a.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_scale/images/01_0_920e55b3eed4248203e4.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/files/media/images/val_scale/images/03_0_49e0c325869d63e8686c.png filter=lfs diff=lfs merge=lfs -text
+home/ubuntu/aaaaa/data/rgbmr/outputs/MCVAE_v1.1.0/wandb/run-20251109_143631-069z520z/run-069z520z.wandb filter=lfs diff=lfs merge=lfs -text

home/ubuntu/aaaaa/data/rgbmr/.gitignore

@@ -0,0 +1,46 @@
+# .gitignore for mcgen project
+
+# Training / experiment outputs
+outputs/
+wandb/
+
+# Model / checkpoint files
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+
+# Notebooks
+*.ipynb
+.ipynb_checkpoints/
+
+# Python cache / build
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Numpy array dumps
+*.npy
+*.npz
+
+# Editors / OS noise
+.vscode/
+.idea/
+.DS_Store
+
+# MCGEN stuff
+taming/
+outputs*/
+temp_*/
+metrics_eval/
+metrics_eval_final/
+removethis/
+timing_results/
+metrics_summary.csv

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/MeshRender.py

@@ -0,0 +1,1519 @@
+import cv2
+import torch
+import trimesh
+import numpy as np
+from PIL import Image
+import torch.nn.functional as F
+from typing import Union, Optional, Tuple, List, Any, Callable
+from dataclasses import dataclass
+from enum import Enum
+from .camera_utils import (
+    transform_pos,
+    get_mv_matrix,
+    get_orthographic_projection_matrix,
+    get_perspective_projection_matrix,
+)
+
+try:
+    from .mesh_utils import load_mesh, save_mesh
+except:
+    print("Bpy IO CAN NOT BE Imported!!!")
+
+from .obj_to_glb import obj_to_pbr_glb
+
+try:
+    from .mesh_inpaint_processor import meshVerticeInpaint  # , meshVerticeColor
+except ImportError as e:
+    print("InPaint Function CAN NOT BE Imported!!!")
+
+
+class RenderMode(Enum):
+    """Rendering mode enumeration."""
+
+    NORMAL = "normal"
+    POSITION = "position"
+    ALPHA = "alpha"
+    UV_POS = "uvpos"
+
+
+class ReturnType(Enum):
+    """Return type enumeration."""
+
+    TENSOR = "th"
+    NUMPY = "np"
+    PIL = "pl"
+
+
+class TextureType(Enum):
+    """Texture type enumeration."""
+
+    DIFFUSE = "diffuse"
+    METALLIC_ROUGHNESS = "mr"
+    NORMAL = "normal"
+
+
+@dataclass
+class RenderConfig:
+    """Unified rendering configuration."""
+
+    elev: float = 0
+    azim: float = 0
+    camera_distance: Optional[float] = None
+    center: Optional[List[float]] = None
+    resolution: Optional[Union[int, Tuple[int, int]]] = None
+    bg_color: List[float] = None
+    return_type: str = "th"
+
+    def __post_init__(self):
+        if self.bg_color is None:
+            self.bg_color = [1, 1, 1]
+
+
+@dataclass
+class ViewState:
+    """Camera view state for rendering pipeline."""
+
+    proj_mat: torch.Tensor
+    mv_mat: torch.Tensor
+    pos_camera: torch.Tensor
+    pos_clip: torch.Tensor
+    resolution: Tuple[int, int]
+
+
+def stride_from_shape(shape):
+    """
+    Calculate stride values from a given shape for multi-dimensional indexing.
+
+    Args:
+        shape: Tuple or list representing tensor dimensions
+
+    Returns:
+        List of stride values for each dimension
+    """
+    stride = [1]
+    for x in reversed(shape[1:]):
+        stride.append(stride[-1] * x)
+    return list(reversed(stride))
+
+
+def scatter_add_nd_with_count(input, count, indices, values, weights=None):
+    """
+    Perform scatter-add operation on N-dimensional tensors with counting.
+
+    Args:
+        input: Input tensor [..., C] with D dimensions + C channels
+        count: Count tensor [..., 1] with D dimensions
+        indices: Index tensor [N, D] of type long
+        values: Value tensor [N, C] to scatter
+        weights: Optional weight tensor [N, C], defaults to ones if None
+
+    Returns:
+        Tuple of (updated_input, updated_count) tensors
+    """
+    # input: [..., C], D dimension + C channel
+    # count: [..., 1], D dimension
+    # indices: [N, D], long
+    # values: [N, C]
+
+    D = indices.shape[-1]
+    C = input.shape[-1]
+    size = input.shape[:-1]
+    stride = stride_from_shape(size)
+
+    assert len(size) == D
+
+    input = input.view(-1, C)  # [HW, C]
+    count = count.view(-1, 1)
+
+    flatten_indices = (indices * torch.tensor(stride, dtype=torch.long, device=indices.device)).sum(-1)  # [N]
+
+    if weights is None:
+        weights = torch.ones_like(values[..., :1])
+
+    input.scatter_add_(0, flatten_indices.unsqueeze(1).repeat(1, C), values)
+    count.scatter_add_(0, flatten_indices.unsqueeze(1), weights)
+
+    return input.view(*size, C), count.view(*size, 1)
+
+
+def linear_grid_put_2d(H, W, coords, values, return_count=False):
+    """
+    Place values on a 2D grid using bilinear interpolation.
+
+    Args:
+        H: Grid height
+        W: Grid width
+        coords: Coordinate tensor [N, 2] with values in range [0, 1]
+        values: Value tensor [N, C] to place on grid
+        return_count: Whether to return count information
+
+    Returns:
+        2D grid tensor [H, W, C] with interpolated values, optionally with count tensor
+    """
+    # coords: [N, 2], float in [0, 1]
+    # values: [N, C]
+
+    C = values.shape[-1]
+
+    indices = coords * torch.tensor([H - 1, W - 1], dtype=torch.float32, device=coords.device)
+    indices_00 = indices.floor().long()  # [N, 2]
+    indices_00[:, 0].clamp_(0, H - 2)
+    indices_00[:, 1].clamp_(0, W - 2)
+    indices_01 = indices_00 + torch.tensor([0, 1], dtype=torch.long, device=indices.device)
+    indices_10 = indices_00 + torch.tensor([1, 0], dtype=torch.long, device=indices.device)
+    indices_11 = indices_00 + torch.tensor([1, 1], dtype=torch.long, device=indices.device)
+
+    h = indices[..., 0] - indices_00[..., 0].float()
+    w = indices[..., 1] - indices_00[..., 1].float()
+    w_00 = (1 - h) * (1 - w)
+    w_01 = (1 - h) * w
+    w_10 = h * (1 - w)
+    w_11 = h * w
+
+    result = torch.zeros(H, W, C, device=values.device, dtype=values.dtype)  # [H, W, C]
+    count = torch.zeros(H, W, 1, device=values.device, dtype=values.dtype)  # [H, W, 1]
+    weights = torch.ones_like(values[..., :1])  # [N, 1]
+
+    result, count = scatter_add_nd_with_count(
+        result, count, indices_00, values * w_00.unsqueeze(1), weights * w_00.unsqueeze(1)
+    )
+    result, count = scatter_add_nd_with_count(
+        result, count, indices_01, values * w_01.unsqueeze(1), weights * w_01.unsqueeze(1)
+    )
+    result, count = scatter_add_nd_with_count(
+        result, count, indices_10, values * w_10.unsqueeze(1), weights * w_10.unsqueeze(1)
+    )
+    result, count = scatter_add_nd_with_count(
+        result, count, indices_11, values * w_11.unsqueeze(1), weights * w_11.unsqueeze(1)
+    )
+
+    if return_count:
+        return result, count
+
+    mask = count.squeeze(-1) > 0
+    result[mask] = result[mask] / count[mask].repeat(1, C)
+
+    return result
+
+
+def mipmap_linear_grid_put_2d(H, W, coords, values, min_resolution=128, return_count=False):
+    """
+    Place values on 2D grid using mipmap-based multiresolution interpolation to fill holes.
+
+    Args:
+        H: Grid height
+        W: Grid width
+        coords: Coordinate tensor [N, 2] with values in range [0, 1]
+        values: Value tensor [N, C] to place on grid
+        min_resolution: Minimum resolution for mipmap levels
+        return_count: Whether to return count information
+
+    Returns:
+        2D grid tensor [H, W, C] with filled values, optionally with count tensor
+    """
+    # coords: [N, 2], float in [0, 1]
+    # values: [N, C]
+
+    C = values.shape[-1]
+
+    result = torch.zeros(H, W, C, device=values.device, dtype=values.dtype)  # [H, W, C]
+    count = torch.zeros(H, W, 1, device=values.device, dtype=values.dtype)  # [H, W, 1]
+
+    cur_H, cur_W = H, W
+
+    while min(cur_H, cur_W) > min_resolution:
+
+        # try to fill the holes
+        mask = count.squeeze(-1) == 0
+        if not mask.any():
+            break
+
+        cur_result, cur_count = linear_grid_put_2d(cur_H, cur_W, coords, values, return_count=True)
+        result[mask] = (
+            result[mask]
+            + F.interpolate(
+                cur_result.permute(2, 0, 1).unsqueeze(0).contiguous(), (H, W), mode="bilinear", align_corners=False
+            )
+            .squeeze(0)
+            .permute(1, 2, 0)
+            .contiguous()[mask]
+        )
+        count[mask] = (
+            count[mask]
+            + F.interpolate(cur_count.view(1, 1, cur_H, cur_W), (H, W), mode="bilinear", align_corners=False).view(
+                H, W, 1
+            )[mask]
+        )
+        cur_H //= 2
+        cur_W //= 2
+
+    if return_count:
+        return result, count
+
+    mask = count.squeeze(-1) > 0
+    result[mask] = result[mask] / count[mask].repeat(1, C)
+
+    return result
+
+
+# ============ Core utility functions for reducing duplication ============
+
+
+def _normalize_image_input(image: Union[np.ndarray, torch.Tensor, Image.Image]) -> Union[np.ndarray, torch.Tensor]:
+    """Normalize image input to consistent format."""
+    if isinstance(image, Image.Image):
+        return np.array(image) / 255.0
+    elif isinstance(image, torch.Tensor):
+        return image.cpu().numpy() if image.is_cuda else image
+    return image
+
+
+def _convert_texture_format(
+    tex: Union[np.ndarray, torch.Tensor, Image.Image],
+    texture_size: Tuple[int, int],
+    device: str,
+    force_set: bool = False,
+) -> torch.Tensor:
+    """Unified texture format conversion logic."""
+    if not force_set:
+        if isinstance(tex, np.ndarray):
+            tex = Image.fromarray((tex * 255).astype(np.uint8))
+        elif isinstance(tex, torch.Tensor):
+            tex_np = tex.cpu().numpy()
+            tex = Image.fromarray((tex_np * 255).astype(np.uint8))
+
+        tex = tex.resize(texture_size).convert("RGB")
+        tex = np.array(tex) / 255.0
+        return torch.from_numpy(tex).to(device).float()
+    else:
+        if isinstance(tex, np.ndarray):
+            tex = torch.from_numpy(tex)
+        return tex.to(device).float()
+
+
+def _format_output(image: torch.Tensor, return_type: str) -> Union[torch.Tensor, np.ndarray, Image.Image]:
+    """Convert output to requested format."""
+    if return_type == ReturnType.NUMPY.value:
+        return image.cpu().numpy()
+    elif return_type == ReturnType.PIL.value:
+        img_np = image.cpu().numpy() * 255
+        return Image.fromarray(img_np.astype(np.uint8))
+    return image
+
+
+def _ensure_resolution_format(
+    resolution: Optional[Union[int, Tuple[int, int]]], default: Tuple[int, int]
+) -> Tuple[int, int]:
+    """Ensure resolution is in (height, width) format."""
+    if resolution is None:
+        return default
+    if isinstance(resolution, (int, float)):
+        return (int(resolution), int(resolution))
+    return tuple(resolution)
+
+
+def _apply_background_mask(
+    content: torch.Tensor, visible_mask: torch.Tensor, bg_color: List[float], device: str
+) -> torch.Tensor:
+    """Apply background color to masked regions."""
+    bg_tensor = torch.tensor(bg_color, dtype=torch.float32, device=device)
+    return content * visible_mask + bg_tensor * (1 - visible_mask)
+
+
+class MeshRender:
+    def __init__(
+        self,
+        camera_distance=1.45,
+        camera_type="orth",
+        default_resolution=1024,
+        texture_size=1024,
+        use_antialias=True,
+        max_mip_level=None,
+        filter_mode="linear-mipmap-linear",
+        bake_mode="back_sample",
+        raster_mode="cr",
+        shader_type="face",
+        use_opengl=False,
+        device="cuda",
+    ):
+        """
+        Initialize mesh renderer with configurable parameters.
+
+        Args:
+            camera_distance: Distance from camera to object center
+            camera_type: Type of camera projection ("orth" or "perspective")
+            default_resolution: Default rendering resolution
+            texture_size: Size of texture maps
+            use_antialias: Whether to use antialiasing
+            max_mip_level: Maximum mipmap level for texture filtering
+            filter_mode: Texture filtering mode
+            bake_mode: Texture baking method ("back_sample", "linear", "mip-map")
+            raster_mode: Rasterization backend ("cr" for custom rasterizer)
+            shader_type: Shading type ("face" or "vertex")
+            use_opengl: Whether to use OpenGL backend (deprecated)
+            device: Computing device ("cuda" or "cpu")
+        """
+
+        self.device = device
+
+        self.set_default_render_resolution(default_resolution)
+        self.set_default_texture_resolution(texture_size)
+
+        self.camera_distance = camera_distance
+        self.use_antialias = use_antialias
+        self.max_mip_level = max_mip_level
+        self.filter_mode = filter_mode
+        self.bake_angle_thres = 75
+        self.set_boundary_unreliable_scale(4)
+        self.bake_mode = bake_mode
+        self.shader_type = shader_type
+
+        self.raster_mode = raster_mode
+        if self.raster_mode == "cr":
+            import custom_rasterizer as cr
+
+            self.raster = cr
+        else:
+            raise f"No raster named {self.raster_mode}"
+
+        if camera_type == "orth":
+            self.set_orth_scale(1.1)
+        elif camera_type == "perspective":
+            self.camera_proj_mat = get_perspective_projection_matrix(
+                49.13, self.default_resolution[1] / self.default_resolution[0], 0.01, 100.0
+            )
+        else:
+            raise f"No camera type {camera_type}"
+
+        # Removed multiprocessing components for single-threaded version
+
+    def _create_view_state(self, config: RenderConfig) -> ViewState:
+        """Create unified view state for rendering pipeline."""
+        proj = self.camera_proj_mat
+        r_mv = get_mv_matrix(
+            elev=config.elev,
+            azim=config.azim,
+            camera_distance=self.camera_distance if config.camera_distance is None else config.camera_distance,
+            center=config.center,
+        )
+
+        pos_camera = transform_pos(r_mv, self.vtx_pos, keepdim=True)
+        pos_clip = transform_pos(proj, pos_camera)
+        resolution = _ensure_resolution_format(config.resolution, self.default_resolution)
+
+        return ViewState(proj, r_mv, pos_camera, pos_clip, resolution)
+
+    def _compute_face_normals(self, triangles: torch.Tensor) -> torch.Tensor:
+        """Compute face normals from triangle vertices."""
+        return F.normalize(
+            torch.cross(
+                triangles[:, 1, :] - triangles[:, 0, :],
+                triangles[:, 2, :] - triangles[:, 0, :],
+                dim=-1,
+            ),
+            dim=-1,
+        )
+
+    def _get_normals_for_shading(self, view_state: ViewState, use_abs_coor: bool = False) -> torch.Tensor:
+        """Get normals based on shader type and coordinate system."""
+        if use_abs_coor:
+            mesh_triangles = self.vtx_pos[self.pos_idx[:, :3], :]
+        else:
+            pos_camera = view_state.pos_camera[:, :3] / view_state.pos_camera[:, 3:4]
+            mesh_triangles = pos_camera[self.pos_idx[:, :3], :]
+
+        face_normals = self._compute_face_normals(mesh_triangles)
+
+        # Common rasterization
+        rast_out, _ = self.raster_rasterize(view_state.pos_clip, self.pos_idx, resolution=view_state.resolution)
+
+        if self.shader_type == "vertex":
+            vertex_normals = trimesh.geometry.mean_vertex_normals(
+                vertex_count=self.vtx_pos.shape[0],
+                faces=self.pos_idx.cpu(),
+                face_normals=face_normals.cpu(),
+            )
+            vertex_normals = torch.from_numpy(vertex_normals).float().to(self.device).contiguous()
+            normal, _ = self.raster_interpolate(vertex_normals[None, ...], rast_out, self.pos_idx)
+
+        elif self.shader_type == "face":
+            tri_ids = rast_out[..., 3]
+            tri_ids_mask = tri_ids > 0
+            tri_ids = ((tri_ids - 1) * tri_ids_mask).long()
+            normal = torch.zeros(rast_out.shape[0], rast_out.shape[1], rast_out.shape[2], 3).to(rast_out)
+            normal.reshape(-1, 3)[tri_ids_mask.view(-1)] = face_normals.reshape(-1, 3)[tri_ids[tri_ids_mask].view(-1)]
+
+        return normal, rast_out
+
+    def _unified_render_pipeline(self, config: RenderConfig, mode: RenderMode, **kwargs) -> torch.Tensor:
+        """Unified rendering pipeline for all render modes."""
+        view_state = self._create_view_state(config)
+
+        if mode == RenderMode.ALPHA:
+            rast_out, _ = self.raster_rasterize(view_state.pos_clip, self.pos_idx, resolution=view_state.resolution)
+            return rast_out[..., -1:].long()
+
+        elif mode == RenderMode.UV_POS:
+            return self.uv_feature_map(self.vtx_pos * 0.5 + 0.5)
+
+        elif mode == RenderMode.NORMAL:
+            use_abs_coor = kwargs.get("use_abs_coor", False)
+            normalize_rgb = kwargs.get("normalize_rgb", True)
+
+            normal, rast_out = self._get_normals_for_shading(view_state, use_abs_coor)
+            visible_mask = torch.clamp(rast_out[..., -1:], 0, 1)
+
+            result = _apply_background_mask(normal, visible_mask, config.bg_color, self.device)
+
+            if normalize_rgb:
+                result = (result + 1) * 0.5
+
+            if self.use_antialias:
+                result = self.raster_antialias(result, rast_out, view_state.pos_clip, self.pos_idx)
+
+            return result[0, ...]
+
+        elif mode == RenderMode.POSITION:
+            rast_out, _ = self.raster_rasterize(view_state.pos_clip, self.pos_idx, resolution=view_state.resolution)
+
+            tex_position = 0.5 - self.vtx_pos[:, :3] / self.scale_factor
+            tex_position = tex_position.contiguous()
+
+            position, _ = self.raster_interpolate(tex_position[None, ...], rast_out, self.pos_idx)
+            visible_mask = torch.clamp(rast_out[..., -1:], 0, 1)
+
+            result = _apply_background_mask(position, visible_mask, config.bg_color, self.device)
+
+            if self.use_antialias:
+                result = self.raster_antialias(result, rast_out, view_state.pos_clip, self.pos_idx)
+
+            return result[0, ...]
+
+    def set_orth_scale(self, ortho_scale):
+        """
+        Set the orthographic projection scale and update camera projection matrix.
+
+        Args:
+            ortho_scale: Scale factor for orthographic projection
+        """
+        self.ortho_scale = ortho_scale
+        self.camera_proj_mat = get_orthographic_projection_matrix(
+            left=-self.ortho_scale * 0.5,
+            right=self.ortho_scale * 0.5,
+            bottom=-self.ortho_scale * 0.5,
+            top=self.ortho_scale * 0.5,
+            near=0.1,
+            far=100,
+        )
+
+    def raster_rasterize(self, pos, tri, resolution, ranges=None, grad_db=True):
+        """
+        Rasterize triangular mesh using the configured rasterization backend.
+
+        Args:
+            pos: Vertex positions in clip space
+            tri: Triangle indices
+            resolution: Rendering resolution [height, width]
+            ranges: Optional rendering ranges (unused in current implementation)
+            grad_db: Whether to compute gradients (unused in current implementation)
+
+        Returns:
+            Tuple of (rasterization_output, gradient_info)
+        """
+
+        if self.raster_mode == "cr":
+            rast_out_db = None
+            if pos.dim() == 2:
+                pos = pos.unsqueeze(0)
+
+            # 确保pos是float32类型
+            if pos.dtype == torch.float64:
+                pos = pos.to(torch.float32)
+
+            # 确保tri是int32类型
+            if tri.dtype == torch.int64:
+                tri = tri.to(torch.int32)
+
+            findices, barycentric = self.raster.rasterize(pos, tri, resolution)
+            rast_out = torch.cat((barycentric, findices.unsqueeze(-1)), dim=-1)
+            rast_out = rast_out.unsqueeze(0)
+        else:
+            raise f"No raster named {self.raster_mode}"
+
+        return rast_out, rast_out_db
+
+    def raster_interpolate(self, uv, rast_out, uv_idx):
+        """
+        Interpolate texture coordinates or vertex attributes across rasterized triangles.
+
+        Args:
+            uv: UV coordinates or vertex attributes to interpolate
+            rast_out: Rasterization output containing barycentric coordinates
+            uv_idx: UV or vertex indices for triangles
+
+        Returns:
+            Tuple of (interpolated_values, gradient_info)
+        """
+
+        if self.raster_mode == "cr":
+            textd = None
+            barycentric = rast_out[0, ..., :-1]
+            findices = rast_out[0, ..., -1]
+            if uv.dim() == 2:
+                uv = uv.unsqueeze(0)
+            textc = self.raster.interpolate(uv, findices, barycentric, uv_idx)
+        else:
+            raise f"No raster named {self.raster_mode}"
+
+        return textc, textd
+
+    def raster_antialias(self, color, rast, pos, tri, topology_hash=None, pos_gradient_boost=1.0):
+        """
+        Apply antialiasing to rendered colors (currently returns input unchanged).
+
+        Args:
+            color: Input color values
+            rast: Rasterization output
+            pos: Vertex positions
+            tri: Triangle indices
+            topology_hash: Optional topology hash for optimization
+            pos_gradient_boost: Gradient boosting factor
+
+        Returns:
+            Antialiased color values
+        """
+
+        if self.raster_mode == "cr":
+            color = color
+        else:
+            raise f"No raster named {self.raster_mode}"
+
+        return color
+
+    def set_boundary_unreliable_scale(self, scale):
+        """
+        Set the kernel size for boundary unreliable region detection during texture baking.
+
+        Args:
+            scale: Scale factor relative to 512 resolution baseline
+        """
+        self.bake_unreliable_kernel_size = int(
+            (scale / 512) * max(self.default_resolution[0], self.default_resolution[1])
+        )
+
+    def load_mesh(
+        self,
+        mesh,
+        scale_factor=1.0,
+        auto_center=True,
+    ):
+        """
+        Load mesh from file and set up rendering data structures.
+
+        Args:
+            mesh: Path to mesh file or mesh object
+            scale_factor: Scaling factor for mesh normalization
+            auto_center: Whether to automatically center the mesh
+        """
+        vtx_pos, pos_idx, vtx_uv, uv_idx, texture_data = load_mesh(mesh)
+        self.set_mesh(
+            vtx_pos, pos_idx, vtx_uv=vtx_uv, uv_idx=uv_idx, scale_factor=scale_factor, auto_center=auto_center
+        )
+        if texture_data is not None:
+            self.set_texture(texture_data)
+
+    def save_mesh(self, mesh_path, downsample=False):
+        """
+        Save current mesh with textures to GLB file.
+
+        Args:
+            mesh_path: Output file path (will be saved as .glb)
+            downsample: Whether to downsample textures by half
+        """
+        # Ensure the output path has .glb extension
+        if not mesh_path.endswith('.glb'):
+            mesh_path = mesh_path.rsplit('.', 1)[0] + '.glb'
+
+        # Get mesh geometry
+        vtx_pos, pos_idx, vtx_uv, uv_idx = self.get_mesh(normalize=False)
+        
+        # Get textures
+        texture_data = self.get_texture()  # [H, W, 3], numpy array in [0, 1]
+        texture_metallic, texture_roughness = self.get_texture_mr()  # each [H, W, 3] or None
+        
+        # Downsample if requested
+        if downsample:
+            texture_data = cv2.resize(texture_data, (texture_data.shape[1] // 2, texture_data.shape[0] // 2))
+            if texture_metallic is not None:
+                texture_metallic = cv2.resize(
+                    texture_metallic, (texture_metallic.shape[1] // 2, texture_metallic.shape[0] // 2)
+                )
+            if texture_roughness is not None:
+                texture_roughness = cv2.resize(
+                    texture_roughness, (texture_roughness.shape[1] // 2, texture_roughness.shape[0] // 2)
+                )
+        
+        # Convert texture_data from [0, 1] float to [0, 255] uint8 for PIL
+        albedo_uint8 = (np.clip(texture_data, 0, 1) * 255).astype(np.uint8)
+        albedo_pil = Image.fromarray(albedo_uint8, mode='RGB')
+        
+        # Create ORM texture (Occlusion, Roughness, Metallic)
+        # glTF standard: R=unused/occlusion, G=roughness, B=metallic
+        orm_pil = None
+        if texture_metallic is not None and texture_roughness is not None:
+            # Extract single channel from the repeated 3-channel textures
+            # texture_metallic and texture_roughness are [H, W, 3] with repeated channels
+            roughness_channel = (np.clip(texture_roughness[:, :, 0], 0, 1) * 255).astype(np.uint8)
+            metallic_channel = (np.clip(texture_metallic[:, :, 0], 0, 1) * 255).astype(np.uint8)
+            
+            # Create ORM image: R=1 (full occlusion/unused), G=roughness, B=metallic
+            h, w = roughness_channel.shape
+            orm_array = np.ones((h, w, 3), dtype=np.uint8) * 255
+            orm_array[:, :, 1] = roughness_channel  # G channel = roughness
+            orm_array[:, :, 2] = metallic_channel   # B channel = metallic
+            
+            orm_pil = Image.fromarray(orm_array, mode='RGB')
+        
+        # Create trimesh object
+        # Note: trimesh expects vertices and faces, UV data will be set via visual
+        mesh = trimesh.Trimesh(
+            vertices=vtx_pos,
+            faces=pos_idx,
+            process=False  # Don't process to preserve UV mapping
+        )
+        
+        # Set UV coordinates
+        # trimesh uses per-vertex UVs, but we have per-face-vertex UVs
+        # We need to create a TextureVisuals object
+        if vtx_uv is not None and uv_idx is not None:
+            # Check if UV indices match position indices (simple case)
+            if np.array_equal(uv_idx, pos_idx):
+                # Simple case: per-vertex UVs
+                mesh.visual = trimesh.visual.TextureVisuals(uv=vtx_uv)
+            else:
+                # Complex case: need to expand vertices to match UV mapping
+                # Create new vertices where each face corner gets its own vertex
+                new_vertices = vtx_pos[pos_idx.flatten()]
+                new_uvs = vtx_uv[uv_idx.flatten()]
+                new_faces = np.arange(len(pos_idx) * 3).reshape(-1, 3)
+                
+                mesh = trimesh.Trimesh(
+                    vertices=new_vertices,
+                    faces=new_faces,
+                    process=False
+                )
+                mesh.visual = trimesh.visual.TextureVisuals(uv=new_uvs)
+        
+        # Use obj_to_pbr_glb to save as GLB
+        if obj_to_pbr_glb is not None:
+            obj_to_pbr_glb(
+                obj_path_or_mesh=mesh,
+                base_color_path=albedo_pil,
+                orm_path=orm_pil,
+                output_glb_path=mesh_path,
+                flip_uv=False,
+                center=False,
+                scale_to_unit=False,
+            )
+        else:
+            # Fallback to old method if obj_to_pbr_glb is not available
+            print("Warning: obj_to_pbr_glb not available, falling back to OBJ export")
+            texture_normal = self.get_texture_normal()
+            if downsample and texture_normal is not None:
+                texture_normal = cv2.resize(
+                    texture_normal, (texture_normal.shape[1] // 2, texture_normal.shape[0] // 2)
+                )
+            save_mesh(
+                mesh_path.replace('.glb', '.obj'),
+                vtx_pos,
+                pos_idx,
+                vtx_uv,
+                uv_idx,
+                texture_data,
+                metallic=texture_metallic,
+                roughness=texture_roughness,
+                normal=texture_normal,
+            )
+
+    def set_mesh(self, vtx_pos, pos_idx, vtx_uv=None, uv_idx=None, scale_factor=1.0, auto_center=True):
+        """
+        Set mesh geometry data and perform coordinate transformations.
+
+        Args:
+            vtx_pos: Vertex positions [N, 3]
+            pos_idx: Triangle vertex indices [F, 3]
+            vtx_uv: UV coordinates [N, 2], optional
+            uv_idx: Triangle UV indices [F, 3], optional
+            scale_factor: Scaling factor for mesh normalization
+            auto_center: Whether to automatically center and scale the mesh
+        """
+        self.vtx_pos = torch.from_numpy(vtx_pos).to(self.device)
+        self.pos_idx = torch.from_numpy(pos_idx).to(self.device)
+
+        # 确保顶点位置是float32类型
+        if self.vtx_pos.dtype == torch.float64:
+            self.vtx_pos = self.vtx_pos.to(torch.float32)
+
+        # 确保索引类型为int32
+        if self.pos_idx.dtype == torch.int64:
+            self.pos_idx = self.pos_idx.to(torch.int32)
+
+        if (vtx_uv is not None) and (uv_idx is not None):
+            self.vtx_uv = torch.from_numpy(vtx_uv).to(self.device)
+            self.uv_idx = torch.from_numpy(uv_idx).to(self.device)
+
+            # 确保UV坐标是float32类型
+            if self.vtx_uv.dtype == torch.float64:
+                self.vtx_uv = self.vtx_uv.to(torch.float32)
+
+            # 确保UV索引类型为int32
+            if self.uv_idx.dtype == torch.int64:
+                self.uv_idx = self.uv_idx.to(torch.int32)
+        else:
+            self.vtx_uv = None
+            self.uv_idx = None
+
+        self.vtx_pos[:, [0, 1]] = -self.vtx_pos[:, [0, 1]]
+        self.vtx_pos[:, [1, 2]] = self.vtx_pos[:, [2, 1]]
+        # if (vtx_uv is not None) and (uv_idx is not None):
+        #     self.vtx_uv[:, 1] = 1.0 - self.vtx_uv[:, 1]
+        #     pass
+
+        if auto_center:
+            # Calculate bounding box center (equivalent to mesh.bounds.mean(axis=0))
+            max_bb = self.vtx_pos.max(0)[0]
+            min_bb = self.vtx_pos.min(0)[0]
+            bbox_center = (max_bb + min_bb) / 2
+            
+            # Move to center (equivalent to: mesh.vertices -= bbox_center)
+            self.vtx_pos = self.vtx_pos - bbox_center
+            transform_offset = bbox_center
+            
+            # Rescale (equivalent to: max_scale = np.abs(mesh.vertices).max())
+            max_scale = torch.abs(self.vtx_pos).max()
+            if max_scale > 0:
+                transform_scale = max_scale / scale_factor * 2
+                self.vtx_pos = self.vtx_pos / transform_scale
+            else:
+                transform_scale = torch.tensor(1.0, device=self.device)
+            
+            # Store transformation parameters for inverse operation
+            self.scale_factor = scale_factor
+            self.mesh_normalize_scale_factor = float(transform_scale)
+            self.mesh_normalize_scale_center = transform_offset.unsqueeze(0).cpu().numpy()
+        else:
+            self.scale_factor = 1.0
+            self.mesh_normalize_scale_factor = 1.0
+            self.mesh_normalize_scale_center = np.array([[0, 0, 0]])
+
+        if uv_idx is not None:
+            self.extract_textiles()
+
+    def _set_texture_unified(
+        self, tex: Union[np.ndarray, torch.Tensor, Image.Image], texture_type: TextureType, force_set: bool = False
+    ):
+        """Unified texture setting method."""
+        converted_tex = _convert_texture_format(tex, self.texture_size, self.device, force_set)
+
+        if texture_type == TextureType.DIFFUSE:
+            self.tex = converted_tex
+        elif texture_type == TextureType.METALLIC_ROUGHNESS:
+            self.tex_mr = converted_tex
+        elif texture_type == TextureType.NORMAL:
+            self.tex_normalMap = converted_tex
+
+    def set_texture(self, tex, force_set=False):
+        """Set the main diffuse texture for the mesh."""
+        self._set_texture_unified(tex, TextureType.DIFFUSE, force_set)
+
+    def set_texture_mr(self, mr, force_set=False):
+        """Set metallic-roughness texture for PBR rendering."""
+        self._set_texture_unified(mr, TextureType.METALLIC_ROUGHNESS, force_set)
+
+    def set_texture_normal(self, normal, force_set=False):
+        """Set normal map texture for surface detail."""
+        self._set_texture_unified(normal, TextureType.NORMAL, force_set)
+
+    def set_default_render_resolution(self, default_resolution):
+        """
+        Set the default resolution for rendering operations.
+
+        Args:
+            default_resolution: Resolution as int (square) or tuple (height, width)
+        """
+        if isinstance(default_resolution, int):
+            default_resolution = (default_resolution, default_resolution)
+        self.default_resolution = default_resolution
+
+    def set_default_texture_resolution(self, texture_size):
+        """
+        Set the default texture resolution for UV mapping operations.
+
+        Args:
+            texture_size: Texture size as int (square) or tuple (height, width)
+        """
+        if isinstance(texture_size, int):
+            texture_size = (texture_size, texture_size)
+        self.texture_size = texture_size
+
+    def get_face_num(self):
+        """
+        Get the number of triangular faces in the mesh.
+
+        Returns:
+            Number of faces as integer
+        """
+        return self.pos_idx.shape[0]
+
+    def get_vertex_num(self):
+        """
+        Get the number of vertices in the mesh.
+
+        Returns:
+            Number of vertices as integer
+        """
+        return self.vtx_pos.shape[0]
+
+    def get_face_areas(self, from_one_index=False):
+        """
+        Calculate the area of each triangular face in the mesh.
+
+        Args:
+            from_one_index: If True, insert zero at beginning for 1-indexed face IDs
+
+        Returns:
+            Numpy array of face areas
+        """
+        v0 = self.vtx_pos[self.pos_idx[:, 0], :]
+        v1 = self.vtx_pos[self.pos_idx[:, 1], :]
+        v2 = self.vtx_pos[self.pos_idx[:, 2], :]
+
+        # 计算两个边向量
+        edge1 = v1 - v0
+        edge2 = v2 - v0
+
+        # 计算叉积的模长的一半即为面积
+        areas = torch.norm(torch.cross(edge1, edge2, dim=-1), dim=-1) * 0.5
+
+        areas = areas.cpu().numpy()
+
+        if from_one_index:
+            # 在数组前面插入一个0,因为三角片索引是从1开始的
+            areas = np.insert(areas, 0, 0)
+
+        return areas
+
+    def get_mesh(self, normalize=True):
+        """
+        Get mesh geometry with optional coordinate denormalization.
+
+        Args:
+            normalize: Whether to keep normalized coordinates (True) or restore original scale (False)
+
+        Returns:
+            Tuple of (vertex_positions, face_indices, uv_coordinates, uv_indices)
+        """
+        vtx_pos = self.vtx_pos.cpu().numpy()
+        pos_idx = self.pos_idx.cpu().numpy()
+        vtx_uv = self.vtx_uv.cpu().numpy()
+        uv_idx = self.uv_idx.cpu().numpy()
+
+        # 坐标变换的逆变换
+        if not normalize:
+            vtx_pos = vtx_pos / self.mesh_normalize_scale_factor
+            vtx_pos = vtx_pos + self.mesh_normalize_scale_center
+        vtx_pos[:, [1, 2]] = vtx_pos[:, [2, 1]]
+        vtx_pos[:, [0, 1]] = -vtx_pos[:, [0, 1]]
+
+        # vtx_uv[:, 1] = 1.0 - vtx_uv[:, 1]
+        return vtx_pos, pos_idx, vtx_uv, uv_idx
+
+    def get_texture(self):
+        """
+        Get the current diffuse texture as numpy array.
+
+        Returns:
+            Texture as numpy array in range [0, 1]
+        """
+        return self.tex.cpu().numpy()
+
+    def get_texture_mr(self):
+        """
+        Get metallic and roughness textures as separate channels.
+
+        Returns:
+            Tuple of (metallic_texture, roughness_texture) as numpy arrays, or (None, None) if not set
+        """
+        metallic, roughness = None, None
+        if hasattr(self, "tex_mr"):
+            mr = self.tex_mr.cpu().numpy()
+            metallic = np.repeat(mr[:, :, 2:3], repeats=3, axis=2)
+            roughness = np.repeat(mr[:, :, 1:2], repeats=3, axis=2)
+        return metallic, roughness
+
+    def get_texture_normal(self):
+        """
+        Get the normal map texture as numpy array.
+
+        Returns:
+            Normal map as numpy array, or None if not set
+        """
+        normal = None
+        if hasattr(self, "tex_normalMap"):
+            normal = self.tex_normalMap.cpu().numpy()
+        return normal
+
+    def to(self, device):
+        """
+        Move all tensor attributes to the specified device.
+
+        Args:
+            device: Target device ("cuda", "cpu", etc.)
+        """
+        self.device = device
+
+        for attr_name in dir(self):
+            attr_value = getattr(self, attr_name)
+            if isinstance(attr_value, torch.Tensor):
+                setattr(self, attr_name, attr_value.to(self.device))
+
+    def color_rgb_to_srgb(self, image):
+        """
+        Convert RGB color values to sRGB color space using gamma correction.
+
+        Args:
+            image: Input image as PIL Image, numpy array, or torch tensor
+
+        Returns:
+            sRGB corrected image in same format as input
+        """
+        if isinstance(image, Image.Image):
+            image_rgb = torch.tesnor(np.array(image) / 255.0).float().to(self.device)
+        elif isinstance(image, np.ndarray):
+            image_rgb = torch.tensor(image).float()
+        else:
+            image_rgb = image.to(self.device)
+
+        image_srgb = torch.where(
+            image_rgb <= 0.0031308, 12.92 * image_rgb, 1.055 * torch.pow(image_rgb, 1 / 2.4) - 0.055
+        )
+
+        if isinstance(image, Image.Image):
+            image_srgb = Image.fromarray((image_srgb.cpu().numpy() * 255).astype(np.uint8))
+        elif isinstance(image, np.ndarray):
+            image_srgb = image_srgb.cpu().numpy()
+        else:
+            image_srgb = image_srgb.to(image.device)
+
+        return image_srgb
+
+    def extract_textiles(self):
+        """
+        Extract texture-space position and normal information by rasterizing
+        the mesh in UV coordinate space. Creates texture-space geometry mappings.
+        """
+
+        vnum = self.vtx_uv.shape[0]
+        vtx_uv = torch.cat(
+            (self.vtx_uv, torch.zeros_like(self.vtx_uv[:, 0:1]), torch.ones_like(self.vtx_uv[:, 0:1])), axis=1
+        )
+        vtx_uv = vtx_uv.view(1, vnum, 4) * 2 - 1
+
+        rast_out, rast_out_db = self.raster_rasterize(vtx_uv, self.uv_idx, resolution=self.texture_size)
+        position, _ = self.raster_interpolate(self.vtx_pos, rast_out, self.pos_idx)
+
+        v0 = self.vtx_pos[self.pos_idx[:, 0], :]
+        v1 = self.vtx_pos[self.pos_idx[:, 1], :]
+        v2 = self.vtx_pos[self.pos_idx[:, 2], :]
+        face_normals = F.normalize(torch.cross(v1 - v0, v2 - v0, dim=-1), dim=-1)
+        vertex_normals = trimesh.geometry.mean_vertex_normals(
+            vertex_count=self.vtx_pos.shape[0],
+            faces=self.pos_idx.cpu(),
+            face_normals=face_normals.cpu(),
+        )
+        vertex_normals = torch.from_numpy(vertex_normals).to(self.vtx_pos).contiguous()
+        position_normal, _ = self.raster_interpolate(vertex_normals[None, ...], rast_out, self.pos_idx)
+        visible_mask = torch.clamp(rast_out[..., -1:], 0, 1)[0, ..., 0]
+        position = position[0]
+        position_normal = position_normal[0]
+        tri_ids = rast_out[0, ..., 3]
+        tri_ids_mask = tri_ids > 0
+        tri_ids = ((tri_ids - 1) * tri_ids_mask).long()
+        position_normal.reshape(-1, 3)[tri_ids_mask.view(-1)] = face_normals.reshape(-1, 3)[
+            tri_ids[tri_ids_mask].view(-1)
+        ]
+
+        row = torch.arange(position.shape[0]).to(visible_mask.device)
+        col = torch.arange(position.shape[1]).to(visible_mask.device)
+        grid_i, grid_j = torch.meshgrid(row, col, indexing="ij")
+
+        mask = visible_mask.reshape(-1) > 0
+        position = position.reshape(-1, 3)[mask]
+        position_normal = position_normal.reshape(-1, 3)[mask]
+        position = torch.cat((position, torch.ones_like(position[:, :1])), axis=-1)
+        grid = torch.stack((grid_i, grid_j), -1).reshape(-1, 2)[mask]
+
+        texture_indices = (
+            torch.ones(self.texture_size[0], self.texture_size[1], device=self.device, dtype=torch.long) * -1
+        )
+        texture_indices.view(-1)[grid[:, 0] * self.texture_size[1] + grid[:, 1]] = torch.arange(grid.shape[0]).to(
+            device=self.device, dtype=torch.long
+        )
+
+        self.tex_position = position
+        self.tex_normal = position_normal
+        self.tex_grid = grid
+        self.texture_indices = texture_indices
+
+    def render_normal(
+        self,
+        elev,
+        azim,
+        camera_distance=None,
+        center=None,
+        resolution=None,
+        bg_color=[1, 1, 1],
+        use_abs_coor=False,
+        normalize_rgb=True,
+        return_type="th",
+    ):
+        """Render surface normals of the mesh from specified viewpoint."""
+        config = RenderConfig(elev, azim, camera_distance, center, resolution, bg_color, return_type)
+        image = self._unified_render_pipeline(
+            config, RenderMode.NORMAL, use_abs_coor=use_abs_coor, normalize_rgb=normalize_rgb
+        )
+        return _format_output(image, return_type)
+
+    def convert_normal_map(self, image):
+        """
+        Convert normal map from standard format to renderer's coordinate system.
+        Applies coordinate transformations for proper normal interpretation.
+
+        Args:
+            image: Input normal map as PIL Image or numpy array
+
+        Returns:
+            Converted normal map as PIL Image
+        """
+        # blue is front, red is left, green is top
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+        mask = (image == [255, 255, 255]).all(axis=-1)
+
+        image = (image / 255.0) * 2.0 - 1.0
+
+        image[..., [1]] = -image[..., [1]]
+        image[..., [1, 2]] = image[..., [2, 1]]
+        image[..., [0]] = -image[..., [0]]
+
+        image = (image + 1.0) * 0.5
+
+        image = (image * 255).astype(np.uint8)
+        image[mask] = [127, 127, 255]
+
+        return Image.fromarray(image)
+
+    def render_position(
+        self, elev, azim, camera_distance=None, center=None, resolution=None, bg_color=[1, 1, 1], return_type="th"
+    ):
+        """Render world-space positions of visible mesh surface points."""
+        config = RenderConfig(elev, azim, camera_distance, center, resolution, bg_color, return_type)
+        image = self._unified_render_pipeline(config, RenderMode.POSITION)
+
+        if return_type == ReturnType.PIL.value:
+            image = image.squeeze(-1).cpu().numpy() * 255
+            return Image.fromarray(image.astype(np.uint8))
+        return _format_output(image, return_type)
+
+    def render_uvpos(self, return_type="th"):
+        """Render vertex positions mapped to UV texture space."""
+        config = RenderConfig(return_type=return_type)
+        image = self._unified_render_pipeline(config, RenderMode.UV_POS)
+        return _format_output(image, return_type)
+
+    def render_alpha(self, elev, azim, camera_distance=None, center=None, resolution=None, return_type="th"):
+        """Render binary alpha mask indicating visible mesh regions."""
+        config = RenderConfig(elev, azim, camera_distance, center, resolution, return_type=return_type)
+        image = self._unified_render_pipeline(config, RenderMode.ALPHA)
+
+        if return_type == ReturnType.PIL.value:
+            raise Exception("PIL format not supported for alpha rendering")
+        return _format_output(image, return_type)
+
+    def uv_feature_map(self, vert_feat, bg=None):
+        """
+        Map per-vertex features to UV texture space using mesh topology.
+
+        Args:
+            vert_feat: Per-vertex feature tensor [N, C]
+            bg: Background value for unmapped regions (optional)
+
+        Returns:
+            Feature map in UV texture space [H, W, C]
+        """
+        vtx_uv = self.vtx_uv * 2 - 1.0
+        vtx_uv = torch.cat([vtx_uv, torch.zeros_like(self.vtx_uv)], dim=1).unsqueeze(0)
+        vtx_uv[..., -1] = 1
+        uv_idx = self.uv_idx
+        rast_out, rast_out_db = self.raster_rasterize(vtx_uv, uv_idx, resolution=self.texture_size)
+        feat_map, _ = self.raster_interpolate(vert_feat[None, ...], rast_out, uv_idx)
+        feat_map = feat_map[0, ...]
+        if bg is not None:
+            visible_mask = torch.clamp(rast_out[..., -1:], 0, 1)[0, ...]
+            feat_map[visible_mask == 0] = bg
+        return feat_map
+
+    def render_sketch_from_geometry(self, normal_image, depth_image):
+        """
+        Generate sketch-style edge image from rendered normal and depth maps.
+
+        Args:
+            normal_image: Rendered normal map tensor
+            depth_image: Rendered depth map tensor
+
+        Returns:
+            Binary edge sketch image as tensor
+        """
+        normal_image_np = normal_image.cpu().numpy()
+        depth_image_np = depth_image.cpu().numpy()
+
+        normal_image_np = (normal_image_np * 255).astype(np.uint8)
+        depth_image_np = (depth_image_np * 255).astype(np.uint8)
+        normal_image_np = cv2.cvtColor(normal_image_np, cv2.COLOR_RGB2GRAY)
+
+        normal_edges = cv2.Canny(normal_image_np, 80, 150)
+        depth_edges = cv2.Canny(depth_image_np, 30, 80)
+
+        combined_edges = np.maximum(normal_edges, depth_edges)
+
+        sketch_image = torch.from_numpy(combined_edges).to(normal_image.device).float() / 255.0
+        sketch_image = sketch_image.unsqueeze(-1)
+
+        return sketch_image
+
+    def render_sketch_from_depth(self, depth_image):
+        """
+        Generate sketch-style edge image from depth map using edge detection.
+
+        Args:
+            depth_image: Input depth map tensor
+
+        Returns:
+            Binary edge sketch image as tensor
+        """
+        depth_image_np = depth_image.cpu().numpy()
+        depth_image_np = (depth_image_np * 255).astype(np.uint8)
+        depth_edges = cv2.Canny(depth_image_np, 30, 80)
+        combined_edges = depth_edges
+        sketch_image = torch.from_numpy(combined_edges).to(depth_image.device).float() / 255.0
+        sketch_image = sketch_image.unsqueeze(-1)
+        return sketch_image
+
+    def back_project(self, image, elev, azim, camera_distance=None, center=None, method=None):
+        """
+        Back-project a rendered image onto the mesh's UV texture space.
+        Handles visibility, viewing angle, and boundary detection for texture baking.
+
+        Args:
+            image: Input image to back-project (PIL Image, numpy array, or tensor)
+            elev: Camera elevation angle in degrees used for rendering
+            azim: Camera azimuth angle in degrees used for rendering
+            camera_distance: Camera distance (uses default if None)
+            center: Camera focus center (uses origin if None)
+            method: Back-projection method ("linear", "mip-map", "back_sample", uses default if None)
+
+        Returns:
+            Tuple of (texture, cosine_map, boundary_map) tensors in UV space
+        """
+
+        if isinstance(image, Image.Image):
+            image = torch.tensor(np.array(image) / 255.0)
+        elif isinstance(image, np.ndarray):
+            image = torch.tensor(image)
+        if image.dim() == 2:
+            image = image.unsqueeze(-1)
+        image = image.float().to(self.device)
+        resolution = image.shape[:2]
+        channel = image.shape[-1]
+        texture = torch.zeros(self.texture_size + (channel,)).to(self.device)
+        cos_map = torch.zeros(self.texture_size + (1,)).to(self.device)
+
+        proj = self.camera_proj_mat
+        r_mv = get_mv_matrix(
+            elev=elev,
+            azim=azim,
+            camera_distance=self.camera_distance if camera_distance is None else camera_distance,
+            center=center,
+        )
+        pos_camera = transform_pos(r_mv, self.vtx_pos, keepdim=True)
+        pos_clip = transform_pos(proj, pos_camera)
+        pos_camera = pos_camera[:, :3] / pos_camera[:, 3:4]
+
+        v0 = pos_camera[self.pos_idx[:, 0], :]
+        v1 = pos_camera[self.pos_idx[:, 1], :]
+        v2 = pos_camera[self.pos_idx[:, 2], :]
+        face_normals = F.normalize(torch.cross(v1 - v0, v2 - v0, dim=-1), dim=-1)
+
+        tex_depth = pos_camera[:, 2].reshape(1, -1, 1).contiguous()
+        rast_out, rast_out_db = self.raster_rasterize(pos_clip, self.pos_idx, resolution=resolution)
+        visible_mask = torch.clamp(rast_out[..., -1:], 0, 1)[0, ...]
+
+        if self.shader_type == "vertex":
+            vertex_normals = trimesh.geometry.mean_vertex_normals(
+                vertex_count=self.vtx_pos.shape[0],
+                faces=self.pos_idx.cpu(),
+                face_normals=face_normals.cpu(),
+            )
+            vertex_normals = torch.from_numpy(vertex_normals).float().to(self.device).contiguous()
+            normal, _ = self.raster_interpolate(vertex_normals[None, ...], rast_out, self.pos_idx)
+        elif self.shader_type == "face":
+            tri_ids = rast_out[..., 3]
+            tri_ids_mask = tri_ids > 0
+            tri_ids = ((tri_ids - 1) * tri_ids_mask).long()
+            normal = torch.zeros(rast_out.shape[0], rast_out.shape[1], rast_out.shape[2], 3).to(rast_out)
+            normal.reshape(-1, 3)[tri_ids_mask.view(-1)] = face_normals.reshape(-1, 3)[tri_ids[tri_ids_mask].view(-1)]
+
+        normal = normal[0, ...]
+        uv, _ = self.raster_interpolate(self.vtx_uv[None, ...], rast_out, self.uv_idx)
+        depth, _ = self.raster_interpolate(tex_depth, rast_out, self.pos_idx)
+        depth = depth[0, ...]
+
+        depth_max, depth_min = depth[visible_mask > 0].max(), depth[visible_mask > 0].min()
+        depth_normalized = (depth - depth_min) / (depth_max - depth_min)
+        depth_image = depth_normalized * visible_mask  # Mask out background.
+
+        sketch_image = self.render_sketch_from_depth(depth_image)
+
+        lookat = torch.tensor([[0, 0, -1]], device=self.device)
+        # cos_image = torch.nn.functional.cosine_similarity(lookat, normal.view(-1, 3))
+        # cos_image = cos_image.view(normal.shape[0], normal.shape[1], 1)
+        cos_raw = torch.nn.functional.cosine_similarity(lookat, normal.view(-1, 3)).view(normal.shape[0], normal.shape[1], 1)
+        cos_image = cos_raw.abs()  # 양면 처리
+
+        cos_thres = np.cos(self.bake_angle_thres / 180 * np.pi)
+        cos_image[cos_image < cos_thres] = 0
+
+        # shrink
+        if self.bake_unreliable_kernel_size > 0:
+            kernel_size = self.bake_unreliable_kernel_size * 2 + 1
+            kernel = torch.ones((1, 1, kernel_size, kernel_size), dtype=torch.float32).to(sketch_image.device)
+
+            visible_mask = visible_mask.permute(2, 0, 1).unsqueeze(0).float()
+            visible_mask = F.conv2d(1.0 - visible_mask, kernel, padding=kernel_size // 2)
+            visible_mask = 1.0 - (visible_mask > 0).float()  # 二值化
+            visible_mask = visible_mask.squeeze(0).permute(1, 2, 0)
+
+            sketch_image = sketch_image.permute(2, 0, 1).unsqueeze(0)
+            sketch_image = F.conv2d(sketch_image, kernel, padding=kernel_size // 2)
+            sketch_image = (sketch_image > 0).float()  # 二值化
+            sketch_image = sketch_image.squeeze(0).permute(1, 2, 0)
+            visible_mask = visible_mask * (sketch_image < 0.5)
+
+        cos_image[visible_mask == 0] = 0
+
+        method = self.bake_mode if method is None else method
+
+        if method == "linear":
+            proj_mask = (visible_mask != 0).view(-1)
+            uv = uv.squeeze(0).contiguous().view(-1, 2)[proj_mask]
+            image = image.squeeze(0).contiguous().view(-1, channel)[proj_mask]
+            cos_image = cos_image.contiguous().view(-1, 1)[proj_mask]
+            sketch_image = sketch_image.contiguous().view(-1, 1)[proj_mask]
+
+            texture = linear_grid_put_2d(self.texture_size[1], self.texture_size[0], uv[..., [1, 0]], image)
+            cos_map = linear_grid_put_2d(self.texture_size[1], self.texture_size[0], uv[..., [1, 0]], cos_image)
+            boundary_map = linear_grid_put_2d(self.texture_size[1], self.texture_size[0], uv[..., [1, 0]], sketch_image)
+        elif method == "mip-map":
+            proj_mask = (visible_mask != 0).view(-1)
+            uv = uv.squeeze(0).contiguous().view(-1, 2)[proj_mask]
+            image = image.squeeze(0).contiguous().view(-1, channel)[proj_mask]
+            cos_image = cos_image.contiguous().view(-1, 1)[proj_mask]
+
+            texture = mipmap_linear_grid_put_2d(
+                self.texture_size[1], self.texture_size[0], uv[..., [1, 0]], image, min_resolution=128
+            )
+            cos_map = mipmap_linear_grid_put_2d(
+                self.texture_size[1], self.texture_size[0], uv[..., [1, 0]], cos_image, min_resolution=256
+            )
+
+            if self.vtx_map is not None:
+                vertex_normals = vertex_normals[self.vtx_map, :]
+            normal_map = self.uv_feature_map(vertex_normals)
+            # cos_map_uv = torch.nn.functional.cosine_similarity(lookat, normal_map.view(-1, 3))  # .abs()
+            cos_map_uv = torch.nn.functional.cosine_similarity(lookat, normal_map.view(-1, 3)).abs()
+            cos_map_uv = cos_map_uv.view(1, 1, normal_map.shape[0], normal_map.shape[1])
+            cos_map_uv = torch.nn.functional.max_pool2d(cos_map_uv, kernel_size=3, stride=1, padding=1)
+            cos_map_uv = cos_map_uv.reshape(self.texture_size[0], self.texture_size[1], 1)
+            cos_map_uv[cos_map_uv < cos_thres] = 0
+            # cos_map = torch.min(cos_map, cos_map_uv)
+            cos_map[cos_map_uv < cos_thres] = 0
+        elif method == "back_sample":
+
+            img_proj = torch.from_numpy(
+                np.array(((proj[0, 0], 0, 0, 0), (0, proj[1, 1], 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)))
+            ).to(self.tex_position)
+            w2c = torch.from_numpy(r_mv).to(self.tex_position)
+            v_proj = self.tex_position @ w2c.T @ img_proj
+            inner_mask = (v_proj[:, 0] <= 1.0) & (v_proj[:, 0] >= -1.0) & (v_proj[:, 1] <= 1.0) & (v_proj[:, 1] >= -1.0)
+            inner_valid_idx = torch.where(inner_mask)[0].long()
+            img_x = torch.clamp(
+                ((v_proj[:, 0].clamp(-1, 1) * 0.5 + 0.5) * (resolution[0])).long(), 0, resolution[0] - 1
+            )
+            img_y = torch.clamp(
+                ((v_proj[:, 1].clamp(-1, 1) * 0.5 + 0.5) * (resolution[1])).long(), 0, resolution[1] - 1
+            )
+
+            indices = img_y * resolution[0] + img_x
+            sampled_z = depth.reshape(-1)[indices]
+            sampled_m = visible_mask.reshape(-1)[indices]
+            v_z = v_proj[:, 2]
+
+            sampled_w = cos_image.reshape(-1)[indices]
+            depth_thres = 3e-3
+
+            # valid_idx = torch.where((torch.abs(v_z - sampled_z) < depth_thres) * (sampled_m*sampled_w>0))[0]
+            valid_idx = torch.where((torch.abs(v_z - sampled_z) < depth_thres) & (sampled_m * sampled_w > 0))[0]
+
+            intersection_mask = torch.isin(valid_idx, inner_valid_idx)
+            valid_idx = valid_idx[intersection_mask].to(inner_valid_idx)
+
+            indices = indices[valid_idx]
+            sampled_b = sketch_image.reshape(-1)[indices]
+            sampled_w = sampled_w[valid_idx]
+
+            # bilinear sampling rgb
+            wx = ((v_proj[:, 0] * 0.5 + 0.5) * resolution[0] - img_x)[valid_idx].reshape(-1, 1)
+            wy = ((v_proj[:, 1] * 0.5 + 0.5) * resolution[1] - img_y)[valid_idx].reshape(-1, 1)
+            img_x = img_x[valid_idx]
+            img_y = img_y[valid_idx]
+            img_x_r = torch.clamp(img_x + 1, 0, resolution[0] - 1)
+            img_y_r = torch.clamp(img_y + 1, 0, resolution[1] - 1)
+            indices_lr = img_y * resolution[0] + img_x_r
+            indices_rl = img_y_r * resolution[0] + img_x
+            indices_rr = img_y_r * resolution[0] + img_x_r
+            rgb = image.reshape(-1, channel)
+            sampled_rgb = (rgb[indices] * (1 - wx) + rgb[indices_lr] * wx) * (1 - wy) + (
+                rgb[indices_rl] * (1 - wx) + rgb[indices_rr] * wx
+            ) * wy
+
+            # return sampled_rgb, sampled_w, sampled_b, valid_idx
+            texture = torch.zeros(self.texture_size[0], self.texture_size[1], channel, device=self.device).reshape(
+                -1, channel
+            )
+            cos_map = torch.zeros(self.texture_size[0], self.texture_size[1], 1, device=self.device).reshape(-1)
+            boundary_map = torch.zeros(self.texture_size[0], self.texture_size[1], 1, device=self.device).reshape(-1)
+
+            valid_tex_indices = self.tex_grid[valid_idx, 0] * self.texture_size[1] + self.tex_grid[valid_idx, 1]
+            texture[valid_tex_indices, :] = sampled_rgb
+            cos_map[valid_tex_indices] = sampled_w
+            boundary_map[valid_tex_indices] = sampled_b
+
+            texture = texture.view(self.texture_size[0], self.texture_size[1], channel)
+            cos_map = cos_map.view(self.texture_size[0], self.texture_size[1], 1)
+            # texture = torch.clamp(texture,0,1)
+
+        else:
+            raise f"No bake mode {method}"
+        return texture, cos_map, boundary_map
+
+    def bake_texture(self, colors, elevs, azims, camera_distance=None, center=None, exp=6, weights=None):
+        """
+        Bake multiple view images into a single UV texture using weighted blending.
+
+        Args:
+            colors: List of input images (tensors, numpy arrays, or PIL Images)
+            elevs: List of elevation angles for each view
+            azims: List of azimuth angles for each view
+            camera_distance: Camera distance (uses default if None)
+            center: Camera focus center (uses origin if None)
+            exp: Exponent for cosine weighting (higher values favor front-facing views)
+            weights: Optional per-view weights (defaults to 1.0 for all views)
+
+        Returns:
+            Tuple of (merged_texture, trust_map) tensors in UV space
+        """
+        if isinstance(colors, torch.Tensor):
+            colors = [colors[i, ...].float().permute(1, 2, 0) for i in range(colors.shape[0])]
+        else:
+            for i in range(len(colors)):
+                if isinstance(colors[i], Image.Image):
+                    colors[i] = torch.tensor(np.array(colors[i]) / 255.0, device=self.device).float()
+        if weights is None:
+            weights = [1.0 for _ in range(len(colors))]
+        textures = []
+        cos_maps = []
+        for color, elev, azim, weight in zip(colors, elevs, azims, weights):
+            texture, cos_map, _ = self.back_project(color, elev, azim, camera_distance, center)
+            cos_map = weight * (cos_map**exp)
+            textures.append(texture)
+            cos_maps.append(cos_map)
+
+        texture_merge, trust_map_merge = self.fast_bake_texture(textures, cos_maps)
+        return texture_merge, trust_map_merge
+
+    @torch.no_grad()
+    def fast_bake_texture(self, textures, cos_maps):
+        """
+        Efficiently merge multiple textures using cosine-weighted blending.
+        Optimizes by skipping views that don't contribute new information.
+
+        Args:
+            textures: List of texture tensors to merge
+            cos_maps: List of corresponding cosine weight maps
+
+        Returns:
+            Tuple of (merged_texture, valid_mask) tensors
+        """
+
+        channel = textures[0].shape[-1]
+        texture_merge = torch.zeros(self.texture_size + (channel,)).to(self.device)
+        trust_map_merge = torch.zeros(self.texture_size + (1,)).to(self.device)
+        for texture, cos_map in zip(textures, cos_maps):
+            view_sum = (cos_map > 0).sum()
+            painted_sum = ((cos_map > 0) * (trust_map_merge > 0)).sum()
+            if painted_sum / view_sum > 0.99:
+                continue
+            texture_merge += texture * cos_map
+            trust_map_merge += cos_map
+        texture_merge = texture_merge / torch.clamp(trust_map_merge, min=1e-8)
+
+        return texture_merge, trust_map_merge > 1e-8
+
+    @torch.no_grad()
+    def uv_inpaint(self, texture, mask, vertex_inpaint=True, method="NS", return_float=False):
+        """
+        Inpaint missing regions in UV texture using mesh-aware and traditional methods.
+
+        Args:
+            texture: Input texture as tensor, numpy array, or PIL Image
+            mask: Binary mask indicating regions to inpaint (1 = keep, 0 = inpaint)
+            vertex_inpaint: Whether to use mesh vertex connectivity for inpainting
+            method: Inpainting method ("NS" for Navier-Stokes)
+            return_float: Whether to return float values (False returns uint8)
+
+        Returns:
+            Inpainted texture as numpy array
+        """
+
+        if isinstance(texture, torch.Tensor):
+            texture_np = texture.cpu().numpy()
+        elif isinstance(texture, np.ndarray):
+            texture_np = texture
+        elif isinstance(texture, Image.Image):
+            texture_np = np.array(texture) / 255.0
+
+        if isinstance(mask, torch.Tensor):
+            mask = (mask.squeeze(-1).cpu().numpy() * 255).astype(np.uint8)
+
+        if vertex_inpaint:
+            vtx_pos, pos_idx, vtx_uv, uv_idx = self.get_mesh()
+            texture_np, mask = meshVerticeInpaint(texture_np, mask, vtx_pos, vtx_uv, pos_idx, uv_idx)
+            # save the mask image for debug
+            mask_image = Image.fromarray(255 - mask)
+            mask_image.save("debug_uv_mask.png")
+
+        if method == "NS":
+            texture_np = cv2.inpaint((texture_np * 255).astype(np.uint8), 255 - mask, 3, cv2.INPAINT_NS)
+            assert return_float == False
+
+        return texture_np

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/camera_utils.py

@@ -0,0 +1,93 @@
+import math
+
+import numpy as np
+import torch
+
+
+def transform_pos(mtx, pos, keepdim=False):
+    t_mtx = torch.from_numpy(mtx).to(pos.device) if isinstance(mtx, np.ndarray) else mtx
+    if pos.shape[-1] == 3:
+        posw = torch.cat([pos, torch.ones([pos.shape[0], 1]).to(pos.device)], axis=1)
+    else:
+        posw = pos
+
+    if keepdim:
+        return torch.matmul(posw, t_mtx.t())[...]
+    else:
+        return torch.matmul(posw, t_mtx.t())[None, ...]
+
+
+def get_mv_matrix(elev, azim, camera_distance, center=None):
+    elev = -elev
+    azim += 90
+
+    elev_rad = math.radians(elev)
+    azim_rad = math.radians(azim)
+
+    camera_position = np.array(
+        [
+            camera_distance * math.cos(elev_rad) * math.cos(azim_rad),
+            camera_distance * math.cos(elev_rad) * math.sin(azim_rad),
+            camera_distance * math.sin(elev_rad),
+        ]
+    )
+
+    if center is None:
+        center = np.array([0, 0, 0])
+    else:
+        center = np.array(center)
+
+    lookat = center - camera_position
+    lookat = lookat / np.linalg.norm(lookat)
+
+    up = np.array([0, 0, 1.0])
+    right = np.cross(lookat, up)
+    right = right / np.linalg.norm(right)
+    up = np.cross(right, lookat)
+    up = up / np.linalg.norm(up)
+
+    c2w = np.concatenate([np.stack([right, up, -lookat], axis=-1), camera_position[:, None]], axis=-1)
+
+    w2c = np.zeros((4, 4))
+    w2c[:3, :3] = np.transpose(c2w[:3, :3], (1, 0))
+    w2c[:3, 3:] = -np.matmul(np.transpose(c2w[:3, :3], (1, 0)), c2w[:3, 3:])
+    w2c[3, 3] = 1.0
+
+    return w2c.astype(np.float32)
+
+
+def get_orthographic_projection_matrix(left=-1, right=1, bottom=-1, top=1, near=0, far=2):
+    """
+    计算正交投影矩阵。
+
+    参数:
+        left (float): 投影区域左侧边界。
+        right (float): 投影区域右侧边界。
+        bottom (float): 投影区域底部边界。
+        top (float): 投影区域顶部边界。
+        near (float): 投影区域近裁剪面距离。
+        far (float): 投影区域远裁剪面距离。
+
+    返回:
+        numpy.ndarray: 正交投影矩阵。
+    """
+    ortho_matrix = np.eye(4, dtype=np.float32)
+    ortho_matrix[0, 0] = 2 / (right - left)
+    ortho_matrix[1, 1] = 2 / (top - bottom)
+    ortho_matrix[2, 2] = -2 / (far - near)
+    ortho_matrix[0, 3] = -(right + left) / (right - left)
+    ortho_matrix[1, 3] = -(top + bottom) / (top - bottom)
+    ortho_matrix[2, 3] = -(far + near) / (far - near)
+    return ortho_matrix
+
+
+def get_perspective_projection_matrix(fovy, aspect_wh, near, far):
+    fovy_rad = math.radians(fovy)
+    return np.array(
+        [
+            [1.0 / (math.tan(fovy_rad / 2.0) * aspect_wh), 0, 0, 0],
+            [0, 1.0 / math.tan(fovy_rad / 2.0), 0, 0],
+            [0, 0, -(far + near) / (far - near), -2.0 * far * near / (far - near)],
+            [0, 0, -1, 0],
+        ]
+    ).astype(np.float32)

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/compile_mesh_painter.sh

@@ -0,0 +1 @@
+c++ -O3 -Wall -shared -std=c++11 -fPIC `python -m pybind11 --includes` mesh_inpaint_processor.cpp -o mesh_inpaint_processor`python3-config --extension-suffix`

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/mesh_inpaint_processor.cpp

@@ -0,0 +1,550 @@
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <queue>
+#include <vector>
+#include <functional>
+
+namespace py = pybind11;
+using namespace std;
+
+namespace {
+
+// =========================
+// Core mesh data container
+// =========================
+struct MeshData {
+    int texture_height, texture_width, texture_channel;
+    int vtx_num;
+    float* texture_ptr;
+    uint8_t* mask_ptr;
+    float* vtx_pos_ptr;
+    float* vtx_uv_ptr;
+    int* pos_idx_ptr;
+    int* uv_idx_ptr;
+
+    // Keep buffers alive
+    py::buffer_info texture_buf, mask_buf, vtx_pos_buf, vtx_uv_buf, pos_idx_buf, uv_idx_buf;
+
+    MeshData(py::array_t<float>& texture, py::array_t<uint8_t>& mask,
+             py::array_t<float>& vtx_pos, py::array_t<float>& vtx_uv,
+             py::array_t<int>& pos_idx, py::array_t<int>& uv_idx) {
+        texture_buf = texture.request();
+        mask_buf = mask.request();
+        vtx_pos_buf = vtx_pos.request();
+        vtx_uv_buf = vtx_uv.request();
+        pos_idx_buf = pos_idx.request();
+        uv_idx_buf = uv_idx.request();
+
+        texture_height = static_cast<int>(texture_buf.shape[0]);
+        texture_width  = static_cast<int>(texture_buf.shape[1]);
+        texture_channel= static_cast<int>(texture_buf.shape[2]);
+        texture_ptr = static_cast<float*>(texture_buf.ptr);
+        mask_ptr    = static_cast<uint8_t*>(mask_buf.ptr);
+
+        vtx_num     = static_cast<int>(vtx_pos_buf.shape[0]);
+        vtx_pos_ptr = static_cast<float*>(vtx_pos_buf.ptr);
+        vtx_uv_ptr  = static_cast<float*>(vtx_uv_buf.ptr);
+        pos_idx_ptr = static_cast<int*>(pos_idx_buf.ptr);
+        uv_idx_ptr  = static_cast<int*>(uv_idx_buf.ptr);
+    }
+};
+
+// =========================
+// Helpers
+// =========================
+
+// Integer pixel (y, x) from UV with vertical flip (V -> image y)
+pair<int,int> calculateUVCoordinates(int vtx_uv_idx, const MeshData& data) {
+    int x = static_cast<int>(std::round(data.vtx_uv_ptr[vtx_uv_idx * 2] * (data.texture_width - 1)));
+    int y = static_cast<int>(std::round((1.0f - data.vtx_uv_ptr[vtx_uv_idx * 2 + 1]) * (data.texture_height - 1)));
+    return {y, x}; // (y, x)
+}
+
+// Float pixel (x, y) from UV with vertical flip
+inline pair<float,float> uvIdxToXYFloat(int vtx_uv_idx, const MeshData& data) {
+    float x = data.vtx_uv_ptr[vtx_uv_idx * 2] * (data.texture_width - 1);
+    float y = (1.0f - data.vtx_uv_ptr[vtx_uv_idx * 2 + 1]) * (data.texture_height - 1);
+    return {x, y}; // (x, y)
+}
+
+float calculateDistanceWeight(const array<float,3>& v0, const array<float,3>& v1) {
+    float dx = v0[0] - v1[0];
+    float dy = v0[1] - v1[1];
+    float dz = v0[2] - v1[2];
+    float d  = std::sqrt(dx*dx + dy*dy + dz*dz);
+    float inv = 1.0f / std::max(d, 1e-4f);
+    return inv * inv;
+}
+
+array<float,3> getVertexPosition(int vtx_idx, const MeshData& data) {
+    return { data.vtx_pos_ptr[vtx_idx*3+0],
+             data.vtx_pos_ptr[vtx_idx*3+1],
+             data.vtx_pos_ptr[vtx_idx*3+2] };
+}
+
+// Undirected 1-ring graph from faces
+void buildGraph(vector<vector<int>>& G, const MeshData& data) {
+    G.clear();
+    G.resize(data.vtx_num);
+    const int F = static_cast<int>(data.uv_idx_buf.shape[0]);
+    for (int i = 0; i < F; ++i) {
+        for (int k = 0; k < 3; ++k) {
+            int a = data.pos_idx_ptr[i * 3 + k];
+            int b = data.pos_idx_ptr[i * 3 + (k + 1) % 3];
+            G[a].push_back(b);
+            G[b].push_back(a);
+        }
+    }
+}
+
+// =========================
+// Vertex-aware initialization
+// - For each 3D vertex, aggregate samples from all its UV corners.
+// - If a UV corner pixel is invalid (mask==0), search a small neighborhood.
+// - Average the found samples to get a stable vertex color.
+// =========================
+
+// Search nearest valid (mask>0) pixel around (x0,y0). Returns true if found.
+bool sample_color_near_uv(const MeshData& data, int x0, int y0, int r_max, vector<float>& out_color) {
+    const int W = data.texture_width;
+    const int H = data.texture_height;
+    const int C = data.texture_channel;
+    out_color.assign(C, 0.0f);
+
+    // Clamp seed
+    x0 = std::min(std::max(x0, 0), W - 1);
+    y0 = std::min(std::max(y0, 0), H - 1);
+
+    // If seed is valid, take it.
+    if (data.mask_ptr[y0 * W + x0] > 0) {
+        for (int c = 0; c < C; ++c) {
+            out_color[c] = data.texture_ptr[(y0 * W + x0) * C + c];
+        }
+        return true;
+    }
+
+    // Expand square neighborhood up to r_max
+    float best_d2 = std::numeric_limits<float>::infinity();
+    int best_x = -1, best_y = -1;
+
+    for (int r = 1; r <= r_max; ++r) {
+        int xmin = std::max(0, x0 - r);
+        int xmax = std::min(W - 1, x0 + r);
+        int ymin = std::max(0, y0 - r);
+        int ymax = std::min(H - 1, y0 + r);
+        bool found_this_ring = false;
+
+        for (int y = ymin; y <= ymax; ++y) {
+            for (int x = xmin; x <= xmax; ++x) {
+                if (data.mask_ptr[y * W + x] == 0) continue;
+                float dx = float(x - x0), dy = float(y - y0);
+                float d2 = dx*dx + dy*dy;
+                if (d2 < best_d2) {
+                    best_d2 = d2;
+                    best_x = x;
+                    best_y = y;
+                    found_this_ring = true;
+                }
+            }
+        }
+        // Early exit when ring finds something (closest for this r)
+        if (found_this_ring) break;
+    }
+
+    if (best_x >= 0) {
+        for (int c = 0; c < C; ++c) {
+            out_color[c] = data.texture_ptr[(best_y * W + best_x) * C + c];
+        }
+        return true;
+    }
+    return false;
+}
+
+template<typename MaskType>
+void initializeVertexDataVertexAware(const MeshData& data,
+                                     vector<MaskType>& vtx_mask,
+                                     vector<vector<float>>& vtx_color,
+                                     vector<int>* uncolored_vtxs = nullptr,
+                                     MaskType mask_value = static_cast<MaskType>(1),
+                                     int r_max = 5) {
+    const int V = data.vtx_num;
+    const int C = data.texture_channel;
+    const int F = static_cast<int>(data.uv_idx_buf.shape[0]);
+
+    vtx_mask.assign(V, static_cast<MaskType>(0));
+    vtx_color.assign(V, vector<float>(C, 0.0f));
+    vector<float> accum_w(V, 0.0f);
+    if (uncolored_vtxs) uncolored_vtxs->clear();
+
+    for (int face_idx = 0; face_idx < F; ++face_idx) {
+        for (int k = 0; k < 3; ++k) {
+            int vtx_idx    = data.pos_idx_ptr[face_idx * 3 + k];
+            int vtx_uv_idx = data.uv_idx_ptr[face_idx * 3 + k];
+
+            // Seed pixel from this UV corner
+            auto uv_xy_int = calculateUVCoordinates(vtx_uv_idx, data); // (y, x)
+            int sx = uv_xy_int.second;
+            int sy = uv_xy_int.first;
+
+            vector<float> col;
+            if (!sample_color_near_uv(data, sx, sy, r_max, col)) {
+                continue; // no contribution from this corner
+            }
+
+            // Equal weight per found corner (can be replaced by distance-based if needed)
+            float w = 1.0f;
+            for (int c = 0; c < C; ++c) {
+                vtx_color[vtx_idx][c] += w * col[c];
+            }
+            accum_w[vtx_idx] += w;
+        }
+    }
+
+    for (int v = 0; v < V; ++v) {
+        if (accum_w[v] > 0.0f) {
+            float inv = 1.0f / accum_w[v];
+            for (int c = 0; c < C; ++c) vtx_color[v][c] *= inv;
+            vtx_mask[v] = mask_value;
+        } else {
+            if (uncolored_vtxs) uncolored_vtxs->push_back(v);
+        }
+    }
+}
+
+// =========================
+// Smoothing / Propagation
+// =========================
+template<typename MaskType>
+void performSmoothingAlgorithm(const MeshData& data, const vector<vector<int>>& G,
+                               vector<MaskType>& vtx_mask, vector<vector<float>>& vtx_color,
+                               const vector<int>& uncolored_vtxs,
+                               function<bool(MaskType)> is_colored_func,
+                               function<void(MaskType&)> set_colored_func) {
+    // Limit to a small fixed number of passes for stability
+    const int max_pass = 8;
+    const int C = data.texture_channel;
+
+    for (int pass = 0; pass < max_pass; ++pass) {
+        int remained = 0;
+
+        for (int vtx_idx : uncolored_vtxs) {
+            if (is_colored_func(vtx_mask[vtx_idx])) continue;
+
+            vector<float> sum_color(C, 0.0f);
+            float total_w = 0.0f;
+
+            array<float,3> v0 = getVertexPosition(vtx_idx, data);
+            for (int nb : G[vtx_idx]) {
+                if (!is_colored_func(vtx_mask[nb])) continue;
+                array<float,3> v1 = getVertexPosition(nb, data);
+                float w = calculateDistanceWeight(v0, v1);
+                for (int c = 0; c < C; ++c) sum_color[c] += vtx_color[nb][c] * w;
+                total_w += w;
+            }
+
+            if (total_w > 0.0f) {
+                float inv = 1.0f / total_w;
+                for (int c = 0; c < C; ++c) vtx_color[vtx_idx][c] = sum_color[c] * inv;
+                set_colored_func(vtx_mask[vtx_idx]);
+            } else {
+                remained++;
+            }
+        }
+
+        if (remained == 0) break; // converged
+    }
+}
+
+void performForwardPropagation(const MeshData& data, const vector<vector<int>>& G,
+                               vector<float>& vtx_mask, vector<vector<float>>& vtx_color,
+                               queue<int>& active_vtxs) {
+    const int C = data.texture_channel;
+
+    while (!active_vtxs.empty()) {
+        queue<int> pending;
+
+        while (!active_vtxs.empty()) {
+            int vtx_idx = active_vtxs.front();
+            active_vtxs.pop();
+
+            array<float,3> v0 = getVertexPosition(vtx_idx, data);
+            for (int nb : G[vtx_idx]) {
+                if (vtx_mask[nb] > 0) continue;
+
+                array<float,3> v1 = getVertexPosition(nb, data);
+                float w = calculateDistanceWeight(v0, v1);
+                for (int c = 0; c < C; ++c) vtx_color[nb][c] += vtx_color[vtx_idx][c] * w;
+
+                if (vtx_mask[nb] == 0.0f) pending.push(nb);
+                vtx_mask[nb] -= w;
+            }
+        }
+
+        while (!pending.empty()) {
+            int v = pending.front(); pending.pop();
+            for (int c = 0; c < C; ++c) vtx_color[v][c] /= -vtx_mask[v];
+            vtx_mask[v] = 1.0f;
+            active_vtxs.push(v);
+        }
+    }
+}
+
+// =========================
+// Triangle rasterization
+// =========================
+inline float edgeFunc(float x0,float y0,float x1,float y1,float x,float y){
+    return (x - x0)*(y1 - y0) - (y - y0)*(x1 - x0);
+}
+
+// Create output by rasterizing per-face colors from vertex colors.
+// Only fills pixels where original mask == 0 (keeps existing valid texels).
+pair<py::array_t<float>, py::array_t<uint8_t>> createOutputArrays(
+    const MeshData& data, const vector<float>& vtx_mask,
+    const vector<vector<float>>& vtx_color) {
+
+    // Allocate and copy originals
+    py::array_t<float> new_texture(data.texture_buf.size);
+    py::array_t<uint8_t> new_mask(data.mask_buf.size);
+
+    auto new_texture_buf = new_texture.request();
+    auto new_mask_buf    = new_mask.request();
+
+    float*   new_texture_ptr = static_cast<float*>(new_texture_buf.ptr);
+    uint8_t* new_mask_ptr    = static_cast<uint8_t*>(new_mask_buf.ptr);
+
+    std::copy(data.texture_ptr, data.texture_ptr + data.texture_buf.size, new_texture_ptr);
+    std::copy(data.mask_ptr,    data.mask_ptr    + data.mask_buf.size,    new_mask_ptr);
+
+    const int W = data.texture_width;
+    const int H = data.texture_height;
+    const int C = data.texture_channel;
+    const int F = static_cast<int>(data.uv_idx_buf.shape[0]);
+
+    for (int face_idx = 0; face_idx < F; ++face_idx) {
+        int v0 = data.pos_idx_ptr[face_idx*3 + 0];
+        int v1 = data.pos_idx_ptr[face_idx*3 + 1];
+        int v2 = data.pos_idx_ptr[face_idx*3 + 2];
+
+        // If no vertex has color, skip
+        if (!(vtx_mask[v0] > 0.0f || vtx_mask[v1] > 0.0f || vtx_mask[v2] > 0.0f)) continue;
+
+        int u0 = data.uv_idx_ptr[face_idx*3 + 0];
+        int u1 = data.uv_idx_ptr[face_idx*3 + 1];
+        int u2 = data.uv_idx_ptr[face_idx*3 + 2];
+
+        auto xy0 = uvIdxToXYFloat(u0, data); float x0 = xy0.first, y0 = xy0.second;
+        auto xy1 = uvIdxToXYFloat(u1, data); float x1 = xy1.first, y1 = xy1.second;
+        auto xy2 = uvIdxToXYFloat(u2, data); float x2 = xy2.first, y2 = xy2.second;
+
+        // Prepare vertex colors; if some are missing, use average of existing ones
+        vector<float> col0(C, 0.0f), col1(C, 0.0f), col2(C, 0.0f);
+        int cnt = 0;
+        if (vtx_mask[v0] > 0.0f) { for (int c = 0; c < C; ++c) col0[c] = vtx_color[v0][c]; cnt++; }
+        if (vtx_mask[v1] > 0.0f) { for (int c = 0; c < C; ++c) col1[c] = vtx_color[v1][c]; cnt++; }
+        if (vtx_mask[v2] > 0.0f) { for (int c = 0; c < C; ++c) col2[c] = vtx_color[v2][c]; cnt++; }
+
+        if (cnt > 0 && cnt < 3) {
+            // compute average of available
+            vector<float> avg(C, 0.0f);
+            if (vtx_mask[v0] > 0.0f) for (int c = 0; c < C; ++c) avg[c] += vtx_color[v0][c];
+            if (vtx_mask[v1] > 0.0f) for (int c = 0; c < C; ++c) avg[c] += vtx_color[v1][c];
+            if (vtx_mask[v2] > 0.0f) for (int c = 0; c < C; ++c) avg[c] += vtx_color[v2][c];
+            for (int c = 0; c < C; ++c) avg[c] /= float(cnt);
+            if (!(vtx_mask[v0] > 0.0f)) col0 = avg;
+            if (!(vtx_mask[v1] > 0.0f)) col1 = avg;
+            if (!(vtx_mask[v2] > 0.0f)) col2 = avg;
+        }
+
+        // Bounding box
+        int xmin = std::max(0, (int)std::floor(std::min({x0, x1, x2})));
+        int xmax = std::min(W-1, (int)std::ceil (std::max({x0, x1, x2})));
+        int ymin = std::max(0, (int)std::floor(std::min({y0, y1, y2})));
+        int ymax = std::min(H-1, (int)std::ceil (std::max({y0, y1, y2})));
+
+        float area = edgeFunc(x0,y0, x1,y1, x2,y2);
+        if (std::fabs(area) < 1e-6f) continue;
+
+        for (int y = ymin; y <= ymax; ++y) {
+            for (int x = xmin; x <= xmax; ++x) {
+                // Respect original valid texels
+                if (new_mask_ptr[y * W + x] > 0) continue;
+
+                float px = x + 0.5f, py = y + 0.5f;
+                float w0 = edgeFunc(x1,y1, x2,y2, px,py);
+                float w1 = edgeFunc(x2,y2, x0,y0, px,py);
+                float w2 = edgeFunc(x0,y0, x1,y1, px,py);
+
+                if ((w0 >= 0 && w1 >= 0 && w2 >= 0) || (w0 <= 0 && w1 <= 0 && w2 <= 0)) {
+                    w0 /= area; w1 /= area; w2 /= area;
+                    for (int c = 0; c < C; ++c) {
+                        float v = w0*col0[c] + w1*col1[c] + w2*col2[c];
+                        new_texture_ptr[(y * W + x) * C + c] = v;
+                    }
+                    new_mask_ptr[y * W + x] = 255;
+                }
+            }
+        }
+    }
+
+    // Reshape to HxWxC and HxW
+    new_texture.resize({ data.texture_height, data.texture_width, data.texture_channel });
+    new_mask.resize({ data.texture_height, data.texture_width });
+    return { new_texture, new_mask };
+}
+
+// Vertex color dump (unchanged interface)
+pair<py::array_t<float>, py::array_t<uint8_t>> createVertexColorOutput(
+    const MeshData& data, const vector<int>& vtx_mask,
+    const vector<vector<float>>& vtx_color) {
+
+    py::array_t<float> py_vtx_color({ data.vtx_num, data.texture_channel });
+    py::array_t<uint8_t> py_vtx_mask({ data.vtx_num });
+
+    auto py_vtx_color_buf = py_vtx_color.request();
+    auto py_vtx_mask_buf  = py_vtx_mask.request();
+
+    float*   py_vtx_color_ptr = static_cast<float*>(py_vtx_color_buf.ptr);
+    uint8_t* py_vtx_mask_ptr  = static_cast<uint8_t*>(py_vtx_mask_buf.ptr);
+
+    for (int i = 0; i < data.vtx_num; ++i) {
+        py_vtx_mask_ptr[i] = static_cast<uint8_t>(vtx_mask[i]);
+        for (int c = 0; c < data.texture_channel; ++c) {
+            py_vtx_color_ptr[i * data.texture_channel + c] = vtx_color[i][c];
+        }
+    }
+    return { py_vtx_color, py_vtx_mask };
+}
+
+} // anonymous namespace
+
+// =========================
+// meshVerticeInpaint - smooth
+// =========================
+pair<py::array_t<float>, py::array_t<uint8_t>> meshVerticeInpaint_smooth(
+    py::array_t<float> texture, py::array_t<uint8_t> mask,
+    py::array_t<float> vtx_pos, py::array_t<float> vtx_uv,
+    py::array_t<int> pos_idx,  py::array_t<int> uv_idx) {
+
+    MeshData data(texture, mask, vtx_pos, vtx_uv, pos_idx, uv_idx);
+
+    vector<float> vtx_mask;
+    vector<vector<float>> vtx_color;
+    vector<int> uncolored_vtxs;
+    vector<vector<int>> G;
+
+    // Vertex-aware initialization (multi-corner with neighborhood search)
+    initializeVertexDataVertexAware<float>(data, vtx_mask, vtx_color, &uncolored_vtxs, 1.0f, 5);
+    buildGraph(G, data);
+
+    performSmoothingAlgorithm<float>(
+        data, G, vtx_mask, vtx_color, uncolored_vtxs,
+        [](float m){ return m > 0.0f; },
+        [](float& m){ m = 1.0f; }
+    );
+
+    return createOutputArrays(data, vtx_mask, vtx_color);
+}
+
+// =========================
+// meshVerticeInpaint - forward
+// =========================
+pair<py::array_t<float>, py::array_t<uint8_t>> meshVerticeInpaint_forward(
+    py::array_t<float> texture, py::array_t<uint8_t> mask,
+    py::array_t<float> vtx_pos, py::array_t<float> vtx_uv,
+    py::array_t<int> pos_idx,  py::array_t<int> uv_idx) {
+
+    MeshData data(texture, mask, vtx_pos, vtx_uv, pos_idx, uv_idx);
+
+    vector<float> vtx_mask;
+    vector<vector<float>> vtx_color;
+    vector<vector<int>> G;
+    queue<int> active_vtxs;
+
+    // Vertex-aware seeds
+    initializeVertexDataVertexAware<float>(data, vtx_mask, vtx_color, nullptr, 1.0f, 5);
+    buildGraph(G, data);
+
+    for (int i = 0; i < data.vtx_num; ++i) {
+        if (vtx_mask[i] == 1.0f) active_vtxs.push(i);
+    }
+
+    performForwardPropagation(data, G, vtx_mask, vtx_color, active_vtxs);
+
+    return createOutputArrays(data, vtx_mask, vtx_color);
+}
+
+// =========================
+// Public inpaint API
+// =========================
+pair<py::array_t<float>, py::array_t<uint8_t>> meshVerticeInpaint(
+    py::array_t<float> texture, py::array_t<uint8_t> mask,
+    py::array_t<float> vtx_pos, py::array_t<float> vtx_uv,
+    py::array_t<int> pos_idx,  py::array_t<int> uv_idx,
+    const string& method = "smooth") {
+
+    if (method == "smooth") {
+        return meshVerticeInpaint_smooth(texture, mask, vtx_pos, vtx_uv, pos_idx, uv_idx);
+    } else if (method == "forward") {
+        return meshVerticeInpaint_forward(texture, mask, vtx_pos, vtx_uv, pos_idx, uv_idx);
+    } else {
+        throw std::invalid_argument("Invalid method. Use 'smooth' or 'forward'.");
+    }
+}
+
+// =========================
+// meshVerticeColor (vertex dump)
+// =========================
+pair<py::array_t<float>, py::array_t<uint8_t>> meshVerticeColor_smooth(
+    py::array_t<float> texture, py::array_t<uint8_t> mask,
+    py::array_t<float> vtx_pos, py::array_t<float> vtx_uv,
+    py::array_t<int> pos_idx,  py::array_t<int> uv_idx) {
+
+    MeshData data(texture, mask, vtx_pos, vtx_uv, pos_idx, uv_idx);
+
+    vector<int> vtx_mask;
+    vector<vector<float>> vtx_color;
+    vector<int> uncolored_vtxs;
+    vector<vector<int>> G;
+
+    // Vertex-aware init for INT mask type
+    initializeVertexDataVertexAware<int>(data, vtx_mask, vtx_color, &uncolored_vtxs, 1, 5);
+    buildGraph(G, data);
+
+    performSmoothingAlgorithm<int>(
+        data, G, vtx_mask, vtx_color, uncolored_vtxs,
+        [](int m){ return m > 0; },
+        [](int& m){ m = 2; } // mark as colored
+    );
+
+    return createVertexColorOutput(data, vtx_mask, vtx_color);
+}
+
+pair<py::array_t<float>, py::array_t<uint8_t>> meshVerticeColor(
+    py::array_t<float> texture, py::array_t<uint8_t> mask,
+    py::array_t<float> vtx_pos, py::array_t<float> vtx_uv,
+    py::array_t<int> pos_idx,  py::array_t<int> uv_idx,
+    const string& method = "smooth") {
+
+    if (method == "smooth") {
+        return meshVerticeColor_smooth(texture, mask, vtx_pos, vtx_uv, pos_idx, uv_idx);
+    } else {
+        throw std::invalid_argument("Invalid method. Use 'smooth' or 'forward'.");
+    }
+}
+
+// =========================
+// PyBind11 module
+// =========================
+PYBIND11_MODULE(mesh_inpaint_processor, m) {
+    m.def("meshVerticeInpaint", &meshVerticeInpaint, "A function to process mesh",
+          py::arg("texture"), py::arg("mask"), py::arg("vtx_pos"), py::arg("vtx_uv"),
+          py::arg("pos_idx"), py::arg("uv_idx"), py::arg("method") = "smooth");
+    m.def("meshVerticeColor", &meshVerticeColor, "A function to process mesh",
+          py::arg("texture"), py::arg("mask"), py::arg("vtx_pos"), py::arg("vtx_uv"),
+          py::arg("pos_idx"), py::arg("uv_idx"), py::arg("method") = "smooth");
+}

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/mesh_inpaint_processor.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b13b87ac483bc2a86adb0812fa7950eef76092e4d6031d3dc4e01f28ecd92609
+size 242392

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/mesh_utils.py

@@ -0,0 +1,270 @@
+import os
+import cv2
+# import bpy
+import math
+import numpy as np
+from io import StringIO
+from typing import Optional, Tuple, Dict, Any
+
+
+def _safe_extract_attribute(obj: Any, attr_path: str, default: Any = None) -> Any:
+    """Extract nested attribute safely from object."""
+    try:
+        for attr in attr_path.split("."):
+            obj = getattr(obj, attr)
+        return obj
+    except AttributeError:
+        return default
+
+
+def _convert_to_numpy(data: Any, dtype: np.dtype) -> Optional[np.ndarray]:
+    """Convert data to numpy array with specified dtype, handling None values."""
+    if data is None:
+        return None
+    return np.asarray(data, dtype=dtype)
+
+
+def load_mesh(mesh):
+    """Load mesh data including vertices, faces, UV coordinates and texture."""
+    # Extract vertex positions and face indices
+    vtx_pos = _safe_extract_attribute(mesh, "vertices")
+    pos_idx = _safe_extract_attribute(mesh, "faces")
+
+    # Extract UV coordinates (reusing face indices for UV indices)
+    vtx_uv = _safe_extract_attribute(mesh, "visual.uv")
+    uv_idx = pos_idx  # Reuse face indices for UV mapping
+
+    # Convert to numpy arrays with appropriate dtypes
+    vtx_pos = _convert_to_numpy(vtx_pos, np.float32)
+    pos_idx = _convert_to_numpy(pos_idx, np.int32)
+    vtx_uv = _convert_to_numpy(vtx_uv, np.float32)
+    uv_idx = _convert_to_numpy(uv_idx, np.int32)
+
+    texture_data = None
+    return vtx_pos, pos_idx, vtx_uv, uv_idx, texture_data
+
+
+def _get_base_path_and_name(mesh_path: str) -> Tuple[str, str]:
+    """Get base path without extension and mesh name."""
+    base_path = os.path.splitext(mesh_path)[0]
+    name = os.path.basename(base_path)
+    return base_path, name
+
+
+def _save_texture_map(
+    texture: np.ndarray,
+    base_path: str,
+    suffix: str = "",
+    image_format: str = ".jpg",
+    color_convert: Optional[int] = None,
+) -> str:
+    """Save texture map with optional color conversion."""
+    path = f"{base_path}{suffix}{image_format}"
+    processed_texture = (texture * 255).astype(np.uint8)
+
+    if color_convert is not None:
+        processed_texture = cv2.cvtColor(processed_texture, color_convert)
+        cv2.imwrite(path, processed_texture)
+    else:
+        cv2.imwrite(path, processed_texture[..., ::-1])  # RGB to BGR
+
+    return os.path.basename(path)
+
+
+def _write_mtl_properties(f, properties: Dict[str, Any]):
+    """Write material properties to MTL file."""
+    for key, value in properties.items():
+        if isinstance(value, (list, tuple)):
+            f.write(f"{key} {' '.join(map(str, value))}\n")
+        else:
+            f.write(f"{key} {value}\n")
+
+
+def _create_obj_content(
+    vtx_pos: np.ndarray, vtx_uv: np.ndarray, pos_idx: np.ndarray, uv_idx: np.ndarray, name: str
+) -> str:
+    """Create OBJ file content."""
+    buffer = StringIO()
+
+    # Write header and vertices
+    buffer.write(f"mtllib {name}.mtl\no {name}\n")
+    np.savetxt(buffer, vtx_pos, fmt="v %.6f %.6f %.6f")
+    np.savetxt(buffer, vtx_uv, fmt="vt %.6f %.6f")
+    buffer.write("s 0\nusemtl Material\n")
+
+    # Write faces
+    pos_idx_plus1 = pos_idx + 1
+    uv_idx_plus1 = uv_idx + 1
+    face_format = np.frompyfunc(lambda *x: f"{int(x[0])}/{int(x[1])}", 2, 1)
+    faces = face_format(pos_idx_plus1, uv_idx_plus1)
+    face_strings = [f"f {' '.join(face)}" for face in faces]
+    buffer.write("\n".join(face_strings) + "\n")
+
+    return buffer.getvalue()
+
+
+def save_obj_mesh(mesh_path, vtx_pos, pos_idx, vtx_uv, uv_idx, texture, metallic=None, roughness=None, normal=None):
+    """Save mesh as OBJ file with textures and material."""
+    # Convert inputs to numpy arrays
+    vtx_pos = _convert_to_numpy(vtx_pos, np.float32)
+    vtx_uv = _convert_to_numpy(vtx_uv, np.float32)
+    pos_idx = _convert_to_numpy(pos_idx, np.int32)
+    uv_idx = _convert_to_numpy(uv_idx, np.int32)
+
+    base_path, name = _get_base_path_and_name(mesh_path)
+
+    # Create and save OBJ content
+    obj_content = _create_obj_content(vtx_pos, vtx_uv, pos_idx, uv_idx, name)
+    with open(mesh_path, "w") as obj_file:
+        obj_file.write(obj_content)
+
+    # Save texture maps
+    texture_maps = {}
+    texture_maps["diffuse"] = _save_texture_map(texture, base_path)
+
+    if metallic is not None:
+        texture_maps["metallic"] = _save_texture_map(metallic, base_path, "_metallic", color_convert=cv2.COLOR_RGB2GRAY)
+    if roughness is not None:
+        texture_maps["roughness"] = _save_texture_map(
+            roughness, base_path, "_roughness", color_convert=cv2.COLOR_RGB2GRAY
+        )
+    if normal is not None:
+        texture_maps["normal"] = _save_texture_map(normal, base_path, "_normal")
+
+    # Create MTL file
+    _create_mtl_file(base_path, texture_maps, metallic is not None)
+
+
+def _create_mtl_file(base_path: str, texture_maps: Dict[str, str], is_pbr: bool):
+    """Create MTL material file."""
+    mtl_path = f"{base_path}.mtl"
+
+    with open(mtl_path, "w") as f:
+        f.write("newmtl Material\n")
+
+        if is_pbr:
+            # PBR material properties
+            properties = {
+                "Kd": [0.800, 0.800, 0.800],
+                "Ke": [0.000, 0.000, 0.000],  # 鐜鍏夐伄钄�
+                "Ni": 1.500,  # 鎶樺皠绯绘暟
+                "d": 1.0,  # 閫忔槑搴�
+                "illum": 2,  # 鍏夌収妯″瀷
+                "map_Kd": texture_maps["diffuse"],
+            }
+            _write_mtl_properties(f, properties)
+
+            # Additional PBR maps
+            map_configs = [("metallic", "map_Pm"), ("roughness", "map_Pr"), ("normal", "map_Bump -bm 1.0")]
+
+            for texture_key, mtl_key in map_configs:
+                if texture_key in texture_maps:
+                    f.write(f"{mtl_key} {texture_maps[texture_key]}\n")
+        else:
+            # Standard material properties
+            properties = {
+                "Ns": 250.000000,
+                "Ka": [0.200, 0.200, 0.200],
+                "Kd": [0.800, 0.800, 0.800],
+                "Ks": [0.500, 0.500, 0.500],
+                "Ke": [0.000, 0.000, 0.000],
+                "Ni": 1.500,
+                "d": 1.0,
+                "illum": 3,
+                "map_Kd": texture_maps["diffuse"],
+            }
+            _write_mtl_properties(f, properties)
+
+
+def save_mesh(mesh_path, vtx_pos, pos_idx, vtx_uv, uv_idx, texture, metallic=None, roughness=None, normal=None):
+    """Save mesh using OBJ format."""
+    save_obj_mesh(
+        mesh_path, vtx_pos, pos_idx, vtx_uv, uv_idx, texture, metallic=metallic, roughness=roughness, normal=normal
+    )
+
+
+# def _setup_blender_scene():
+#     """Setup Blender scene for conversion."""
+#     if "convert" not in bpy.data.scenes:
+#         bpy.data.scenes.new("convert")
+#     bpy.context.window.scene = bpy.data.scenes["convert"]
+
+
+# def _clear_scene_objects():
+#     """Clear all objects from current Blender scene."""
+#     for obj in bpy.context.scene.objects:
+#         obj.select_set(True)
+#         bpy.data.objects.remove(obj, do_unlink=True)
+
+
+# def _select_mesh_objects():
+#     """Select all mesh objects in scene."""
+#     bpy.ops.object.select_all(action="DESELECT")
+#     for obj in bpy.context.scene.objects:
+#         if obj.type == "MESH":
+#             obj.select_set(True)
+
+
+# def _merge_vertices_if_needed(merge_vertices: bool):
+#     """Merge duplicate vertices if requested."""
+#     if not merge_vertices:
+#         return
+
+#     for obj in bpy.context.selected_objects:
+#         if obj.type == "MESH":
+#             bpy.context.view_layer.objects.active = obj
+#             bpy.ops.object.mode_set(mode="EDIT")
+#             bpy.ops.mesh.select_all(action="SELECT")
+#             bpy.ops.mesh.remove_doubles()
+#             bpy.ops.object.mode_set(mode="OBJECT")
+
+
+# def _apply_shading(shade_type: str, auto_smooth_angle: float):
+#     """Apply shading to selected objects."""
+#     shading_ops = {
+#         "SMOOTH": lambda: bpy.ops.object.shade_smooth(),
+#         "FLAT": lambda: bpy.ops.object.shade_flat(),
+#         "AUTO_SMOOTH": lambda: _apply_auto_smooth(auto_smooth_angle),
+#     }
+
+#     if shade_type in shading_ops:
+#         shading_ops[shade_type]()
+
+
+# def _apply_auto_smooth(auto_smooth_angle: float):
+#     """Apply auto smooth based on Blender version."""
+#     angle_rad = math.radians(auto_smooth_angle)
+
+#     if bpy.app.version < (4, 1, 0):
+#         bpy.ops.object.shade_smooth(use_auto_smooth=True, auto_smooth_angle=angle_rad)
+#     elif bpy.app.version < (4, 2, 0):
+#         bpy.ops.object.shade_smooth_by_angle(angle=angle_rad)
+#     else:
+#         bpy.ops.object.shade_auto_smooth(angle=angle_rad)
+
+
+# def convert_obj_to_glb(
+#     obj_path: str,
+#     glb_path: str,
+#     shade_type: str = "SMOOTH",
+#     auto_smooth_angle: float = 60,
+#     merge_vertices: bool = False,
+# ) -> bool:
+#     """Convert OBJ file to GLB format using Blender."""
+#     try:
+#         _setup_blender_scene()
+#         _clear_scene_objects()
+
+#         # Import OBJ file
+#         bpy.ops.wm.obj_import(filepath=obj_path)
+#         _select_mesh_objects()
+
+#         # Process meshes
+#         _merge_vertices_if_needed(merge_vertices)
+#         _apply_shading(shade_type, auto_smooth_angle)
+
+#         # Export to GLB
+#         bpy.ops.export_scene.gltf(filepath=glb_path, use_active_scene=True)
+#         return True
+#     except Exception:
+#         return False

home/ubuntu/aaaaa/data/rgbmr/DifferentiableRenderer/obj_to_glb.py

@@ -0,0 +1,332 @@
+import os
+import io
+from typing import Optional, Tuple, Union
+
+import numpy as np
+from PIL import Image
+import trimesh
+
+from gltflib import (
+    GLTF, GLTFModel, Asset, Scene, Node, Mesh, Primitive, Attributes,
+    Buffer, BufferView, Accessor, AccessorType, BufferTarget, ComponentType,
+    Material, PBRMetallicRoughness, Texture, Image as GLTFImage, TextureInfo,
+    FileResource, Sampler
+)
+
+def _mime_from_path(path: str) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in [".jpg", ".jpeg"]:
+        return "image/jpeg"
+    if ext == ".png":
+        return "image/png"
+    if ext == ".webp":
+        return "image/webp"
+    # PIL로 최후 판정
+    try:
+        with Image.open(path) as im:
+            fmt = (im.format or "").lower()
+        return {"jpeg": "image/jpeg", "png": "image/png", "webp": "image/webp"}.get(fmt, "image/png")
+    except Exception:
+        return "image/png"
+
+def _mime_from_image(img: Image.Image) -> str:
+    """PIL Image로부터 MIME 타입 추론"""
+    fmt = (img.format or "").lower()
+    return {"jpeg": "image/jpeg", "png": "image/png", "webp": "image/webp"}.get(fmt, "image/png")
+
+def _align4(n: int) -> int:
+    return (n + 3) & ~3
+
+def _pack_f32(arr: np.ndarray) -> bytes:
+    return arr.astype("<f4", copy=False).tobytes(order="C")
+
+def _pack_indices(arr: np.ndarray) -> Tuple[bytes, int]:
+    max_idx = int(arr.max()) if arr.size > 0 else 0
+    if max_idx < 65536:
+        return arr.astype("<u2", copy=False).tobytes(order="C"), ComponentType.UNSIGNED_SHORT.value
+    return arr.astype("<u4", copy=False).tobytes(order="C"), ComponentType.UNSIGNED_INT.value
+
+def _mins_maxs(vec: np.ndarray) -> Tuple[list, list]:
+    if vec.size == 0:
+        return [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
+    mins = [float(vec[:, i].min()) for i in range(vec.shape[1])]
+    maxs = [float(vec[:, i].max()) for i in range(vec.shape[1])]
+    return mins, maxs
+
+def obj_to_pbr_glb(
+    obj_path_or_mesh: Union[str, trimesh.Trimesh],
+    base_color_path: Union[str, Image.Image],
+    orm_path: Optional[Union[str, Image.Image]],
+    output_glb_path: str,
+    *,
+    flip_uv: bool = True,
+    center: bool = False,
+    scale_to_unit: bool = False,
+    generator: str = "obj2pbr-glb (gltflib)",
+    material_name: str = "Material",
+    node_name: str = "Node",
+    mesh_name: str = "Mesh",
+) -> None:
+    # ---- 1) OBJ 로드 (단일 메시로 직접 로드) ----
+    # OBJ는 단일 메시이므로 force="mesh"로 직접 로드
+    if isinstance(obj_path_or_mesh, str):
+        mesh = trimesh.load(obj_path_or_mesh, force="mesh", process=True)
+    elif isinstance(obj_path_or_mesh, trimesh.Trimesh):
+        mesh = obj_path_or_mesh
+    else:
+        raise ValueError("Invalid input type for obj_path_or_mesh.")
+
+    if not isinstance(mesh, trimesh.Trimesh):
+        raise ValueError("Failed to load OBJ as a Trimesh.")
+    
+    if center:
+        mesh.vertices -= mesh.vertices.mean(axis=0)
+    if scale_to_unit:
+        s = np.max(np.linalg.norm(mesh.vertices, axis=1))
+        if s > 0:
+            mesh.vertices /= s
+    if mesh.faces is None or len(mesh.faces) == 0:
+        raise ValueError("Mesh has no faces. Ensure the OBJ is triangulated.")
+
+    # ---- 2) 속성 수집 ----
+    positions = np.asarray(mesh.vertices, dtype=np.float32)
+    normals = np.asarray(mesh.vertex_normals, dtype=np.float32)
+    
+    # UV 좌표 추출 (여러 경로 시도)
+    texcoords = None
+    
+    # 방법 1: mesh.visual.uv 확인
+    if hasattr(mesh.visual, "uv") and mesh.visual.uv is not None and len(mesh.visual.uv) > 0:
+        texcoords = np.asarray(mesh.visual.uv, dtype=np.float32)
+        print(f"UV loaded from mesh.visual.uv: shape={texcoords.shape}")
+    
+    # 방법 2: TextureVisuals의 uv 속성 확인
+    elif hasattr(mesh.visual, "kind") and mesh.visual.kind == "texture":
+        if hasattr(mesh.visual, "uv") and mesh.visual.uv is not None:
+            texcoords = np.asarray(mesh.visual.uv, dtype=np.float32)
+            print(f"UV loaded from TextureVisuals: shape={texcoords.shape}")
+    
+    # 방법 3: metadata에서 UV 확인
+    elif hasattr(mesh, "metadata") and mesh.metadata is not None:
+        if "uv" in mesh.metadata:
+            texcoords = np.asarray(mesh.metadata["uv"], dtype=np.float32)
+            print(f"UV loaded from metadata: shape={texcoords.shape}")
+    
+    if texcoords is None or len(texcoords) == 0:
+        # 디버깅 정보 출력
+        print(f"Debug info:")
+        print(f"  mesh.visual type: {type(mesh.visual)}")
+        print(f"  hasattr(mesh.visual, 'uv'): {hasattr(mesh.visual, 'uv')}")
+        if hasattr(mesh.visual, 'uv'):
+            print(f"  mesh.visual.uv: {mesh.visual.uv}")
+        print(f"  mesh.vertices.shape: {mesh.vertices.shape}")
+        print(f"  mesh.faces.shape: {mesh.faces.shape}")
+        raise ValueError(
+            "OBJ has no UVs but textures were provided. "
+            "The OBJ file may not have proper UV mapping or the UV data is not being loaded correctly. "
+            "Please check if the OBJ file has 'vt' (texture coordinates) entries."
+        )
+    
+    # UV 좌표 정규화 및 플립
+    texcoords = texcoords - np.floor(texcoords)  # wrap to [0, 1]
+    if flip_uv:
+        texcoords[:, 1] = 1.0 - texcoords[:, 1]
+
+    faces = np.asarray(mesh.faces, dtype=np.uint32)
+    indices = faces.reshape(-1)
+
+    # ---- 3) 단일 버퍼(bin_data) 구성 (기하 + 이미지) ----
+    bin_data = bytearray()
+    views = {}  # name -> (offset, length, target)
+
+    def _append_bytes(name: str, payload: bytes, target: Optional[int]) -> int:
+        """payload를 4바이트 정렬로 추가하고 BufferView 인덱스를 반환하지 않고, 오프셋만 기록한다."""
+        nonlocal bin_data, views
+        off = _align4(len(bin_data))
+        if off > len(bin_data):
+            bin_data.extend(b"\x00" * (off - len(bin_data)))
+        bin_data.extend(payload)
+        views[name] = (off, len(payload), target)
+        return off
+
+    # 기하 데이터
+    _append_bytes("POSITION", _pack_f32(positions), BufferTarget.ARRAY_BUFFER.value)
+    _append_bytes("NORMAL", _pack_f32(normals), BufferTarget.ARRAY_BUFFER.value)
+    _append_bytes("TEXCOORD_0", _pack_f32(texcoords), BufferTarget.ARRAY_BUFFER.value)
+    idx_bytes, idx_ct = _pack_indices(indices)
+    _append_bytes("INDICES", idx_bytes, BufferTarget.ELEMENT_ARRAY_BUFFER.value)
+
+    # 이미지(알베도 / ORM)를 bufferView로 임베드
+    def _embed_image_to_buffer(name: str, path_or_image: Union[str, Image.Image]) -> Tuple[str, str]:
+        if isinstance(path_or_image, Image.Image):
+            # PIL Image인 경우
+            mime = _mime_from_image(path_or_image)
+            # Image를 바이트로 변환 (PNG 형식으로 저장)
+            img_buffer = io.BytesIO()
+            # format이 없거나 알 수 없는 경우 PNG로 저장
+            save_format = (path_or_image.format or "PNG").upper()
+            if save_format not in ["PNG", "JPEG", "WEBP"]:
+                save_format = "PNG"
+                mime = "image/png"
+            path_or_image.save(img_buffer, format=save_format)
+            img_bytes = img_buffer.getvalue()
+        else:
+            # 파일 경로인 경우
+            mime = _mime_from_path(path_or_image)
+            with open(path_or_image, "rb") as f:
+                img_bytes = f.read()
+        _append_bytes(name, img_bytes, None)  # images는 target 없음
+        return name, mime
+
+    img_entries = []  # (key, mime)
+    base_key, base_mime = _embed_image_to_buffer("IMG_BASE", base_color_path)
+    img_entries.append((base_key, base_mime))
+    orm_key, orm_mime = (None, None)
+    if orm_path is not None:
+        orm_key, orm_mime = _embed_image_to_buffer("IMG_ORM", orm_path)
+        img_entries.append((orm_key, orm_mime))
+
+    # 마지막 정렬 패딩
+    final_len = _align4(len(bin_data))
+    if final_len > len(bin_data):
+        bin_data.extend(b"\x00" * (final_len - len(bin_data)))
+
+    # ---- 4) Buffer / BufferViews / Accessors ----
+    # Buffer는 하나, uri는 리소스 이름으로 설정(내보내기 시 GLB에 임베드됨)
+    buffer = Buffer(byteLength=final_len, uri="buffer0.bin")
+
+    # BufferView들(기하)
+    bviews = []
+    bv_index = {}
+    for key in ["POSITION", "NORMAL", "TEXCOORD_0", "INDICES"]:
+        off, ln, tgt = views[key]
+        bv_idx = len(bviews)
+        bviews.append(BufferView(buffer=0, byteOffset=off, byteLength=ln, target=tgt))
+        bv_index[key] = bv_idx
+
+    # BufferView들(이미지) — target 없음
+    image_view_indices = {}
+    for key, mime in img_entries:
+        off, ln, _ = views[key]
+        bv_idx = len(bviews)
+        bviews.append(BufferView(buffer=0, byteOffset=off, byteLength=ln))
+        image_view_indices[key] = (bv_idx, mime)
+
+    # Accessors
+    pos_min, pos_max = _mins_maxs(positions)
+    accessors = [
+        Accessor(  # 0: POSITION
+            bufferView=bv_index["POSITION"], byteOffset=0,
+            componentType=ComponentType.FLOAT.value, count=positions.shape[0],
+            type=AccessorType.VEC3.value, min=pos_min, max=pos_max
+        ),
+        Accessor(  # 1: NORMAL
+            bufferView=bv_index["NORMAL"], byteOffset=0,
+            componentType=ComponentType.FLOAT.value, count=normals.shape[0],
+            type=AccessorType.VEC3.value
+        ),
+        Accessor(  # 2: TEXCOORD_0
+            bufferView=bv_index["TEXCOORD_0"], byteOffset=0,
+            componentType=ComponentType.FLOAT.value, count=texcoords.shape[0],
+            type=AccessorType.VEC2.value
+        ),
+        Accessor(  # 3: INDICES
+            bufferView=bv_index["INDICES"], byteOffset=0,
+            componentType=idx_ct, count=indices.size,
+            type=AccessorType.SCALAR.value
+        ),
+    ]
+
+    # ---- 5) Images / Textures / Material (PBR) ----
+    # 이미지: bufferView 기반, uri 없음!
+    images = []
+    textures = []
+    samplers = [Sampler()]
+
+    # base color
+    base_view_idx, base_mime = image_view_indices["IMG_BASE"]
+    base_img_idx = len(images)
+    images.append(GLTFImage(bufferView=base_view_idx, mimeType=base_mime))
+    base_tex_idx = len(textures)
+    textures.append(Texture(source=base_img_idx, sampler=0))
+
+    # orm (선택)
+    orm_tex_idx = None
+    if orm_key is not None:
+        orm_view_idx, orm_mime = image_view_indices["IMG_ORM"]
+        orm_img_idx = len(images)
+        images.append(GLTFImage(bufferView=orm_view_idx, mimeType=orm_mime))
+        orm_tex_idx = len(textures)
+        textures.append(Texture(source=orm_img_idx, sampler=0))
+
+    # PBR 머티리얼
+    pbr = PBRMetallicRoughness(
+        baseColorTexture=TextureInfo(index=base_tex_idx),
+        baseColorFactor=[1.0, 1.0, 1.0, 1.0],
+    )
+    if orm_tex_idx is not None:
+        # glTF 표준: G=roughness, B=metallic
+        pbr.metallicRoughnessTexture = TextureInfo(index=orm_tex_idx)
+        pbr.metallicFactor = 1.0
+        pbr.roughnessFactor = 1.0
+    else:
+        pbr.metallicFactor = 0.0
+        pbr.roughnessFactor = 0.9
+
+    material = Material(name=material_name, pbrMetallicRoughness=pbr)
+
+    # ---- 6) Mesh / Node / Scene ----
+    primitive = Primitive(
+        attributes=Attributes(POSITION=0, NORMAL=1, TEXCOORD_0=2),
+        indices=3,
+        material=0,
+        mode=4  # TRIANGLES
+    )
+    gltf_mesh = Mesh(name=mesh_name, primitives=[primitive])
+    node = Node(name=node_name, mesh=0)
+    scene = Scene(nodes=[0])
+
+    # ---- 7) GLTF 모델 조립 및 GLB 내보내기 ----
+    model = GLTFModel(
+        asset=Asset(version="2.0", generator=generator),
+        scenes=[scene],
+        scene=0,
+        nodes=[node],
+        meshes=[gltf_mesh],
+        materials=[material],
+        buffers=[buffer],
+        bufferViews=bviews,
+        accessors=accessors,
+        images=images,
+        textures=textures,
+        samplers=samplers,
+    )
+
+    # 단일 리소스(버퍼)만 GLB에 임베드
+    resources = [FileResource("buffer0.bin", data=bytearray(bin_data))]
+    gltf = GLTF(model=model, resources=resources)
+    gltf.export(output_glb_path)
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Convert OBJ to GLB")
+    parser.add_argument("input_obj", help="Path to the input OBJ file")
+    parser.add_argument("--base_color", required=True, help="Path to the base color texture (RGB)")
+    parser.add_argument("--orm", required=True, help="Path to the ORM texture (R:unused, G:roughness, B:metallic)")
+    parser.add_argument("--output_glb", required=False, help="Path to the output GLB file")
+    parser.add_argument("--flip_uv", action="store_true", help="Flip the V coordinate of UVs")
+    parser.add_argument("--center", action="store_true", help="Center the model")
+    parser.add_argument("--scale_to_unit", action="store_true", help="Scale to unit bounding radius")
+    args = parser.parse_args()
+
+    out = args.output_glb or os.path.splitext(args.input_obj)[0] + ".glb"
+    obj_to_pbr_glb(
+        obj_path_or_mesh=args.input_obj,
+        base_color_path=args.base_color,
+        orm_path=args.orm,
+        output_glb_path=out,
+        flip_uv=args.flip_uv,
+        center=args.center,
+        scale_to_unit=args.scale_to_unit,
+    )
+    print(f"Converted '{args.input_obj}' to '{out}' successfully.")

home/ubuntu/aaaaa/data/rgbmr/MCVAE_CONFIG_UPGRADE_SUMMARY.md

@@ -0,0 +1,212 @@
+# MCVAE Config System Upgrade - Implementation Summary
+
+## Overview
+Successfully upgraded MCVAE's config management system to match MCDiff's base-variant inheritance structure. The new system is **fully backward compatible** while adding powerful new configuration management capabilities.
+
+## Changes Made
+
+### 1. Updated `train_mcvae.py`
+
+#### Added Import
+```python
+from mcgen.utils.config import load_config
+```
+
+#### Removed Old Simple Config Loader
+Removed the basic `load_config()` function that only supported simple OmegaConf merging:
+```python
+# REMOVED:
+def load_config(path: str, overrides: list[str] | None = None):
+    base = OmegaConf.load(path)
+    cli = OmegaConf.from_cli(overrides or [])
+    cfg = OmegaConf.merge(base, cli)
+    OmegaConf.resolve(cfg)
+    return cfg
+```
+
+#### Updated `main()` Function
+- Enhanced argument parsing with better documentation
+- Now uses `mcgen.utils.config.load_config()` which supports base-variant inheritance
+- Changed `override_tokens` to `cli_overrides` parameter name for consistency
+- Added comprehensive docstring with usage examples
+
+### 2. Created Example Variant Config
+Created `configs/mcvae/variant_example.yaml` demonstrating the inheritance pattern:
+```yaml
+base: configs/mcvae/default.yaml
+
+# Override specific parameters
+project:
+  run_name: MCVAE_v1.1.0_variant_example
+trainer:
+  max_steps: 50001
+optim:
+  lr: 1.0e-4
+data:
+  train:
+    batch_size: 6
+```
+
+### 3. Created Comprehensive Test Suite
+Created `test_mcvae_config.py` that validates:
+- ✅ Loading `default.yaml` directly (backward compatibility)
+- ✅ Applying CLI overrides to default config
+- ✅ Loading variant configs with base inheritance
+- ✅ Combining variant inheritance with CLI overrides
+- ✅ Verifying all original default.yaml parameters remain unchanged
+
+## Features Now Supported
+
+### 1. Base-Variant Inheritance
+Variant configs can inherit from `default.yaml`:
+```yaml
+base: configs/mcvae/default.yaml
+
+# Only override what you need
+trainer:
+  max_steps: 100000
+```
+
+### 2. CLI Overrides
+Override any config parameter from command line:
+```bash
+python train_mcvae.py trainer.max_steps=50000 optim.lr=1e-4
+```
+
+### 3. Priority System
+Configuration values are merged with proper precedence:
+**default.yaml < variant.yaml < CLI arguments**
+
+### 4. Full Backward Compatibility
+Existing workflows continue to work exactly as before:
+```bash
+# Still works identically
+python train_mcvae.py --config configs/mcvae/default.yaml
+
+# Also still works
+python train_mcvae.py trainer.max_steps=50000
+```
+
+## Usage Examples
+
+### Example 1: Use Default Config
+```bash
+python train_mcvae.py
+# or explicitly:
+python train_mcvae.py --config configs/mcvae/default.yaml
+```
+
+### Example 2: Quick Parameter Tweaks
+```bash
+python train_mcvae.py trainer.max_steps=100000 optim.lr=1e-4 data.train.batch_size=4
+```
+
+### Example 3: Create and Use Variant Config
+Create `configs/mcvae/my_experiment.yaml`:
+```yaml
+base: configs/mcvae/default.yaml
+
+project:
+  run_name: MCVAE_my_experiment
+
+trainer:
+  max_steps: 200000
+  
+optim:
+  lr: 5e-5
+```
+
+Run it:
+```bash
+python train_mcvae.py --config configs/mcvae/my_experiment.yaml
+```
+
+### Example 4: Variant + CLI Override
+```bash
+python train_mcvae.py --config configs/mcvae/my_experiment.yaml seed=999
+```
+
+## Validation Results
+
+All tests passed successfully:
+
+### Test 1: Default Config Loading ✅
+- All 23 key parameters match original `default.yaml`
+- Seed: 43, max_steps: 400001, lr: 3e-05, batch_size: 8, etc.
+
+### Test 2: CLI Overrides ✅
+- Successfully overrode: max_steps, lr, batch_size
+- Non-overridden values remain from default
+
+### Test 3: Variant Inheritance ✅
+- Inherited values: seed, offset_mode, etc.
+- Overridden values: run_name, max_steps, lr, batch_size
+
+### Test 4: Priority Order ✅
+- Confirmed: default < variant < CLI
+
+### Test 5: Backward Compatibility ✅
+- Original default.yaml produces **identical** config as before
+- Zero breaking changes
+
+## Files Modified
+
+1. **train_mcvae.py**: Updated config loading to use centralized system
+2. **configs/mcvae/variant_example.yaml**: New - example variant config
+3. **test_mcvae_config.py**: New - comprehensive test suite
+
+## Files Using Centralized Config System
+
+Both training scripts now use the same config management:
+- ✅ `train_mcdiff.py` - Already using `mcgen.utils.config.load_config`
+- ✅ `train_mcvae.py` - Now using `mcgen.utils.config.load_config`
+
+## Verification Commands
+
+```bash
+# Run comprehensive test suite
+python test_mcvae_config.py
+
+# Test default config loading
+python train_mcvae.py --config configs/mcvae/default.yaml
+
+# Test CLI overrides
+python train_mcvae.py trainer.max_steps=1000
+
+# Test variant inheritance
+python train_mcvae.py --config configs/mcvae/variant_example.yaml
+```
+
+## Migration Guide for Existing Users
+
+**Good news: No migration needed!** 
+
+Your existing commands will continue to work exactly as before:
+- ✅ `python train_mcvae.py` - works
+- ✅ `python train_mcvae.py --config configs/mcvae/default.yaml` - works
+- ✅ `python train_mcvae.py trainer.max_steps=50000` - works
+
+**New capabilities** are available whenever you want to use them:
+- Create variant configs to organize experiments
+- Mix variants with CLI overrides
+- Enjoy better config management
+
+## Implementation Quality
+
+✅ **Zero Breaking Changes**: All existing functionality preserved  
+✅ **Thoroughly Tested**: 5 comprehensive test scenarios  
+✅ **Consistent with MCDiff**: Same config system across codebase  
+✅ **Well Documented**: Inline docs + examples + this summary  
+✅ **Production Ready**: No errors, all tests passing  
+
+## Conclusion
+
+The MCVAE config system has been successfully upgraded to match MCDiff's sophisticated base-variant inheritance pattern. The implementation is:
+
+1. **Backward Compatible**: Existing workflows unchanged
+2. **Feature Rich**: Supports inheritance, overrides, and proper precedence
+3. **Well Tested**: Comprehensive test suite validates all scenarios
+4. **Consistent**: Same system used by both training scripts
+5. **Production Ready**: Zero errors, all tests passing
+
+Users can continue using MCVAE exactly as before, or take advantage of the new config management features whenever needed.

home/ubuntu/aaaaa/data/rgbmr/README.md

@@ -0,0 +1,207 @@
+# MCGen: RGBMR Dataset · Rendering · Evaluation
+
+## TL;DR (Quick Start)
+
+### 1) GLB 생성 – Run Mesh Texturing
+
+```bash
+python inference_batch.py \
+  --glb_list glbs_eval_ref.txt \
+  --prompt_csv prompts_bs.csv \
+  --output_dir ./outputs_eval/ours_glbs \
+  --devices 0 1 2 3 4 5 6 7
+```
+
+### 2) 렌더링 – 무작위 envmap으로 GLB list 전체에 대해 실행
+
+```bash
+python tools/render_eval_batch.py \
+  --glb_list glbs_eval_ours.txt \
+  --hdr_list /home/USER/data/envmaps/hdr_list.txt \
+  --output_dir ./outputs_eval/ours \
+  --devices 0 1 2 3 4 5 6 7
+```
+
+### 3) 평가 – reference에 대한 비교 지표 산출
+
+```bash
+python tools/evaluate.py \
+  --ref_root outputs_eval/ref/ \
+  --method_root outputs_eval/ours/ \
+  --prompts_csv prompts_bs.csv \
+  --out_csv metrics_summary.csv
+```
+
+---
+
+## 1. RGBMR Dataset
+
+### 1.1 스키마 개요
+
+* **SCHEMA_RGBMR** 기반 `views`와 오브젝트 단위 필드로 구성된 WebDataset.
+* 내부 후처리로 아래의 텐서들이 준비됩니다.
+
+  * `pixel_values` : ((V,5,H,W)) — **rgbRM** = `albedo`(RGB 3채널) + `orm`의 **[roughness, metallic]** 2채널 → 범위 ([-1,1])
+  * `cond_values` : ((V,6,H,W)) — **position (x,y,z)** + **normal (nx,ny,nz)** → 범위 ([-1,1])
+  * `normal_fullres` : 원본 해상도 노멀(([-1,1]))
+  * `depth` : Raw depth map ranging from 0.5 ~ 1.5. Background region has the value **NaN**.
+  * `pos_token` : Block-average downsampled position map for token position embedding.
+  * `w2c` : `c2w`의 역행렬
+  * 모든 키(`albedo`,`orm`,`pos`,`normal`)는 `size×size`로 리사이즈 후 ([-1,1]) 스케일링
+  * `prompt_embeds` : preprocessed prompt embeddings for SD3.5.
+  * `pooled_prompt_embeds` : preprocessed pooled prompt embeddings for SD3.5.
+
+
+### 1.2 `build_mcdiff_dataset(...)` 인자
+
+| 인자                   | 타입        | 기본값     | 설명                                             |
+| -------------------- | --------- | ------- | ---------------------------------------------- |
+| `dataset_path`       | str       | -       | WebDataset Shard(s) 경로 또는 패턴                   |
+| `schema`             | Dict      | -       | 반드시 `{"views": {...}}` 포함                      |
+| `num_views`          | int       | -       | 샘플당 선택할 뷰 수 (`1 ≤ num_views ≤ meta.num_views`) |
+| `size`               | int       | 1024    | 최종 해상도. **16의 배수 & ≤1024** 제약                  |
+| `shardshuffle`       | int       | 1000    | 샤드 셔플 윈도우                                      |
+| `split_by_node`      | bool      | True    | 분산에서 노드별 샤드 분할                                 |
+| `split_by_worker`    | bool      | True    | 워커별 샤드 분할                                      |
+| `fixed_view_indices` | List[int] | None    | validation 시 고정 뷰 인덱스. **길이 = `num_views`**                 |
+
+### 1.3 DataLoader 예시
+
+```python
+from data.rgbmr_dataset import SCHEMA_RGBMR, build_mcdiff_dataset
+from webdataset import WebLoader
+
+train_dataset = build_mcdiff_dataset(
+    cfg.data.train.root,
+    SCHEMA_RGBMR,
+    cfg.model.num_views,
+    size=cfg.model.resolution,
+).shuffle(8).batched(cfg.data.train.batch_size, partial=False)
+
+train_dataloader = WebLoader(
+    train_dataset,
+    batch_size=None,
+    num_workers=cfg.data.train.num_workers,
+    pin_memory=True,
+    persistent_workers=False,
+)
+
+val_dataset = build_mcdiff_dataset(
+    cfg.data.val.root,
+    SCHEMA_RGBMR,
+    cfg.model.num_views,
+    size=cfg.model.resolution,
+    split_by_node=False,
+    split_by_worker=False,
+    shardshuffle=False,
+    fixed_view_indices=[0, 14, 1, 15, 2, 3],
+)
+
+# 배치 사용 예
+pixel_values_mv = batch["pixel_values"].to(device)       # (B,V,5,H,W) in [-1,1]
+cond_values_mv  = batch["cond_values"].to(device)        # (B,V,6,H,W) in [-1,1]
+prompt_embeds_mv = batch["prompt_embeds"]                # (B, T, D)
+pooled_prompt_embeds_mv = batch["pooled_prompt_embeds"]  # (B, Dp)
+```
+
+---
+
+## 2. Rendering (for Eval)
+
+`tools/render_eval_batch.py`는 다수의 GLB를 **Deterministic**한 방식으로 HDR과 매핑해 Blender로 렌더링을 수행합니다.
+
+### 2.1 인자 설명
+
+| 인자             |  필수 | 설명                                                 |
+| -------------- | :-: | -------------------------------------------------- |
+| `--glb_list`   |  ✓  | GLB 경로 목록(.txt, 라인당 1개)                            |
+| `--hdr_list`   |  ✓  | HDR/HDRI 경로 목록(.txt)                               |
+| `--output_dir` |  ✓  | 결과 베이스 디렉토리                                        |
+| `--devices`    |  ✓  | 사용할 CUDA 디바이스 인덱스들(e.g., `0 1 2`)                  |
+| `--timeout`    |     | 각 작업 최대 실행 시간(초), 기본 `999999`                      |
+| `--blender`    |     | Blender 실행 파일 경로. 기본은 `blender` 또는 `$BLENDER_EXEC` |
+| `--script`     |     | 실행할 `render_eval.py` 경로 (기본: runner와 같은 폴더)        |
+| `--extra`      |     | 렌더 스크립트에 그대로 전달할 추가 인자 문자열                         |
+
+* **GLB→HDR 매핑**: 내부 해시를 사용해 각 GLB에 대해 일관된 HDR이 선택됩니다(재현성 확보).
+* **멀티 GPU 큐잉**: 지정한 `--devices`를 라운드로빈으로 할당하여 병렬 실행.
+
+### 2.2 사용 예시
+
+```bash
+python tools/render_eval_batch.py \
+  --glb_list glbs_eval_ours.txt \
+  --hdr_list /home/USER/data/envmaps/hdr_list.txt \
+  --output_dir ./outputs_eval/ours \
+  --devices 0 1 2 3 4 5 6 7
+```
+
+> 환경 변수: `BLENDER_EXEC`를 설정하면 `--blender`를 생략할 수 있습니다.
+
+---
+
+## 3. Batched Inference (GLB Generation)
+
+`inference_batch.py`는 GLB 스템 이름을 **프롬프트 CSV**와 매칭하여 `inference.py`를 병렬 실행합니다.
+
+### 3.1 인자 설명
+
+| 인자              |  필수 | 설명                                        |
+| --------------- | :-: | ----------------------------------------- |
+| `--glb_list`    |  ✓  | GLB 경로 목록(.txt, 라인당 1개) — 스템으로 프롬프트 매칭    |
+| `--prompt_csv`  |  ✓  | CSV (`gid,prompt` 컬럼)                     |
+| `--output_dir`  |  ✓  | `inference.py`의 `--out`으로 전달될 베이스 출력 디렉토리 |
+| `--devices`     |  ✓  | CUDA 디바이스 인덱스 리스트                         |
+| `--timeout`     |     | 작업 최대 시간(초)                               |
+| `--python_exec` |     | 파이썬 실행 경로. 기본: 현재 파이썬 또는 `$PYTHON_EXEC`   |
+| `--script`      |     | 실행할 `inference.py` 경로 (기본: runner와 같은 폴더) |
+| `--extra`       |     | `inference.py`에 그대로 전달할 추가 인자 문자열         |
+
+### 3.2 사용 예시
+
+```bash
+python inference_batch.py \
+  --glb_list ../glbs_eval_ref.txt \
+  --prompt_csv ../prompts_bs.csv \
+  --output_dir ./outputs_eval/ours_glbs \
+  --devices 2
+```
+
+> 매칭 불가 스템은 스킵되며, 요약 박스에 누락 개수가 표시됩니다.
+
+---
+
+## 4. Evaluation
+
+`tools/evaluate.py`는 동일한 뷰 설정으로 렌더된 **참조(ref)** vs **방법(ours)** 결과를 비교합니다.
+
+### 4.1 인자 설명
+
+| 인자              |  필수 | 설명                                         |
+| --------------- | :-: | ------------------------------------------ |
+| `--ref_root`    |  ✓  | 참조 렌더 폴더 루트                                |
+| `--method_root` |  ✓  | 방법 렌더 폴더 루트                                |
+| `--prompts_csv` |  ✓  | `gid,prompt` 컬럼 보유 CSV (텍스트-이미지 CLIP 점수용)  |
+| `--out_csv`     |     | 요약 메트릭 CSV 파일명 (기본: `metrics_summary.csv`) |
+| `--device`      |     | `auto`/`cpu`/`cuda` (기본: `auto`)           |
+| `--batch_size`  |     | 피처 추출 배치 사이즈 (기본: 64)                      |
+| `--num_workers` |     | DataLoader 워커 수 (기본: 8)                    |
+
+### 4.2 산출 지표
+
+* **FID‑CLIP (shaded, albedo)**: CLIP 임베딩 공간에서의 분포 차이 지표
+* **KID (shaded, albedo)**: 커널 기반 분포 차이 지표
+* **CLIP text‑image (shaded, albedo; ours만)**: 프롬프트와 결과 간 유사도
+* **RMSE (roughness, metallic)**: 채널별 픽셀 RMSE
+
+### 4.3 출력
+
+* 콘솔 요약 + `--out_csv`에 최종 metric이 저장됨.
+
+---
+
+## 5. 입출력 파일 규약
+
+* **`glb_list`**: GLB 경로를 한 줄에 하나씩 기록한 `.txt`
+* **`hdr_list`**: HDR/HDRI 경로를 한 줄에 하나씩 기록한 `.txt`
+* **`prompts_csv`**: 두 컬럼 `gid,prompt`를 보유. **GLB 스템명 = `gid`**로 매칭

home/ubuntu/aaaaa/data/rgbmr/complex_object_ids.json

@@ -0,0 +1,1678 @@
+[
+  "002f9bf02cdf4ff695ebbf61190ed89f",
+  "00366db8bb464e5c8b26703c70a686bc",
+  "00452de0ad4342daa0e139ad70ed2232",
+  "005e6a893d984538a7caee0cd403e0c6",
+  "00795a3f52d84b5d90fc352f220e6f8e",
+  "008be41361a44dfebe0d2003523e8f85",
+  "00e1ec5c6754447cbf3ccbf0a6383506",
+  "00ff6f491b1c4a74a5f90deb51c9a686",
+  "014012ec8eb3434d87adaaecb6fc9592",
+  "014d21f3b726425298b1a7a70a92b5a4",
+  "014ebfab735341248431da3d6447bbb5",
+  "017b9b167c654f18b2fee876dc5d4d25",
+  "01893d6934224c90a021ca9f1b592c59",
+  "01b077eae2de4aadac1e8de7d1cf3ba9",
+  "01d685032bb7401a90a57d2c775d7cd9",
+  "01e93883acac478386f049e339d5ae54",
+  "01f637d4083443548b382840d61a68a7",
+  "02583ecd6d02499daf73a1ba1981014e",
+  "02614a69beb24b10a01d34aa27ee7f58",
+  "02684df750894322ad1dcdbb9a798135",
+  "02873313e26f4543be9650357ee75448",
+  "02a5748af09c491780997e4af41fe316",
+  "03038d3742d6460db54ec989c8752831",
+  "030b98bbffd6481ebc86f6133e42ebcd",
+  "0319cbd39597460ba079c4737f856339",
+  "031debe8efad46dd9ba362604707ebb1",
+  "032ddebdff8b40e0bd2a51495753493a",
+  "03685bda9cb843d88f550a1f7f393184",
+  "037b2fde967243d883a0ee54b9aa4972",
+  "038348f33b27488e9b6ed0efe8415647",
+  "0397ff8b6a3148028f6db1e9e77925a8",
+  "03f33486821448e7961b111285525503",
+  "03f341ca580b47fb89fdc828a3248cd6",
+  "043353aec9b7403a8d2be7e075315528",
+  "043dbd8f74144e29bcd45ccfd59592b1",
+  "04629445e5b14f93bf18dcd211fa3d78",
+  "04ca24df177a4d14985a2e23b78def83",
+  "04db7c9a9ee9485b82999083b957b1c9",
+  "04e2f89dff504a1db0d62c2fc0788d6e",
+  "04f1cb7bb04d41e2bb7e291bf92f0744",
+  "04f51877ba25493d94d05f6086492f37",
+  "0534bc651ac84d0a912666060b8c0db1",
+  "0579a70d5a1b4e0fac473bb6861eeac5",
+  "059a7936ed89419ba9eae3153753ae86",
+  "05a396517a184002a943d309f4a2a317",
+  "05ee6c82045a4e3d9144d4cf56215f1f",
+  "05fc2a534c524c27ba7cfd74508ac482",
+  "0641654877a44c70b3ee5a44e163746b",
+  "0642122de7a04c8b8a694ce3735f8a2d",
+  "0657a328adde41ef978fa181c09955f5",
+  "0680fe1bd60343279824f50ba4c6f57f",
+  "068969f41a3245e8a4657e86db500e61",
+  "069b86d4b4a2492e92eb3349805479f9",
+  "06d400aa4d2343e490d07c23ff661e4c",
+  "06d5a80a04fc4c5ab552759e9a97d91a",
+  "06f867be028f44ed91f39471108c76de",
+  "0702225ca7e449c9ba85f3a142c65bee",
+  "07121d29537c4c70bccd4d02db6a6466",
+  "072d99792e534c22a163c20a917da4f9",
+  "076a510d663d41c380d8937581b68249",
+  "077c9dff3d824c8caf0e98df24debf57",
+  "07ff66a33eff4a0a93252317708d9cff",
+  "081f2783a8e44b559d37c08f7a402843",
+  "0846167f9302450cba1926c6fc5d6d42",
+  "084c7bc72c934da09d5aa2e00543a6b3",
+  "0853e9a4988b4953aae535dd23440e60",
+  "087d5869e9c34ac380a96ac0f892e05a",
+  "089327b8a40c48ec9d5b5946caf528df",
+  "089aa02943704e1aba9c953a89611d2c",
+  "08d237ffee3d4898b000ae0878a15a5a",
+  "08e02f5b80c34cb9b09c0a6a48deba9d",
+  "08eabca8888a41609cbc0043048dbd80",
+  "09146af7b959498482a73e717747ccd0",
+  "09415b04c271474a9757c53a7e27c414",
+  "0972ddcebed24084b47bab5eee38748c",
+  "09740836b5f04e8397a3b826ced11ab0",
+  "097fceeb1d85448882f5f9e385dbb144",
+  "09862077f68b4cb3a0c9c2ef82e359f5",
+  "09da8c6710654aa1b1ec8d6fb785b9b9",
+  "09fb79ac0c7c43ae9b1a1bd461619d9f",
+  "0a3e122170504d1dbddbde0a49f549e7",
+  "0a4c078d52e64241ad4da67e2f5ae3a0",
+  "0a4f3c74e1ee4ed5b9a5e36c7374aa37",
+  "0a5a267ffc814be49592cab5bdcf5d92",
+  "0a8293cd82b141d09b480a3f80c17b7e",
+  "0aa08cfba5bc422198828d1b720c53fb",
+  "0ad8b6a0fe5b40328bea1581000b9c9a",
+  "0ae52abcca054a57b58a0e9265b89b17",
+  "0af3d81c117e4e8aa84757b8f0df2ea8",
+  "0b04cb995fcc4c8cac5bfc8fc1aa4f3f",
+  "0b1e10b981194005b9fd842e45665fbd",
+  "0b73b0c1550746f38e4018f53e7bb56f",
+  "0b90478f3e1a4a1ba99fe0bfad77b96d",
+  "0b98efe575c446beb105a8dfd321f3e9",
+  "0ba8079c88fe44a49b84c051359a64e8",
+  "0bb43ca370104656959b91a27acfb6ab",
+  "0bc8be3751fd4af6b9171273a82592fc",
+  "0be09d151cfe4db5a6812306e9234ff3",
+  "0be84630c8e84508926c5922c541e1ce",
+  "0c1f1e1bc488444c8c5931d8c51ffedc",
+  "0c2d347c89b44323bc989ca85b6334a4",
+  "0c34e7efe79f4672ae5472fbe89e466d",
+  "0c9286b463384164877261b6ad6cd48c",
+  "0d322eeac13543c3b02ddf5a9dc5d66d",
+  "0d63a37b476a4338aa82084ba8d5e82e",
+  "0db114d7753344d6825aa4f21ec56db9",
+  "0ddefb81adf94e44a00ec5fa2db02630",
+  "0de0219a9d114947ae5626bd8a2abc75",
+  "0df3d7b24cba42ebbe2b6d542df0b2eb",
+  "0dfa5395abcb446c8779c1e369fc3727",
+  "0e09d9cd2efb473394e8977c57fba0f3",
+  "0e4cd5dff04143dda558b7b52d61f616",
+  "0e57497e42d74c76b5bd05021250dac0",
+  "0e5cd116d92c4100951056487260e026",
+  "0e80fb1e983943e78c64018efa7d8837",
+  "0eb317b09e5c44beb0e4681b06c15ae6",
+  "0eecf555488e4adfb57cbb0afe7836d6",
+  "0f03d940e6184871a0f38d429bfc006f",
+  "0f1a699145f441299d09ac3c0cf20e12",
+  "0f64e9fd042e4036a806cb1a4beb3690",
+  "0f88101d09d1408bb882fce581d9ec0c",
+  "0f9ebd68d56b443bae52cfebdbed0f24",
+  "0fdcb7df01d34aeea01ed1758d629f34",
+  "0feb0ffcfa9a47ba84ea7d3ac0ce5d70",
+  "1002c84db1ca45dc9d77c9e8e12a6437",
+  "1019140d9e354b489eaaf32895f8a7a3",
+  "1034844d4d564d1d9127b920c0f182da",
+  "1059e80a5f414388b2f240313acc5533",
+  "108635ed9e1c48b7a94f77e2405c4608",
+  "109ee24f61fe4c9bac7e4853dacca608",
+  "109f4aa661a24ffcb44758de9fdbff20",
+  "10b46ec4c10944faba5c00aa38a8c79c",
+  "10bff3bb4b474689968752ef9e2c0647",
+  "10d03a06c3474517b94a8d09f760aa41",
+  "10e1cceb4f1d4ab8bdb0c768afafad2c",
+  "11884dc5030840efa444dcfcc446389c",
+  "118ad6a688f24b75aa1751bbd05dd89d",
+  "119d5abe285545559f2a8b25760f7354",
+  "11aa844a77384a7cac91f1e7d0e39544",
+  "11aab5e450e640f5834da7c968b8d31c",
+  "11cc190943df4e69bf3b59c49defe013",
+  "11cdd06d68de4e42a1acf23093efddad",
+  "11ff1777e9254a5f8f510ff56108247c",
+  "122f100ebdec482eb5c81d01156246e1",
+  "1234ef64b5bd42be8f0e32725144790b",
+  "124ad78379bd4d259d9a253fb1a977a7",
+  "125c54f0b85746d496291418ab5607c5",
+  "12846c4c93d048feb07e96fb65f82ad1",
+  "12b5e7216c28431da88b63502faa7c6b",
+  "12d2ded2734a49aeabec371415409a18",
+  "12d76407cbd047d2a23a86c73e556c9e",
+  "12f2ba3da13c47f0a4a0e6c1521cf01a",
+  "13289bcc70ee4bd8a2f573b642aa1133",
+  "136494ed0f6c410caf53530bbe14ca64",
+  "138125d59ade4d328cc14cea5ff6f143",
+  "13987fff4df94d298c69027b98000516",
+  "13a1a1f76ec741e7abf4b4483ad36605",
+  "13aaa9a0462249f199ac808682fd57e8",
+  "13caef3c8cd344d6b696222deafa8515",
+  "14142eb541474335945c06a3630cafe1",
+  "141c59f3250c430d9e40c67887ba39bc",
+  "143f0bc1ebef48a4906597acbea6ea71",
+  "144051ab17b948359dc413c5a74968b6",
+  "147255b123c4419cb745c9a688f5a460",
+  "147a9dd1ec4d49e18ea793368ce4404b",
+  "14800755f6df45bcb07d71bee1464ab2",
+  "14c7c5d33a264a9c8de921aa77487941",
+  "1502810bac424f1fa91e3512dff3c59e",
+  "151f9f9b09a7455e9368d1cca370f545",
+  "15d86ea3b13444229dc8a9d3ca612369",
+  "15dfa9a9920d4508a5011a2d34a7ee9e",
+  "15edc8bf5aeb4185b6c0fb3753520c88",
+  "15fda9e154434cbc8a66bee0ccf71c65",
+  "1605c3b534de4de496c25012f8425dc2",
+  "162270d1e1f54c26b60cb691f5951f22",
+  "1633021c9ec94986b8f84ea703e1c979",
+  "16583a12813d41f1afe021389c6e8b7e",
+  "167151b4ff1842959d86ce589619b21f",
+  "16a421af043c438ca4cca51eb6ebe220",
+  "16ba45d18fd2443db23c858d3819952e",
+  "16d9b596dd384dbea7b88e5b3145b8f6",
+  "16e87b9d1c1c416db183baeb5aae8a50",
+  "16fa6474f4e6432fbfd33af10134d31f",
+  "1706b681036f41eab7156a461679420b",
+  "172615267260434f99da009ac53c22a0",
+  "17529cf13c1c4f7dac42b3a84e7915dc",
+  "176f8676f5214fdbbd2a5f780d062ff5",
+  "17f0b9d773fc4e968b162069fa5232d5",
+  "1852b23b73a94d4da46992c54e629da3",
+  "18c081f765854d249bb8dc580a1e9f7c",
+  "18d603a1f4b149d1b232563eba466a8a",
+  "18e60c14f46a4c3c9b361b80bf02beb2",
+  "18f67de6592a4cd4b8c31ff30cf4eaab",
+  "18f85fec08084a5d82a97347dc2b10be",
+  "193036f84cf34d489d49d0b8275e589e",
+  "193a7d0218b8400a9a7de60cbeae26df",
+  "1969eafcb62049e4b513aee276987ac7",
+  "19c02044ccf444038ac784dc88709a01",
+  "19c1558f1bbb403b943f338a9a70da89",
+  "19e4f6e71dba45ac8a3f027f33c4c3f1",
+  "1a0e4275e04442679edc4a8f09fff71f",
+  "1a35afde483f49f69a4a3c1da2df63e3",
+  "1a4a3013741e4fa5a70f5548958c21f0",
+  "1a5f0ad5860742c7be1da6757359230c",
+  "1a735bd0fcfc4e87ae3b89a7cdcecf4a",
+  "1a7aa42ca78c4e10ae98c1e77b0087be",
+  "1a7e9fe5bc284ea8ae54bbdb0fa8e87c",
+  "1ac4581e09b04ea6968a50e404a781ce",
+  "1ae3b14b5d5c4d0fb21abbf94655158b",
+  "1b03759aca22488a801662ed266068df",
+  "1b24bd7f2ca84cc4b9713065c211c5be",
+  "1b347387cd8741b5846534742ebc476b",
+  "1b3c4bcf091840b986c88c2a1740739a",
+  "1b5443261efb4c99be19ec82e3fcbecb",
+  "1b5ae52c77524c57b15f4a4c6a546087",
+  "1b834999835249228d4afb25cbc9b9ef",
+  "1b996dd59072468da9fcad2c8f0a8ef5",
+  "1b9c5e3b31fb4613b7be4ba640d70f0c",
+  "1be961388f3f4a858f9413232656c957",
+  "1beba9b24a9143df8559410f1522aad6",
+  "1c45284044f545d0888036ad34ac3657",
+  "1c670c8f241043d793dae59e1af693e1",
+  "1ca4dfff5736410fa3de378891b04eae",
+  "1cc0466a1cf14992b3329b13676e1295",
+  "1cc3e5baf8b54a358fc41062f74d97bd",
+  "1d0819976773469183e100765aa17244",
+  "1d0ceb703f704cd4ad3d0bf8e35f6b0d",
+  "1d133a74071c40bb9a49eb2bdb612827",
+  "1d13dbcab1224d54adef7dcf760ede5f",
+  "1d26bb676f044b6f81488ff7b43fd408",
+  "1d7537713c3c444fada9c650b84116c1",
+  "1db0bf90fad9413f9c70bd9afb8dd252",
+  "1dceb198db1d4c7db0777b85a57454ab",
+  "1ded9f27d0ae46e9a7f4c871eef7ed8e",
+  "1dfdb8070a8a42e1aab9fd38fa5630ac",
+  "1e025ab1bf234858ba48db14a54f26fc",
+  "1e61211efb1c49939ba6e45022e42873",
+  "1e704ff821fb4df5acb42117855e0370",
+  "1f2a9fc9bc0043328a40064dbe3fcd28",
+  "1f2ead206be24675bfbc63c3aec9aab7",
+  "1f5516c73928421cbc0ba1d7e1ff24d6",
+  "1f75786d2bf047a38f3971d7758aa990",
+  "1f8aabdf44424d72818bfcdc600bcad7",
+  "200ebda19ef44aeba975cf35e8d78cd6",
+  "204f47380bfc4d83901e19112c116bb9",
+  "2051d1d1a15b4d03bf3424fdd7717858",
+  "205a9efa37a54e8d8c3a1248de4c804a",
+  "20703acffbba47ce8b3755faa966ae22",
+  "2099b1f909a345d0be4ec934186ba866",
+  "20b77794b58d4f91b257676482fdf28d",
+  "20dd7f7bdc9a4c36aef491f12afa14d8",
+  "20ed29af326943a690ed71cee3efb5e5",
+  "20f9af9b8a404d5cb022ac6fe87f21f5",
+  "212980eff27d4d45abb2d72421a7ed9e",
+  "2144e2292abd45a58b75332a920fde98",
+  "2145f8891d0446b2ac4c25c285ff338d",
+  "215641b9f8e04a5585be12f050c29e45",
+  "216abeb437454c53bb556148bec71404",
+  "21705607294b4c1691e3770757f969fb",
+  "2177902e39d24548b3b1bbeb290a13ca",
+  "21851bfa7ee94bd49ae8161874e0b669",
+  "21ec37b286474fedb43307f6f289269e",
+  "22071b002d96499396a447b9235cec79",
+  "2221a5081f6d4ef9a1977d8d09d72941",
+  "22ac998056374bc3bd82d78b921debbd",
+  "22eb777ecde1455c9accc98b05fe1140",
+  "22f3cadbccad4ac68cec0a22a95a6d9b",
+  "232a246915e34a0cb7fd0485c5344401",
+  "2330d6dddc0d4a2b9fa9a644d249b766",
+  "2333799431754d42aab6712986a312c7",
+  "23466a346e9b4755a392d9cf69606a07",
+  "23b89235f11247e5a1dc1f55ba69f09c",
+  "23eb94cac33d4099b7185a81bdc038e4",
+  "23ede16550d84e81a4c255183510825f",
+  "23fa151346304c8bb8c58f58a76e6407",
+  "240d0bb449a949ca8b64cf1e776065c0",
+  "244b511ee2ca4f3794d118b872ee229c",
+  "254815aada9e445e927fea6a25a6d22e",
+  "254eb565be1b490bb64ef97e1274057f",
+  "2566ee4337b2410081cedc901b932618",
+  "256f723c10be45c0a2b662b3ca656026",
+  "2597f49cb567419f838c7df39c45d5ce",
+  "25ea2f17700e4f1ab9dc38b3fcaaba0b",
+  "26349afbeb094d1684e90884d98e38d9",
+  "264d5fe5038c408b87a7d2e62eaf0e35",
+  "266271bf84724e91ba76807e9d84e204",
+  "26847febe5af4c8e8615e1052ff69fac",
+  "269997245d764743a648d3ee4208e4a0",
+  "26f48e21a7f7487cada9cd59d840a9c4",
+  "2738b65016284ea3bdf041ea9135a121",
+  "273b53c4bd464b4daaba1fa94a9b8722",
+  "27c6ac2f6db648618186d4c00f3acfff",
+  "27da060494084e12a41403eec5a96498",
+  "27e541911b994ce0a0b546f0a861145e",
+  "27f6af85b7e9485da35e1bdbb5da680e",
+  "280a65bca20b425e96617b0dd78cce21",
+  "2819271389e1451eab2ef7e1333b45de",
+  "28215c6ceef6454cacebb92b5f2d4784",
+  "2834f838915b42f89f7dc299e6c39a0e",
+  "285420b2b0474a1199030d820f641d66",
+  "2871ff97b5d5478f9aa80a431a0049f1",
+  "2884eeef3d324910b50d10061dd884ae",
+  "28b76708813b402eaa71877738954df5",
+  "28dff4ee44a6444f98243982b6363b6a",
+  "28e7eedb0c4849ff8b0d744a74e9e424",
+  "28ec724bf8c141848b7910fa7ad25a89",
+  "290a75f5b21f4fc88c2a10849b4eb21d",
+  "292d33c6f0bb40c2b229cf8ba480f7b5",
+  "29360182779942f39104f227a161b987",
+  "293a20a6a9284de9a1c4d40092dd7bcf",
+  "293fc6beecd44a8aaf20df205822e742",
+  "2967048d83614382a43e1e9817b89573",
+  "296a53dcaca64681819a43b8a7ff7db9",
+  "29f78283c38d487aa8f34497d1233015",
+  "29fac935b6984498977832bcce0b1ffe",
+  "2a2927434cd14316a445044b69c6cf3e",
+  "2a6667ef214b4596b5dc407f4b073fdb",
+  "2a86f45c248d4b06a8ef86213916e089",
+  "2a8d375f2aef42259c6b6814a3ab72a6",
+  "2ac7e46b2ee6451e877c8f2a7d203859",
+  "2acda3ed2f9046129897f0f1e36092bd",
+  "2ad22ad416e74cc0a2a99567fd9c8f8e",
+  "2b1eab63ef4a48ad8e62be8d6b42d83b",
+  "2b273f7abb484ed29ace055984eb26b9",
+  "2b32f215f41d447c9fc1cbc75b64cd51",
+  "2b3e6f8e37344325b98a6165030f3340",
+  "2b4a5d2057824f44bf35056f531f8b69",
+  "2b4c4ce5ffef4646adf1c6b78d29b47a",
+  "2b4d6590fa6a4226a1366e2f636df7f6",
+  "2b9de21987c6419ebe72df19e9c4163a",
+  "2bb06b2f975545e0bf74b0be3c522d6e",
+  "2bd82aa8ca92482882241a3762684509",
+  "2ca8d4fbb25d49cb9da094549ed4ffaa",
+  "2cd2108f386f4b19aee80c782c3ee20d",
+  "2d1d858c4bca475b9eb5d6d95f7b6ea8",
+  "2d4f0a9502a346bba2718b7c43dd43a6",
+  "2d69c8441654486c872e7ef70ee913c6",
+  "2d76588c822942259b579e15640d7511",
+  "2d8b169f416f43df84fb679420e0a148",
+  "2da2098bab544c688fd106ed05ead14c",
+  "2dbd978c84da4270aa19091ed599007e",
+  "2dd385cde1c142deb8e3ae4b12e85dd1",
+  "2e09121c47cb493bb9fe754ee92653f9",
+  "2e0c2c37a55f48bba314c894ca5e5f0b",
+  "2e1fcfe8fd3b4ae4b41f79dfb2fcfc4b",
+  "2e283153e26146fc876895570d1ef74f",
+  "2e2bb2aa721748e785adbb86c98b7a23",
+  "2e352e9c26cd4109bb67132c40df8146",
+  "2e3fd6aa4e6b424391c1a13dbdffbfdc",
+  "2ea97968269c45e3abe17f84e625e609",
+  "2ed70b1329684b56a83d0490660cc066",
+  "2f09bba881d34aa1885f3b0476d94e61",
+  "2f1706233a3248cf9a74586fc2e7120c",
+  "2f1f291be93b4e09898a17f99e99d5d4",
+  "2f3b88cc0211484992b393a381a97fb4",
+  "2f6ab901c5a84ed6bbdf85a67b22a2ee",
+  "2f8b1430ff634501aa3a19717bed0319",
+  "2faa80cfd86a4af785c25ef632dc4309",
+  "2fb0edd32d1f4b1dac176f5d8352725d",
+  "2fbb8cea1ee740008ae5882e48fed8bb",
+  "2fcd9c9f248a46e5a2ea5b27379dcdf3",
+  "2fe47279d65d429f8101f97e7c89de7f",
+  "2ff892fcc6334a3d97d5bbf023b149a1",
+  "30017d8129674ed0b5d38dedf3f5686f",
+  "3030f6abd4854140ac3c278c3cdba25b",
+  "3086fd6d56e54573bdb00844ebca3c77",
+  "30cf4a33eaca4e53804f5abc0b8d00a7",
+  "30e22b51951945168006423813c26885",
+  "30fa4d77375349a49fcd60c4b2039a3c",
+  "31e0899e65f74cb9bfdc9df8e71288ee",
+  "31fd6b50eb5845d7b0e47d71639a07fe",
+  "3218791489fd47c59a33ee6ca38f0c72",
+  "32285d0de78b43b18defffcb3f647f37",
+  "324e3febdbc74b29a506760d6edb85dd",
+  "3269b8399110482cbf6bab889e70da25",
+  "3285d5f705604a74835c2b51df373d04",
+  "328840dc30c846d6833b57e7a33a41f0",
+  "328eb54341cc4b3f9c7a07fa1cb71a02",
+  "32c521425f124f24b86c64924d7fddd8",
+  "32f46385978241eaaae7ea692367d4e0",
+  "32fd9fd8240a4c49a1ed45f9d9c1e828",
+  "330b94a411bb465698c5eaf984c46bf1",
+  "331c237cc2044d87977cd3d3e9deabbd",
+  "3356fd1647c7403f90de64805545c77e",
+  "3366c19e79694be0896d569459dde186",
+  "3426ec60832b4f7c867ba29dc6d0e808",
+  "345fe9f4ebdd47b587f03cd3b81cd9db",
+  "3484a4e0862b4205aaeb1ef2c62e483b",
+  "349d730859c948b88f172fc5158e32ce",
+  "349e97902e844189b17cd86e01d5e2f8",
+  "34a383c7dab64f2a9267bd19acd0e8a0",
+  "34c2c5615fcc47b0a34de9fc9f77db8c",
+  "34ece7dccc4a42cd995a099f3c69e9ba",
+  "34eebb66d54b467888d446206bfe6ddf",
+  "35002d28d3fe4359be492bd444569744",
+  "351f5d4bfb0f416b8cffeb957f88d4c4",
+  "3529e97a616241f480a0115d74f97e80",
+  "356d3e62399b466fb6578fb1302bffa9",
+  "356d6ae5584f40aab1aced6bd6571a74",
+  "358be2d78ce8457b8fd37187d9f70976",
+  "3598d4508c8c4568a35e2ed00e4cd193",
+  "35bd8acad6f64c7eb7a9ff026868410e",
+  "3630b9ef86124610932a328aaf2ab023",
+  "36342df2dae44dd4894ad4658720c2a4",
+  "366d20b241a5446b85e0cd6fc399afaa",
+  "3687a268a444492bae2c81d83efde675",
+  "36d5b9c904ee4eea9a55ab0eccf7dee8",
+  "36d90cc8de3847379c8a636f548ffacf",
+  "36e269a8f74143a3b567f582781acaa2",
+  "36f06f5bc599499aa7a127c68668edc4",
+  "36f768d11a6342b7b36a121e014f521e",
+  "37071678dc284350b5268796adffb6d2",
+  "3708b0bedf8d47efafe22bea1c00a951",
+  "372200b925ef4dc69cf3364daadf786f",
+  "3724de1e56ba4f4bb0be2ca3170e39f2",
+  "374ed6172d2c405fabaef72b2b644149",
+  "3750fba31c2f445a864584cea5e2d78b",
+  "376b733d888c41d9ad3ac39eec4498d6",
+  "378988e0236c444daea672330e2686df",
+  "37b041d8521c4179b3c8679e2ff8dd17",
+  "383e4b856aed493a9ef70365cc3685de",
+  "387cd4307d1c472493254a659325fbd4",
+  "3886c1ca9a0942e19ef288493e1643cf",
+  "3893793770594f83a059317f587af8b8",
+  "38d1079a273f46349203fa2c3db35d29",
+  "38f04a4243f64e808fc7a6866c08dfcc",
+  "38f24c1eb8ae44d5bf2a4f9b940c96ec",
+  "392a59d222a647828cf3ee4c505edc38",
+  "394d1e8122554e00876789fafa68a03a",
+  "3953a48277d8460990162d60123c57dc",
+  "3959cdc6c8ca475eaa04f9a8d2dbf055",
+  "39a5dc35a05d4ac59f22c7d9ea050299",
+  "39a61e9a65994ebda5806039ef1afac6",
+  "39d799f20f4041228704749c854b60af",
+  "39db3486652b45548ab4dbb63a86911e",
+  "3a0d055986d74a9598a7a54c3fd05b9d",
+  "3a135daf87db490d9d9afb4b19a5a9d7",
+  "3a2954f4e11842f69482d1d6ff4eaf23",
+  "3a3afdfd1d2b41f68ed7d98c90b69d5e",
+  "3a4df884aff945eaa44e31d1b3a16f7f",
+  "3a5572342c5c4bdabaf0ac27b6577cb7",
+  "3a6019602c234c13a376c55a6c52c0b8",
+  "3a7fb4375e8941caae37767f0e30cf45",
+  "3a7ff8c34baa4caaa6098ee8ad447679",
+  "3a9a470a1d324a49bd362c580d046721",
+  "3af2417fa730468b81bcfcac715469b8",
+  "3af37c2c89d14ccdbc99563f969ce7c5",
+  "3af6861d9c604482a3a4354731c52c1a",
+  "3b1393cb24a74ab9a4a25003ea26ca6b",
+  "3b44c656b90341108cf27d3dbb88c4dc",
+  "3b6d35b6b4f44cb3832a8c0b7e124748",
+  "3b7d058289cc433da8338acccb4a59e0",
+  "3b84b153520c40048a1f2fa3fda8b866",
+  "3bae6520516e4d6d9f67c51837855144",
+  "3be2b07c8dab46dca538d21dae5b678e",
+  "3beec67e1ee84ed4b8d9e454d682e1f7",
+  "3bf8f2214b7043d3bdc543b8136d8e17",
+  "3c0cec271575485c83518d710384d084",
+  "3c1bd2de915941118890332de06d5df2",
+  "3c3ffeccb5be42ed8280d1e65ac2d200",
+  "3c53f38f89434099b973c2016e7d6535",
+  "3c7d73032bbf4b9eafb58bb943c2d859",
+  "3c8ecf379cde41bc8203945e00cf4487",
+  "3c8fabdb9e4c4bcd832e2c0b6913a17f",
+  "3cc81831328d405880c3fb5df62755a2",
+  "3cf7343ec2714fefaa21d4a9005e2f28",
+  "3d1429899c464501ad23cbf13449fde2",
+  "3d49477c17e9405683601bf9107b7513",
+  "3d5487df45fe47cca585e5c786abfde3",
+  "3d64b354413e48fca9fef934f25a882f",
+  "3d6f9421a9b54fe18b8cf894b17b3bff",
+  "3dc5d502413c41ac97eaa871deb32e9b",
+  "3de0ba7fb9ac41d6b438501487d2bd83",
+  "3e18491fe92c47e8bfae9f4064699e1c",
+  "3e3b24b28cde4650b71dbca053056995",
+  "3e83a01ee91b4e029f634b54439dc78b",
+  "3e8c37f3d701413897c6333446a76a6b",
+  "3e9b9f7841f54577829c0a9167b167d7",
+  "3f46bca9feaf43338e8956d227163738",
+  "3f49492bbed14d89b43cdc3efd5993c2",
+  "3f72a9830c2249e5ab397f30de1af84a",
+  "3f741c7f7d94427aa413683b71f2d31f",
+  "3fc51a48f58f42d28f325db7688be17c",
+  "3fda15638cd84814bda4f97327984e42",
+  "4047c9ac5e224f738bd67f6a409975bb",
+  "405351166c1d4f5d88162d941d44cd60",
+  "407bb4001ac746039d654f1332a3e40e",
+  "40b27a1c061242a89f8b313c7905533c",
+  "40db95838f9f4258bb4767a34fcf48e6",
+  "40dc15941e0b456692c83a97bfcd2474",
+  "40f09323341f436aa2814c3391e04223",
+  "410026f520dc4e6999006b38cfaf5eb5",
+  "41075d1b3e714637a16b4ed88bafe1c5",
+  "413d197f7c0f40f9a0aaafc323dae2da",
+  "41657917b9064ce6b4715e8ba282e100",
+  "417e3873fcb34f7ab9744506d7bcc838",
+  "41842c8d2ebd402da04def3c53c41633",
+  "418553c4a96347bfa4f9b349fb8d89b5",
+  "41873763c2c641599a3220b675a5fca7",
+  "41f03702289940b29831dcb771fb5f3a",
+  "42141d069d8148e3b6eb2d1d803f3596",
+  "421de5857e8c43f1b865d1f4d69fe708",
+  "423b8807f56147d68ee764c7ba7aa440",
+  "424df49ef1334360a9490da34c72b522",
+  "4282341a050f4fa9ac9d79c72948e042",
+  "4288f5d3a1554b90ade37894c40936a1",
+  "429e6e5cf5014e24b5e0c8dd8cb9259b",
+  "42ddfe3afe55443ea7ffd7e3e806a631",
+  "42fe263b572e4402bba90a41a3110a3d",
+  "430f3f8741d54753beb8b238d75c28b8",
+  "430f5651a39c46258abb30a22f7b5634",
+  "430f90b413c0491b8b3af457236449e4",
+  "435326b23a6240f48c2a48140522aa08",
+  "4390e3589d8a42e6838c001d697c79d5",
+  "43b44305830748d08e9a807006df124e",
+  "44112469dea546f396dbb6d35539e8e0",
+  "44358bf4519d4815b037cec09e92b7f7",
+  "4450069fee444ae0920aa5babd5d9239",
+  "4460c58b184244d8906ae6b822ff1ccd",
+  "449c75ac880f401eaf0fbc36fd17526b",
+  "44aeb49fd30549f08fe28a9c495c3ed6",
+  "44b7df77727143169c545e39956a77e2",
+  "4544f87c79d647bb985524155829d0ee",
+  "455c1b96e8214b45ac06bb2742d8b50d",
+  "459c229bb92a4f9481ea42b167082ff8",
+  "45a730f934154d0d94c99d1744c92564",
+  "45b619b9080a40968af0874e4ca30879",
+  "45e0eb9afc694a808fc847332b759bc0",
+  "46026de3201245fba3f64f42e502f32c",
+  "4608272844e143f3abce6473fd80d3de",
+  "462d3296495944f890e24749d251c573",
+  "4663bb43c0504c59bea8227084945502",
+  "4665bdec11204bfa8e1edc00020c63aa",
+  "46b3d3077d304c5695ef4ceef7685970",
+  "46e59cb1580e4de4884cc8bb93e91b6a",
+  "4713c91e35684df08700e4f75f4f6f60",
+  "472037a7db9a444094b92b55dfeca564",
+  "47267dcf929946c1816932b6961f83a2",
+  "4752dddced01498dbac8cfc0cb469b24",
+  "47ace76546294deb85503e7b5f8d8b55",
+  "47b7026b98d54cd7bbbada1ba1eb755b",
+  "47bf3947748f4d24afdddfe680734ab6",
+  "47d4b60361e747edb1f88deb29f26e14",
+  "47ec876aa4034f8f8af6f3856513faa4",
+  "48016ceb77654dd7af9cd699148afecd",
+  "48567d6a1702493080293ea6c21ebf94",
+  "48814a3c57f74772a9fcb68e6d720611",
+  "489d6b65fc484a25a3c0e26180630719",
+  "48ae4ca557d842c3aa3b5e5652dcdab0",
+  "48b4f5e4b6f04fa9a13d9df0b7a82309",
+  "48c4cfee42f548ecb86b46bf187fa222",
+  "49024fa002a14b6ea7b5b45b3087c7db",
+  "4903ff98262a43a99bba6184678d5103",
+  "492f2d0058104ec2ad5ca7ff09751930",
+  "494bb58e60984098afcbf2f095f92830",
+  "497228f579654318bd6a371880995a35",
+  "49bb763a0f804641ac6101872fb56422",
+  "49c59c03ea424fc496c82aa2e3143b85",
+  "49ed32b8617e49ec9f580b5f4a753b71",
+  "4a31f6063c3d4183b5faaf926540996c",
+  "4a3435ce074c4f35a28ff3d1bd7623a4",
+  "4abbe8f3478f408aa2c9a4f772976cda",
+  "4b18b0caed204f2d8be554b0336749d4",
+  "4b33cf70ffca4b95829bec5548eb00f1",
+  "4b78a721ae3b4e3aa4587153fed3f4c7",
+  "4b883942ae254cdbb32bfe9ff5420455",
+  "4bb4247ccc5740b8a5e1db834a62d1a1",
+  "4bc0da4c9df0406b85f03a08aeb42091",
+  "4c33ad28bbbb4c07bcb765bf7cd5327e",
+  "4c3d66f810e74a4bb0d16b41ba93204d",
+  "4c593d53f1e64f909de169125c977cbb",
+  "4c7033acf418436992d85319cb995851",
+  "4c7f765936cf4abdabdd6f48c1b2e4cf",
+  "4ce5c565a567461fa1d3fa124d2bf862",
+  "4cea6c63123149278f1f4c14a11986ef",
+  "4cf149f5d6ee4b8e98620568aa3947aa",
+  "4d0bd5f9eaee4bdba2360496fa83a3ce",
+  "4d18aabb12cd45e691a5eeae60feaa2f",
+  "4d31a5f2c68d4e41bd324e2b23767469",
+  "4d41a273fe4c42a59777ac80c50e7f65",
+  "4d490543088d43e9bf7e3817a4adddb4",
+  "4d5418cedfb9476ebf9093d7ed67133d",
+  "4d6ce2d72fd74a66b43d866e8e5f7530",
+  "4dea0b20b2fa4a699410274fca4d4947",
+  "4df51ea0c3974840b029a515ca975709",
+  "4e1634929caf4f85a608fa17b55a1ea3",
+  "4e22aca5a799466aa194b173ff53b815",
+  "4e3e9de83ea74dae9598b4dd47ada072",
+  "4e719b26038f4011a59f4b901c10596f",
+  "4e94a564395b4b148eba76f85a5068a2",
+  "4e9c3cccbaaa4adc947ad8e8ab351d0d",
+  "4eaadfaa977d43ed9afd8064a9932a20",
+  "4eb495cdd69e439591557481b7cb408f",
+  "4ef030bb0eda45648b34633e61fd5e99",
+  "4f0ddf5603b94885aa69279381c3c411",
+  "4f1478dc330f4da2a728795b729991dc",
+  "4f1ed455fb764463adb0ed1cb779b4c4",
+  "4f21c24a1f47436787798485138b6c2d",
+  "4f260979c88e4865bebfdd707cb7edbf",
+  "4f33982b99d6487084676ed5f2fb0f71",
+  "4f3882be7e184b129946d25a75df3b76",
+  "4f38ab83cacc477b9f5b5f6d0230f1c9",
+  "4f682b0b32204a2b88f1cec535e58242",
+  "4fb5fcff117a400ebf5514e69a654a9d",
+  "4fcf8b855af7464a98f26f11ccd4ade8",
+  "4fd48175b15b4047a2deba77ca22d44a",
+  "4febddbd35e64d4a946ece70ce564f82",
+  "4fef9ff01ba14955962d05be6e3205a1",
+  "4ff2fe86bf0a4f8c84f7894e151c39e4",
+  "4ff545286db441c1ad23a49cc0439262",
+  "502ff900e8ec4612acdde695650dd3cc",
+  "50b0c61bdcc7488f8a5c9fa40f1a04ed",
+  "50cfdb6dfc2d4bb399f84603eb9807ca",
+  "51341f3ba62a4d76a9216b4c36d673c5",
+  "518fe53890f5439bba014f47c5c1b272",
+  "5191cdca98ca4b4ba961f00747029b03",
+  "5191fd63062340de9173dc3157731917",
+  "51a661d02b804960bedb89ae0e753288",
+  "51acfb9670c34e18ad4678c8c0c2a9d9",
+  "51c73ff41be14fbb88f70f7a5e78e142",
+  "51d59c2e12044e90bed75ea1154dcbaf",
+  "520dd7d5295a48ebacfada13df7548fa",
+  "5227b0c53a794a5d8507d722e9deef03",
+  "5285e04a70d543c3a2d88cfb7b55665a",
+  "52b2283f5ad14f248dccf7a139662993",
+  "531b7f9d88f244729068fa024c28d7e8",
+  "535f1c0e90a64a1997d1e0a7fe972d07",
+  "536c5d02d1e94d02bcbcb17883cfe85d",
+  "537de3ffbd2649da865bbc842126f828",
+  "53880a84c7214c3486125b10803aa664",
+  "539fe5e6624341f3a0139322423eec85",
+  "53c53a112c674d29a2afdbddbe3cecb5",
+  "53ca491de67147539b60ea971cceb415",
+  "540606ed90d4449ca14d713cc6386d5b",
+  "5406fedb5aa6425f87ad0328a3313d56",
+  "540c1e3114a244d0b684f3aa9f8adf87",
+  "541b53467ad045d59a81fe79d740ea66",
+  "542e27eef15b41bc93105e4f1d847942",
+  "543b4973b8e246879712903e3f580219",
+  "54712cc9bbfe4937acbc0fe252336f54",
+  "54926ff096ac4b5686211685e834d908",
+  "54b4d912eead40c49c03ed90d07db8e4",
+  "54c43cf57ab34f74b349577ba28d6705",
+  "550402c03f5544d5b2a9824ceb7eacc7",
+  "5527751e780541658d1443693c3b02e4",
+  "5532b05f53504abeb8fb8646a6a68e16",
+  "553b1d7ee9a7455a8ca0aa71cfe1f289",
+  "5564981a8ee24599a780553fa2b88c90",
+  "557963f94d0043d9a991dc9306cc7e73",
+  "55de8d707c8a4bd6a92122c51bc00fa1",
+  "55ee397cf40c4f86af1ee31fb2096d82",
+  "560055d1f3294a0ba6586957521cae11",
+  "56280d1b819d47d081646a509b4ea50c",
+  "562aa156220a4c88b34ee564657c1119",
+  "563ab2826c5548d1878213506475cb5f",
+  "56591b27807d43d5ab96704449412667",
+  "5684c00652674451be036fc5d7dd7217",
+  "56c1e1a540a8451bb84c759a753050ff",
+  "56c2dc07f2674b80b1cc42b5cf9b4c89",
+  "571125aedf354c60a9efb91ef5c789ca",
+  "574728d8f8c248e59932f314704503a5",
+  "57477e790a354b07bbb319588992f06d",
+  "5780da17fceb40edb810cec008acada0",
+  "579082d20a7c4b37a9764c84f602c59a",
+  "57a9862778bd4a5c95f4d2cd2819763d",
+  "57deddbbaf4445c888b229660cea5e28",
+  "582f50faf1734840a0d2694a5f869157",
+  "58baf3bd5f2b453aae930394725fc228",
+  "58cd53de211e4a97b6172c43b82aafca",
+  "58cd73335e334ee5a7382b018f9285b4",
+  "58d223c211994c8b9f691c69a3742250",
+  "59037103a2664590af810ccdd0669c0a",
+  "593975b416ec47a8b9d04925bce78690",
+  "599261e8b6fd43c280da33b32cf6925d",
+  "599a25f9afa54718b686fbb5069747a3",
+  "59b1014a0d8c48519d210230045b7c1d",
+  "59c577503fcf43a992d061f76fd0e4b2",
+  "59cb77de6a8c417a90db182c30a60135",
+  "59ed5e0f87c349909aa621ddf27c0036",
+  "5a05dc5c2f8c4f0ab67fecd33ff08249",
+  "5a561e2ad060465fb9452eba307a76b1",
+  "5a8243d749264f319b2c9a9a985db956",
+  "5aa35c1999b34c21b97491698128775b",
+  "5aae6d93c5cd48c8a39bd561f0e411a3",
+  "5aba0956e8f048dead78bda3bf8b2ce1",
+  "5ac666618edd491b830f5993a1a361a8",
+  "5b313936cf1b4412b7ee0c418745308e",
+  "5b316b26d0f844fc987825b975adcad5",
+  "5b6f1f3e3d444e1bbf4d737fd262743b",
+  "5b7a57bede754e16adacaae90f9dcfd0",
+  "5babcc376eb744d894cecedda6a22e4b",
+  "5bb9ff97fb9f4e93aaa1f41ba7a47be0",
+  "5bf4fcbbc6ea40b69c734f54180fa38c",
+  "5c10edda4dc44aa482827753be742d82",
+  "5c231d0b680d4f04ae334907b4d7dc18",
+  "5c45848fbc8d4184bedbec4c3162d1ff",
+  "5c88598e4d65455796c32745d1172865",
+  "5c92fe5c54e44f9f95da2cf2e7a3e700",
+  "5ca514218156463f922e7b80ec1ed5fa",
+  "5ccc35586cb843c48b0b4fdbe16c46d9",
+  "5d1544f61cc74047a2453d55791882ba",
+  "5d6b77a9180043f0b2dcabac21bc27a7",
+  "5d74e5db6e554e0cbca82346602928ed",
+  "5d92d3a2be7640a190efee26d69d1347",
+  "5db5890c5fe7473aaad2b7507969ac66",
+  "5dd9ae47211c476f8d4226147fb1ed68",
+  "5e579948ac0b427da1b88306fc65f581",
+  "5e972cfb6d42405b8ac32477711bb22c",
+  "5eee9d9172dd4738adc6a1916f53eb1f",
+  "5f05a5cf07e6423ba546642af5debcab",
+  "5fc5ea17fa3043e196d3febae7802329",
+  "5fca91a6280d438a9512c21ba8d27e63",
+  "5ff9f5f3cbed4312b8db212c25457050",
+  "604a8cc0467d47e8b473d8aeb85f5c3a",
+  "60586aa3584d4f2d9f2a717d5f728c84",
+  "607d8d582d3545a5a11f1209863e25e2",
+  "60d5ff8cf56747fba0864be02022ef84",
+  "6119e54641db4c1bb3110186d66dd21d",
+  "615fd1374bea4eb6bc1689de109f3b23",
+  "6161c738388641b5b0803bc23111650e",
+  "617015b472d641a9b57269f1136337f5",
+  "6175a1681d0648de97b2d62730b2317a",
+  "6178e02461f9419a9d8fab1a28ff5c95",
+  "618758dd359e415eaa9dacdc212d00a2",
+  "61a66adce11d4093a269f92ee615b3e4",
+  "61acbe77d630470496e51d0c932ae5b3",
+  "61ba551451894a19855a6e9ac1c8ffeb",
+  "61e13992d9ff4af7bfbce8f08c23f0b2",
+  "6211a8e24151428a9ebef3678fd4b6ed",
+  "621948ce0a564a30857c3716ac7ebd0b",
+  "62260f2abbff4b1b82e982b515fcc652",
+  "6254e180378b416b8aa18fb1b5284c39",
+  "6267ab80b28745a68d6d1357e1e0543a",
+  "62a4c16ac8084bf88aef8daba8f15249",
+  "62c30a8ddb7c41c0a627e602c23fdd4e",
+  "62d3322948f849099efd16281a1079aa",
+  "62ef67ed44bc49caa8428116257f64f2",
+  "62f162c31a404e8d88c7c691c886b6de",
+  "634e34ce3c0b4d75addce41c96e7b5ba",
+  "635453e91f0f47b5bd81a2f2fdfa91b6",
+  "63c36c9b479c48dd9df620d4bef2a5e9",
+  "63ca6b766c004b2d917e871dd863b8c9",
+  "63e0c9e309df49f8a209229321153742",
+  "63ea7be8390a40938613da78ec736038",
+  "640b33ee7d784da68c25208c843b5419",
+  "6466a4a5cff4418a9d7f4e4f2415d282",
+  "6470a004a99b40ef859df84f045c6654",
+  "648b81c7b0ba432a865131844b749971",
+  "64998ee900d641d2b5096caaa5cdf006",
+  "64cc765c1dad479a8b19844775a2aef6",
+  "6592c60e5caf48d0b92458bb9e086bc7",
+  "65972fba83074d5581abbcc66260999b",
+  "659ff4224a2748bfa49ebd4791471530",
+  "65b130cabf4446d292880a00b4363555",
+  "65ce677e4d8142f89db7c10bbe0f16be",
+  "65cfc4b3a40c487e94254f2844eb86f6",
+  "65d2c1ff090c44ec8178ff7d14e9d7ef",
+  "65ee1e9da62d42609c533716bb98a411",
+  "6602fa4a62774841991c5c35783d884b",
+  "6613e638925247d6b90e31761dd04e00",
+  "661a23e81a5342d1a8225bf078d5c028",
+  "664b09353cc342159eb5039c0e8c5131",
+  "66cb2ab19a1e4320aae97049c19ef521",
+  "66e1041a107248f9a6a154c886b0583d",
+  "67175ce64e6b47838ec0eb90bbf4233e",
+  "671af27feac14c39826b6d6704806a4c",
+  "67a7bfd33fd04a7d91c127ca468bf047",
+  "67b08bb5755643c6b4a8e0aa409eed04",
+  "67b2d6983ae0405daa199b5ff2d06c5a",
+  "6802cd54a7c44ca586a89435e317af5d",
+  "68055038a07e4819bd38bc3ff3ee39be",
+  "68097329eafd41a4bd1d5f02c1926a72",
+  "681fff8a91354f71ad73e8622a28c588",
+  "68268b376b174123bf753f0beaf195f6",
+  "684b3d859f924c229ef67d0bd8aaf4b8",
+  "686496a328f04a42a54ca48c8c1e8c0b",
+  "686d33ba777740baa87ec2583a076dcf",
+  "6879bd0426894258b7118bfa74b612a9",
+  "688c0525bd564087a24e55a19b45e8d0",
+  "68b6a8afb6da4e829cbede4e50235db2",
+  "68dd5c8e5c7245548edcb533087bdbad",
+  "68f783c1fd6c49edb6ebc3478a30fb85",
+  "690832b29fd74f80adfb9c70a72aac8a",
+  "690afb5cd5114368939b5fb4728ba516",
+  "691c480c4e564fac90d64efbdc6a1a8c",
+  "69368f6373104f7dbd1fc3b9e5fde801",
+  "6941f28a27b742b08dadbf48b12ddf4c",
+  "695c62069ac44614acbfc6effcf7499d",
+  "6984a2f59b2642e2b021c1f1883d0c6c",
+  "69ae6c5ba6574ba1b9cf67ffd3052a79",
+  "69c164a0131f4170a6d747eaad66b458",
+  "69e273358c994685885a5cf43cbc2a87",
+  "69ee8a7b246948d3a8c4d00f5fe99548",
+  "6a0987a9fc1b43518a651d77a362fef0",
+  "6a1ac7dc4a72440f8aab912cd7c8c639",
+  "6a1c75c5fd984767ba49d3ae3ddd5fdb",
+  "6a35f92b163d4a54a4c227180262725b",
+  "6a65365b39a94b8f87bef73242a8cd4c",
+  "6acaac9c73214edeb4145bb3d4d75906",
+  "6afefa97b3e14024a0d498310f8fa3b2",
+  "6b00a054ee2e4cafbf126d6e7aceb935",
+  "6b023e2439a8440e8fe1f263ccbe489d",
+  "6b33d7c1a28c4459a1058b829b1d8022",
+  "6b37230169d44874998e0ddcb106ca8e",
+  "6baf3fa1245e4039baca7109bf602dba",
+  "6bb4b73d2daf4ca39f9044171c9c474c",
+  "6bcaee578c8e4dbbbaf5fdb746e5ff8c",
+  "6bd2f94a87ca45209520b431749b282c",
+  "6c04b2c2c8004dc18817e522e5543589",
+  "6c44adc2475b4710817508ef565f5cbf",
+  "6c574b913a84456a87dc631a0dfd69c4",
+  "6cda14331c9c401f8586ed9e93626594",
+  "6cdb44a5385047f48b2dcdf1c9edb771",
+  "6cdd6964383e41778e517abd6d11b3a7",
+  "6cf216e7c4b44eeeb8c32286c2ad3508",
+  "6cfe3dcd556d49e0b953042ec327b22b",
+  "6d38c30873c542eb984deea1be3a5fef",
+  "6d4f5b7a603b43ec80dd8689ebf092ec",
+  "6d6c3b8cfa54457a8ffaeb520744c0d9",
+  "6d6dc89a87554b58b1cdd477e2c5bee8",
+  "6d8bd1fa499b4815b234ab46244cdf83",
+  "6d946bfd1ab44200b97f63a39416eaf7",
+  "6dabbf3037f841a2a41cf7a6d4639324",
+  "6daf0cd669934d1cae88e31fedfa183f",
+  "6db9e7aad9d94e5bbf375ad5e23be4ab",
+  "6df9eea2a5be4f8fbec679cf1b34c059",
+  "6e444e52e656441d82394022f27053c4",
+  "6e68d8a8a909449991623605a46ff62c",
+  "6e9a71be6fb64785b09f2a4bbf2abcdf",
+  "6f29a99af529414a8c98f208dd9ef90e",
+  "6f2a81b4544c4518b705f6cad6244597",
+  "6f47d38de28b4a879481850b68bca501",
+  "6f5a60845785415eb34b556c65e290c5",
+  "6fde18e184154bfcb1c662333f54fb03",
+  "6fe0e1ee53eb4045b6d1a37f39221ad4",
+  "7054d2d8710b4213ad3857c1e37e57ec",
+  "7071b9cf40654ca68a618cc3aa3e8731",
+  "7095ad6338ec49ab86f026c5aabd1a2e",
+  "70a9556f1f2848eea9c1b4999c1d1d98",
+  "70c2c16114654e7e924f6254d4143c80",
+  "70c42fc642394764822e47f490c26471",
+  "70df779f759a471386ca79f735d0ccf8",
+  "711acde9db7149b79c6b90c8f9a736e7",
+  "711e1a7e980342c79428ef608d67653e",
+  "71416aa96c174625b4fd7b4fe5ed203f",
+  "715b5bd2832145c7b86ea7f785a2b73e",
+  "71893dc577d2466298b045f965482fbc",
+  "71a32216dea14f259a04745594bc1a69",
+  "71d34d3c50c84e9f8a7a22dfc6bce68d",
+  "724432b2187b496dabd74c8ffd119c1a",
+  "7291e2fd86b84a05844d23c4ed75d1f4",
+  "729f690692a5421592e8ab3217426de0",
+  "72d16ce9a267457680325b448853ff73",
+  "72dfd7ef4b564a55b5e1ab13da8d6a55",
+  "7328466df47b4c2c88c5194a26de281a",
+  "736bafbf63a045f080528e4f0b8cb552",
+  "739415ddd194434f81777eef8b041bc3",
+  "73f80ae78964472bbda19328b354fa35",
+  "742fbdd5bf314a488494a4afdba92b25",
+  "744715eecfa4452b8624e955679c3068",
+  "749ba33db8c243d986c864afe3955731",
+  "74e2f89c66c94d788a840ef7dc3cfc4e",
+  "750d9b866e5645ba9709bcb1dc9121ec",
+  "753427678aa74a248ec40c1a35d2c05e",
+  "7574c2f8e93a4628a00ca6fd58255e6d",
+  "75c60cb24bfa4ec4836f81a6ce6e6103",
+  "75ebaecaeebd4ccabd71729b296dc6e2",
+  "76069f879e974bdeb43af713082f2a21",
+  "761d9a3648eb4139aeb4c47cf93cfd1c",
+  "761dd9c19dbc4bfeae9d08c06722710a",
+  "761e5907082a4044a8417bfdf7ee4c66",
+  "762dbae73b7d46688d8b3657b7196423",
+  "7641ca70948247a48f57a8abb70db602",
+  "7684d220b9cf49c9ba1bd6256aa0416f",
+  "7689b79133234e5c9ccc5e881f8b8a7d",
+  "76a5864ca4f74c83a125041af4daa586",
+  "76fa02bee7e34413bd1f2af04a706107",
+  "7722d01005314531a1551a890127fc6b",
+  "7730b7282b254cd0a4f6163790e0bff2",
+  "7746283c634c4855b7e2b08351ab44dd",
+  "7758742ed2dd49f49c8a107c9845f597",
+  "775975bc98294259b76c44b0d75e9d58",
+  "776c21864f8341de9ee7454aa5b220fe",
+  "776d4b1c05ff463593d46fe3aad1f1a5",
+  "7777f9563f734375abf37aec8c4ff55e",
+  "77a20b0c965f4422885f558e94f69f87",
+  "77b1336e9c2042fabb5a7175427d5ded",
+  "77bc75c7ecbf435da1724062eced10c2",
+  "77bd325607974c4c8e3db77a0814842d",
+  "77ca17defa6845f8bc09fa350fd8c422",
+  "77e19e91f00e40a983d4d41ccb524ec7",
+  "7833f24887b14d1b9d2f98e9fd2e744b",
+  "78506b95bd5d4132ae00344e4c147d60",
+  "78514023844c4401a61b259630a39b88",
+  "789e28c00c72440d93b494bbcabf6bd5",
+  "78d89086a6f64b89b85158987ac366c0",
+  "78db1c0163b74cc8947edeb42dd79edd",
+  "78dbcac5eb3d4c9dafb9226cd78ce9ed",
+  "78fc5eaf6edd4c7f80fad7ed953822d6",
+  "790c40ccff6843eab0b7b4bd18421ff8",
+  "793d83afac59488cbfeee6ec4b0c0c18",
+  "794712e7d8a14367bafbeb2864f2695e",
+  "79477474139945a5a5a0164c8fa1b465",
+  "7973d98b789b44deb93c76aacbb8e66f",
+  "799b7ba3c0f242ba8d78dea38a54b916",
+  "79bc0a1e5ad2453b8ca761b7a12063e7",
+  "79c293346e5247ca84b31c4a6ea23131",
+  "79ce537a22044a3494b477739a650889",
+  "79ddf53a0a8b42b59540b29c42458620",
+  "79ef8744e7974cd69ba6c992f0ebaf1b",
+  "7a0496b2bfc5419e8d2e0b9b6cbb500b",
+  "7a6c27097bcc43859f146eacf34945c3",
+  "7a9f728fbf37420f9bd68cb3be8a2e5f",
+  "7aa8750fd1aa4dcd89a5c039caab5940",
+  "7ac460ae0e2d44fe977db67f4e90ec27",
+  "7b090422e3b745d2ac7632838adc2793",
+  "7b48292340ed466d831ef99b17df227d",
+  "7b863e9c3fda4147a35a2b5e4421dee2",
+  "7b8e7485eb0a4e9fb1cff992765f5be7",
+  "7c05c683425740febabd29a937de624f",
+  "7c1582b839fd4b318bfcc976e94e6c25",
+  "7c2652a35dbb48deb82bd6e87693a12e",
+  "7c65246246f74b7e83fb720fe062444c",
+  "7c66faf7b6104fa1b29035e3b5eb7102",
+  "7c86cf1acb4f4f7c9751c16101cc62ea",
+  "7c954751f56d4715ae7ce99aa0158b78",
+  "7cec9c91c93e48b185adb045404e8f2f",
+  "7cf2a742340647608e9ef7af049b6ac0",
+  "7d34a706b55d4acebea87abbe2e67d79",
+  "7d4dc0e32cd545109ed8a00bd85a7840",
+  "7d996ae0f69945e9a87fc3c542ce2683",
+  "7d9f4c78ef6f486fa94e3581548ed5bf",
+  "7dc5903c241c48d9989e10396e82f90e",
+  "7de0fde2ea434e378c0c948abcf5a91b",
+  "7e0ea5afa2464e3190f141d983382b6a",
+  "7e1fae1510be4ebeb41d0e7fca9b2fe9",
+  "7e45ad634364474798ba58c0db46ecde",
+  "7e464462d6fd463e860f91f70db01848",
+  "7e6f3be701224306be49375af2e39025",
+  "7e7703b966f44564a93b54cf5d61d2ab",
+  "7eab76e784054c7fb23afb9bf93feab2",
+  "7ec3859752304e1497fcad1dbc8fd27f",
+  "7edddfba4b51475f9438cfd8043ded86",
+  "7eee9870d8664dee9966228052d249ab",
+  "7f74cf149f434c378816bbc17084323e",
+  "7f7d9831de524660b6e2428ac19a674f",
+  "7fbd63691be243e996af064ba8e196fe",
+  "7fbfd3bef2d043729900839e6ca21355",
+  "7fc0b31e990c435ea4029ad2a1670cec",
+  "7ffeaf23240141f5b0974abb74c0e452",
+  "801da8da9e244c06a5af7b48e052b365",
+  "8026dc5f17254c9dbaeae2ee6e4f2779",
+  "8034f1419ad5453a8d79d9d641b3ef38",
+  "803cf6b3a1ac4de9b3306e9c119516c3",
+  "808cfda3601a4d978b2591133204c844",
+  "8094f24d861044c3a03b0fad4e8445f6",
+  "809fd40376ce47deaf0cba856ec2785d",
+  "81e14da144654169938f316d9962a27d",
+  "81ea8c1314fc4517995b7ce5218c676d",
+  "822dd26fa82143c98eb769729c245843",
+  "822e9386244749c98992fb5c09029c17",
+  "826d09ed54ab425a83ba09e82f082c70",
+  "82919f5c92a04c7cbabaed43ad02c33d",
+  "82de9078a05444e7b24bdca8f45b08a1",
+  "832e6fddc6104248bdc37545c7b506b6",
+  "8337f24d481b4b62a528b25ce544158c",
+  "83479a56bcfb45078bf65cfdccaf895b",
+  "834858034a794ce59d428379dd9b0f1f",
+  "83781a711aa9491f96bdeee95c819715",
+  "83ba11956b8c4c2ba48f00b27d3e076f",
+  "83e0f5401e15427a90cae22d0ec8fd02",
+  "840a2c9386c242d88bd1a6f8a3bf491b",
+  "840f27f03b464cb88423df7afb28c9ca",
+  "84a6575ac1d04589b7379f3b73944e2c",
+  "84a997ff428b4afb87d5e9ac3213eb09",
+  "84acd48c7e17498ea1d486556e635ba3",
+  "84b15921c86b4f7ba1bdbec7c854854b",
+  "84c113fd7225428c8aa8db4f28563b2c",
+  "854dbbb2ab994ec8a1b46289a333a9b4",
+  "85b31e7e54b74bcc92fdf9bf5dddd4cf",
+  "8606f632251943fab5c37de86ce86e44",
+  "8616350c05974bc28c6ae44ac788d8f3",
+  "8657d2c5e7734a1aba0b71abcb0e04ab",
+  "865ef12fcce64e61b97b83b04794d07d",
+  "867410393151465c8b48b4333602358d",
+  "86a5abfa102948119febdec47db00706",
+  "86c0e546489a426c941f26d522621c93",
+  "8700abc1bd4c4a90b97e6c462503cf88",
+  "8700d16e247d4a51956ef904643b95fa",
+  "8708af3768a743e7bc0c0b2c3bd2c5c7",
+  "872d01ee121c4d1ebfd38c5c2616e181",
+  "873144f3192a4b4490675151af5529a6",
+  "8772d82deffe4b8c868641618049bd3f",
+  "878781513c784e8c915a4df019faf22a",
+  "8795471e399040f6bf10813221f6dc22",
+  "880fa188c1704773b40aa222dcf485d2",
+  "881a9a5f16f04cb68ad1dfb5e3bec34e",
+  "8846701f077241e6bf4090b5abb19919",
+  "8859ecb3dafd4bacb977839427e43317",
+  "887796ef013c42c9837320edaa316d07",
+  "888947939fb743fd9cea71a2a5c07684",
+  "88e140a5035f4ab093fb62e494675b8a",
+  "88eec6b796df4444a7b24383369f350c",
+  "8926de526bdb487a94e3c3ce3dd49935",
+  "89301025dd73470c89fd328407a12011",
+  "895a7a7d01f64785b03ee102c0344371",
+  "896222fc3f2c454ab9cbe701bdeb7b33",
+  "897be755cbd04f1a8f33ea0ec852a280",
+  "8983e5d47f12435bbd1189168b75abeb",
+  "898feb7c028c4763b9627543038f5ea8",
+  "899d758d99294a019ca24fb848d0a60c",
+  "89f6779a95804832be2b52d2b1efd273",
+  "8a20e56e69e14851bb157a3d0ce2eb9f",
+  "8a4b9859fd6b4ce1a9619cee2dcd3e42",
+  "8a547261211b45ca96a852ca1dc5ba61",
+  "8a7d086e0a8949cbb9341f0763c98265",
+  "8a9edc74f8444057a0a17d4a42ad3aad",
+  "8ab0fec878924fd295e705ae080ce9a3",
+  "8abdc0b307634afaa099b9e38132c151",
+  "8acc1b8ae90c4ed78f9fc91285dedbe4",
+  "8acd766e66b6478a8843f03ebb085ba2",
+  "8b224a3b0b8d46c98e8cb572453d0eca",
+  "8b297620c9664c09bd216395868e3fc2",
+  "8b34d4b347154db5adad199575cb8fec",
+  "8b39b8957231420d919b60febb627bd5",
+  "8b7a073c112c48fbbcef3e02a14eb619",
+  "8b8b6a5ba71741e39934826d268a09af",
+  "8ba53f9043e64e89a7b7abb45651c932",
+  "8c07ef9c69b3482a86904cf6f6d12457",
+  "8c10d8b64f1d40afad35ebd9dc414177",
+  "8c564dccf3184669880b729e36541c3b",
+  "8ca5fcbf41734109928e08c3ba03b96d",
+  "8cb42925a5c5487596ef76b27d3d373e",
+  "8ccecf650a4a47d68f7d2ab27b87850f",
+  "8cd40f962f2c440c9caf1db1a505357f",
+  "8ce3d9559a134bb1895654770f721956",
+  "8d7f958e192b454fbeacd2f789dd4cd0",
+  "8d96c299671c4116bde407991e2ff04c",
+  "8db2af4b6a474097b946b767dfff8a8f",
+  "8db69d80a04e4afd82be3f95a66c9dde",
+  "8de9c1b24cc741b19eed5e6ff572383f",
+  "8df86390e8c34a42ae64100f03d2384e",
+  "8dfbf3c06ea4426d9bb9ff7ec125393a",
+  "8e46cd880daa4cb6ae7e18897cf98180",
+  "8e65882e534245c5b283577c5521acaf",
+  "8ea24adb9e9e4cd2b429b132ef049052",
+  "8efa4f8b34d042d78b1512fc5135eb1f",
+  "8f0d6e7582b44bb9b4a81e2f18b2584e",
+  "8f1cbc19dc414ad89097eabe063ada88",
+  "8f285bed98a641b383a45e7fe970175a",
+  "8f31a85c22d14760974c23535d32c3f2",
+  "8f33734764b64263b998610438addfe4",
+  "8f485e3c4d7f4cf291869b53d4bfb04a",
+  "8f79577525dd4c81bff24b86848785e8",
+  "8f8a6439e1c64106afa27b28936d5ef8",
+  "8fa283778cf84b6faf26114a40289e60",
+  "8fb4d6efb8c94cfb8c5b6f986a009726",
+  "8fc9e1a422c24deebbc955e871693709",
+  "9055288483244d228a5d183b206ab9ec",
+  "906df3a351564d2aa34e2fb6a85b71ba",
+  "90789439e18c4f3cbdb5c51b6c43b531",
+  "90acd51924864030ad8e019b332716e4",
+  "90c364a220514d20b9be9e06c1a0a184",
+  "90e943ba104e45f5bf8edb878d99ab95",
+  "91277c9935a745ac83507bf6a1f1ce0a",
+  "91413c86c92d47c4a61afc7e1875b1ac",
+  "9228178641df4a4cac543f129d526b16",
+  "92384abd65874b8eaecee88cacc299ae",
+  "924d926858e84e6cbe124cc5e4d3d797",
+  "92acb79620954d7faafe1b33f4ffadb9",
+  "92ba44c964614eccb41c7b0b2fe9ac5f",
+  "92cb6892fd2e46059a9fef031aa3ac11",
+  "92fc926cadae41468a3976b931c58ba4",
+  "9310ddb8efff44b3b59e1d553ce18a2c",
+  "933435c0db8640ffb17191b029727048",
+  "9338582032f348a49da8be159a650699",
+  "937718e4bfb040d08ecfb57f88028cd9",
+  "939c65e55bec4a27978f1480462d78de",
+  "93a6d86f97ff49e18220c8d5af6f2410",
+  "93d57f0c4ae04a89b698b84a5cc28620",
+  "93e9d54392d34f45ab3bb9183c9e721e",
+  "94007567ad674848baaa184dd69316c7",
+  "9415b5a3d80646a6a04c95021eead04c",
+  "9417265e5b1a44c9b96e4ea1c3133356",
+  "9436fc1799344a0a95133338978cb575",
+  "9442cb6575b3424fb608b1ef883f8ae4",
+  "9458727177e44b6194f518712be17d61",
+  "94c25097256547498d3119e1d3442aca",
+  "94c3787a948349f288a83a9a7accc76d",
+  "95028bb2100d48418161062f2d84e637",
+  "952bcd70171d4c4b965192cb284e2fb1",
+  "956cef1ca1af49f5953fc202b20dcfb9",
+  "957da1be796943dc988d10f5b087d8c8",
+  "95b6ed35955e4d13af13584f79fd96dd",
+  "95b6fbc975624eb1b88afb92e15658e6",
+  "95c53161769f4c259afbb41bfc94f5f3",
+  "95ef0d8332c44c8cb2892900d6cb27d9",
+  "95f6f7d8904f4a719eabff7d38e022ee",
+  "960bdb8733104752a1327d89d9fc8046",
+  "963c49228f73402ab93c59c8d8af8380",
+  "964b92911b4e4fbfbe82360ea1d476d7",
+  "967b58b39a244dea8ccf934d6973054f",
+  "96d5e95a6627478e9a9b7ce59738b1fc",
+  "9701c9240e5b40e7b5da140716a78d0e",
+  "9706a8b7365945ecb40fb57693c9b23f",
+  "9747c1a7c1e54e079fc5b8ecff22b96c",
+  "975bf43d39fd4440aafa511aa85c4693",
+  "976564c01fb341e3b75fc4dcc4e96ba8",
+  "978b2d75c8964f969c6513d140d15f0b",
+  "98161ac528d8469da7f1e98d05c8b4dd",
+  "9833113cb50c4e96b931e1500996d12f",
+  "9855438bf7d14f9b8a83e779c03e937f",
+  "9865812391e1410ebf320ba485cdc2f7",
+  "98cafbdff0c54ddb9f4b26d6a79768fa",
+  "98f31e11891d4b92b03ba96745fae9f2",
+  "991635b829a944768c92b65587279051",
+  "993a9c9ec519406ba3957046b8ed07f0",
+  "996d7f11a517464eaca8ac6fced3b1c8",
+  "9992ec94247644ec8f86e75159749f8c",
+  "9994a32ac7f041258ce42db6927109df",
+  "99b9da73ba7b42f19de8c3008224eb72",
+  "99c8aa6c73f7482ca9008a97393f8a3c",
+  "9a1f55860bb44de1bb536cd01cabd155",
+  "9a42e5c2337d43a69b7def22736cb369",
+  "9a49e336092d4e5aacc01aba739f601a",
+  "9a4c584a1e444676960846d8bc4cbbce",
+  "9a78cc1efe5148af93df636a777019c4",
+  "9a7d317fea29496ba0b2c5cd83be473f",
+  "9a89d1c9bda24ca1b777f5f0b4637bd2",
+  "9a93c60936614cb7bebc4791f8c7b318",
+  "9ad64e4cc1de4b719a669ef7caf6e329",
+  "9ad868279fe746cdbf64afe5668d7b02",
+  "9b12c91d3fad415392a3956cff795bb6",
+  "9b693a5b97c54adcb815701889f7fe1b",
+  "9b7ae513a2294711a9e083de1a4dcae5",
+  "9b82427e59aa44509713f4d5b2ae5b3c",
+  "9b8a6c99aec9431b811121675bba0f08",
+  "9bab8b2b13094066a36af285c2e20a9c",
+  "9bc7394303a34558b0c6324e56f47d54",
+  "9bf986e0ca924aca92462c5bf271e3d3",
+  "9c41cd8aa389471f9e95b6ed5367fb35",
+  "9c4b477d7d834ecf8b15cae2d2883438",
+  "9c8a9a46e86e4bdfb084c658eee53dcb",
+  "9c90baefd9444fd0a8d71e789e22d548",
+  "9c9c46a8146443deb081230ef202e987",
+  "9ccadc2945c34826a0ce1c37de13675e",
+  "9cd02abf1e3f43e388bdbee8562d5687",
+  "9d5502124c954756a347d7ab07557b93",
+  "9d7456f25298471aa7b736f2e1c3ffd9",
+  "9db3ddd3c9d549f3a35b92288bbd6a1d",
+  "9dcb7e0e87194b0a9d0bc81fb3685920",
+  "9dd25a357ed642b1b2607ce2b1cfc0f3",
+  "9dee38c8c7d544018dd60410c8dd7059",
+  "9df9e5041a48418ca9691045b4e59730",
+  "9e0bdadfc8c24565b1160497fb0f4f27",
+  "9e1fd2f3d79348b9a45350c644fb2e29",
+  "9e4011bc059c4a1db5f8bea8bb96484c",
+  "9e4b555e7d4a4e9d896b284d8faa03c1",
+  "9e6b76fab17a4b40ad79cb72a46f3899",
+  "9e6db7d9a00a417c978a71b371c68a5f",
+  "9e74bafc9d0e4d739b33a08e5361e7db",
+  "9ee0770e069448f6ab316ef8300bd5cb",
+  "9eedfb865cf84cd59a15e65f7f2d393b",
+  "9f0a3283cbca4454bf04c8d43494247a",
+  "9f24973fc9c344539a6105a1e7357fb4",
+  "9f4c5635597e4edea48b6f069f12a154",
+  "9f691379311f40289c6b661973eb2633",
+  "9fa2da2c42234b58896e8d23393cac24",
+  "a022864ae7b642a39469652c3eda2b9a",
+  "a0426fb42d044ce386d55ed4594a328f",
+  "a067690ca5ba4734a6cecb51816c534f",
+  "a0ae47edf24b4e8ea3b4d66afd70a95e",
+  "a0bf19176b5245bfa4704242fb16aee4",
+  "a0d0ea06fcea41fd843af40691e85f34",
+  "a0fd7b70748f469e8a984b84ae570d6f",
+  "a117781bb5724467bdb321aa7ac02d1e",
+  "a11b00033ce344aba75918fea71b1863",
+  "a14e7cc8ae6643d69395276456d813eb",
+  "a1613311507a4fc8b6a4f3d859a447e6",
+  "a1754867f6094ba28b32cfd72dce0ff3",
+  "a193d18c46084d60b2500cf235a41a89",
+  "a19f6e77e5f244188ae31c800e17fc1c",
+  "a1bce4d33d3d4d47a32745b785de6003",
+  "a1c46bc271bf44b3afcc7320de94797c",
+  "a1caf2c91b9745949ab91cdc9902fea4",
+  "a1f6743d821c41028f095731fabf54da",
+  "a21b111d6bf34c6b8e3e553f653f83fd",
+  "a2296d354281424188ab006d3ccc8b0f",
+  "a268989869814587add9bce658d79ea6",
+  "a28a424008f04771865712e5e3054f04",
+  "a28f97adf9ad47d6806a4d6d85706b81",
+  "a29496f73923481fb509e002671e6a62",
+  "a2d8cd051fe04166909a8eb3fd2af233",
+  "a2f31b5a37fc44c49c11026cf2a97f74",
+  "a304a6be438241c5bf8eb89f574e3d7c",
+  "a30cdc34303c42cd953dc935e1bf2110",
+  "a35c9d88cc9b48d099a69dd1d3aa69d7",
+  "a3911e5dafc44f9fafde9e8d424f4a4e",
+  "a391c14193234bb9b654848a2b386c22",
+  "a3a5829c7e5141f3a4ac46740bb440f3",
+  "a3d79ffe82f94c1daa45b8ffe4933851",
+  "a3f3028abd154ce3804f8711c30d4f6c",
+  "a4070f7a072043ba86a590b2cb48a45c",
+  "a4197833548745c2b13ef53fb2cc4d38",
+  "a4909ba08ad540c289d03c3c67b9d856",
+  "a4b0fa883f0649f4968c94f3c421d493",
+  "a4efba8b24f0499c8c248b0ea366db88",
+  "a5023a5400274762ae9c128c07c82443",
+  "a52bc5f0be6746888734e7b6277bfabf",
+  "a55418a161a14c369d01fefbf7f4c442",
+  "a5cf428b41374afdac04c62137c87fb7",
+  "a5ed5a1f630b4d689b2d65e5ae8b56fa",
+  "a6004ae37b2247208e80b8b8412f3b61",
+  "a63b41bf6b364c9f9177c9b1e3da049d",
+  "a63b931003a44d45aa22e9bad9dc8b1a",
+  "a645ef2489244f52bf3ccf6836b60984",
+  "a646038eb9ae434f80dc6dc726c1dda0",
+  "a654dcfdd5744259a88885c20d14cd9b",
+  "a65ec17538c3429ea50ceda913fa565e",
+  "a6b9bca28b9f44429e41b815976584ad",
+  "a6d34a86d9444ebd9690ea1ae8ba594e",
+  "a700978deeb14f67b2710afaedc2a807",
+  "a707582f74e74ddb86bb109bb956e750",
+  "a71b6d54f71f43e28c019cdb42be55b9",
+  "a7229ddcde4043f6a0e34ef3f6df19ff",
+  "a734f7a8acfc431cb19993dd98a2998a",
+  "a7352824623f4629976067a996dbc37e",
+  "a739fbc9d88c4daf9f730dd9f6778c68",
+  "a73d63f44fd54f209bb6bac37fe247b9",
+  "a7780e3667954bbf97bb619cb8a3e272",
+  "a828fe9dc5a9415ba3d7f977a9825ea5",
+  "a82cb8c7613a47a693e084fa52d0d9bb",
+  "a87a76e7544a41de971814dc9a19eb11",
+  "a893146b76cb470b9056e6b88ba8afb0",
+  "a8ad20910503482db578f9298afd81c6",
+  "a8c375384be9427b91a4f68125c3942a",
+  "a9161e6c2ec14d7aa9fe10194468f8d6",
+  "a93e93e3e41e49feac04747c6f540b05",
+  "a977c54c25c74a0c9fc0fc4de99ecd45",
+  "a9a6555b9cf949d3a01003c3bed6dac8",
+  "a9cd031ef92f459995d4d2e8595583bd",
+  "a9ce75a690c84f06ba0934c2a27e7fcb",
+  "a9ddc86165ba4b819360231d29b9defa",
+  "a9e576e05442468a94e07d5c6a652b3b",
+  "a9fa5d325b1f4b2b84c212faf1254ccf",
+  "aa0183f6bf584115a7d3edeec4d7dac9",
+  "aa2be996b12f431cbb9a214519b0923c",
+  "aa5f73e3d7774a9c9e72b25db2b89da9",
+  "aa7f2187820c49d886e40c69c24c10e3",
+  "aab20be23bde45cbbf26a46f51a09e91",
+  "aac11115274f4fc78265b0f04df2e520",
+  "aaeb0e31501e4f6d8724b6065f7a62be",
+  "aaf795d26d2045a2ad366a62f661ef6e",
+  "aaff1dffbcc44f2e8ba35516509185ed",
+  "abbf5216c6a44b70a7a26d35ced8e1c1",
+  "abcb0be28b944a49887d49935464be9e",
+  "abe0b76027f6445ea496499cab9bf2d0",
+  "abef4ff1da264d88b10f99e910759ddc",
+  "abf756cea6e34b14835b7c0dcbf07c3a",
+  "ac3483cf825249dfab4fdc00fe8e21ac",
+  "ac37aa4de6394799bd3c1143f0a0742f",
+  "ac6ae15a135a4e848036c0b4eef86d09",
+  "ac723edacfe94c9a9233de5e82a227b2",
+  "ac967d0e52d04e87a2e9accc69260636",
+  "ac9f145a25fc4eacb6fe3904a7e2c9f6",
+  "ad0a47e65810464e9d4ba6ef65208367",
+  "ad224585dc804988b812821a51a573e4",
+  "ad22be23ff8d40b9928500b13180b47d",
+  "ad5f24c0c0544c12934a1e8be286f5e8",
+  "ad82c1a7ee664dc5a260ff947c693fd8",
+  "ad837c6229fe4a82a1a60dda23c8a1ef",
+  "ad984cb5ced945d7a5c53a7ed2232c7b",
+  "adb078c42d0746798efaa3e4686afd33",
+  "adb24e49311b48e69a95c3a5324817ec",
+  "adc46168b8c54bc4ab01343638c42e10",
+  "adcc143d66344019bf695d63299486b3",
+  "adea146fdc9c4fa5a9a68a257e1f7060",
+  "ae0411f1f2b44d8189028448ab49b2d3",
+  "ae07b87675b24418b6763cd18cab83e2",
+  "ae1fc814ccd5461aa243c53fcd0d6c83",
+  "ae314dc3de994d2a8d7ea9dc052b28e0",
+  "ae3ce147938d47788cf9d5f29d32fa66",
+  "ae5a5ef80af440daba1b97464429c519",
+  "ae5e5283d56647beaaeb029d4fb92faa",
+  "ae61592e73224a6c90897dfe4e51e0fe",
+  "ae707476ba784da2bfa83406cbfc4f3d",
+  "ae87e445e97e48648b073dee0abe72ef",
+  "ae90aff7b8834654a6f5cabff7d35437",
+  "ae9d7a4529134cb0b3601c0ca699ffe6",
+  "aeef6d53b5ce4f2eb391281a2c04e89e",
+  "aef67d7de76247969056225468ac1764",
+  "af57904d39954ce09375f94134105ee1",
+  "afe31faf1d5541d3bfed9f2cd86f29b5",
+  "b0264b10cab6494f94b4073b7dd92357",
+  "b02d58f07e7243a0ad4077e5f778abef",
+  "b089ed83b2974a81a00b5ac6330c07d0",
+  "b0b69dac8c0748578c5a9a948ca7c2a0",
+  "b0c00b0f224c4b04b4ecf0468445d0d8",
+  "b0cf6517af894b59a25ff95aa6e83aa4",
+  "b0e026d0c08448bdb38fc60ce71e488a",
+  "b0e695e8483f46f88943173a70be9709",
+  "b0f83707ec294bb2813e67c8c3e5db31",
+  "b101fd45b31c4719b7caca788619716a",
+  "b13e35727e404b2b9fd3ea64c083ff2e",
+  "b15c6bc6090f40009ed8e8511820827a",
+  "b19b27b5bf0d498289c662177b465350",
+  "b1a1aae682f241b280eab323cff8014a",
+  "b1f89ce951194147bce1bc55f9248c28",
+  "b207d9d282484037b072daecbf96c2a8",
+  "b21b62f911e54b29863d37b2912105f7",
+  "b228a29fa84544c2be501c295653ffe7",
+  "b266a2134d9945f697123fc6c8e23522",
+  "b2686595ad1d4907bc46e87e9131df1e",
+  "b2698fff89454bd5ac826ac762fd0a32",
+  "b28364e02a294f9bbd8b3fdfeb33cb6a",
+  "b2935e579f4141dc96e16f77151997b1",
+  "b2a9701db8b84d3a82f99d1f719af0d4",
+  "b2f80a34e1cb428f9f0139870a18f1a3",
+  "b2fe519bf8ca4aeabdb5f489c260294a",
+  "b333b3e6066443debac98c0ab1897e13",
+  "b3389be723684644b731483f31ccfc15",
+  "b342af82a6ba4d3f94f546611782b963",
+  "b34f1c1ef15b4a07a160b1792eb2ebca",
+  "b369627b8a8f47c297a2a4e67929d3af",
+  "b379e058279844a7b6bc4e7e16476171",
+  "b3fc468b4c4c4e94816cf878f01fb0a4",
+  "b43d9c7d138f49ab9f03ceec47d636b5",
+  "b4621c3f42c04db3ac22ee782a77abdb",
+  "b47899d1db7c4d068c9abb6f78c5f147",
+  "b4dcf459298b43f19ccef6a999ca88ac",
+  "b4e4c397f4f045adbe9999d414fae54c",
+  "b522897d579b4520be476c586a5f14ab",
+  "b587a8c1714c4dca8810ba06b6f65475",
+  "b5ac89e44bd3413495ed6b6ec7fb6837",
+  "b652c476dfeb46f283afb1b471bff652",
+  "b6695c4c642a473ebc870cf303a6b78a",
+  "b66b45a9f46045f7914dc2a5472a7e50",
+  "b67ae7fa7aad4fe0865d0fce24a5ee07",
+  "b6d4f852379f4504b2e7abc28a7dc740",
+  "b6eb96e28f184cf5a8098f68570f2314",
+  "b6fe8b5f49d04d1788829597bb65d410",
+  "b7074ce8f0b34ebb8e11eb1af7a857f3",
+  "b72b882899824e1aa4b7c361654948c9",
+  "b73508fc71c045e7b8895e5b5e13c4a5",
+  "b75ecd7e5126418cb1988a91efb324fa",
+  "b7a85dc6d37a4f06a2275c70f045ce6e",
+  "b7c2b3de4e6a48dda3909a6db64c4ac4",
+  "b7d498a138f343c7910ea169ed1c2a3f",
+  "b836c6e9ffac44f1bba88d57bf225f16",
+  "b8c35388ecd443178c24a5e5cb4c972c",
+  "b8ea5f41413f4c9baba3cbd38bfbc899",
+  "b9057fa941aa41d0be9f20514c1bed24",
+  "b920ba1ce9a14e41a222749c24e5abed",
+  "b93effd9393b44e08b4b89911ff56c0a",
+  "b961b284a61d4347bdbc63399cdcf8cd",
+  "b969d3c8b4fb4222901c3de1ace9cabc",
+  "b96cd6917b974bfe99116ecc288a98cb",
+  "b97e39d020364038aec5809c10729c20",
+  "b9a66b51a6ca4262a6b3d5c8e5f963ec",
+  "b9f15edeb58647c08a9adab01c91683b",
+  "b9fd273288e445bbafe8c149434214ea",
+  "ba09a16bc68e47f28d9900ca2ee70cf8",
+  "ba197f0c7dc147a78005c100a8c67cde",
+  "ba3d56e0c6b843bdacabfcb4b4f90801",
+  "ba5c799fb68b4ac8a1eedfa0586f04f8",
+  "ba6c4234114f4378bf852a5ba12bb7c5",
+  "ba7fbe198ac8410b8b27f81243cacc8a",
+  "ba81bdfa19d54db2a15422341ca8ab87",
+  "baabe69ab1c44cf0b29c147ff0dcedaf",
+  "baad87b0ba9448399d7f72d0fbbc97ff",
+  "bab447d504d94e9691c43ab851e37221",
+  "badc51f2098a4f40a7d166fec9812f4f",
+  "badee623199445cab579b25c535311e0",
+  "bb3d01e7dfd941ecaa8757d59aa560b1",
+  "bb5452b2711c444290834a31996537e1",
+  "bb57ddbb1c2140358b027dfd16b7154b",
+  "bb7483cfa54a47dd856bd529818673c3",
+  "bb8ac243ce464df1af1922599fb3e901",
+  "bb9468613b2f419788f74f94a0820878",
+  "bb9f64ffbff74a0ab4db3d3fe2667388",
+  "bbb693d729264b76a667c2db6d35b2e7",
+  "bbddc0cc8d6a4c9a96a0fc4170594336",
+  "bbe6eb2ff68e46c19f1bd22c1b24dc07",
+  "bc013f0ea12d426d9338d3b437dd5593",
+  "bc0cbd2413a148658db983de5dd1f80b",
+  "bc2ef0701e464672ad8ce2bc3e78f8b3",
+  "bc32d3d924774b3caab10356c1177505",
+  "bc445514ea3c4fd9a316053928cbba12",
+  "bc5030885a5548e595b0a3bea9599354",
+  "bc63ebaf707f4185888bce9c54b6d59c",
+  "bc872d79faa34693adfe6436bb806c39",
+  "bc9c1ec4957b4e32bdbdaf8e70ce9966",
+  "bcdb24f0968c4e1fb7f82154f8adc4ee",
+  "bcfae6acaa254778921933e9ca0f52b9",
+  "bd0065fbb3e745a3907a42b65ef74e23",
+  "bd1b88e868a74e07b2da0512e5041820",
+  "bd5889e7b8ce4c3693e7b58f7de60660",
+  "bd5d5a1fdbc7470fab575738d1741a3d",
+  "bd82374391904aea903d68e22c3b98d8",
+  "bdbcf20dc4e44c34bd6783a025a25dbf",
+  "bdc57a0bf55742edb3a819adb23f52ac",
+  "bdcf5dad9bd4495ea32975f36bb536dd",
+  "bdd3558ddd854a24a090e88595814508",
+  "bdd8a24ad40c4b1facd2d463d2a8dadf",
+  "be162fbb800a41188853844ff0779fc6",
+  "be182bab94004469a07fb9283cd0966f",
+  "be52a68f4f2a409486cf6c0bbceb7f4c",
+  "beaa427961df495c970495d81cc684c3",
+  "becfc582462b432cbd158ada35106a17",
+  "befdd451a67e40698ce02773ca146e13",
+  "bf1cadd21a704739bc19d535ae741728",
+  "bf3e162cdda84afc8c1057bd8ca59b12",
+  "bf429028039d40b1b6da66b27e5cec80",
+  "bf4a3f32b0af40e58653049bdf2265c6",
+  "bf530a7f485c42a2aa650aaa6a3b38f2",
+  "bf859e10b7e74b13b1f76a90b33c13d8",
+  "bfc22926b2f842ab83dc31ce1e95de8f",
+  "bfdb7491cbe04dfd84a1f60bbac3f77e",
+  "c0156044d4834a18a44eb9f01d406bcc",
+  "c0618ebd49724b838060fb70859a23d2",
+  "c063d1a11b0848a5ab12ce20e6f4fb51",
+  "c06cba99d6cd47c6a5b0ad90545f211f",
+  "c072b4097f894f34a2144c6d53c13ade",
+  "c0951700653e4e978ef6199c38d07012",
+  "c098dab6131b4e41a3aff26ab21fb72b",
+  "c0e2a0ad0cf34e4cb8c8695c1470ad47",
+  "c0e3e1f810c446ba943b7ae635846362",
+  "c0f8d797244541948e916984c5b4b79d",
+  "c1130e0746cd41a5b108c5c7a8bbe321",
+  "c11c343241d54c1fbbf2bbc5f0f4f3c4",
+  "c1322815d25c4e2aa50fcb93cd3417f2",
+  "c1338e44401949c1be64e6668d38c100",
+  "c15bff78b50442a39c821330cdd02fd1",
+  "c17e8692f8d141b39ef30ff643163c42",
+  "c1ffea27ec114116951a1d99bdf68aa7",
+  "c205ed51b2554c9ba9fa2c3ccefb8473",
+  "c23e4e9a003a4c1a8e7a12897cb2989b",
+  "c2a66c76348b493196e765361b30b82f",
+  "c2d9dfa3c9f74a54805b6266dffdcac6",
+  "c301fe7e7b5f4ffd9984888ea676ac18",
+  "c3505b11077b4b2d824c33b573fc6e08",
+  "c35eac0ca1274ef7954f80dccf7c7fde",
+  "c38973bee1784c6eb644e28057b1b207",
+  "c3b896134b184ad9a52f542b0ad539da",
+  "c3e41b2565094c56ba594cb9697d0c98",
+  "c3e92af004704cc2b8f2ac99c706208c",
+  "c3edeb36f0ca4dd698b4262abe128bc1",
+  "c3f58532473d4796a9b0de9c0136a0bd",
+  "c433d675d27d489b99db4683f092fda0",
+  "c445e6ac66764779b262014cc97e9192",
+  "c45475ead1024e42b6665339544791cf",
+  "c46a254e08384b23883a570f483ededf",
+  "c4d94ba01c1d44a5a998e09b7dbd52a5",
+  "c4dd2ae8d8ee463a8eda2a8ed770ce34",
+  "c4e9a94ae8d14822a9ec49778868a1d8",
+  "c51100de7bb84e6882f92c9b6ab4b62f",
+  "c51feb09710645bd9df7617f7655f065",
+  "c547abcd2b594a449964b0123e96b2f4",
+  "c54b4c5e6cb64da58d2bc48c7f8a2115",
+  "c56c8aae879b43c292a0f2516b8d3715",
+  "c573303be1f04e0c94cfa245c2f2ddcf",
+  "c5740d905b0143a5831cac15c887bd8a",
+  "c5fdf4ef354b4b6ead18dbfb6e07805c",
+  "c60aa3efb391448faa955426411d485a",
+  "c612eeac87ae4b19a7ade75418a3b42a",
+  "c61a7acb3f7649c786cce53aa80df1fe",
+  "c624b290938c411880ec5254091ab572",
+  "c65995ebe77347ff8a782b3f22cd92b2",
+  "c68f8b1a585a4de6ac0bb133e822b8e5",
+  "c69887e12a164e20bfdc40c5a57c9d77",
+  "c6b5a0a815174bd8bb7410668af0f67d",
+  "c6cf38c5fcf446c6ad9c68f97ea9d924",
+  "c7255f3e4e9d47dca1e66c42c3abf00b",
+  "c7314a1d76c541df8d6723d772ad38c1",
+  "c737dcaa92a74959a6dbf73ce9f6f80c",
+  "c73a0aeaf5184b8d920e26209a381cd6",
+  "c7cc79f24c3046958bb2e3b62fcba583",
+  "c80234658ea34ea4b0fdbcf53f997651",
+  "c84221e0bc74453f96c27c6440081f56",
+  "c885e000d9964d3b89c72d1034414d40",
+  "c8c39f135f324c188448cfa37d63b1a4",
+  "c8d2ae976cec4fcabe1837f1caa40b8e",
+  "c8f071466cd149968a5304b2267f270a",
+  "c99e544549a244ce87938a9e3ab4e0e5",
+  "c9b9c316434547c892e7ac7bde27a74b",
+  "c9dc675a3b9e419da43020b005f2daf8",
+  "c9e8e4f732304503a2f1dab5bd3575a8",
+  "ca4c5fb30d4f4e33a145e0ec21004538",
+  "ca788d3707e74a8eb2a11b4ba3c663fc",
+  "ca98ed893c6e4279a27678a28bf12bca",
+  "ca9ab0992cfa4704a7369bb8a1e354ce",
+  "ca9ba816376147c39bbe86a0e963c2a6",
+  "cae4483da950451dad042eaaa0ec3f71",
+  "caef776ade4249beb2df98a19e640922",
+  "caf3e1a20fec4d85b2b82b28b7c9748a",
+  "cb0e7bf9c2c34681a1c46510298eca2e",
+  "cb4868a7428e4c868112600d4258d467",
+  "cb55690638a24306b5af6829fbf2fd3b",
+  "cbaea52a561a485985187467cc4cebba",
+  "cbdf402976724a82949f655eb2769db2",
+  "cbea02f813454fdb88ddf695dad0ba95",
+  "cc084f03563d4fc8a842cd1b144af160",
+  "cc1b43705a4e41fb93278436dfd19aa7",
+  "cc474a048f2d406fae7ddccc6e33b5e4",
+  "cca59986dfb24be5bb3ef76ef03e6446",
+  "ccb5addc6298440b9387eba77cd96b3f",
+  "ccc764da89ab48f089ec24646b099fd2",
+  "cd75d662c61e47be9b7eed198bbc4653",
+  "cde1c503e1384e45a897ad33621c039c",
+  "ce27aef8f565405ab97345111f56cbcf",
+  "ce35cd13734c47f8b0dbfb1a7ce7d737",
+  "ce4059f8cee64886b4900bae6081a412",
+  "cef43d0b4ee54de191d8d6d1c607c3b4",
+  "cefa7ff3c50d4b599dee919173771f10",
+  "cefe8210e84b41efa52f932dd5bdbbf8",
+  "cf09960a2b76439eac0dad00e36e321d",
+  "cf15f213e497421abf1b0c559b9a7bf1",
+  "cf32f764ec5a43ad9243aec1b7981817",
+  "cf47293c05f1485eaba4437965ec7cb6",
+  "cf4c2238567c42eb8bf5f3a1cf269f26",
+  "cf7dc5fb55214706b2725e900515c9ea",
+  "cf7f3eb8fdbe43b29e4f6ee5a17fe913",
+  "cf96e6948340491c97370f2f75d6a715",
+  "cfa8ae9850724ecc9137297a6cf48661",
+  "cfb21be3208142e58302a954bb258638",
+  "cfc48976f7474878bd2236b2e9fcbcfa",
+  "cfd1a14262c9452a98265ff51df738da",
+  "d01a7b47c5634beca150febdc9eb3804",
+  "d023021664b14066ba2091b46796d48a",
+  "d0296bd8998b4d64a156ec3614194cf8",
+  "d02ba46d170143e58ec7f9e4c7edb09c",
+  "d03d0eddd62b49e39b6916825fe2cc4a",
+  "d081cded74804470bc3b0874cbeae248",
+  "d0a9268f7fb24dcd8f77c66f2fee33d9",
+  "d0e93f7b8717493b959d797cad7a7051",
+  "d124e83b3bb243488241b8ac07f6ba3b",
+  "d143036cc7cd4810aa1b135ce4b75186",
+  "d1563c5e2d29424fb1ce03e03a4f0e2c",
+  "d16736e243904210b938590a42c8ea88",
+  "d18a91b5578c4e6fa9e8fa0f4f892655",
+  "d18c53e5716941a79385dc1b7a20aa33",
+  "d19600dfb01044819f0e2ad57c5b144f",
+  "d1b8af21f2a7463a800dd21828143d73",
+  "d1feaa811a43422eb9918abc60b6d03e",
+  "d2134da7512c4a4ea3acb5efc038939c",
+  "d21cf60625aa40aa984bc52a5c1d28b6",
+  "d25283e6dc7c4af9858db4b33b2cd898",
+  "d263b96494e046c3a7721039d52c70bd",
+  "d281b292903d422aa0cef4e97f47c516",
+  "d2840479d3764edaaec419baa528b686",
+  "d29681d43409491ca48a1a4daa08c9c0",
+  "d2ad89ca538043b5a705578f7d63e26b",
+  "d2bca193811341a9b6626fb9440e1483",
+  "d2c42715bc8f4ac793365a9e018a9154",
+  "d2ec14c4188e4cbe9bf8f649d54e9026",
+  "d341a70ad72d4aef890642bf4b351164",
+  "d370a3eb0a164dc19ba4547a89956599",
+  "d3df4b71522a4af492642fd8b4188bb2",
+  "d446483c0dc44723a520d1dc5019ef41",
+  "d44d57497d0e49378dc6cc030a3a795c",
+  "d468bad5f0da414b80a7a10e0ce06963",
+  "d4879dcacecd4e31841b6f85853059e3",
+  "d4afdbf2942b4d028c8e5ae678748618",
+  "d50988a3159f488193d45c33e1bc42d2",
+  "d54709facd344eb68b60778618ee30b1",
+  "d54b3349d9454dce842ba7cb29d2f55d",
+  "d557afd3c789449a81deea08cf8b38e6",
+  "d5658d7c19b54a7eb651fb90f49a1eb1",
+  "d576f209de3448d9992b1e3475bef5ff",
+  "d5879bee6d804e06b91eac1ab17c0865",
+  "d5af027ff24a49478cfdb02ae813636e",
+  "d5d862bcfd4441c98daeb64b81f478e5",
+  "d604adba8218419984863c94d55e179a",
+  "d645572faab04171a80b508787ce2e94",
+  "d665b19e9b27446abffefed954dc08bd",
+  "d67c689abb49402dbd5531e658e1228a",
+  "d68520a7d7fd457da9abafec6b55bce6",
+  "d6993387c8fc49c49ef427a5e43556dd",
+  "d6c3ff1f15344a31b1120f48fd2718c5",
+  "d6c53cc6b38d47b4bd44c1355151fa8a",
+  "d6ee29b78ed54a51b99069dfb50f23ae",
+  "d739778fc14a4edcafaa62e0d8722f2e",
+  "d74022bfc72f452bbed363059bbb79d6",
+  "d76d9d2174a14235af9ec89b6fbe2f37",
+  "d7d6e3e059e2492188d7bb7b17626a45",
+  "d7df7692001a427caee08f0997f52316",
+  "d7ff32605636455a813c60c77e7817ba",
+  "d831ace59eea441f971547b991d0b6ce",
+  "d85e6f53c445408bab71e9c68eb59140",
+  "d86759c3aa944793bd8e79a6339a7342",
+  "d892496c52524e0ebfe1db7482c3c3af",
+  "d896c972fc894772b47748fbbbf4b5eb",
+  "d89e46167ef045bb8c2d279dc2b51ff7",
+  "d8bc73eb1ead46fb8594b8caf926bda7",
+  "d961bc05652f41b1b90f9358f69eb23a",
+  "d9b5a2c032244ccf8ee63bd26ed8bb2b",
+  "d9e3f302b8ef4b0297cbe4a042b1887c",
+  "d9ecc99108a643ab887296cb986be937",
+  "da256042b24f41469b605ec24f027301",
+  "da26fbe1b21340cca9d2e31f4c70571f",
+  "da4e172fddde4d2d8b2072aa6560ed6d",
+  "da6ab3a8f5554d6ca485bfb5698fabe9",
+  "da8b73929a5843e185c627bc675c730a",
+  "da8bbcb226fc4b2a862e94a4c5ce1930",
+  "da8fcc845fdf4227839784102dc182e7",
+  "da97043fbee64b1d92c5406ef80a5ea9",
+  "db49d1d472704b19836ab1a8aeb09d58",
+  "db80c36bf818475bb43f84cc015d7803",
+  "db9bc936d89d4f63aaf2f58c8048eec4",
+  "dba737640da74746afa8189dfc867d98",
+  "dbf9c15333814afa88345312b521ddab",
+  "dbfd139a36ef42e59392c8a9cd878986",
+  "dc436f07d85146a49747ee01e4259049",
+  "dc4c91abf45342b4bb8822f50fa162b2",
+  "dc5edb6be1c14fb1b5484541ae3aa673",
+  "dd6ccc2389454afda4a5d34c8b6ce4d5",
+  "ddabe7f3825643048541f8d570560c36",
+  "ddf2459697d54117a2d0ac499f7fdb6b",
+  "de522f0520794e8ba79361b235a08bd1",
+  "de5b614cdb2042e29fcf0f848b26af21",
+  "de8616a79cb74d9d8618c91ce254c9a6",
+  "dec9e92b1a86422c8df32c835704387c",
+  "df0511efc31b431daebe5825eefcc12d",
+  "df14fec21675475c871568b7b89bac22",
+  "df224818be2946f69e1cac929504b07b",
+  "df232d48ce254cb8bf156b20dd096e16",
+  "df261dc53ac1410f9cd462d6de578f5d",
+  "df9f511762f44544a37799e18dce3f83",
+  "dfa463836cdd48b4bb4caa3f868ed07a",
+  "dfd3fab648834cd586230ecde5d80498",
+  "dfd734a9ae4343fc8f572b11fe09ead3",
+  "dfffd398b6cc4e14bb76aa73fc1bda33",
+  "e02091a7f05d4a78a8a7ee07054c68f0",
+  "e05d63a78f2c44c5a64fbc419998e603",
+  "e06a0ddd061b4919a33868e84e0bb59c",
+  "e06d06101cc8434e91034b97211d5dd5",
+  "e088a1fc5a67448589f15e78517ebd39",
+  "e0c7ddea147e4843a3f69d78362be91d",
+  "e0ea25464d2442a183fd1d16b31d0d6d",
+  "e1083bbb88ac4e55b31613f98bc39aee",
+  "e108c545e1194c36841e43a32b007312",
+  "e13434a196e842b3980aef22835e4ecb",
+  "e16778a84a054a68a93c0a843ceaca9c",
+  "e16ed5283fd1443da96d30b14fbe26a3",
+  "e1773e5177454abea4410b442cd51bc3",
+  "e17e25c330704fb9b75a14470d1602b2",
+  "e19e12c46c5849feb4559bf12fb1a1d0",
+  "e1afbb66a7974c2ca15efa9186af729c",
+  "e1b76ff0ea3046dfbe81a05c61f28ef2",
+  "e1bc7fd65d7b4a5b85624fc9cb483993",
+  "e1e2705f28eb468f8995be58cc59e180",
+  "e1eeec54327545438376e773dfbb95a3",
+  "e204b769571444e5916c3d7ca67a4219",
+  "e21fdbef2bca4ef5a46d2f0a523b530a",
+  "e24ee911ddac4ab9b2869913c6a8e969",
+  "e2e4bb23e9214105879b033692377580",
+  "e311b9100c564c599b64c98d0ceb879b",
+  "e317dd0031794072a86e1e9fb7fb0f3d",
+  "e33e35f643334b8fa5861c14fde1edc1",
+  "e35dab813fe34035b66ac15989b1e2be",
+  "e378396052674803a8990bd1d8c0b04f",
+  "e38c85b66b974f769446c8dbb0e15c2e",
+  "e39ec3c45acc40b79db8bf133e1dfc77",
+  "e3a23079ea72443f9b469806d4ddb002",
+  "e3aca5ecbbdf4d3585c3e241faf97206",
+  "e3c0b2df930b48f5bc1fa5d38155e54d",
+  "e3df35afea5d4f3fa8ec2c0b9574bcd8",
+  "e3fa8eda5cd648f8b3b2a88189fe3e2f",
+  "e406259aefca4cb8844e55a42ea45c87",
+  "e4087350c4d84d8391de09b405c96488",
+  "e4158753fe574a86ac7f457179db6ecf",
+  "e43ed4c1b7254bedb8ec34ea8bbf341a",
+  "e4656569bcb44476b5d8676724c22b6f",
+  "e47be5f609ef415f97b51b264cd16259",
+  "e4cfa0c54f474f918f40277fe2bbacfb",
+  "e4ec75222bb44422bf0b7c90453b7f94"
+]

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/default.yaml

@@ -0,0 +1,130 @@
+# ===== MC-diffusion Training Config (SD3.5 + mcVAE) =====
+
+seed: 43
+
+project:
+  output_dir: outputs/mcdiff
+  logging_dir: logs
+  null_pe: precomputed_tensors/null_prompt_embeds.pt
+  null_ppe: precomputed_tensors/null_pooled_prompt_embeds.pt
+
+data:
+  train:
+    root: /home/aaaaa/data/rgbmr_mv_web2/merged
+    num_workers: 2
+    batch_size: 4
+  val:
+    root: /home/aaaaa/data/rgbmr_mv_web2/validation
+
+model:
+  pretrained_model_name_or_path: stabilityai/stable-diffusion-3.5-medium
+  init_transformer_weights: null
+  sd_vae_path: vae_sd35
+  mcvae_config: configs/mcvae/config.json
+  mcvae_ckpt: null
+  mcvae_offset_mode: true  # If true, mcVAE encoder outputs offsets added to base mean/logvar. If false, directly predicts mean/logvar.
+  num_views: 6
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false  # If true, use global frame (identity) instead of local query frame (w2c) for delta position
+  resolution: 512
+  condition_channels: 32  # 0 | 16 | 32
+  corr_dilate_iterations: 2  # Number of times to apply dilate_f2l to correspondence tensors
+  
+  attn_lora:
+    enabled: true
+    r_q: 32
+    r_k: 32
+    r_v: 32
+    alpha_q: 32
+    alpha_k: 32
+    alpha_v: 32
+    apply_to_self: true
+    limit_joint: null
+    limit_self: null
+
+lora:
+  rank: 0
+  lora_layers: null
+  lora_blocks: null
+  lora_dropout: 0.0
+
+train:
+  max_train_steps: 40001
+  gradient_accumulation_steps: 1
+  gradient_checkpointing: false
+  allow_tf32: true
+  mixed_precision: bf16
+  upcast_before_saving: false
+  local_rank: -1
+  resume_from_checkpoint: null
+  checkpointing_steps: 1000
+  checkpoints_total_limit: 40
+  validation_steps: 1000
+  proportion_empty_prompts: 0.1
+  max_grad_norm: 1.0
+
+optim:
+  optimizer: AdamW
+  use_8bit_adam: true
+  learning_rate: 5e-5
+  scale_lr: false
+  adam_beta1: 0.9
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-4
+  adam_epsilon: 1e-8
+  prodigy_beta3: null
+  prodigy_decouple: true
+  prodigy_use_bias_correction: true
+  prodigy_safeguard_warmup: true
+
+scheduler:
+  lr_scheduler: constant
+  lr_warmup_steps: 500
+  lr_num_cycles: 5
+  lr_power: 1.0
+
+weighting:
+  weighting_scheme: logit_normal
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  precondition_outputs: false
+
+
+# For Single-Full: (42hr)
+# accelerate launch --num_processes 8 --main_process_port 0 train_mcdiff.py \
+# train.max_train_steps=40001 data.train.batch_size=4 \
+# model.mcvae_ckpt="outputs/mcvae_v1.8.1.pt" \
+# project.output_dir=outputs/mcdiff_v.single_full \
+# model.use_dual_branch=false model.use_caa=false
+
+# For Single-CAA(5x5): (42hr)
+# accelerate launch --num_processes 8 --main_process_port 0 train_mcdiff.py \
+# train.max_train_steps=40001 data.train.batch_size=4 \
+# model.mcvae_ckpt="outputs/mcvae_v1.8.1.pt" \
+# project.output_dir=outputs/mcdiff_v.single_caa \
+# model.use_dual_branch=false model.use_caa=true
+
+# For Single-Full-Global(3x3): (36hr)
+# accelerate launch --num_processes 8 --main_process_port 0 train_mcdiff.py \
+# train.max_train_steps=40001 data.train.batch_size=4 \
+# model.mcvae_ckpt="outputs/mcvae_v1.8.1.pt" \
+# project.output_dir=outputs/mcdiff_v.single_caa_global \
+# model.use_dual_branch=false model.use_caa=true model.use_global_token=true
+
+# For Dual-Full: (72hr)
+# accelerate launch --num_processes 8 --main_process_port 0 train_mcdiff.py \
+# train.max_train_steps=40001 data.train.batch_size=1 train.gradient_accumulation_steps=4 \
+# model.mcvae_ckpt="outputs/mcvae_v1.8.1.pt" \
+# project.output_dir=outputs/mcdiff_v.dual_full \
+# model.use_dual_branch=true model.use_caa=false
+
+# For Dual-CAA: (72hr)
+# accelerate launch --num_processes 8 --main_process_port 0 train_mcdiff.py \
+# train.max_train_steps=40001 data.train.batch_size=1 train.gradient_accumulation_steps=4 \
+# model.mcvae_ckpt="outputs/mcvae_v1.8.1.pt" \
+# project.output_dir=outputs/mcdiff_v.dual_caa \
+# model.use_dual_branch=true model.use_caa=true

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/dual_caa.yaml

@@ -0,0 +1,22 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.dual_caa
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 1
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: true
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  max_train_steps: 80001
+  gradient_accumulation_steps: 4

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/dual_full.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.dual_full
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 1
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: true
+  use_caa: false
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 4

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_caa.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_caa
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 4
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 1

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_caa_100k_vae.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_caa_100k_vae
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 4
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1_100k.pt"
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 1

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_caa_global_pos.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_caa_global_pos
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 4
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: true
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 1

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_caa_global_token.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_caa_global_token
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 4
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: true
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 1

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_caa_tmp.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_caa_tmp
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 4
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 1

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_caaa.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_caaa
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 4
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: true
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 1

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_full.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_full
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 2
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: false
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 2

home/ubuntu/aaaaa/data/rgbmr/configs/mcdiff/single_fulll.yaml

@@ -0,0 +1,21 @@
+base: configs/mcdiff/default.yaml
+
+project:
+  output_dir: outputs/mcdiff_v.single_fulll
+
+data:
+  train:
+    num_workers: 4
+    batch_size: 2
+
+model:
+  mcvae_ckpt: "outputs/mcvae_v1.8.1.pt"
+  use_dual_branch: false
+  use_caa: false
+  use_rope: true
+  use_global_token: false
+  use_global_pos: false
+  corr_dilate_iterations: 2
+
+train:
+  gradient_accumulation_steps: 2

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/config.json

@@ -0,0 +1,38 @@
+{
+  "_class_name": "AutoencoderKL",
+  "_diffusers_version": "0.31.0.dev0",
+  "_name_or_path": "../sdxl-vae/",
+  "act_fn": "silu",
+  "block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": false,
+  "in_channels": 5,
+  "latent_channels": 16,
+  "latents_mean": null,
+  "latents_std": null,
+  "layers_per_block": 2,
+  "mid_block_add_attention": true,
+  "norm_num_groups": 32,
+  "out_channels": 5,
+  "sample_size": 1024,
+  "scaling_factor": null,
+  "shift_factor": null,
+  "up_block_types": [
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D"
+  ],
+  "use_post_quant_conv": false,
+  "use_quant_conv": false
+}

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/default.yaml

@@ -0,0 +1,92 @@
+
+# ===== Multi-Channel VAE Training Config (SD3.5 VAE, z=16) =====
+
+seed: 43
+device: cuda
+
+project:
+  name: MCVAE_revised
+  run_name: MCVAE_v1.1.0
+  notes: "SD3.5-like (z=16)"
+  save_dir: ./outputs/${project.run_name}
+
+data:
+  train:
+    root: /scratch/aaaaa/data/rgbmr_mv_web2/merged
+    num_workers: 2
+    batch_size: 8
+  val:
+    root: /scratch/aaaaa/data/rgbmr_mv_web2/validation_mcvae
+    num_workers: 1
+    batch_size: 6
+
+model:
+  resolution: 512
+  image_range: [-1.0, 1.0]
+  mcvae_config: ./configs/mcvae/config.json
+
+  init_layers_from: null  # path to checkpoint to init layers from, or null to train from sd vae
+  init_layers_strict: false
+  
+  offset_mode: true  # If true, encoder outputs offsets added to base mean/logvar. If false, directly predicts mean/logvar.
+  deterministic_mode: false  # If true, encoder outputs deterministic latents (logvar=-30, Dirac delta). KL terms auto-disabled.
+
+  sd_vae:
+    from_pretrained: ./vae_sd35
+    dtype: bfloat16
+  
+  latent_transform:
+    type: scaling+crop+rotation  # identity | scaling | crop | rotation | ...
+    identity_prob: 0.5  # Probability of NOT applying augmentation
+    tiebreaking_prob: 0.3  # When both scaling and crop are enabled, prob of choosing scaling
+    scaling_range: [16, 64]  # Min and max for 64-based scaling
+    crop_range: [3, 32]  # Min and max for 64-based crop
+
+loss:
+  disc_start: 40001
+  disc_num_layers: 5
+  disc_in_channels: 5
+  disc_loss: hinge
+  disc_factor: 1.0
+  base_recon_weight: 3.0
+  disc_weight: 0.02
+  recon_loss_type: mse
+  perceptual_rgb_weight: 0.24  # should be 3/5 * 0.4
+  perceptual_orm_weight: 0.16  # should be 2/5 * 0.4
+  orm_loss_type: lpips_per_channel
+  orm_loss_params: {}
+  use_identity_loss: false  # If true, adds identity loss: L2(vae.decode(mcvae.encode(x)), x[:,:3])
+
+optim:
+  lr: 3.0e-5
+  betas: [0.9, 0.99]
+  weight_decay: 0.0
+  use_8bit_adam: true
+
+trainer:
+  max_steps: 400001  # double counted by lightning, so 200k = 400001
+  val_check_interval: 750
+  log_every_n_steps: 50
+  limit_val_batches: 128
+  precision: bf16-mixed
+  accumulate_grad_batches: 1
+  gradient_clip_val: 0.0
+  devices: -1
+  accelerator: gpu
+  num_sanity_val_steps: 1
+
+logging:
+  image_log_every_n_val_epochs: 1
+  n_log_images: 6
+  save_top_k: 5
+  monitor: val/recon_loss
+  mode: min
+  layers_save_every_n_steps: 10000
+  layers_weights_filename: layer_weights.pt
+  train_image_every_n_steps: 400001
+
+lambdas:
+  lambda_recon: 1.0
+  lambda_kl: 1e-6
+  lambda_kl_base: 3e-9
+  lambda_identity: 3.0  # Weight for identity loss (only used if loss.use_identity_loss=true)

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/layerdiffuse.yaml

@@ -0,0 +1,34 @@
+
+base: configs/mcvae/default.yaml
+
+project:
+  name: MCVAE_FINAL
+  run_name: MCVAE_v.layerdiffuse
+
+data:
+  train:
+    root: /home/ubuntu/aaaaa/data/rgbmr/merged
+    batch_size: 8
+  val:
+    root: /home/ubuntu/aaaaa/data/rgbmr/validation_mcvae
+
+model:
+  offset_mode: true
+  deterministic_mode: true  # Enable deterministic mode (logvar=-30, Dirac delta, KL auto-disabled)
+
+  latent_transform:
+    type: scaling+crop+rotation  # identity | scaling | crop | rotation | ...
+    identity_prob: 0.5
+    
+loss:
+  use_identity_loss: true  # If true, adds identity loss: L2(vae.decode(mcvae.encode(x)), x[:,:3])
+
+trainer:
+  max_steps: 400001  # double counted by lightning, so 200k = 400001
+  accumulate_grad_batches: 1
+
+lambdas:
+  lambda_recon: 1.0
+  lambda_kl: 0.0  # Auto-disabled by deterministic_mode
+  lambda_kl_base: 0.0  # Auto-disabled by deterministic_mode
+  lambda_identity: 3.0

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/no_crop.yaml

@@ -0,0 +1,29 @@
+
+base: configs/mcvae/default.yaml
+
+project:
+  name: MCVAE_FINAL
+  run_name: MCVAE_v.no_crop
+
+data:
+  train:
+    root: /home/aaaaa/data/rgbmr_mv_web2/merged
+    batch_size: 8
+  val:
+    root: /home/aaaaa/data/rgbmr_mv_web2/validation_mcvae
+
+model:
+  offset_mode: true
+
+  latent_transform:
+    type: identity  # identity | scaling | crop | rotation | ...
+    identity_prob: 1.0
+
+trainer:
+  max_steps: 400001  # double counted by lightning, so 200k = 400001
+  accumulate_grad_batches: 1
+
+lambdas:
+  lambda_recon: 1.0
+  lambda_kl: 1e-6
+  lambda_kl_base: 3e-9

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/orchid.yaml

@@ -0,0 +1,29 @@
+
+base: configs/mcvae/default.yaml
+
+project:
+  name: MCVAE_FINAL
+  run_name: MCVAE_v.orchid
+
+data:
+  train:
+    root: /home/ubuntu/aaaaa/data/rgbmr/merged
+    batch_size: 8
+  val:
+    root: /home/ubuntu/aaaaa/data/rgbmr/validation_mcvae
+
+model:
+  offset_mode: false
+
+  latent_transform:
+    type: scaling+crop+rotation  # identity | scaling | crop | rotation | ...
+    identity_prob: 0.5
+
+trainer:
+  max_steps: 400001  # double counted by lightning, so 200k = 400001
+  accumulate_grad_batches: 1
+
+lambdas:
+  lambda_recon: 1.0
+  lambda_kl: 1e-6
+  lambda_kl_base: 3e-9

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/ours.yaml

@@ -0,0 +1,29 @@
+
+base: configs/mcvae/default.yaml
+
+project:
+  name: MCVAE_FINAL
+  run_name: MCVAE_v.ours
+
+data:
+  train:
+    root: /home/aaaaa/data/rgbmr_mv_web2/merged
+    batch_size: 8
+  val:
+    root: /home/aaaaa/data/rgbmr_mv_web2/validation_mcvae
+
+model:
+  offset_mode: true
+
+  latent_transform:
+    type: scaling+crop+rotation  # identity | scaling | crop | rotation | ...
+    identity_prob: 0.5
+
+trainer:
+  max_steps: 400001  # double counted by lightning, so 200k = 400001
+  accumulate_grad_batches: 1
+
+lambdas:
+  lambda_recon: 1.0
+  lambda_kl: 1e-6
+  lambda_kl_base: 3e-9

home/ubuntu/aaaaa/data/rgbmr/configs/mcvae/variant_example.yaml

@@ -0,0 +1,24 @@
+# Example variant config that inherits from default.yaml
+# This demonstrates the base-variant inheritance structure
+
+base: configs/mcvae/default.yaml
+
+# Override specific parameters
+project:
+  run_name: MCVAE_v1.1.0_variant_example
+  notes: "Example variant configuration"
+
+# Override training parameters
+trainer:
+  max_steps: 50001
+  val_check_interval: 500
+
+# Override optimizer parameters
+optim:
+  lr: 1.0e-4
+
+# Override data parameters
+data:
+  train:
+    batch_size: 6
+    num_workers: 4

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/custom_rasterizer/__init__.py

@@ -0,0 +1,4 @@
+"""
+from .render import rasterize, interpolate
+"""
+from .render import *

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/custom_rasterizer/render.py

@@ -0,0 +1,18 @@
+import custom_rasterizer_kernel
+import torch
+
+
+def rasterize(pos, tri, resolution, clamp_depth=torch.zeros(0), use_depth_prior=0):
+    assert pos.device == tri.device
+    findices, barycentric = custom_rasterizer_kernel.rasterize_image(
+        pos[0], tri, clamp_depth, resolution[1], resolution[0], 1e-6, use_depth_prior
+    )
+    return findices, barycentric
+
+
+def interpolate(col, findices, barycentric, tri):
+    f = findices - 1 + (findices == 0)
+    vcol = col[0, tri.long()[f.long()]]
+    result = barycentric.view(*barycentric.shape, 1) * vcol
+    result = torch.sum(result, axis=-2)
+    return result.view(1, *result.shape)

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/lib/custom_rasterizer_kernel/grid_neighbor.cpp

@@ -0,0 +1,574 @@
+#include "rasterizer.h"
+#include <fstream>
+
+inline int pos2key(float* p, int resolution) {
+    int x = (p[0] * 0.5 + 0.5) * resolution;
+    int y = (p[1] * 0.5 + 0.5) * resolution;
+    int z = (p[2] * 0.5 + 0.5) * resolution;
+    return (x * resolution + y) * resolution + z;
+}
+
+inline void key2pos(int key, int resolution, float* p) {
+    int x = key / resolution / resolution;
+    int y = key / resolution % resolution;
+    int z = key % resolution;
+    p[0] = ((x + 0.5) / resolution - 0.5) * 2;
+    p[1] = ((y + 0.5) / resolution - 0.5) * 2;
+    p[2] = ((z + 0.5) / resolution - 0.5) * 2;
+}
+
+inline void key2cornerpos(int key, int resolution, float* p) {
+    int x = key / resolution / resolution;
+    int y = key / resolution % resolution;
+    int z = key % resolution;
+    p[0] = ((x + 0.75) / resolution - 0.5) * 2;
+    p[1] = ((y + 0.25) / resolution - 0.5) * 2;
+    p[2] = ((z + 0.75) / resolution - 0.5) * 2;
+}
+
+inline float* pos_ptr(int l, int i, int j, torch::Tensor t) {
+    float* pdata = t.data_ptr<float>();
+    int height = t.size(1);
+    int width = t.size(2);
+    return &pdata[((l * height + i) * width + j) * 4];
+}
+
+struct Grid
+{
+    std::vector<int> seq2oddcorner;
+    std::vector<int> seq2evencorner;
+    std::vector<int> seq2grid;
+    std::vector<int> seq2normal;
+    std::vector<int> seq2neighbor;
+    std::unordered_map<int, int> grid2seq;
+    std::vector<int> downsample_seq;
+    int num_origin_seq;
+    int resolution;
+    int stride;
+};
+
+inline void pos_from_seq(Grid& grid, int seq, float* p) {
+    auto k = grid.seq2grid[seq];
+    key2pos(k, grid.resolution, p);
+}
+
+inline int fetch_seq(Grid& grid, int l, int i, int j, torch::Tensor pdata) {
+    float* p = pos_ptr(l, i, j, pdata);
+    if (p[3] == 0)
+        return -1;
+    auto key = pos2key(p, grid.resolution);
+    int seq = grid.grid2seq[key];
+    return seq;
+}
+
+inline int fetch_last_seq(Grid& grid, int i, int j, torch::Tensor pdata) {
+    int num_layers = pdata.size(0);
+    int l = 0;
+    int idx = fetch_seq(grid, l, i, j, pdata);
+    while (l < num_layers - 1) {
+        l += 1;
+        int new_idx = fetch_seq(grid, l, i, j, pdata);
+        if (new_idx == -1)
+            break;
+        idx = new_idx;
+    }
+    return idx;
+}
+
+inline int fetch_nearest_seq(Grid& grid, int i, int j, int dim, float d, torch::Tensor pdata) {
+    float p[3];
+    float max_dist = 1e10;
+    int best_idx = -1;
+    int num_layers = pdata.size(0);
+    for (int l = 0; l < num_layers; ++l) {
+        int idx = fetch_seq(grid, l, i, j, pdata);
+        if (idx == -1)
+            break;
+        pos_from_seq(grid, idx, p);
+        float dist = std::abs(d - p[(dim + 2) % 3]);
+        if (dist < max_dist) {
+            max_dist = dist;
+            best_idx = idx;
+        }
+    }
+    return best_idx;
+}
+
+inline int fetch_nearest_seq_layer(Grid& grid, int i, int j, int dim, float d, torch::Tensor pdata) {
+    float p[3];
+    float max_dist = 1e10;
+    int best_layer = -1;
+    int num_layers = pdata.size(0);
+    for (int l = 0; l < num_layers; ++l) {
+        int idx = fetch_seq(grid, l, i, j, pdata);
+        if (idx == -1)
+            break;
+        pos_from_seq(grid, idx, p);
+        float dist = std::abs(d - p[(dim + 2) % 3]);
+        if (dist < max_dist) {
+            max_dist = dist;
+            best_layer = l;
+        }
+    }
+    return best_layer;
+}
+
+void FetchNeighbor(Grid& grid, int seq, float* pos, int dim, int boundary_info, std::vector<torch::Tensor>& view_layer_positions,
+    int* output_indices)
+{
+    auto t = view_layer_positions[dim];
+    int height = t.size(1);
+    int width = t.size(2);
+    int top = 0;
+    int ci = 0;
+    int cj = 0;
+    if (dim == 0) {
+        ci = (pos[1]/2+0.5)*height;
+        cj = (pos[0]/2+0.5)*width;
+    }
+    else if (dim == 1) {
+        ci = (pos[1]/2+0.5)*height;
+        cj = (pos[2]/2+0.5)*width;
+    }
+    else {
+        ci = (-pos[2]/2+0.5)*height;
+        cj = (pos[0]/2+0.5)*width;
+    }
+    int stride = grid.stride;
+    for (int ni = ci + stride; ni >= ci - stride; ni -= stride) {
+        for (int nj = cj - stride; nj <= cj + stride; nj += stride) {
+            int idx = -1;
+            if (ni == ci && nj == cj)
+                idx = seq;
+            else if (!(ni < 0 || ni >= height || nj < 0 || nj >= width)) {
+                if (boundary_info == -1)
+                    idx = fetch_seq(grid, 0, ni, nj, t);
+                else if (boundary_info == 1)
+                    idx = fetch_last_seq(grid, ni, nj, t);
+                else
+                    idx = fetch_nearest_seq(grid, ni, nj, dim, pos[(dim + 2) % 3], t);
+            }
+            output_indices[top] = idx;
+            top += 1;
+        }
+    }
+}
+
+void DownsampleGrid(Grid& src, Grid& tar)
+{
+    src.downsample_seq.resize(src.seq2grid.size(), -1);
+    tar.resolution = src.resolution / 2;
+    tar.stride = src.stride * 2;
+    float pos[3];
+    std::vector<int> seq2normal_count;
+    for (int i = 0; i < src.seq2grid.size(); ++i) {
+        key2pos(src.seq2grid[i], src.resolution, pos);
+        int k = pos2key(pos, tar.resolution);
+        int s = seq2normal_count.size();
+        if (!tar.grid2seq.count(k)) {
+            tar.grid2seq[k] = tar.seq2grid.size();
+            tar.seq2grid.emplace_back(k);
+            seq2normal_count.emplace_back(0);
+            seq2normal_count.emplace_back(0);
+            seq2normal_count.emplace_back(0);
+            //tar.seq2normal.emplace_back(src.seq2normal[i]);
+        } else {
+            s = tar.grid2seq[k] * 3;
+        }
+        seq2normal_count[s + src.seq2normal[i]] += 1;
+        src.downsample_seq[i] = tar.grid2seq[k];
+    }
+    tar.seq2normal.resize(seq2normal_count.size() / 3);
+    for (int i = 0; i < seq2normal_count.size(); i += 3) {
+        int t = 0;
+        for (int j = 1; j < 3; ++j) {
+            if (seq2normal_count[i + j] > seq2normal_count[i + t])
+                t = j;
+        }
+        tar.seq2normal[i / 3] = t;
+    }
+}
+
+void NeighborGrid(Grid& grid, std::vector<torch::Tensor> view_layer_positions, int v)
+{
+    grid.seq2evencorner.resize(grid.seq2grid.size(), 0);
+    grid.seq2oddcorner.resize(grid.seq2grid.size(), 0);
+    std::unordered_set<int> visited_seq;
+    for (int vd = 0; vd < 3; ++vd) {
+        auto t = view_layer_positions[vd];
+        auto t0 = view_layer_positions[v];
+        int height = t.size(1);
+        int width = t.size(2);
+        int num_layers = t.size(0);
+        int num_view_layers = t0.size(0);
+        for (int i = 0; i < height; ++i) {
+            for (int j = 0; j < width; ++j) {
+                for (int l = 0; l < num_layers; ++l) {
+                    int seq = fetch_seq(grid, l, i, j, t);
+                    if (seq == -1)
+                        break;
+                    int dim = grid.seq2normal[seq];
+                    if (dim != v)
+                        continue;
+
+                    float pos[3];
+                    pos_from_seq(grid, seq, pos);
+
+                    int ci = 0;
+                    int cj = 0;
+                    if (dim == 0) {
+                        ci = (pos[1]/2+0.5)*height;
+                        cj = (pos[0]/2+0.5)*width;
+                    }
+                    else if (dim == 1) {
+                        ci = (pos[1]/2+0.5)*height;
+                        cj = (pos[2]/2+0.5)*width;
+                    }
+                    else {
+                        ci = (-pos[2]/2+0.5)*height;
+                        cj = (pos[0]/2+0.5)*width;
+                    }
+
+                    if ((ci % (grid.stride * 2) < grid.stride) && (cj % (grid.stride * 2) >= grid.stride))
+                        grid.seq2evencorner[seq] = 1;
+
+                    if ((ci % (grid.stride * 2) >= grid.stride) && (cj % (grid.stride * 2) < grid.stride))
+                        grid.seq2oddcorner[seq] = 1;
+
+                    bool is_boundary = false;
+                    if (vd == v) {
+                        if (l == 0 || l == num_layers - 1)
+                            is_boundary = true;
+                        else {
+                            int seq_new = fetch_seq(grid, l + 1, i, j, t);
+                            if (seq_new == -1)
+                                is_boundary = true;
+                        }
+                    }
+                    int boundary_info = 0;
+                    if (is_boundary && (l == 0))
+                        boundary_info = -1;
+                    else if (is_boundary)
+                        boundary_info = 1;
+                    if (visited_seq.count(seq))
+                        continue;
+                    visited_seq.insert(seq);
+
+                    FetchNeighbor(grid, seq, pos, dim, boundary_info, view_layer_positions, &grid.seq2neighbor[seq * 9]);
+                }
+            }
+        }
+    }
+}
+
+void PadGrid(Grid& src, Grid& tar, std::vector<torch::Tensor>& view_layer_positions) {
+    auto& downsample_seq = src.downsample_seq;
+    auto& seq2evencorner = src.seq2evencorner;
+    auto& seq2oddcorner = src.seq2oddcorner;
+    int indices[9];
+    std::vector<int> mapped_even_corners(tar.seq2grid.size(), 0);
+    std::vector<int> mapped_odd_corners(tar.seq2grid.size(), 0);
+    for (int i = 0; i < downsample_seq.size(); ++i) {
+        if (seq2evencorner[i] > 0) {
+            mapped_even_corners[downsample_seq[i]] = 1;
+        }
+        if (seq2oddcorner[i] > 0) {
+            mapped_odd_corners[downsample_seq[i]] = 1;
+        }
+    }
+    auto& tar_seq2normal = tar.seq2normal;
+    auto& tar_seq2grid = tar.seq2grid;
+    for (int i = 0; i < tar_seq2grid.size(); ++i) {
+        if (mapped_even_corners[i] == 1 && mapped_odd_corners[i] == 1)
+            continue;
+        auto k = tar_seq2grid[i];
+        float p[3];
+        key2cornerpos(k, tar.resolution, p);
+
+        int src_key = pos2key(p, src.resolution);
+        if (!src.grid2seq.count(src_key)) {
+            int seq = src.seq2grid.size();
+            src.grid2seq[src_key] = seq;
+            src.seq2evencorner.emplace_back((mapped_even_corners[i] == 0));
+            src.seq2oddcorner.emplace_back((mapped_odd_corners[i] == 0));
+            src.seq2grid.emplace_back(src_key);
+            src.seq2normal.emplace_back(tar_seq2normal[i]);
+            FetchNeighbor(src, seq, p, tar_seq2normal[i], 0, view_layer_positions, indices);
+            for (int j = 0; j < 9; ++j) {
+                src.seq2neighbor.emplace_back(indices[j]);
+            }
+            src.downsample_seq.emplace_back(i);
+        } else {
+            int seq = src.grid2seq[src_key];
+            if (mapped_even_corners[i] == 0)
+                src.seq2evencorner[seq] = 1;
+            if (mapped_odd_corners[i] == 0)
+                src.seq2oddcorner[seq] = 1;
+        }
+    }
+}
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy(std::vector<torch::Tensor> view_layer_positions,
+    std::vector<torch::Tensor> view_layer_normals, int num_level, int resolution)
+{
+    if (view_layer_positions.size() != 3 || num_level < 1) {
+        printf("Alert! We require 3 layers and at least 1 level! (%d %d)\n", view_layer_positions.size(), num_level);
+        return {{},{},{},{}};
+    }
+
+    std::vector<Grid> grids;
+    grids.resize(num_level);
+
+    std::vector<float> seq2pos;
+    auto& seq2grid = grids[0].seq2grid;
+    auto& seq2normal = grids[0].seq2normal;
+    auto& grid2seq = grids[0].grid2seq;
+    grids[0].resolution = resolution;
+    grids[0].stride = 1;
+
+    auto int64_options = torch::TensorOptions().dtype(torch::kInt64).requires_grad(false);
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).requires_grad(false);
+
+    for (int v = 0; v < 3; ++v) {
+        int num_layers = view_layer_positions[v].size(0);
+        int height = view_layer_positions[v].size(1);
+        int width = view_layer_positions[v].size(2);
+        float* data = view_layer_positions[v].data_ptr<float>();
+        float* data_normal = view_layer_normals[v].data_ptr<float>();
+        for (int l = 0; l < num_layers; ++l) {
+            for (int i = 0; i < height; ++i) {
+                for (int j = 0; j < width; ++j) {
+                    float* p = &data[(i * width + j) * 4];
+                    float* n = &data_normal[(i * width + j) * 3];
+                    if (p[3] == 0)
+                        continue;
+                    auto k = pos2key(p, resolution);
+                    if (!grid2seq.count(k)) {
+                        int dim = 0;
+                        for (int d = 0; d < 3; ++d) {
+                            if (std::abs(n[d]) > std::abs(n[dim]))
+                                dim = d;
+                        }
+                        dim = (dim + 1) % 3;
+                        grid2seq[k] = seq2grid.size();
+                        seq2grid.emplace_back(k);
+                        seq2pos.push_back(p[0]);
+                        seq2pos.push_back(p[1]);
+                        seq2pos.push_back(p[2]);
+                        seq2normal.emplace_back(dim);
+                    }
+                }
+            }
+            data += (height * width * 4);
+            data_normal += (height * width * 3);
+        }
+    }
+
+    for (int i = 0; i < num_level - 1; ++i) {
+        DownsampleGrid(grids[i], grids[i + 1]);
+    }
+
+    for (int l = 0; l < num_level; ++l) {
+        grids[l].seq2neighbor.resize(grids[l].seq2grid.size() * 9, -1);
+        grids[l].num_origin_seq = grids[l].seq2grid.size();
+        for (int d = 0; d < 3; ++d) {
+            NeighborGrid(grids[l], view_layer_positions, d);
+        }
+    }
+
+    for (int i = num_level - 2; i >= 0; --i) {
+        PadGrid(grids[i], grids[i + 1], view_layer_positions);
+    }
+    for (int i = grids[0].num_origin_seq; i < grids[0].seq2grid.size(); ++i) {
+        int k = grids[0].seq2grid[i];
+        float p[3];
+        key2pos(k, grids[0].resolution, p);
+        seq2pos.push_back(p[0]);
+        seq2pos.push_back(p[1]);
+        seq2pos.push_back(p[2]);
+    }
+
+    std::vector<torch::Tensor> texture_positions(2);
+    std::vector<torch::Tensor> grid_neighbors(grids.size());
+    std::vector<torch::Tensor> grid_downsamples(grids.size() - 1);
+    std::vector<torch::Tensor> grid_evencorners(grids.size());
+    std::vector<torch::Tensor> grid_oddcorners(grids.size());
+
+    texture_positions[0] = torch::zeros({seq2pos.size() / 3, 3}, float_options);
+    texture_positions[1] = torch::zeros({seq2pos.size() / 3}, float_options);
+    float* positions_out_ptr = texture_positions[0].data_ptr<float>();
+    memcpy(positions_out_ptr, seq2pos.data(), sizeof(float) * seq2pos.size());
+    positions_out_ptr = texture_positions[1].data_ptr<float>();
+    for (int i = 0; i < grids[0].seq2grid.size(); ++i) {
+        positions_out_ptr[i] = (i < grids[0].num_origin_seq);
+    }
+
+    for (int i = 0; i < grids.size(); ++i) {
+        grid_neighbors[i] = torch::zeros({grids[i].seq2grid.size(), 9}, int64_options);
+        long* nptr = grid_neighbors[i].data_ptr<long>();
+        for (int j = 0; j < grids[i].seq2neighbor.size(); ++j) {
+            nptr[j] = grids[i].seq2neighbor[j];
+        }
+
+        grid_evencorners[i] = torch::zeros({grids[i].seq2evencorner.size()}, int64_options);
+        grid_oddcorners[i] = torch::zeros({grids[i].seq2oddcorner.size()}, int64_options);
+        long* dptr = grid_evencorners[i].data_ptr<long>();
+        for (int j = 0; j < grids[i].seq2evencorner.size(); ++j) {
+            dptr[j] = grids[i].seq2evencorner[j];
+        }
+        dptr = grid_oddcorners[i].data_ptr<long>();
+        for (int j = 0; j < grids[i].seq2oddcorner.size(); ++j) {
+            dptr[j] = grids[i].seq2oddcorner[j];
+        }            
+        if (i + 1 < grids.size()) {
+            grid_downsamples[i] = torch::zeros({grids[i].downsample_seq.size()}, int64_options);
+            long* dptr = grid_downsamples[i].data_ptr<long>();
+            for (int j = 0; j < grids[i].downsample_seq.size(); ++j) {
+                dptr[j] = grids[i].downsample_seq[j];
+            }
+        }
+
+    }
+    return {texture_positions, grid_neighbors, grid_downsamples, grid_evencorners, grid_oddcorners};
+}
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy_with_feat(
+    std::vector<torch::Tensor> view_layer_positions,
+    std::vector<torch::Tensor> view_layer_normals,
+    std::vector<torch::Tensor> view_layer_feats,
+    int num_level, int resolution)
+{
+    if (view_layer_positions.size() != 3 || num_level < 1) {
+        printf("Alert! We require 3 layers and at least 1 level! (%d %d)\n", view_layer_positions.size(), num_level);
+        return {{},{},{},{}};
+    }
+
+    std::vector<Grid> grids;
+    grids.resize(num_level);
+
+    std::vector<float> seq2pos;
+    std::vector<float> seq2feat;
+    auto& seq2grid = grids[0].seq2grid;
+    auto& seq2normal = grids[0].seq2normal;
+    auto& grid2seq = grids[0].grid2seq;
+    grids[0].resolution = resolution;
+    grids[0].stride = 1;
+
+    auto int64_options = torch::TensorOptions().dtype(torch::kInt64).requires_grad(false);
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).requires_grad(false);
+
+    int feat_channel = 3;
+    for (int v = 0; v < 3; ++v) {
+        int num_layers = view_layer_positions[v].size(0);
+        int height = view_layer_positions[v].size(1);
+        int width = view_layer_positions[v].size(2);
+        float* data = view_layer_positions[v].data_ptr<float>();
+        float* data_normal = view_layer_normals[v].data_ptr<float>();
+        float* data_feat = view_layer_feats[v].data_ptr<float>();
+        feat_channel = view_layer_feats[v].size(3);
+        for (int l = 0; l < num_layers; ++l) {
+            for (int i = 0; i < height; ++i) {
+                for (int j = 0; j < width; ++j) {
+                    float* p = &data[(i * width + j) * 4];
+                    float* n = &data_normal[(i * width + j) * 3];
+                    float* f = &data_feat[(i * width + j) * feat_channel];
+                    if (p[3] == 0)
+                        continue;
+                    auto k = pos2key(p, resolution);
+                    if (!grid2seq.count(k)) {
+                        int dim = 0;
+                        for (int d = 0; d < 3; ++d) {
+                            if (std::abs(n[d]) > std::abs(n[dim]))
+                                dim = d;
+                        }
+                        dim = (dim + 1) % 3;
+                        grid2seq[k] = seq2grid.size();
+                        seq2grid.emplace_back(k);
+                        seq2pos.push_back(p[0]);
+                        seq2pos.push_back(p[1]);
+                        seq2pos.push_back(p[2]);
+                        for (int c = 0; c < feat_channel; ++c) {
+                            seq2feat.emplace_back(f[c]);
+                        }
+                        seq2normal.emplace_back(dim);
+                    }
+                }
+            }
+            data += (height * width * 4);
+            data_normal += (height * width * 3);
+            data_feat += (height * width * feat_channel);
+        }
+    }
+
+    for (int i = 0; i < num_level - 1; ++i) {
+        DownsampleGrid(grids[i], grids[i + 1]);
+    }
+
+    for (int l = 0; l < num_level; ++l) {
+        grids[l].seq2neighbor.resize(grids[l].seq2grid.size() * 9, -1);
+        grids[l].num_origin_seq = grids[l].seq2grid.size();
+        for (int d = 0; d < 3; ++d) {
+            NeighborGrid(grids[l], view_layer_positions, d);
+        }
+    }
+
+    for (int i = num_level - 2; i >= 0; --i) {
+        PadGrid(grids[i], grids[i + 1], view_layer_positions);
+    }
+    for (int i = grids[0].num_origin_seq; i < grids[0].seq2grid.size(); ++i) {
+        int k = grids[0].seq2grid[i];
+        float p[3];
+        key2pos(k, grids[0].resolution, p);
+        seq2pos.push_back(p[0]);
+        seq2pos.push_back(p[1]);
+        seq2pos.push_back(p[2]);
+        for (int c = 0; c < feat_channel; ++c) {
+            seq2feat.emplace_back(0.5);
+        }
+    }
+
+    std::vector<torch::Tensor> texture_positions(2);
+    std::vector<torch::Tensor> texture_feats(1);
+    std::vector<torch::Tensor> grid_neighbors(grids.size());
+    std::vector<torch::Tensor> grid_downsamples(grids.size() - 1);
+    std::vector<torch::Tensor> grid_evencorners(grids.size());
+    std::vector<torch::Tensor> grid_oddcorners(grids.size());
+
+    texture_positions[0] = torch::zeros({seq2pos.size() / 3, 3}, float_options);
+    texture_positions[1] = torch::zeros({seq2pos.size() / 3}, float_options);
+    texture_feats[0] = torch::zeros({seq2feat.size() / feat_channel, feat_channel}, float_options);
+    float* positions_out_ptr = texture_positions[0].data_ptr<float>();
+    memcpy(positions_out_ptr, seq2pos.data(), sizeof(float) * seq2pos.size());
+    positions_out_ptr = texture_positions[1].data_ptr<float>();
+    for (int i = 0; i < grids[0].seq2grid.size(); ++i) {
+        positions_out_ptr[i] = (i < grids[0].num_origin_seq);
+    }
+    float* feats_out_ptr = texture_feats[0].data_ptr<float>();
+    memcpy(feats_out_ptr, seq2feat.data(), sizeof(float) * seq2feat.size());
+
+    for (int i = 0; i < grids.size(); ++i) {
+        grid_neighbors[i] = torch::zeros({grids[i].seq2grid.size(), 9}, int64_options);
+        long* nptr = grid_neighbors[i].data_ptr<long>();
+        for (int j = 0; j < grids[i].seq2neighbor.size(); ++j) {
+            nptr[j] = grids[i].seq2neighbor[j];
+        }
+        grid_evencorners[i] = torch::zeros({grids[i].seq2evencorner.size()}, int64_options);
+        grid_oddcorners[i] = torch::zeros({grids[i].seq2oddcorner.size()}, int64_options);
+        long* dptr = grid_evencorners[i].data_ptr<long>();
+        for (int j = 0; j < grids[i].seq2evencorner.size(); ++j) {
+            dptr[j] = grids[i].seq2evencorner[j];
+        }
+        dptr = grid_oddcorners[i].data_ptr<long>();
+        for (int j = 0; j < grids[i].seq2oddcorner.size(); ++j) {
+            dptr[j] = grids[i].seq2oddcorner[j];
+        }
+        if (i + 1 < grids.size()) {
+            grid_downsamples[i] = torch::zeros({grids[i].downsample_seq.size()}, int64_options);
+            long* dptr = grid_downsamples[i].data_ptr<long>();
+            for (int j = 0; j < grids[i].downsample_seq.size(); ++j) {
+                dptr[j] = grids[i].downsample_seq[j];
+            }
+        }
+    }
+    return {texture_positions, texture_feats, grid_neighbors, grid_downsamples, grid_evencorners, grid_oddcorners};
+}

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/lib/custom_rasterizer_kernel/rasterizer.cpp

@@ -0,0 +1,139 @@
+#include "rasterizer.h"
+
+void rasterizeTriangleCPU(int idx, float* vt0, float* vt1, float* vt2, int width, int height, INT64* zbuffer, float* d, float occlusion_truncation) {
+    float x_min = std::min(vt0[0], std::min(vt1[0],vt2[0]));
+    float x_max = std::max(vt0[0], std::max(vt1[0],vt2[0]));
+    float y_min = std::min(vt0[1], std::min(vt1[1],vt2[1]));
+    float y_max = std::max(vt0[1], std::max(vt1[1],vt2[1]));
+
+    for (int px = x_min; px < x_max + 1; ++px) {
+        if (px < 0 || px >= width)
+            continue;
+        for (int py = y_min; py < y_max + 1; ++py) {
+            if (py < 0 || py >= height)
+                continue;
+            float vt[2] = {px + 0.5, py + 0.5};
+            float baryCentricCoordinate[3];
+            calculateBarycentricCoordinate(vt0, vt1, vt2, vt, baryCentricCoordinate);
+            if (isBarycentricCoordInBounds(baryCentricCoordinate)) {
+                int pixel = py * width + px;
+                if (zbuffer == 0) {
+                    zbuffer[pixel] = (INT64)(idx + 1);
+                    continue;
+                }
+
+                float depth = baryCentricCoordinate[0] * vt0[2] + baryCentricCoordinate[1] * vt1[2] + baryCentricCoordinate[2] * vt2[2];
+                float depth_thres = 0;
+                if (d) {
+                    depth_thres = d[pixel] * 0.49999f + 0.5f + occlusion_truncation;
+                }
+                
+                int z_quantize = depth * (2<<17);
+                INT64 token = (INT64)z_quantize * MAXINT + (INT64)(idx + 1);
+                if (depth < depth_thres)
+                    continue;
+                zbuffer[pixel] = std::min(zbuffer[pixel], token);
+            }
+        }
+    }
+}
+
+void barycentricFromImgcoordCPU(float* V, int* F, int* findices, INT64* zbuffer, int width, int height, int num_vertices, int num_faces,
+    float* barycentric_map, int pix)
+{
+    INT64 f = zbuffer[pix] % MAXINT;
+    if (f == (MAXINT-1)) {
+        findices[pix] = 0;
+        barycentric_map[pix * 3] = 0;
+        barycentric_map[pix * 3 + 1] = 0;
+        barycentric_map[pix * 3 + 2] = 0;
+        return;
+    }
+    findices[pix] = f;
+    f -= 1;
+    float barycentric[3] = {0, 0, 0};
+    if (f >= 0) {
+        float vt[2] = {float(pix % width) + 0.5f, float(pix / width) + 0.5f};
+        float* vt0_ptr = V + (F[f * 3] * 4);
+        float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+        float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+        float vt0[2] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f};
+        float vt1[2] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f};
+        float vt2[2] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f};
+
+        calculateBarycentricCoordinate(vt0, vt1, vt2, vt, barycentric);
+
+        barycentric[0] = barycentric[0] / vt0_ptr[3];
+        barycentric[1] = barycentric[1] / vt1_ptr[3];
+        barycentric[2] = barycentric[2] / vt2_ptr[3];
+        float w = 1.0f / (barycentric[0] + barycentric[1] + barycentric[2]);
+        barycentric[0] *= w;
+        barycentric[1] *= w;
+        barycentric[2] *= w;
+
+    }
+    barycentric_map[pix * 3] = barycentric[0];
+    barycentric_map[pix * 3 + 1] = barycentric[1];
+    barycentric_map[pix * 3 + 2] = barycentric[2];
+}
+
+void rasterizeImagecoordsKernelCPU(float* V, int* F, float* d, INT64* zbuffer, float occlusion_trunc, int width, int height, int num_vertices, int num_faces, int f)
+{
+    float* vt0_ptr = V + (F[f * 3] * 4);
+    float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+    float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+    float vt0[3] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f, vt0_ptr[2] / vt0_ptr[3] * 0.49999f + 0.5f};
+    float vt1[3] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f, vt1_ptr[2] / vt1_ptr[3] * 0.49999f + 0.5f};
+    float vt2[3] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f, vt2_ptr[2] / vt2_ptr[3] * 0.49999f + 0.5f};
+
+    rasterizeTriangleCPU(f, vt0, vt1, vt2, width, height, zbuffer, d, occlusion_trunc);
+}
+
+std::vector<torch::Tensor> rasterize_image_cpu(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior)
+{
+    int num_faces = F.size(0);
+    int num_vertices = V.size(0);
+    auto options = torch::TensorOptions().dtype(torch::kInt32).requires_grad(false);
+    auto INT64_options = torch::TensorOptions().dtype(torch::kInt64).requires_grad(false);
+    auto findices = torch::zeros({height, width}, options);
+    INT64 maxint = (INT64)MAXINT * (INT64)MAXINT + (MAXINT - 1);
+    auto z_min = torch::ones({height, width}, INT64_options) * (long)maxint;
+
+    if (!use_depth_prior) {
+        for (int i = 0; i < num_faces; ++i) {
+            rasterizeImagecoordsKernelCPU(V.data_ptr<float>(), F.data_ptr<int>(), 0,
+                (INT64*)z_min.data_ptr<long>(), occlusion_truncation, width, height, num_vertices, num_faces, i); 
+        }
+    } else {
+        for (int i = 0; i < num_faces; ++i)
+            rasterizeImagecoordsKernelCPU(V.data_ptr<float>(), F.data_ptr<int>(), D.data_ptr<float>(),
+                (INT64*)z_min.data_ptr<long>(), occlusion_truncation, width, height, num_vertices, num_faces, i);
+    }
+
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).requires_grad(false);
+    auto barycentric = torch::zeros({height, width, 3}, float_options);
+    for (int i = 0; i < width * height; ++i)
+        barycentricFromImgcoordCPU(V.data_ptr<float>(), F.data_ptr<int>(),
+            findices.data_ptr<int>(), (INT64*)z_min.data_ptr<long>(), width, height, num_vertices, num_faces, barycentric.data_ptr<float>(), i);
+
+    return {findices, barycentric};
+}
+
+std::vector<torch::Tensor> rasterize_image(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior)
+{
+    int device_id = V.get_device();
+    if (device_id == -1)
+        return rasterize_image_cpu(V, F, D, width, height, occlusion_truncation, use_depth_prior);
+    else
+        return rasterize_image_gpu(V, F, D, width, height, occlusion_truncation, use_depth_prior);
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("rasterize_image", &rasterize_image, "Custom image rasterization");
+  m.def("build_hierarchy", &build_hierarchy, "Custom image rasterization");
+  m.def("build_hierarchy_with_feat", &build_hierarchy_with_feat, "Custom image rasterization");
+}

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/lib/custom_rasterizer_kernel/rasterizer.h

@@ -0,0 +1,54 @@
+#ifndef RASTERIZER_H_
+#define RASTERIZER_H_
+
+#include <torch/extension.h>
+#include <vector>
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h> // For CUDA context
+
+#define INT64 unsigned long long
+#define MAXINT 2147483647
+
+__host__ __device__ inline float calculateSignedArea2(float* a, float* b, float* c) {
+    return ((c[0] - a[0]) * (b[1] - a[1]) - (b[0] - a[0]) * (c[1] - a[1]));
+}
+
+__host__ __device__  inline void calculateBarycentricCoordinate(float* a, float* b, float* c, float* p,
+    float* barycentric)
+{
+    float beta_tri = calculateSignedArea2(a, p, c);
+    float gamma_tri = calculateSignedArea2(a, b, p);
+    float area = calculateSignedArea2(a, b, c);
+    if (area == 0) {
+        barycentric[0] = -1.0;
+        barycentric[1] = -1.0;
+        barycentric[2] = -1.0;
+        return;
+    }
+    float tri_inv = 1.0 / area;
+    float beta = beta_tri * tri_inv;
+    float gamma = gamma_tri * tri_inv;
+    float alpha = 1.0 - beta - gamma;
+    barycentric[0] = alpha;
+    barycentric[1] = beta;
+    barycentric[2] = gamma;
+}
+
+__host__ __device__  inline bool isBarycentricCoordInBounds(float* barycentricCoord) {
+    return barycentricCoord[0] >= 0.0 && barycentricCoord[0] <= 1.0 &&
+           barycentricCoord[1] >= 0.0 && barycentricCoord[1] <= 1.0 &&
+           barycentricCoord[2] >= 0.0 && barycentricCoord[2] <= 1.0;
+}
+
+std::vector<torch::Tensor> rasterize_image_gpu(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior);
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy(std::vector<torch::Tensor> view_layer_positions, std::vector<torch::Tensor> view_layer_normals, int num_level, int resolution);
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy_with_feat(
+    std::vector<torch::Tensor> view_layer_positions,
+    std::vector<torch::Tensor> view_layer_normals,
+    std::vector<torch::Tensor> view_layer_feats,
+    int num_level, int resolution);
+
+#endif

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/lib/custom_rasterizer_kernel/rasterizer_gpu.cu

@@ -0,0 +1,127 @@
+#include "rasterizer.h"
+
+__device__ void rasterizeTriangleGPU(int idx, float* vt0, float* vt1, float* vt2, int width, int height, INT64* zbuffer, float* d, float occlusion_truncation) {
+    float x_min = std::min(vt0[0], std::min(vt1[0],vt2[0]));
+    float x_max = std::max(vt0[0], std::max(vt1[0],vt2[0]));
+    float y_min = std::min(vt0[1], std::min(vt1[1],vt2[1]));
+    float y_max = std::max(vt0[1], std::max(vt1[1],vt2[1]));
+
+    for (int px = x_min; px < x_max + 1; ++px) {
+        if (px < 0 || px >= width)
+            continue;
+        for (int py = y_min; py < y_max + 1; ++py) {
+            if (py < 0 || py >= height)
+                continue;
+            float vt[2] = {px + 0.5f, py + 0.5f};
+            float baryCentricCoordinate[3];
+            calculateBarycentricCoordinate(vt0, vt1, vt2, vt, baryCentricCoordinate);
+            if (isBarycentricCoordInBounds(baryCentricCoordinate)) {
+                int pixel = py * width + px;
+                if (zbuffer == 0) {
+                    atomicExch(&zbuffer[pixel], (INT64)(idx + 1));
+                    continue;
+                }
+                float depth = baryCentricCoordinate[0] * vt0[2] + baryCentricCoordinate[1] * vt1[2] + baryCentricCoordinate[2] * vt2[2];
+                float depth_thres = 0;
+                if (d) {
+                    depth_thres = d[pixel] * 0.49999f + 0.5f + occlusion_truncation;
+                }
+                
+                int z_quantize = depth * (2<<17);
+                INT64 token = (INT64)z_quantize * MAXINT + (INT64)(idx + 1);
+                if (depth < depth_thres)
+                    continue;
+                atomicMin(&zbuffer[pixel], token);
+            }
+        }
+    }
+}
+
+__global__ void barycentricFromImgcoordGPU(float* V, int* F, int* findices, INT64* zbuffer, int width, int height, int num_vertices, int num_faces,
+    float* barycentric_map)
+{
+    int pix = blockIdx.x * blockDim.x + threadIdx.x;
+    if (pix >= width * height)
+        return;
+    INT64 f = zbuffer[pix] % MAXINT;
+    if (f == (MAXINT-1)) {
+        findices[pix] = 0;
+        barycentric_map[pix * 3] = 0;
+        barycentric_map[pix * 3 + 1] = 0;
+        barycentric_map[pix * 3 + 2] = 0;
+        return;
+    }
+    findices[pix] = f;
+    f -= 1;
+    float barycentric[3] = {0, 0, 0};
+    if (f >= 0) {
+        float vt[2] = {float(pix % width) + 0.5f, float(pix / width) + 0.5f};
+        float* vt0_ptr = V + (F[f * 3] * 4);
+        float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+        float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+        float vt0[2] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f};
+        float vt1[2] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f};
+        float vt2[2] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f};
+
+        calculateBarycentricCoordinate(vt0, vt1, vt2, vt, barycentric);
+
+        barycentric[0] = barycentric[0] / vt0_ptr[3];
+        barycentric[1] = barycentric[1] / vt1_ptr[3];
+        barycentric[2] = barycentric[2] / vt2_ptr[3];
+        float w = 1.0f / (barycentric[0] + barycentric[1] + barycentric[2]);
+        barycentric[0] *= w;
+        barycentric[1] *= w;
+        barycentric[2] *= w;
+
+    }
+    barycentric_map[pix * 3] = barycentric[0];
+    barycentric_map[pix * 3 + 1] = barycentric[1];
+    barycentric_map[pix * 3 + 2] = barycentric[2];
+}
+
+__global__ void rasterizeImagecoordsKernelGPU(float* V, int* F, float* d, INT64* zbuffer, float occlusion_trunc, int width, int height, int num_vertices, int num_faces)
+{
+    int f = blockIdx.x * blockDim.x + threadIdx.x;
+    if (f >= num_faces)
+        return; 
+
+    float* vt0_ptr = V + (F[f * 3] * 4);
+    float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+    float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+    float vt0[3] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f, vt0_ptr[2] / vt0_ptr[3] * 0.49999f + 0.5f};
+    float vt1[3] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f, vt1_ptr[2] / vt1_ptr[3] * 0.49999f + 0.5f};
+    float vt2[3] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f, vt2_ptr[2] / vt2_ptr[3] * 0.49999f + 0.5f};
+
+    rasterizeTriangleGPU(f, vt0, vt1, vt2, width, height, zbuffer, d, occlusion_trunc);
+}
+
+std::vector<torch::Tensor> rasterize_image_gpu(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior)
+{
+    int device_id = V.get_device();
+    cudaSetDevice(device_id);
+    int num_faces = F.size(0);
+    int num_vertices = V.size(0);
+    auto options = torch::TensorOptions().dtype(torch::kInt32).device(torch::kCUDA, device_id).requires_grad(false);
+    auto INT64_options = torch::TensorOptions().dtype(torch::kInt64).device(torch::kCUDA, device_id).requires_grad(false);
+    auto findices = torch::zeros({height, width}, options);
+    INT64 maxint = (INT64)MAXINT * (INT64)MAXINT + (MAXINT - 1);
+    auto z_min = torch::ones({height, width}, INT64_options) * (long)maxint;
+
+    if (!use_depth_prior) {
+        rasterizeImagecoordsKernelGPU<<<(num_faces+255)/256,256,0,at::cuda::getCurrentCUDAStream()>>>(V.data_ptr<float>(), F.data_ptr<int>(), 0,
+            (INT64*)z_min.data_ptr<long>(), occlusion_truncation, width, height, num_vertices, num_faces); 
+    } else {
+        rasterizeImagecoordsKernelGPU<<<(num_faces+255)/256,256,0,at::cuda::getCurrentCUDAStream()>>>(V.data_ptr<float>(), F.data_ptr<int>(), D.data_ptr<float>(),
+            (INT64*)z_min.data_ptr<long>(), occlusion_truncation, width, height, num_vertices, num_faces); 
+    }
+
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA, device_id).requires_grad(false);
+    auto barycentric = torch::zeros({height, width, 3}, float_options);
+    barycentricFromImgcoordGPU<<<(width * height + 255)/256, 256>>>(V.data_ptr<float>(), F.data_ptr<int>(),
+        findices.data_ptr<int>(), (INT64*)z_min.data_ptr<long>(), width, height, num_vertices, num_faces, barycentric.data_ptr<float>());
+
+    return {findices, barycentric};
+}

home/ubuntu/aaaaa/data/rgbmr/custom_rasterizer/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+import torch
+from torch.utils.cpp_extension import BuildExtension, CUDAExtension, CppExtension
+
+# build custom rasterizer
+
+custom_rasterizer_module = CUDAExtension(
+    "custom_rasterizer_kernel",
+    [
+        "lib/custom_rasterizer_kernel/rasterizer.cpp",
+        "lib/custom_rasterizer_kernel/grid_neighbor.cpp",
+        "lib/custom_rasterizer_kernel/rasterizer_gpu.cu",
+    ],
+)
+
+setup(
+    packages=find_packages(),
+    version="0.1",
+    name="custom_rasterizer",
+    include_package_data=True,
+    package_dir={"": "."},
+    ext_modules=[
+        custom_rasterizer_module,
+    ],
+    cmdclass={"build_ext": BuildExtension},
+)

home/ubuntu/aaaaa/data/rgbmr/data/generate_rgbmr_dataset.py

@@ -0,0 +1,389 @@
+import argparse
+import os, sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  # repo root append
+
+import math
+from typing import Any, Callable, Dict, List, Set, Tuple, Optional, Union
+from pathlib import Path
+import glob
+
+import numpy as np
+from PIL import Image
+import torch
+
+from tools.utils.mesh_utils import (
+    load_mesh,
+    get_orthogonal_camera,
+    NVDiffRastContextWrapper,
+    render,
+)
+
+from data.rgbmr_dataset import build_partial_dataset, DT, SCHEMA_RGBMR
+from mcgen.utils.text_encoder_utils import load_text_ctx, encode_prompt
+
+
+# -------------------------
+# Helpers: find glbs, curated ids
+# -------------------------
+
+def load_curated_ids(path: Path) -> List[str]:
+    ids = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            s = line.strip()
+            if not s or s.startswith("#"):
+                continue
+            ids.append(s)
+    return ids
+
+def find_glb_index(root, curated_ids):
+    glbs = {}
+    for p in glob.glob(str(root / "**/*.glb"), recursive=True):
+        p = Path(p)
+        if p.stem in curated_ids:
+            glbs[p.stem] = p
+    return glbs
+
+def shard_list(full_list, num_shards: int, shard_id: int):
+    n = len(full_list)
+    if num_shards <= 1:
+        return full_list
+    sz = (n + num_shards - 1) // num_shards
+    start = shard_id * sz
+    end = min(start + sz, n)
+    return full_list[start:end]
+
+# -------------------------
+# Camera/view sampling
+# -------------------------
+def default_view_sampler(num_elev: int = 1, num_azim: int = 24,
+                         elev_deg: float = 20.0) -> Callable[[Any], List[Tuple[float, float]]]:
+    """
+    Returns a function gid -> list[(elevation_deg, azimuth_deg)].
+    By default: a single elevation ring with uniformly spaced azimuths.
+    """
+    azims = [i * (360.0 / num_azim) for i in range(num_azim)]
+    elevs = [elev_deg for _ in range(num_elev)]
+    views = [(e, a) for e in elevs for a in azims]
+
+    def sampler(_gid: Any) -> List[Tuple[float, float]]:
+        return views
+
+    return sampler
+
+def random_view_sampler(num_views: int = 4,
+                        elev_range: Tuple[float, float] = (-30.0, 60.0)) -> Callable[[Any], List[Tuple[float, float]]]:
+    """
+    Returns a function gid -> list[(elevation_deg, azimuth_deg)].
+    Each object gets num_views random views.
+    """
+    def sampler(_gid: Any) -> List[Tuple[float, float]]:
+        views = []
+        for _ in range(num_views):
+            az = np.random.uniform(0.0, 360.0)
+            el = np.random.uniform(elev_range[0], elev_range[1])
+            views.append((el, az))
+        return views
+    return sampler
+
+def view_sampler_from_list(azim_list: List[float], elev_list: List[float]) -> Callable[[Any], List[Tuple[float, float]]]:
+    """
+    azim_list: list of azimuth angles in degrees
+    elev_list: list of elevation angles in degrees
+    Returns a function gid -> list[(elevation_deg, azimuth_deg)].
+    """
+    if len(azim_list) != len(elev_list):
+        raise ValueError("azim_list and elev_list must have the same length")
+    views = list(zip(elev_list, azim_list))
+
+    def sampler(_gid: Any) -> List[Tuple[float, float]]:
+        return views
+
+    return sampler
+
+
+# -------------------------
+# Backend interface
+# -------------------------
+class RenderBackend:
+    """
+    Implement this with your renderer. The contract is:
+    render(mesh_path, elevation, azimuth, image_size) -> dict with:
+      - 'albedo':   BxHxWx3 uint8 or float[0,1]
+      - 'normal':   BxHxWx3 float[-1,1] or uint8 in [0,255] (we'll convert)
+      - 'depth':    BxHxW float meters
+      - 'orm':      BxHxWx3 (O,R,M) either float[0,1] or uint8[0,255]
+    """
+
+    @torch.no_grad()
+    def render(
+        self,
+        ctx: NVDiffRastContextWrapper,
+        mesh_path: Any,
+        elevation: Union[List[float], float],
+        azimuth: Union[List[float], float],
+        image_size: Tuple[int, int],
+        device: Union[str, torch.device] = "cuda",
+    ) -> Dict[str, Any]:
+        # 로딩
+        mesh = load_mesh(
+            str(mesh_path),
+            rescale=True,
+            move_to_center=True,
+            flip_uv=True,
+            device=device,
+        )
+        elevation = elevation if isinstance(elevation, list) else [elevation]
+        azimuth = azimuth if isinstance(azimuth, list) else [azimuth]
+
+        # 카메라 배치(정사각형 ortho box; rescale=0.5 기준 안전 여유)
+        cams = get_orthogonal_camera(
+            elevation_deg=elevation,
+            distance=[1.0] * len(azimuth),
+            left=-0.55,
+            right=0.55,
+            bottom=-0.55,
+            top=0.55,
+            azimuth_deg=azimuth,
+            device=device,
+            dtype=torch.float32,
+        )
+
+        # 렌더 속성: rgb + roughness + metallic (5채널)
+        tex_ovr = torch.concatenate(
+            [mesh.texture, torch.zeros_like(mesh.roughness), mesh.roughness, mesh.metallic],
+            dim=-1,
+        )
+        out = render(
+            ctx, mesh, cams, height=image_size[0], width=image_size[1], render_attr=True, texture_override=tex_ovr
+        )
+        
+        attr = out.attr  # [B,H,W,5] float in [0,1]
+        pos_batch = out.pos
+        normal_batch = out.normal
+        depth_batch = out.raw_depth  # [B,H,W] float in [0,inf]
+
+        rgb_batch = attr[..., :3].contiguous()
+        orm_batch = attr[..., 3:6].contiguous()
+        orm_batch[..., 0] = (orm_batch[..., 0] < 0.25).float()  # binarize alpha to get foreground mask
+
+        pos_batch = pos_batch + 0.5  # [-0.5,0.5] → [0,1]
+        normal_batch = (normal_batch + 1.0) * 0.5 # [-1,1] → [0,1]
+
+        result: Dict[str, Any] = {
+            "albedo": rgb_batch,
+            "orm": orm_batch,
+            "depth": depth_batch,
+            "pos": pos_batch,
+            "normal": normal_batch,
+            "c2w": cams.c2w,
+            "scale": 1.1,
+        }
+        return result
+
+
+# -------------------------
+# Mesh resolver
+# -------------------------
+def default_mesh_resolver(mesh_index: Dict[str, Any]) -> Callable[[Any], Any]:
+    """
+    mesh_index: e.g., {'obj001': '/path/obj001.obj', ...} or preloaded mesh objects.
+    """
+    def resolve(gid: Any) -> Any:
+        key = str(gid)
+        if key not in mesh_index:
+            raise KeyError(f"Mesh for gid='{gid}' not found")
+        return mesh_index[key]
+    return resolve
+
+def default_prompt_resolver(prompt_index: Dict[str, str]) -> Callable[[Any], str]:
+    """
+    prompt_index: e.g., {'obj001': 'a red apple', ...}
+    """
+    def resolve(gid: Any) -> str:
+        key = str(gid)
+        if key not in prompt_index:
+            raise KeyError(f"Prompt for gid='{gid}' not found")
+        return prompt_index[key]
+    return resolve
+
+
+# -------------------------
+# Factory: make generate_data(gid)
+# -------------------------
+def make_generate_data(
+    render_ctx,
+    text_ctx,
+    mesh_resolver: Callable[[Any], Any],
+    prompt_resolver: Callable[[Any], str],
+    backend: RenderBackend,
+    view_sampler: Callable[[Any], List[Tuple[float, float]]] = default_view_sampler(),
+    image_size: Tuple[int, int] = (512, 512),
+    max_seq_length: int = 77,
+):
+    """
+    Returns a single-argument function: generate_data(gid) -> dict
+    Output structure matches your schema requirements.
+    Per-object:
+      - 'gid' (str)
+      - 'prompt' (str) -> 'a sample text'
+        - 'prompt_embeds' (torch.Tensor) -> (L, D)
+        - 'pooled_prompt_embeds' (torch.Tensor) -> (D,)
+    Per-view (list under 'views'):
+      - 'albedo' (PNG-ready RGB)
+      - 'orm' (PNG-ready RGB)
+      - 'depth' (EXR-ready float32)
+      - 'pos' (PNG-ready RGB)
+      - 'normal' (PNG-ready RGB)
+      - 'elevation' (float, degrees)
+      - 'azimuth'  (float, degrees)
+    """
+    H, W = image_size
+
+    def generate_data(gid: Any) -> Dict[str, Any]:
+        mesh_path = mesh_resolver(gid)
+        prompt = prompt_resolver(gid)
+        views_out: List[Dict[str, Any]] = []
+
+        # Collect all views and render in a single batched call
+        views = view_sampler(gid)
+        if len(views) > 0:
+            elev_list = [e for e, _ in views]
+            azim_list = [a for _, a in views]
+
+            out = backend.render(render_ctx, mesh_path, elev_list, azim_list, (H, W))
+
+            albedo_batch = out['albedo']      # [B,H,W,3] float in [0,1]
+            orm_batch = out['orm']          # [B,H,W,3] float in [0,1]
+            depth_batch = out['depth']      # [B,H,W] float in [0,inf]
+            pos_batch = out['pos']          # [B,H,W,3] float in [0,1]
+            normal_batch = out['normal']    # [B,H,W,3] float in [0,1]
+            c2w_batch = out['c2w']          # [B,4,4]
+            scale = out['scale']      # float scalar
+
+            for i, (elev_deg, azim_deg) in enumerate(views):
+                # ---- albedo ----
+                albedo = albedo_batch[i]
+                orm = orm_batch[i]
+                pos = pos_batch[i]
+                normal = normal_batch[i]
+
+                # ---- depth ----
+                depth = depth_batch[i]
+
+                views_out.append({
+                    "albedo": albedo,  # [H,W,3] float in [0,1], will be converted to PNG
+                    "orm": orm,          # [H,W,3] float in [0,1], will be converted to PNG
+                    "depth": depth,  # [H,W] float, will be saved as EXR
+                    "pos": pos,          # [H,W,3] float in [0,1], will be converted to PNG
+                    "normal": normal,  # [H,W,3] float in [0,1], will be converted to PNG
+                    "elevation": float(elev_deg),         # metadata (store as JSON via schema)
+                    "azimuth": float(azim_deg),
+                    "c2w": c2w_batch[i],
+                    "scale": scale,
+                })
+
+        # encode prompt
+        prompt_embeds, pooled_prompt_embeds = encode_prompt(
+            text_ctx["encoders"], text_ctx["tokenizers"], prompt,
+            max_sequence_length=max_seq_length,
+        )  # (1, L, D), (1, D)
+
+        result: Dict[str, Any] = {
+            "prompt": prompt,
+            "prompt_embeds": prompt_embeds.squeeze(0).cpu(),  # (L, D)
+            "pooled_prompt_embeds": pooled_prompt_embeds.squeeze(0).cpu(),  # (D,)
+            "views": views_out,
+        }
+        return result
+
+    return generate_data
+
+
+# -----------------------------------------
+# Example schema to pair with this generator
+# -----------------------------------------
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out-dir", default="/home/ubuntu/aaaaa/data/rgbmr", help="Dataset root directory")
+    ap.add_argument("--gid-path", default="../obj_keys.txt", help="Curated obj ID list path")
+    ap.add_argument("--prompt-path", default="../prompts_bs.csv", help="Prompt CSV path (id,prompt)")
+    ap.add_argument("--sd-model", default="stabilityai/stable-diffusion-3.5-medium", help="SD3.5 model name")
+    ap.add_argument("--dtype", default="float16", choices=["float16", "float32", "bfloat16"], help="Model dtype")
+    ap.add_argument("--device", default="cuda", help="Device")
+    ap.add_argument("--max_seq", type=int, default=77, help="T5 max token length")
+    ap.add_argument("--num_shards", type=int, default=1)
+    ap.add_argument("--shard_id", type=int, default=0)
+    ap.add_argument("--random-single-view", action="store_true", help="Use random single view per object")
+    ap.add_argument("--part_dir", default=None, help="If given, overrides run_name and uses this dir directly")
+    args = ap.parse_args()
+    # -------------------- schema example --------------------
+
+    dtype_map = {"float16": torch.float16, "float32": torch.float32, "bfloat16": torch.bfloat16}
+    text_ctx = load_text_ctx(args.device, dtype=dtype_map[args.dtype], sd_model_name=args.sd_model)
+    render_ctx = NVDiffRastContextWrapper(device=args.device, context_type="cuda")
+
+    gid_path = Path(args.gid_path)
+    out_dir = Path(args.out_dir)
+    glb_root = Path("/home/ubuntu/.objaverse/hf-objaverse-v1/glbs")
+
+    curated_ids = load_curated_ids(gid_path)
+    glbs_filtered = find_glb_index(glb_root, set(curated_ids))
+    print(f"Found {len(glbs_filtered)} / {len(curated_ids)} curated GLBs")
+
+    mesh_resolver = default_mesh_resolver(glbs_filtered)
+
+    # make prompt resolver
+    import csv
+    prompt_index = {}
+    with open(args.prompt_path, "r", encoding="utf-8") as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if len(row) != 2:
+                raise ValueError(f"Expected 2 columns per row, got {len(row)}: {row}")
+            obj_id, prompt = row
+            prompt_index[obj_id] = prompt
+    prompt_resolver = default_prompt_resolver(prompt_index)
+
+    
+    az = [
+        0.0, 90.0, 180.0, 270.0, 0.0, 0.0,                                          # face
+        45.0, 135.0, 225.0, 315.0, 45.0, 135.0, 225.0, 315.0,                       # corner
+        45.0, 135.0, 225.0, 315.0, 0.0, 90.0, 180.0, 270.0, 0.0, 90.0, 180.0, 270.0 # edge
+    ]
+    el = [
+        0.0, 0.0, 0.0, 0.0, 89.99, -89.99,                                      # face
+        45.0, 45.0, 45.0, 45.0, -45.0, -45.0, -45.0, -45.0,                     # corner
+        0.0, 0.0, 0.0, 0.0, 45.0, 45.0, 45.0, 45.0, -45.0, -45.0, -45.0, -45.0  # edge
+    ]
+    view_sampler = None
+    if args.random_single_view:
+        view_sampler = random_view_sampler(num_views=1, elev_range=(-30.0, 60.0))
+    else:
+        view_sampler = view_sampler_from_list(azim_list=az, elev_list=el)
+
+    generate_data = make_generate_data(
+        render_ctx=render_ctx,
+        text_ctx=text_ctx,
+        prompt_resolver=prompt_resolver,
+        mesh_resolver=mesh_resolver,
+        backend=RenderBackend(),
+        view_sampler=view_sampler,
+        image_size=(512, 512),
+        max_seq_length=args.max_seq,
+    )
+
+    glbs_list = curated_ids
+    # glbs_list.sort()
+    glbs_sharded = shard_list(glbs_list, args.num_shards, args.shard_id)
+
+    build_partial_dataset(
+        generate_data=generate_data,
+        gid_list=glbs_sharded,
+        schema=SCHEMA_RGBMR,
+        root_dir=out_dir,
+        run_name=f"render_{args.shard_id:02d}_of_{args.num_shards:02d}",
+        part_dir=args.part_dir,
+        progress=True,
+    )

home/ubuntu/aaaaa/data/rgbmr/data/rgbmr_dataset.py

@@ -0,0 +1,845 @@
+# rgbmr_dataset.py
+import os
+import io
+import json
+import glob
+import uuid
+import time
+import shutil
+import pathlib
+import random
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+from PIL import Image
+import torch
+import torch.nn.functional as F
+import webdataset as wds
+from tqdm import tqdm
+
+
+# =========================
+# Datatypes and schema utils
+# =========================
+class DT(Enum):
+    """Dataset field datatypes."""
+
+    STR = "str"  # utf-8 text
+    TENSOR = "tensor"  # arbitrary tensor/ndarray -> .npy
+    PNG = "png"  # 3-channel PNG (uint8); float in [0,1] allowed
+    EXR = "exr"  # single-channel EXR (depth as float), lossless PIZ by default
+    JSON = "json"  # json-serializable python object
+    BYTES = "bytes"  # raw bytes
+
+
+SCHEMA_RGBMR = {
+    "prompt": DT.STR,
+    "prompt_embeds": DT.TENSOR,
+    "pooled_prompt_embeds": DT.TENSOR,
+    "views": {
+        "albedo": DT.PNG,
+        "orm": DT.PNG,
+        "depth": DT.EXR,  # float32 depth
+        "pos": DT.PNG,
+        "normal": DT.PNG,
+        "elevation": DT.JSON,  # float degree
+        "azimuth": DT.JSON,  # float degree
+        "c2w": DT.TENSOR,  # camera-to-world matrix (4x4)
+        "scale": DT.JSON,  # float scale
+    },
+}
+
+
+def _ensure_dir(path: str) -> None:
+    os.makedirs(path, exist_ok=True)
+
+
+def _timestamp() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _sanitize_key(name: str) -> str:
+    safe = []
+    for ch in name:
+        if ch.isalnum() or ch in "._-":
+            safe.append(ch)
+        else:
+            safe.append("_")
+    return "".join(safe)
+
+
+# Added: canonicalize DT specs (accept Enum or string)
+def _dt_value(dt: Any) -> str:
+    # direct enum from this module
+    if isinstance(dt, DT):
+        return dt.value
+    # enum-like objects (possibly from reloaded module)
+    if hasattr(dt, "value") and isinstance(getattr(dt, "value"), str):
+        return getattr(dt, "value")
+    # already a string value
+    if isinstance(dt, str):
+        return dt
+    raise ValueError(f"Unsupported DT spec: {dt} (type: {type(dt)})")
+
+
+def _dt_ext(dt: Any) -> str:
+    dtv = _dt_value(dt)
+    if dtv == DT.PNG.value:
+        return "png"
+    if dtv == DT.EXR.value:
+        return "exr"
+    if dtv == DT.TENSOR.value:
+        return "npy"
+    if dtv == DT.STR.value:
+        return "txt"
+    if dtv == DT.JSON.value:
+        return "json"
+    if dtv == DT.BYTES.value:
+        return "bin"
+    raise ValueError(f"Unhandled DT: {dt}, type: {type(dt)}")
+
+
+def _schema_to_jsonable(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert a schema containing DT enums into a JSON-serializable dict.
+
+    The expected input shape is a dict where values are either DT or nested dicts
+    (e.g., {"views": {"rgb": DT.PNG, ...}}). We convert any DT to its string value.
+    """
+
+    def _conv(x: Any) -> Any:
+        if isinstance(x, DT):
+            return x.value
+        if isinstance(x, dict):
+            return {k: _conv(v) for k, v in x.items()}
+        return x
+
+    return {k: _conv(v) for k, v in schema.items()}
+
+
+# =======================
+# Encoders / Decoders I/O
+# =======================
+def _to_numpy(x: Any) -> np.ndarray:
+    if isinstance(x, np.ndarray):
+        return x
+    if torch.is_tensor(x):
+        return x.detach().cpu().numpy()
+    raise TypeError(f"Unsupported array/tensor type: {type(x)}")
+
+
+def _encode_png_3ch(value: Any) -> bytes:
+    """Encode to 3-channel uint8 PNG. Accepts PIL.Image, np.ndarray, or torch.Tensor."""
+    if isinstance(value, Image.Image):
+        img = value.convert("RGB")
+        arr = np.array(img, dtype=np.uint8)
+    else:
+        arr = _to_numpy(value)
+        # normalize layout
+        if arr.ndim == 3 and arr.shape[0] in (1, 3) and arr.shape[2] not in (1, 3):
+            # likely CHW -> HWC
+            arr = np.transpose(arr, (1, 2, 0))
+        if arr.ndim == 2:
+            arr = np.stack([arr, arr, arr], axis=-1)
+        if arr.ndim != 3 or arr.shape[-1] not in (1, 3):
+            raise ValueError(f"PNG expects HxWx{1|3}, got shape {arr.shape}")
+        if arr.shape[-1] == 1:
+            arr = np.repeat(arr, 3, axis=-1)
+
+        # dtype + range handling
+        if np.issubdtype(arr.dtype, np.floating):
+            arr = np.clip(arr, 0.0, 1.0)
+            arr = (arr * 255.0 + 0.5).astype(np.uint8)
+        elif arr.dtype != np.uint8:
+            arr = np.clip(arr, 0, 255).astype(np.uint8)
+
+    im = Image.fromarray(arr, mode="RGB")
+    buf = io.BytesIO()
+    im.save(buf, format="PNG", compress_level=4)
+    return buf.getvalue()
+
+
+def _encode_exr(value: Any, compression: str = "PIZ") -> bytes:
+    """
+    Encode depth (float16/float32) as single-channel EXR ("Z") with compression.
+    Prefers OpenEXR (allows setting compression = PIZ/ZIP/etc.) then imageio, else raises.
+
+    Expected shapes: HxW or HxWx1. Returns bytes.
+    """
+    arr = _to_numpy(value)
+    if arr.ndim == 3 and arr.shape[-1] == 1:
+        arr = arr[..., 0]
+    if arr.ndim != 2:
+        raise ValueError(f"EXR expects HxW (single channel), got shape {arr.shape}")
+    arr = arr.astype(np.float32)
+
+    # Try OpenEXR first (full control on compression; best for high ratios)
+    import OpenEXR, Imath, tempfile, os
+
+    h, w = arr.shape
+    header = OpenEXR.Header(w, h)
+    comp = {
+        "NONE": Imath.Compression.NO_COMPRESSION,
+        "ZIP": Imath.Compression.ZIP_COMPRESSION,
+        "ZIPS": Imath.Compression.ZIPS_COMPRESSION,
+        "PIZ": Imath.Compression.PIZ_COMPRESSION,
+        "DWAA": Imath.Compression.DWAA_COMPRESSION,
+        "DWAB": Imath.Compression.DWAB_COMPRESSION,
+        "B44": Imath.Compression.B44_COMPRESSION,
+        "B44A": Imath.Compression.B44A_COMPRESSION,
+    }.get(compression.upper(), Imath.Compression.PIZ_COMPRESSION)
+    header["compression"] = Imath.Compression(comp)
+    header["channels"] = {"Z": Imath.Channel(Imath.PixelType(Imath.PixelType.FLOAT))}
+    with tempfile.NamedTemporaryFile(suffix=".exr", delete=False) as tmp:
+        outpath = tmp.name
+    try:
+        out = OpenEXR.OutputFile(outpath, header)
+        out.writePixels({"Z": arr.tobytes()})
+        out.close()
+        with open(outpath, "rb") as f:
+            return f.read()
+    finally:
+        os.remove(outpath)
+
+
+def _decode_exr(data: bytes) -> np.ndarray:
+    """
+    Decode EXR bytes → numpy float32 array (HxW or HxWxC).
+    Ensures the OpenEXR.InputFile handle is closed to avoid C-level memory leaks.
+    """
+    import OpenEXR, Imath
+
+    exr = None
+    try:
+        with io.BytesIO(data) as f:
+            # Note: OpenEXR Python bindings support file-like objects.
+            exr = OpenEXR.InputFile(f)
+            header = exr.header()
+            dw = header["dataWindow"]
+            w, h = dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1
+            channels = list(header["channels"].keys())
+            pt = header["channels"][channels[0]].type
+            if pt == Imath.PixelType(Imath.PixelType.FLOAT):
+                np_dtype = np.float32
+            elif pt == Imath.PixelType(Imath.PixelType.HALF):
+                np_dtype = np.float16
+            elif pt == Imath.PixelType(Imath.PixelType.UINT):
+                np_dtype = np.uint32
+            else:
+                raise ValueError(f"Unsupported EXR pixel type: {pt}")
+            arrs = []
+            for c in channels:
+                ch_str = exr.channel(c)
+                arr = np.frombuffer(ch_str, dtype=np_dtype)
+                arr = arr.reshape((h, w))
+                arrs.append(arr)
+            if len(arrs) == 1:
+                return arrs[0]
+            return np.stack(arrs, axis=-1)
+    finally:
+        try:
+            if exr is not None:
+                exr.close()
+        except Exception:
+            # Swallow close errors; decoder already produced output
+            pass
+
+
+def _encode_tensor(value: Any) -> bytes:
+    arr = _to_numpy(value)
+    buf = io.BytesIO()
+    np.save(buf, arr, allow_pickle=False)
+    return buf.getvalue()
+
+
+def _encode_str(value: Any) -> bytes:
+    return str(value).encode("utf-8")
+
+
+def _encode_json(value: Any) -> bytes:
+    return json.dumps(value).encode("utf-8")
+
+
+def _encode_bytes(value: Any) -> bytes:
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        return bytes(value)
+    raise TypeError("BYTES expects bytes-like input")
+
+
+def _encode_by_dt(value: Any, dt: Any) -> bytes:
+    if value is None:
+        raise ValueError("Cannot encode None value")
+    dtv = _dt_value(dt)
+    if dtv == DT.PNG.value:
+        return _encode_png_3ch(value)
+    if dtv == DT.EXR.value:
+        return _encode_exr(value, compression="ZIP")
+    if dtv == DT.TENSOR.value:
+        return _encode_tensor(value)
+    if dtv == DT.STR.value:
+        return _encode_str(value)
+    if dtv == DT.JSON.value:
+        return _encode_json(value)
+    if dtv == DT.BYTES.value:
+        return _encode_bytes(value)
+    raise ValueError(f"Unhandled DT: {dt}")
+
+
+# ============================
+# (1) Partial builder (generic)
+# ============================
+def build_partial_dataset(
+    generate_data,  # callable: gid -> dict with per-object fields and 'views' list of per-view dicts
+    gid_list: List[Any],
+    schema: Dict[
+        str, Any
+    ],  # same structure as generate_data output, except schema["views"] is dict of {key: DT}
+    root_dir: str,
+    run_name: Optional[str] = None,
+    part_dir: Optional[
+        str
+    ] = None,  # if given, overrides run_name and uses this dir directly
+    max_objects_per_shard: int = 64,
+    progress: bool = False,
+) -> Dict[str, str]:
+    """
+    Writes object-level WebDataset shards under {root_dir}/parts/{run}/objects-*.tar.
+
+    File naming (generic, type-driven):
+      - Per-object field 'K' (DT -> ext):         'obj_{K}.{ext}'
+      - Per-view field 'K' at index i:            '{i:04d}.{K}.{ext}'
+      - Minimal header with counts:               'meta.json' (contains {'id': str(gid), 'num_views': int})
+
+    Nothing in this function assumes any concrete keys besides 'views'.
+    """
+    if "views" not in schema or not isinstance(schema["views"], dict):
+        raise ValueError(
+            "Schema must contain a 'views' dict describing per-view fields and their DT."
+        )
+
+    run = run_name or f"part-{uuid.uuid4().hex[:8]}"
+    part_dir = part_dir or os.path.join(root_dir, "parts", run)
+    _ensure_dir(part_dir)
+
+    # persist the schema for provenance
+    with open(os.path.join(part_dir, "schema.json"), "w", encoding="utf-8") as f:
+        json.dump(_schema_to_jsonable(schema), f, indent=2)
+
+    shard_pattern = os.path.join(part_dir, "objects-%06d.tar")
+    shardlist_path = os.path.join(part_dir, "shards.txt")
+    created = []
+
+    obj_fields = {k: v for k, v in schema.items() if k != "views"}
+    view_fields = schema["views"]
+
+    def obj_key_for(gid: Any) -> str:
+        return _sanitize_key(str(gid))
+
+    with wds.ShardWriter(shard_pattern, maxcount=max_objects_per_shard) as sink:
+        if progress:
+            gid_list = tqdm(gid_list, desc=f"Building dataset {run}")
+        for gid in gid_list:
+            data = generate_data(gid)
+            if "views" not in data or not isinstance(data["views"], list):
+                raise ValueError(
+                    "generate_data must return a dict with a 'views' list."
+                )
+
+            sample = {"__key__": obj_key_for(gid)}
+            # per-object fields
+            for k, dt in obj_fields.items():
+                if k == "views":
+                    continue
+                if k in data and data[k] is not None:
+                    ext = _dt_ext(dt)
+                    sample[f"obj_{_sanitize_key(k)}.{ext}"] = _encode_by_dt(data[k], dt)
+
+            # per-view fields
+            num_views = len(data["views"])
+            for i, view in enumerate(data["views"]):
+                if not isinstance(view, dict):
+                    raise ValueError("Each element of 'views' must be a dict.")
+                for vk, vdt in view_fields.items():
+                    if vk in view and view[vk] is not None:
+                        ext = _dt_ext(vdt)
+                        name = f"{i:04d}.{_sanitize_key(vk)}.{ext}"
+                        sample[name] = _encode_by_dt(view[vk], vdt)
+
+            # minimal meta
+            meta = {"id": sample["__key__"], "num_views": num_views}
+            sample["meta.json"] = json.dumps(meta).encode("utf-8")
+
+            sink.write(sample)
+            if getattr(sink, "fname", None) and (
+                not created or created[-1] != sink.fname
+            ):
+                created.append(sink.fname)
+
+    # finalize shard list
+    tars = sorted(glob.glob(os.path.join(part_dir, "objects-*.tar")))
+    if len(tars) != len(created):
+        created = tars
+    with open(shardlist_path, "w", encoding="utf-8") as f:
+        for p in created:
+            f.write(p + "\n")
+
+    with open(os.path.join(part_dir, "manifest.json"), "w", encoding="utf-8") as f:
+        json.dump(
+            {
+                "kind": "webdataset-object-generic-v1",
+                "created": _timestamp(),
+                "run": run,
+                "num_shards": len(created),
+                "root": os.path.abspath(root_dir),
+            },
+            f,
+            indent=2,
+        )
+
+    return {"part_dir": part_dir, "shardlist": shardlist_path}
+
+
+# ===========================
+# (2) Merge partials (O(1) IO)
+# ===========================
+def merge_partials(
+    root_dir: str,
+    part_dirs: List[str],
+    out_name: str = "merged",
+    materialize: bool = False,  # if True, hardlink (or copy) shards into a single subdir
+) -> Dict[str, str]:
+    """
+    Creates {root_dir}/{out_name}/shards.txt covering all shards from given parts.
+    If materialize=True, hardlinks/copies shards into {root_dir}/{out_name}/shards/ and points shards.txt there.
+    """
+    out_dir = os.path.join(root_dir, out_name)
+    _ensure_dir(out_dir)
+    shards_txt = os.path.join(out_dir, "shards.txt")
+
+    all_shards: List[str] = []
+    for pd in part_dirs:
+        pd = os.path.abspath(pd)
+        txt = os.path.join(pd, "shards.txt")
+        if os.path.isfile(txt):
+            with open(txt, "r", encoding="utf-8") as f:
+                all_shards.extend([ln.strip() for ln in f if ln.strip()])
+        else:
+            all_shards.extend(sorted(glob.glob(os.path.join(pd, "objects-*.tar"))))
+
+    if materialize:
+        link_dir = os.path.join(out_dir, "shards")
+        _ensure_dir(link_dir)
+        linked = []
+        for i, src in enumerate(all_shards):
+            dst = os.path.join(link_dir, f"{i:06d}.tar")
+            try:
+                if os.path.exists(dst):
+                    os.remove(dst)
+                os.link(src, dst)  # fast if same filesystem
+            except OSError:
+                shutil.copy2(src, dst)  # fallback across devices
+            linked.append(dst)
+        all_shards = linked
+
+    with open(shards_txt, "w", encoding="utf-8") as f:
+        for p in all_shards:
+            f.write(p + "\n")
+
+    # write a minimal manifest
+    with open(os.path.join(out_dir, "manifest.json"), "w", encoding="utf-8") as f:
+        json.dump(
+            {
+                "kind": "webdataset-merged",
+                "created": _timestamp(),
+                "num_shards": len(all_shards),
+            },
+            f,
+            indent=2,
+        )
+
+    # copy first available schema.json for convenience (optional)
+    for pd in part_dirs:
+        sch = os.path.join(pd, "schema.json")
+        if os.path.isfile(sch):
+            shutil.copy2(sch, os.path.join(out_dir, "schema.json"))
+            break
+
+    return {"dataset_dir": out_dir, "shardlist": shards_txt}
+
+
+# =========================================
+# (3) Loading: row-wise and object-wise views
+# =========================================
+def _resolve_urls(dataset_path: str) -> Union[str, List[str]]:
+    p = pathlib.Path(dataset_path)
+    if p.is_dir():
+        txt = p / "shards.txt"
+        if txt.exists():
+            with open(txt, "r", encoding="utf-8") as f:
+                return [ln.strip() for ln in f if ln.strip()]
+        tars = sorted(p.glob("*.tar"))
+        if tars:
+            return [str(x) for x in tars]
+    if p.suffix == ".txt" and p.exists():
+        with open(p, "r", encoding="utf-8") as f:
+            return [ln.strip() for ln in f if ln.strip()]
+    return dataset_path  # brace/glob allowed by WebDataset
+
+
+def build_mcvae_dataset(
+    dataset_path: str,
+    schema: Dict[str, Any],
+    size: int = 1024,  # final image size (H=W=size)
+    shardshuffle: int = 1000,
+    decode: Union[str, Any] = "torch",  # "pil" or "torch" or a handler
+    split_by_node: bool = True,
+    split_by_worker: bool = True,
+):
+    """
+    Returns an IterableDataset that yields per-view dicts.
+    Each item includes all per-object fields injected into the row.
+    Missing fields are omitted rather than set to None.
+    """
+    if "views" not in schema or not isinstance(schema["views"], dict):
+        raise ValueError("Schema must contain a 'views' dict.")
+
+    urls = _resolve_urls(dataset_path)
+    obj_fields = {k: v for k, v in schema.items() if k != "views"}
+    view_fields = schema["views"]
+
+    # ---- 1) Pre-process (unpacking rows) ----
+    def _preprocess(sample: Dict[str, Any]) -> List[Dict[str, Any]]:
+        # meta.json is bytes (we didn't register a JSON handler) → parse explicitly
+        meta = sample["meta.json"]
+        gid = meta["id"]
+        n = int(meta["num_views"])
+
+        # per-object fields
+        per_object: Dict[str, Any] = {}
+        for k, dt in obj_fields.items():
+            ext = _dt_ext(dt)
+            name = f"obj_{_sanitize_key(k)}.{ext}"
+            if name in sample:
+                per_object[k] = sample[name]
+
+        # per-view fields
+        rows: List[Dict[str, Any]] = []
+        for idx in range(n):
+            v = {"id": gid, "view_index": idx}
+            v.update(per_object)
+            for vk, vdt in view_fields.items():
+                ext = _dt_ext(vdt)
+                vname = f"{idx:04d}.{_sanitize_key(vk)}.{ext}"
+                if vname in sample:
+                    v[vk] = sample[vname]
+            rows.append(v)
+        return rows
+
+    # ---- 2) Post-process (resizing, dataset-specific tweaks) ----
+    def _postprocess(sample: Dict[str, Any]) -> Dict[str, Any]:
+        out: Dict[str, Any] = {}
+        for k, v in sample.items():
+            if isinstance(v, np.ndarray):
+                out[k] = torch.from_numpy(v.copy())
+            else:
+                out[k] = v
+
+        # Dataset-specific postprocessing
+        def _resize_(key: str):
+            out[key] = F.interpolate(
+                out[key].unsqueeze(0),
+                size=(size, size),
+                mode="bilinear",
+                align_corners=False,
+            ).squeeze(0)
+
+        for key in ("albedo", "orm"):
+            _resize_(key)
+            out[key] = out[key] * 2 - 1
+
+        # ready-to-use tensors
+        # print(out['albedo'].shape, out['orm'].shape)
+        out["pixel_values"] = torch.cat(
+            [out["albedo"], out["orm"][1:, ...]], dim=0
+        )  # (5,H,W)
+
+        # cleanup
+        for k in (
+            "prompt",
+            "prompt_embeds",
+            "pooled_prompt_embeds",
+            "elevation",
+            "azimuth",
+            "id",
+            "view_index",
+            "c2w",
+            "scale",
+            "pos",
+            "normal",
+            "depth",
+        ):
+            out.pop(k, None)
+
+        return out
+
+    # For mcVAE training we don't use depth EXR; avoid decoding EXR entirely to reduce memory pressure
+    # and eliminate potential leaks from the EXR decoder. Keep PNG decoding for albedo/orm.
+    ds = (
+        wds.WebDataset(
+            urls,
+            nodesplitter=wds.split_by_node if split_by_node else None,
+            workersplitter=wds.split_by_worker if split_by_worker else None,
+            shardshuffle=shardshuffle,
+        )
+        .decode(
+            wds.imagehandler(decode),
+        )
+        .map(_preprocess)
+        .unlisted()
+        .map(_postprocess)
+    )
+    return ds
+
+
+def build_mcdiff_dataset(
+    dataset_path: str,
+    schema: Dict[str, Any],
+    num_views: int,
+    size: int = 1024,
+    shardshuffle: int = 1000,
+    decode: Union[str, Any] = "torch",
+    split_by_node: bool = True,
+    split_by_worker: bool = True,
+    fixed_view_indices: Optional[List[int]] = None,
+):
+
+    if "views" not in schema or not isinstance(schema["views"], dict):
+        raise ValueError("Schema must contain a 'views' dict.")
+
+    if fixed_view_indices is not None:
+        assert (
+            len(fixed_view_indices) == num_views
+        ), "fixed_view_indices length must match num_views"
+
+    assert size % 16 == 0 and size <= 1024, "size must be multiple of 16 and <= 1024"
+
+    urls = _resolve_urls(dataset_path)
+    obj_fields = {k: v for k, v in schema.items() if k != "views"}
+    view_fields = schema["views"]
+
+    # ---- 1) Pre-sampling (view selection) ----
+    def _presample_filter(sample: Dict[str, Any]) -> Dict[str, Any]:
+        if "meta.json" not in sample:
+            return None
+        meta = json.loads(sample["meta.json"].decode("utf-8"))
+        n = int(meta["num_views"])
+        if not (1 <= num_views <= n):
+            return None
+
+        if fixed_view_indices is not None:
+            chosen = fixed_view_indices
+        else:
+            chosen = random.sample(
+                range(n), num_views
+            )  # epoch마다 DataLoader 시드에 따라 바뀜
+
+        kept: Dict[str, Any] = {}
+        # keep metadata
+        kept["meta.json"] = sample["meta.json"]
+        if "__key__" in sample:
+            kept["__key__"] = sample["__key__"]
+
+        # keep per-object fields
+        for k, dt in obj_fields.items():
+            ext = _dt_ext(dt)
+            name = f"obj_{_sanitize_key(k)}.{ext}"
+            if name in sample:
+                kept[name] = sample[name]
+
+        # keep selected per-view fields
+        for idx in chosen:
+            for vk, vdt in view_fields.items():
+                ext = _dt_ext(vdt)
+                vname = f"{idx:04d}.{_sanitize_key(vk)}.{ext}"
+                if vname in sample:
+                    kept[vname] = sample[vname]
+
+        # store chosen indices for later use
+        kept["_sel.json"] = json.dumps(chosen).encode("utf-8")
+        return kept
+
+    # ---- 2) Post-process (view stacking, resizing, dataset-specific tweaks) ----
+    def _postprocess(sample: Dict[str, Any]) -> Dict[str, Any]:
+        # restore selection order
+        chosen = sample["_sel.json"]
+
+        # per-object fields
+        out: Dict[str, Any] = {}
+        for k, dt in obj_fields.items():
+            ext = _dt_ext(dt)
+            name = f"obj_{_sanitize_key(k)}.{ext}"
+            if name in sample:
+                out[k] = sample[name]
+
+        # selected per-view fields
+        views: List[Dict[str, Any]] = []
+        for idx in chosen:
+            v: Dict[str, Any] = {}
+            for vk, vdt in view_fields.items():
+                ext = _dt_ext(vdt)
+                vname = f"{idx:04d}.{_sanitize_key(vk)}.{ext}"
+                if vname in sample:
+                    v[vk] = sample[vname]
+                    if isinstance(v[vk], np.ndarray):
+                        v[vk] = torch.from_numpy(v[vk].copy())
+            v["view_index"] = idx
+            views.append(v)
+
+        if len(views) == 0:
+            return None
+
+        for k in views[0].keys():
+            arrs = [v[k] for v in views]
+            if isinstance(arrs[0], torch.Tensor):
+                out[k] = torch.stack(arrs, dim=0)
+            elif isinstance(arrs[0], np.ndarray):
+                out[k] = torch.from_numpy(np.stack(arrs, axis=0))
+            else:
+                out[k] = arrs  # e.g., list of strings
+
+        # Dataset-specific postprocessing
+        
+        # normal, depth, pos: (V,3,H,W); albedo, orm: (V,3,H,W) , c2w: (V,4,4)
+        # Always operate in single-channel mode - batched postprocessing will handle dual-channel
+
+        out["normal_fullres"] = out["normal"] * 2 - 1  # [-1,1], for CAA
+
+        mask = out["orm"][:, 0, :, :] > 0.5
+        out["depth"][~mask] = float("nan")
+
+        pos_raw = out["pos"] - 0.5  # [-0.5, 0.5], for pos_token
+        df = int(out["pos"].shape[2] // (size // 16))
+        mask_f = mask.float().unsqueeze(1)  # (V,1,H,W)
+
+        # Weighted block average over valid pixels
+        pos_sum = F.avg_pool2d(
+            pos_raw * mask_f, kernel_size=df, stride=df, divisor_override=1
+        )
+        cnt = F.avg_pool2d(mask_f, kernel_size=df, stride=df, divisor_override=1)
+        pos_ds = pos_sum / cnt.clamp_min(1.0)
+        out["pos_token"] = pos_ds
+
+        def _resize_(key: str):
+            out[key] = F.interpolate(
+                out[key], size=(size, size), mode="bilinear", align_corners=False
+            )
+
+        for key in ("albedo", "orm", "pos", "normal"):
+            _resize_(key)
+            out[key] = out[key] * 2 - 1
+
+        # ready-to-use tensors (always single-channel mode)
+        out["pixel_values"] = torch.cat(
+            [out["albedo"], out["orm"][:, 1:, ...]], dim=1
+        )  # (V,5,H,W)
+            
+        out["cond_values"] = torch.cat([out["pos"], out["normal"]], dim=1)  # (V,6,H,W)
+
+        out["scale"] = out["scale"][0]  # common across views
+        out["w2c"] = torch.linalg.inv(out["c2w"])  # (V,4,4)
+        # albedo, orm, depth, pos, pos_token, normal, pixel_values, cond_values, w2c, normal_fullres
+        
+        # cleanup
+        for k in ("prompt", "elevation", "azimuth"):
+            out.pop(k, None)
+        return out
+
+    # ---- 3) Build dataset ----
+    ds = (
+        wds.WebDataset(
+            urls,
+            nodesplitter=wds.split_by_node if split_by_node else None,
+            workersplitter=wds.split_by_worker if split_by_worker else None,
+            shardshuffle=shardshuffle,
+        )
+        .map(_presample_filter)
+        .decode(
+            wds.handle_extension("exr", _decode_exr),
+            wds.imagehandler(decode),
+        )
+        .map(_postprocess)
+    )
+
+    return ds
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Merge partial RGBMR dataset shards into a single dataset"
+    )
+    parser.add_argument(
+        "--root_dir",
+        type=str,
+        required=True,
+        help="Root directory where the merged dataset will be created"
+    )
+    parser.add_argument(
+        "--part_dirs",
+        type=str,
+        nargs="+",
+        required=True,
+        help="List of partial dataset directories to merge"
+    )
+    parser.add_argument(
+        "--out_name",
+        type=str,
+        default="merged",
+        help="Name of the output merged dataset directory (default: merged)"
+    )
+    parser.add_argument(
+        "--materialize",
+        action="store_true",
+        help="If set, hardlink/copy shards into a single directory instead of just listing paths"
+    )
+    
+    args = parser.parse_args()
+    
+    print(f"[{_timestamp()}] Starting merge operation...")
+    print(f"  Root directory: {args.root_dir}")
+    print(f"  Partial directories: {args.part_dirs}")
+    print(f"  Output name: {args.out_name}")
+    print(f"  Materialize: {args.materialize}")
+    
+    result = merge_partials(
+        root_dir=args.root_dir,
+        part_dirs=args.part_dirs,
+        out_name=args.out_name,
+        materialize=args.materialize
+    )
+    
+    print(f"\n[{_timestamp()}] Merge completed successfully!")
+    print(f"  Dataset directory: {result['dataset_dir']}")
+    print(f"  Shard list: {result['shardlist']}")
+    
+    # Count total shards
+    with open(result['shardlist'], 'r') as f:
+        num_shards = len([line for line in f if line.strip()])
+    print(f"  Total shards: {num_shards}")
+    
+
+
+'''
+python data/rgbmr_dataset.py --root_dir /home/aaaaa/data/rgbmr_mv_web2/ \
+--part_dirs \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_00_of_07 \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_01_of_07 \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_02_of_07 \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_03_of_07 \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_04_of_07 \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_05_of_07 \
+/home/aaaaa/data/rgbmr_mv_web2/parts/render_06_of_07 \
+--out_name merged --materialize
+
+
+'''

home/ubuntu/aaaaa/data/rgbmr/filter_complex.py

@@ -0,0 +1,165 @@
+import os, sys
+import json
+import glob
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torchvision.transforms import ToTensor, ToPILImage
+from scipy.ndimage import distance_transform_edt
+from PIL import Image
+from PIL import ImageDraw, ImageFont
+from tqdm.auto import tqdm
+
+def grid_images(images, ncols=4, labels=None):
+    nrows = (len(images) + ncols - 1) // ncols
+    w, h = images[0].size
+    grid = Image.new('RGB', (ncols * w, nrows * h))
+    for idx, img in enumerate(images):
+        row = idx // ncols
+        col = idx % ncols
+        grid.paste(img, (col * w, row * h))
+
+    if labels is not None:
+        assert len(labels) == ncols
+        grid_tmp = Image.new('RGB', (ncols * w, nrows * h + 20), (255, 255, 255))
+        grid_tmp.paste(grid, (0, 20))
+        grid = grid_tmp
+
+        # draw labels
+        font = ImageFont.load_default(size=16)
+        draw = ImageDraw.Draw(grid)
+        for col, label in enumerate(labels):
+            draw.text((col * w + 5, 0), label, fill=(0, 0, 0), font=font)
+
+    return grid
+
+# ----------------- 내부 유틸 -----------------
+def _erode_mask(mask: torch.Tensor, pixels: int) -> torch.Tensor:
+    """
+    distance transform 기반 마스크 수축(AA 링 제거).
+    입력은 torch.Tensor([H,W] 또는 [1,H,W]) 혹은 numpy.ndarray([H,W]).
+    출력은 torch.bool 텐서([H,W]).
+    """
+    # normalize input
+    m = mask
+    orig_device = m.device
+    m = m.squeeze().to(dtype=torch.float32)  # [H,W]
+    if pixels <= 0:
+        return (m > 0.5).to(dtype=torch.bool, device=orig_device)
+    # EDT in numpy (CPU)
+    m_np = (m.detach().cpu().numpy() > 0.5)
+    d = distance_transform_edt(m_np)
+    out_np = (d > pixels)
+    out = torch.from_numpy(out_np).to(dtype=torch.bool, device=orig_device)
+    return out
+
+def _mean_grad(x: torch.Tensor, mask: torch.Tensor) -> float:
+    """평균 |∇| (Sobel 기반, torch 전용 경로).
+    - x: torch.Tensor([H,W] 또는 [1,H,W]) 혹은 np.ndarray([H,W])
+    - mask: torch.bool Tensor([H,W]) 또는 동일 shape의 numpy bool
+    반환: float
+    """
+    # to torch tensors
+    xt = torch.from_numpy(x) if isinstance(x, np.ndarray) else x
+    mt = torch.from_numpy(mask) if isinstance(mask, np.ndarray) else mask
+    xt = xt.squeeze().to(dtype=torch.float32)  # [H,W]
+    mt = mt.squeeze().to(dtype=torch.bool)    # [H,W]
+    dev = xt.device
+    x4 = xt.unsqueeze(0).unsqueeze(0)  # [1,1,H,W]
+    # Sobel kernels
+    kx = torch.tensor([[1, 0, -1],[2, 0, -2],[1, 0, -1]], device=dev, dtype=x4.dtype).view(1,1,3,3) / 8.0
+    ky = torch.tensor([[1, 2, 1],[0, 0, 0],[-1,-2,-1]], device=dev, dtype=x4.dtype).view(1,1,3,3) / 8.0
+    gx = F.conv2d(x4, kx, padding=1)
+    gy = F.conv2d(x4, ky, padding=1)
+    g = torch.sqrt(gx * gx + gy * gy + 1e-6).squeeze(0).squeeze(0)  # [H,W]
+    vals = g[mt]
+    return float(vals.mean().item()) if vals.numel() else 0.0
+
+# ----------------- 공개 API -----------------
+def complexity_score_rm(
+    rough: torch.Tensor, metallic: torch.Tensor, mask: torch.Tensor,
+    erode_px: int = 2,
+) -> tuple[float, float]:
+    """
+    rough/metallic/마스크 -> (r_grad*100, m_grad*100).
+    입력은 torch.Tensor([H,W]) 또는 numpy.ndarray([H,W]); mask는 {0,1} 또는 bool.
+    """
+    rmask = _erode_mask(mask, erode_px)  # torch.bool [H,W]
+
+    r_grad = _mean_grad(rough, rmask)
+    m_grad = _mean_grad(metallic, rmask)
+    return r_grad * 100.0, m_grad * 100.0
+
+def is_complex_rm(
+    rough: torch.Tensor, metallic: torch.Tensor, mask: torch.Tensor,
+    thres_avg=0.5, thres_r=0.05, thres_m=0.05, erode_px: int = 2
+) -> bool:
+    """
+    복잡 여부(bool) 반환.
+    - 평균 임계치와 채널별 최소 임계치로 판단.
+    """
+    r_grad, m_grad = complexity_score_rm(rough, metallic, mask, erode_px=erode_px)
+    avg_grad = (r_grad + m_grad) / 2.0
+    return (avg_grad >= thres_avg) and (r_grad >= thres_r) and (m_grad >= thres_m)
+
+to_tensor = ToTensor()
+
+img_root = 'temp_outputs/'
+# format: img_root/<object_id>/<albedo, metallic, roughness>/<00, 01>.png
+
+object_ids = sorted(os.listdir(img_root))
+# exclude id including 'warp'.
+object_ids = [oid for oid in object_ids if 'warp' not in oid]
+
+# filter folder having all required images
+valid_ids = []
+for obj_id in tqdm(object_ids):
+    required_paths = [
+        os.path.join(img_root, obj_id, 'albedo', '00.png'),
+        os.path.join(img_root, obj_id, 'albedo', '01.png'),
+        os.path.join(img_root, obj_id, 'metallic', '00.png'),
+        os.path.join(img_root, obj_id, 'metallic', '01.png'),
+        os.path.join(img_root, obj_id, 'roughness', '00.png'),
+        os.path.join(img_root, obj_id, 'roughness', '01.png'),
+    ]
+    if all(os.path.isfile(p) for p in required_paths):
+        valid_ids.append(obj_id)
+object_ids = valid_ids
+
+print(f'Found {len(object_ids)} objects.')
+
+complex_ids = []
+for obj_id in tqdm(object_ids):
+    ok = False
+    for view in ['00', '01']:
+        albedo = Image.open(os.path.join(img_root, obj_id, 'albedo', f'{view}.png'))
+        metallic = Image.open(os.path.join(img_root, obj_id, 'metallic', f'{view}.png'))
+        roughness = Image.open(os.path.join(img_root, obj_id, 'roughness', f'{view}.png'))
+        # infer mask: background region have r=g=b=M=R=0.5.
+        albedo_t = to_tensor(albedo)  # [3,H,W], float32, [0,1]
+        metallic_t = to_tensor(metallic)[0:1]  # [1,H,W], float32, [0,1]
+        roughness_t = to_tensor(roughness)[0:1]  # [1,H,W], float32, [0,1]
+        h, w = albedo_t.shape[1], albedo_t.shape[2]
+        rgbmr = torch.cat([
+            albedo_t, metallic_t, roughness_t
+        ], dim=0)  # [5,H,W]
+        mask_t = ~((rgbmr - 0.5).abs() < 2e-3).all(dim=0)  # [H,W], bool
+        # complexity check
+        is_complex = is_complex_rm(
+            roughness_t.squeeze(0), metallic_t.squeeze(0), mask_t,
+            thres_avg=0.5, thres_r=0.05, thres_m=0.05, erode_px=5
+        )
+        if is_complex:
+            ok = True
+            break
+    if not ok:
+        continue
+    complex_ids.append(obj_id)
+    tqdm.write(f'Complex object: {obj_id}')
+
+# sort
+complex_ids = sorted(complex_ids)
+
+# export complex ids
+with open('complex_object_ids.json', 'w') as f:
+    json.dump(complex_ids, f, indent=2)

home/ubuntu/aaaaa/data/rgbmr/inference.py

@@ -0,0 +1,1211 @@
+"""
+Mesh-to-Textured-Mesh Inference Pipeline
+Mesh (.glb/.obj) + text prompt -> shaded .glb
+"""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Tuple, Dict, Any, Optional, List
+import math
+import json
+import filelock
+import hashlib
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from diffusers import FlowMatchEulerDiscreteScheduler, SD3Transformer2DModel, AutoencoderKL
+from torchvision.transforms import ToPILImage
+from PIL import Image
+from omegaconf import OmegaConf
+from peft import set_peft_model_state_dict
+from safetensors.torch import load_file
+
+from mcgen.utils.model_utils import load_offset_autoencoder, initialize_transformer_weights
+from mcgen.mcdiff.attention_processor_lora import LoRAMessagePassingAttnProcessor
+from mcgen.mcdiff.attention_utils import apply_custom_processors
+from mcgen.utils.text_encoder_utils import load_text_ctx, encode_prompt
+from mcgen.mcdiff.latents import generate_latents
+from mcgen.utils.pipeline_texture import TexturePipeline, ModProcessConfig
+from mcgen.utils.correspondence import build_corr_pairs, downscale_pairs_to_f2l, dilate_f2l, correspondence_psnr
+from mcgen.utils.config import load_config
+from tools.utils.mesh_utils import load_mesh, get_orthogonal_camera, NVDiffRastContextWrapper, render
+from mcgen.utils.image_super_utils import imageSuperNet
+from mcgen.utils.pipeline_utils import ViewProcessor
+from mcgen.utils.uvwrap_utils import mesh_uv_wrap
+from mcgen.utils.geometry_inpaint_utils import texture_inpaint
+from DifferentiableRenderer.MeshRender import MeshRender
+import trimesh
+import copy
+
+# =============================================================================
+# Configuration
+# =============================================================================
+
+# Model paths
+SD35_REPO = "stabilityai/stable-diffusion-3.5-medium"
+TRANSFORMER_PARTIAL_WEIGHTS = "outputs/mcdiff_v1.9.5/checkpoint-40000/transformer/diffusion_pytorch_model.safetensors"
+SD_VAE_PATH = "./vae_sd35"
+MCVAE_CONFIG_PATH = "./configs/mcvae/config.json"
+MCVAE_CKPT_PATH = "./outputs/mcvae_v1.8.1.pt"
+MCVAE_OFFSET_MODE = True  # If True, mcVAE encoder outputs offsets added to base mean/logvar. If False, directly predicts mean/logvar.
+
+# Device & precision
+DEVICE = "cuda"
+DTYPE = torch.float16
+
+# Image & view settings
+HEIGHT = WIDTH = 512
+TOKEN_HW = HEIGHT // 16
+NUM_VIEWS = 6
+ELEV_DEG = [0.0, 0.0, 0.0, 0.0, 89.99, -89.99]
+AZIM_DEG = [0.0, 90.0, 180.0, 270.0, 0.0, 0.0]
+# ELEV_DEG = [0.0, 0.0, 0.0, 0.0, 45, 45, 90.0, -90.0]
+# AZIM_DEG = [0.0, 90.0, 180.0, 270.0, 45, 135, 0.0, 0.0]
+
+# MaterialMVP azimuth convention (90 degree offset from mvadapter)
+AZIM_DEG_MATERIALMVP = [angle + 90 for angle in AZIM_DEG]
+
+# Inference defaults
+GUIDANCE = 4.0
+STEPS = 30
+NEGATIVE_PROMPT = ""
+
+
+# =============================================================================
+# Utility Functions
+# =============================================================================
+
+def seed_everything(seed: int = 42):
+    """Seed all random number generators for reproducibility."""
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def _resize_to_pm1(x: torch.Tensor, *, height: int, width: int) -> torch.Tensor:
+    """Resize to target resolution and normalize to [-1, 1]."""
+    x = F.interpolate(x, size=(height, width), mode="bilinear", align_corners=False)
+    return x * 2.0 - 1.0
+
+
+def _expand_embeddings_for_views(pe: torch.Tensor, pooled: torch.Tensor, *, num_views: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Expand text embeddings from [1, seq, dim] to [num_views, seq, dim]."""
+    pe = pe.expand(1, -1, -1).unsqueeze(1).expand(-1, num_views, -1, -1).reshape(-1, pe.shape[1], pe.shape[2])
+    pooled = pooled.expand(1, -1).unsqueeze(1).expand(-1, num_views, -1).reshape(-1, pooled.shape[-1])
+    return pe, pooled
+
+
+@torch.no_grad()
+def _save_strip(tensor_bchw: torch.Tensor, path: str, nrow: int = 1) -> str:
+    """Save grid of images from batched tensors in [-1, 1] range.
+    
+    Args:
+        tensor_bchw: Batch of images in BCHW format, range [-1, 1]
+        path: Output path for saved image
+        nrow: Number of rows in grid. If 1, creates horizontal strip.
+    """
+    
+    to_pil = ToPILImage()
+    b, c, h, w = tensor_bchw.shape
+    
+    nrow = max(1, nrow)
+    ncol = math.ceil(b / nrow)
+    
+    canvas = Image.new('RGB', (ncol * w, nrow * h))
+    for i in range(b):
+        row = i // ncol
+        col = i % ncol
+        img = to_pil((tensor_bchw[i].clamp(-1, 1) * 0.5 + 0.5))
+        canvas.paste(img, (col * w, row * h))
+    
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    canvas.save(path)
+    return path
+
+
+def _update_cpsnr_json(json_path: str, gid: str, metrics: Dict[str, float]) -> None:
+    """Thread-safe update of cpsnr.json file using file locking.
+    
+    Args:
+        json_path: Path to cpsnr.json file
+        gid: Geometry ID (mesh filename stem)
+        metrics: Dictionary containing 'albedo', 'roughness', 'metallic', 'total' keys
+    """
+    lock_path = json_path + ".lock"
+    lock = filelock.FileLock(lock_path, timeout=60)
+    
+    try:
+        with lock:
+            # Read existing data
+            if os.path.exists(json_path):
+                with open(json_path, "r") as f:
+                    data = json.load(f)
+            else:
+                data = {}
+            
+            # Update with new metrics
+            data[gid] = metrics
+            
+            # Write back atomically using temp file + rename
+            temp_path = json_path + ".tmp"
+            with open(temp_path, "w") as f:
+                json.dump(data, f, indent=2)
+            os.replace(temp_path, json_path)
+    finally:
+        # Clean up lock file if it exists and we can remove it
+        try:
+            if os.path.exists(lock_path):
+                os.remove(lock_path)
+        except OSError:
+            pass
+
+
+def unproject_with_materialmvp(
+    mesh_path: str,
+    output_dir: str,
+    gid: str,
+    albedo_images: List[Image.Image],
+    mr_images: List[Image.Image],
+    *,
+    render_size: int = 512,
+    texture_size: int = 4096,
+    realesrgan_ckpt: str,
+    bake_exp: int = 2,
+    selected_view_weights: Optional[List[float]] = None,
+) -> str:
+    """Alternative unprojection backend using MeshRenderer and ViewProcessor.
+    
+    This method uses the MaterialMVP approach with back-projection and baking,
+    using azimuth angles with a 90-degree offset from the mvadapter convention.
+    
+    Args:
+        mesh_path: Path to input mesh
+        output_dir: Output directory
+        gid: Geometry ID (mesh filename stem)
+        albedo_images: List of albedo views (6 images)
+        mr_images: List of metallic-roughness views (6 images, ORM format)
+        render_size: Rendering resolution (default: 512)
+        texture_size: UV texture resolution (default: 4096)
+        realesrgan_ckpt: Path to RealESRGAN checkpoint
+        bake_exp: Baking exponent for view weighting
+        selected_view_weights: Optional list of per-view weights
+        
+    Returns:
+        Path to saved GLB file
+    """
+    # Initialize renderer
+    render_obj = MeshRender(
+        default_resolution=render_size,
+        texture_size=texture_size,
+        bake_mode="back_sample",
+        raster_mode="cr",
+    )
+    
+    # Load and prepare mesh
+    mesh = trimesh.load(mesh_path)
+    mesh = mesh_uv_wrap(mesh)
+    render_obj.load_mesh(mesh=mesh)
+    
+    # Initialize processors
+    view_processor = ViewProcessor(bake_exp, render_obj)
+    super_model = imageSuperNet(realesrgan_ckpt)
+    
+    # Use MaterialMVP azimuth convention (90-degree offset)
+    selected_camera_azims = AZIM_DEG_MATERIALMVP
+    selected_camera_elevs = ELEV_DEG
+    
+    if selected_view_weights is None:
+        selected_view_weights = [1, 1, 1, 1, 0.5, 0.5]
+    
+    # Prepare images dictionary
+    multiviews_pbr = {
+        "albedo": albedo_images,
+        "mr": mr_images,
+    }
+    
+    # Enhance images
+    enhance_images = {
+        "albedo": copy.deepcopy(multiviews_pbr["albedo"]),
+        "mr": copy.deepcopy(multiviews_pbr["mr"]),
+    }
+    
+    for i in range(len(enhance_images["albedo"])):
+        enhance_images["albedo"][i] = super_model(enhance_images["albedo"][i])
+        enhance_images["mr"][i] = super_model(enhance_images["mr"][i])
+    
+    # Resize to double render size for better quality
+    for i in range(len(enhance_images["albedo"])):
+        enhance_images["albedo"][i] = enhance_images["albedo"][i].resize(
+            (render_size * 2, render_size * 2), Image.LANCZOS
+        )
+        enhance_images["mr"][i] = enhance_images["mr"][i].resize(
+            (render_size * 2, render_size * 2), Image.LANCZOS
+        )
+    
+    # Bake albedo texture
+    texture, mask = view_processor.bake_from_multiview(
+        enhance_images["albedo"],
+        selected_camera_elevs,
+        selected_camera_azims,
+        selected_view_weights
+    )
+    
+    # Bake metallic-roughness texture
+    texture_mr, mask_mr = view_processor.bake_from_multiview(
+        enhance_images["mr"],
+        selected_camera_elevs,
+        selected_camera_azims,
+        selected_view_weights
+    )
+    
+    # Convert baked masks to boolean tensors
+    mask_bool = (mask.squeeze(-1) > 0.5).to(torch.bool)
+    mask_mr_bool = (mask_mr.squeeze(-1) > 0.5).to(torch.bool)
+    
+    # Apply geometry-aware inpainting for albedo texture
+    texture_inpainted = texture_inpaint(
+        texture,
+        mask_bool,
+        render_obj,
+        uv_mask_erode_iters=10,
+        baked_mask_erode_iters=2,
+        vertex_merge_tolerance=1e-5,
+        vertex_color_K=11,
+    )
+    render_obj.set_texture(texture_inpainted, force_set=True)
+    
+    # Apply geometry-aware inpainting for metallic-roughness texture
+    texture_mr_inpainted = texture_inpaint(
+        texture_mr,
+        mask_mr_bool,
+        render_obj,
+        uv_mask_erode_iters=10,
+        baked_mask_erode_iters=2,
+        vertex_merge_tolerance=1e-5,
+        vertex_color_K=11,
+    )
+    render_obj.set_texture_mr(texture_mr_inpainted)
+    
+    # Save mesh
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, f"{gid}.glb")
+    render_obj.save_mesh(output_path, downsample=False)
+    
+    return output_path
+
+# =============================================================================
+# Rendering & Preprocessing
+# =============================================================================
+
+
+@torch.no_grad()
+def render_views(
+    mesh_path: str,
+    *,
+    num_views: int,
+    height: int,
+    width: int,
+    device: str = DEVICE,
+) -> Dict[str, Any]:
+    """Render multi-view geometry attributes from mesh."""
+    ctx = NVDiffRastContextWrapper(device=device, context_type="cuda")
+    mesh = load_mesh(str(mesh_path), rescale=True, move_to_center=True, flip_uv=True, device=device)
+    if len(ELEV_DEG) != num_views or len(AZIM_DEG) != num_views:
+        raise ValueError("ELEV_DEG and AZIM_DEG presets must match num_views.")
+    
+    cams = get_orthogonal_camera(
+        elevation_deg=ELEV_DEG,
+        azimuth_deg=AZIM_DEG,
+        distance=[1.0] * num_views,
+        left=-0.55,
+        right=0.55,
+        bottom=-0.55,
+        top=0.55,
+        device=device, dtype=torch.float32,
+    )
+
+    # Build 5-channel texture override: [rgb, roughness(0), roughness, metallic]
+    tex_ovr = torch.cat([mesh.texture, torch.zeros_like(mesh.roughness), mesh.roughness, mesh.metallic], dim=-1)
+    
+    out = render(ctx, mesh, cams, height=height, width=width, render_attr=True, texture_override=tex_ovr)
+    
+    # Extract and normalize geometry attributes
+    attr = out.attr
+    rgb = attr[..., :3].contiguous()
+    orm = attr[..., 3:6].contiguous()
+    orm[..., 0] = (orm[..., 0] < 0.25).float()  # Binary occupancy mask
+    
+    return {
+        "albedo": rgb,
+        "orm": orm,
+        "pos": out.pos + 0.5,                    # [-0.5, 0.5] -> [0, 1]
+        "normal": (out.normal + 1.0) * 0.5,      # [-1, 1] -> [0, 1]
+        "depth": out.raw_depth,
+        "c2w": cams.c2w,
+        "scale": torch.tensor(1.1, device=device),
+    }
+
+
+def preprocess_geometry(
+    rend: Dict[str, Any],
+    *,
+    device: str,
+    dtype: torch.dtype,
+    height: int,
+    width: int,
+    token_hw: int,
+    num_views: int,
+    use_caa: bool,
+    corr_dilate_iterations: int = 1,
+    use_global_pos: bool = False,
+) -> Dict[str, torch.Tensor]:
+    """Preprocess rendered geometry into model-ready format."""
+    # Convert to channel-first
+    albedo = rend["albedo"].permute(0, 3, 1, 2).contiguous()
+    orm = rend["orm"].permute(0, 3, 1, 2).contiguous()
+    pos = rend["pos"].permute(0, 3, 1, 2).contiguous()
+    normal = rend["normal"].permute(0, 3, 1, 2).contiguous()
+    depth = rend["depth"]
+    c2w = rend["c2w"]
+    scale = rend["scale"]
+    
+    V, _, H_raw, W_raw = albedo.shape
+    assert V == num_views, f"Expected {num_views} views, got {V}"
+    
+    # Normal in [-1, 1] for correspondence computation
+    normal_fullres = normal * 2.0 - 1.0
+    
+    # Mask from occupancy channel
+    mask = orm[:, 0, :, :] > 0.5
+    depth = depth.clone()
+    depth[~mask] = float("nan")
+    
+    # Position tokens via weighted averaging at token grid
+    pos_raw = pos - 0.5  # Convert to [-0.5, 0.5]
+    df = H_raw // token_hw
+    mask_f = mask.float().unsqueeze(1)
+    pos_sum = F.avg_pool2d(pos_raw * mask_f, kernel_size=df, stride=df, divisor_override=1)
+    cnt = F.avg_pool2d(mask_f, kernel_size=df, stride=df, divisor_override=1)
+    pos_token = (pos_sum / cnt.clamp_min(1.0)).to(device=device, dtype=dtype)
+    
+    # Resize and normalize to [-1, 1]
+    albedo_r = _resize_to_pm1(albedo, height=height, width=width)
+    orm_r = _resize_to_pm1(orm, height=height, width=width)
+    pos_r = _resize_to_pm1(pos, height=height, width=width)
+    normal_r = _resize_to_pm1(normal, height=height, width=width)
+    
+    # Condition values: position + normal (6 channels)
+    cond_values = torch.cat([pos_r, normal_r], dim=1)
+    
+    # World-to-camera transformation
+    w2c = torch.linalg.inv(c2w).to(device=device, dtype=dtype)
+    
+    corr_f2l = None
+    corr_f2l_highres = None
+    pos_delta = None
+
+    # Build correspondence pairs
+    corr_pairs = build_corr_pairs(
+        c2w, scale, depth, nor_w=normal_fullres.permute(0, 2, 3, 1),
+        depth_tol=0.01, angle_tol=10, angle_cam_tol=80,
+    )
+    
+    # High resolution correspondence for c-PSNR evaluation
+    corr_high = downscale_pairs_to_f2l(corr_pairs, out_hw=height, device=device)
+    corr_f2l_highres = corr_high.unsqueeze(0)  # (1, V*H*W, K) for later use
+    
+    # Downscale to token resolution
+    corr_low = downscale_pairs_to_f2l(corr_pairs, out_hw=token_hw, device=device)
+    for _ in range(corr_dilate_iterations):
+        corr_low = dilate_f2l(corr_low, V=num_views, out_hw=token_hw)
+    
+    # Convert to global indices (single batch)
+    corr_f2l = corr_low.unsqueeze(0)  # (1, Lq, K)
+    B, Lq, K = corr_f2l.shape
+    X = Lq
+    base = torch.arange(B, device=corr_f2l.device).view(B, 1, 1) * X
+    corr_f2l = torch.where(corr_f2l >= 0, corr_f2l + base, corr_f2l)
+    corr_f2l = corr_f2l.reshape(B * Lq, K)  # (M, K) where M = num_views * token_hw * token_hw
+    
+    # Compute position deltas
+    M = num_views * token_hw * token_hw
+    
+    # pos_token: (V, 3, token_hw, token_hw) -> (M, 3)
+    pos_w_flat = pos_token.view(num_views, 3, -1).permute(0, 2, 1).reshape(M, 3)  # (M, 3)
+    
+    # Get camera transforms for each query token
+    batch_ids = torch.arange(num_views, device=device).repeat_interleave(token_hw * token_hw)  # (M,)
+    
+    # Use identity matrix for global frame, or w2c for local query frame
+    if use_global_pos:
+        # Global frame: use identity matrix (no transformation)
+        Tq = torch.eye(4, device=device, dtype=w2c.dtype).unsqueeze(0).expand(M, -1, -1)  # (M, 4, 4)
+    else:
+        # Local query frame: use w2c transformation
+        Tq = w2c[batch_ids]  # (M, 4, 4)
+    
+    # Transform query positions to camera space
+    ones_M = torch.ones(M, 1, device=device, dtype=pos_w_flat.dtype)
+    pq_h = torch.cat([pos_w_flat, ones_M], dim=-1).unsqueeze(-1)  # (M, 4, 1)
+    pq_cam = (Tq @ pq_h).squeeze(-1)[..., :3]  # (M, 3)
+    
+    # Gather key positions and transform to camera space
+    gather_idx = corr_f2l.clamp(min=0, max=M - 1).reshape(-1)  # (M*K,)
+    pk_world = pos_w_flat.index_select(0, gather_idx).view(M, K, 3)  # (M, K, 3)
+    ones_MK = torch.ones(M, K, 1, device=device, dtype=pk_world.dtype)
+    pk_h = torch.cat([pk_world, ones_MK], dim=-1).unsqueeze(-1)  # (M, K, 4, 1)
+    pk_cam = (Tq[:, None, :, :] @ pk_h).squeeze(-1)[..., :3]  # (M, K, 3)
+    
+    # Compute delta
+    pos_delta = pk_cam - pq_cam[:, None, :]  # (M, K, 3)
+    
+    return {
+        "cond_values": cond_values,
+        "pos_token": pos_token,
+        "w2c": w2c,
+        "corr_f2l": corr_f2l,
+        "corr_f2l_highres": corr_f2l_highres,
+        "pos_delta": pos_delta,
+        "decoded_albedo": albedo_r,
+        "decoded_orm": orm_r,
+    }
+
+
+
+# =============================================================================
+# Model Setup
+# =============================================================================
+
+
+
+def _apply_lora_processors(
+    transformer: SD3Transformer2DModel,
+    model_cfg,
+    *,
+    use_caa: bool,
+    use_rope: bool,
+    use_global_token: bool,
+    num_views: int,
+    num_domains: int,
+) -> None:
+    """Attach LoRA message-passing processors mirroring training setup."""
+    lcfg = getattr(model_cfg, "attn_lora", None)
+    if not lcfg or not getattr(lcfg, "enabled", False):
+        return
+
+    select = {"joint": True, "self": bool(getattr(lcfg, "apply_to_self", False))}
+    limits = {}
+    if getattr(lcfg, "limit_joint", None) is not None:
+        limits["joint"] = lcfg.limit_joint
+    if getattr(lcfg, "limit_self", None) is not None:
+        limits["self"] = lcfg.limit_self
+
+    def processor_factory(_name, _mod, query_dim, inner_dim, out_dim, num_heads, kind="joint"):
+        return LoRAMessagePassingAttnProcessor(
+            r_q=int(getattr(lcfg, "r_q", 8)),
+            r_k=int(getattr(lcfg, "r_k", 8)),
+            r_v=int(getattr(lcfg, "r_v", 8)),
+            alpha_q=float(getattr(lcfg, "alpha_q", getattr(lcfg, "r_q", 8))),
+            alpha_k=float(getattr(lcfg, "alpha_k", getattr(lcfg, "r_k", 8))),
+            alpha_v=float(getattr(lcfg, "alpha_v", getattr(lcfg, "r_v", 8))),
+            query_dim=query_dim,
+            inner_dim=inner_dim,
+            out_dim=out_dim,
+            num_heads=num_heads,
+            num_views=num_views,
+            num_domains=num_domains,
+            use_caa=use_caa,
+            use_rope=use_rope,
+            use_global_token=use_global_token,
+            kind=kind,
+        )
+
+    apply_custom_processors(
+        transformer,
+        model_cfg,
+        processor_factory,
+        select=select,
+        limits=limits if limits else None,
+        as_factory=True,
+    )
+
+
+
+def _extend_pos_embed_in(transformer: SD3Transformer2DModel, extra_channels: int) -> None:
+    """Extend transformer's pos_embed input channels by extra_channels."""
+    conv = transformer.pos_embed.proj
+    new_conv = nn.Conv2d(
+        in_channels=conv.in_channels + extra_channels,
+        out_channels=conv.out_channels,
+        kernel_size=conv.kernel_size, stride=conv.stride, padding=conv.padding,
+        dilation=conv.dilation, groups=conv.groups, padding_mode=conv.padding_mode,
+        device=conv.weight.device, dtype=conv.weight.dtype,
+    )
+    with torch.no_grad():
+        new_conv.weight.zero_()
+        new_conv.weight[:, :conv.in_channels].copy_(conv.weight)
+        new_conv.bias.copy_(conv.bias)
+    transformer.pos_embed.proj = new_conv
+
+
+def _load_conditioning_conv(transformer: SD3Transformer2DModel, cond_path: Path) -> None:
+    if not cond_path.exists():
+        return
+    state = load_file(str(cond_path))
+    weight_key = "pos_embed.proj.weight"
+    bias_key = "pos_embed.proj.bias"
+    pe_proj = transformer.pos_embed.proj
+    if weight_key in state:
+        pe_proj.weight.data.copy_(state[weight_key].to(pe_proj.weight.device, dtype=pe_proj.weight.dtype))
+    if bias_key in state:
+        pe_proj.bias.data.copy_(state[bias_key].to(pe_proj.bias.device, dtype=pe_proj.bias.dtype))
+
+
+def load_transformer_weights(
+    transformer: SD3Transformer2DModel,
+    weights_path: Optional[str],
+    *,
+    condition_channels: int,
+) -> None:
+    if not weights_path:
+        return
+    path = Path(weights_path)
+
+    if path.is_dir():
+        full_dir = path / "transformer"
+        lora_path = path / "pytorch_lora_weights.safetensors"
+        cond_path = path / "pytorch_cond_conv_weights.safetensors"
+
+        if full_dir.is_dir():
+            initialize_transformer_weights(transformer, str(full_dir))
+        elif lora_path.exists():
+            lora_state = load_file(str(lora_path))
+            set_peft_model_state_dict(transformer, lora_state, adapter_name="default")
+        else:
+            # Fallback: attempt direct load from directory
+            initialize_transformer_weights(transformer, str(path))
+
+        if condition_channels > 0:
+            _load_conditioning_conv(transformer, cond_path)
+        return
+
+    initialize_transformer_weights(transformer, str(path))
+
+
+def setup_transformer(
+    *,
+    base_model: str,
+    model_cfg,
+    device: str,
+    dtype: torch.dtype,
+    condition_channels: int,
+    use_caa: bool,
+    use_rope: bool,
+    use_global_token: bool,
+    use_dual_branch: bool,
+    num_views: int,
+    weights_path: Optional[str],
+) -> Tuple[SD3Transformer2DModel, Any]:
+    """Setup transformer with structural modifications and load weights."""
+    transformer = SD3Transformer2DModel.from_pretrained(base_model, subfolder="transformer")
+
+    num_domains = 2 if use_dual_branch else 1
+    print(f'use_dual_branch: {use_dual_branch}, use_caa: {use_caa}, use_rope: {use_rope}, use_global_token: {use_global_token}, num_views: {num_views}, num_domains: {num_domains}')
+
+    _apply_lora_processors(
+        transformer,
+        model_cfg,
+        use_caa=use_caa,
+        use_rope=use_rope,
+        use_global_token=use_global_token,
+        num_views=num_views,
+        num_domains=num_domains,
+    )
+
+    if condition_channels > 0:
+        _extend_pos_embed_in(transformer, condition_channels)
+
+    load_transformer_weights(transformer, weights_path, condition_channels=condition_channels)
+
+    transformer = transformer.to(device=device, dtype=dtype).eval().requires_grad_(False)
+
+    scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(base_model, subfolder="scheduler")
+
+    return transformer, scheduler
+
+
+def load_vae_models(
+    *,
+    sd_vae_path: str,
+    mcvae_config_path: str,
+    mcvae_ckpt_path: Optional[str],
+    mcvae_offset_mode: bool,
+    device: str,
+    dtype: torch.dtype,
+    use_dual_branch: bool,
+) -> Tuple[Any, Optional[Any]]:
+    """Load required autoencoders depending on branch configuration."""
+    if use_dual_branch:
+        vae = AutoencoderKL.from_pretrained(sd_vae_path)
+        vae = vae.to(device=device, dtype=dtype).eval().requires_grad_(False)
+        return vae, None
+
+    vae, mcvae = load_offset_autoencoder(
+        sd_vae_path=sd_vae_path,
+        mcvae_config_path=mcvae_config_path,
+        mcvae_ckpt_path=mcvae_ckpt_path,
+        offset_mode=mcvae_offset_mode,
+    )
+    vae = vae.to(device=device, dtype=dtype).eval().requires_grad_(False)
+    mcvae = mcvae.to(device=device, dtype=dtype).eval().requires_grad_(False)
+    return vae, mcvae
+
+
+def encode_conditions(
+    vae: Any,
+    cond_values: torch.Tensor,
+    *,
+    height: int,
+    width: int,
+    out_dtype: torch.dtype,
+) -> torch.Tensor:
+    """Encode 6-channel condition values into latent space."""
+    cond_values = cond_values.to(device=vae.device, dtype=vae.dtype)
+    lat_chunks = []
+    for c in range(0, cond_values.shape[1], 3):
+        posterior = vae.encode(cond_values[:, c:c+3]).latent_dist
+        lat_chunks.append(posterior.mean)
+    
+    cond_latents = torch.cat(lat_chunks, dim=1)
+    cond_latents = (cond_latents - vae.config.shift_factor) * vae.config.scaling_factor
+    Cc = cond_latents.shape[1]
+    cond_latents = cond_latents.reshape(-1, Cc, height // 8, width // 8)
+    return cond_latents.to(dtype=out_dtype)
+
+
+def encode_text_prompts(
+    prompt: str,
+    *,
+    device: str,
+    dtype: torch.dtype,
+    base_model: str,
+    num_views: int,
+    negative_prompt: str,
+) -> Dict[str, torch.Tensor]:
+    """Encode positive and negative text prompts, expanded for all views."""
+    text_ctx = load_text_ctx(device=device, dtype=dtype, sd_model_name=base_model)
+
+    pe, pooled = encode_prompt(text_ctx["encoders"], text_ctx["tokenizers"], prompt, max_sequence_length=77)
+    npe, npooled = encode_prompt(text_ctx["encoders"], text_ctx["tokenizers"], negative_prompt, max_sequence_length=77)
+    
+    # Clean up text context
+    del text_ctx
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    
+    # Move to device and expand for all views
+    pe, pooled = pe.to(device=device, dtype=dtype), pooled.to(device=device, dtype=dtype)
+    npe, npooled = npe.to(device=device, dtype=dtype), npooled.to(device=device, dtype=dtype)
+    
+    pe, pooled = _expand_embeddings_for_views(pe, pooled, num_views=num_views)
+    npe, npooled = _expand_embeddings_for_views(npe, npooled, num_views=num_views)
+    
+    return {
+        "prompt_embeds": pe,
+        "pooled_prompt_embeds": pooled,
+        "negative_prompt_embeds": npe,
+        "negative_pooled_prompt_embeds": npooled,
+    }
+
+
+# =============================================================================
+# Main Inference Pipeline
+# =============================================================================
+
+@torch.no_grad()
+def run(
+    mesh_path: str,
+    prompt: str,
+    output_dir: str,
+    *,
+    settings: Dict[str, Any],
+    keep_strips: bool = False,
+    seed: int = 42,
+) -> str:
+    """Mesh + prompt → textured GLB using configured MC-Diff pipeline."""
+    gid = Path(mesh_path).stem
+    # Use hashlib.md5 for deterministic seed generation (hash() is not deterministic across runs)
+    hash_input = f"{gid}_{seed}".encode('utf-8')
+    combined_seed = int(hashlib.md5(hash_input).hexdigest(), 16) % (2**32)
+    seed_everything(combined_seed)
+
+    device = settings["device"]
+    dtype = settings["dtype"]
+    height = settings["resolution"]
+    width = settings["resolution"]
+    num_views = settings["num_views"]
+    token_hw = height // 16
+    use_caa = settings["use_caa"]
+    use_rope = settings["use_rope"]
+    use_global_token = settings["use_global_token"]
+    use_global_pos = settings.get("use_global_pos", False)
+    use_dual_branch = settings["use_dual_branch"]
+    branch_factor = 2 if use_dual_branch else 1
+
+    rend = render_views(mesh_path, num_views=num_views, height=height, width=width, device=device)
+    preprocessed = preprocess_geometry(
+        rend,
+        device=device,
+        dtype=dtype,
+        height=height,
+        width=width,
+        token_hw=token_hw,
+        num_views=num_views,
+        use_caa=use_caa,
+        corr_dilate_iterations=settings["corr_dilate_iterations"],
+        use_global_pos=use_global_pos,
+    )
+
+    vae, mcvae = load_vae_models(
+        sd_vae_path=settings["sd_vae_path"],
+        mcvae_config_path=settings["mcvae_config_path"],
+        mcvae_ckpt_path=settings["mcvae_ckpt_path"],
+        mcvae_offset_mode=settings.get("mcvae_offset_mode", True),
+        device=device,
+        dtype=dtype,
+        use_dual_branch=use_dual_branch,
+    )
+    vae_shift, vae_scale = vae.config.shift_factor, vae.config.scaling_factor
+
+    cond_latents = None
+    condition_channels = 0
+    if settings.get("condition_channels_cfg", 0) > 0:
+        cond_latents = encode_conditions(
+            vae,
+            preprocessed["cond_values"],
+            height=height,
+            width=width,
+            out_dtype=dtype,
+        )
+        condition_channels = cond_latents.shape[1]
+
+    text_embeds = encode_text_prompts(
+        prompt,
+        device=device,
+        dtype=dtype,
+        base_model=settings["base_model"],
+        num_views=num_views,
+        negative_prompt=settings["negative_prompt"],
+    )
+
+    transformer, scheduler = setup_transformer(
+        base_model=settings["base_model"],
+        model_cfg=settings["model_cfg"],
+        device=device,
+        dtype=dtype,
+        condition_channels=condition_channels,
+        use_caa=use_caa,
+        use_rope=use_rope,
+        use_global_token=use_global_token,
+        use_dual_branch=use_dual_branch,
+        num_views=num_views,
+        weights_path=settings["weights_path"],
+    )
+
+    def _repeat_branch(tensor: Optional[torch.Tensor]) -> Optional[torch.Tensor]:
+        if tensor is None:
+            return None
+        first_dim = tensor.shape[0]
+        if first_dim == num_views:
+            tensor = tensor.reshape(1, num_views, *tensor.shape[1:])
+        elif first_dim == 1:
+            tensor = tensor.reshape(1, *tensor.shape[1:]).unsqueeze(1)
+        else:
+            return tensor
+        tensor = tensor.repeat(branch_factor, 1, *[1] * (tensor.dim() - 2))
+        return tensor.reshape(branch_factor * num_views, *tensor.shape[2:])
+
+    prompt_embeds = _repeat_branch(text_embeds["prompt_embeds"])
+    pooled_prompt_embeds = _repeat_branch(text_embeds["pooled_prompt_embeds"])
+    negative_prompt_embeds = _repeat_branch(text_embeds["negative_prompt_embeds"])
+    negative_pooled_prompt_embeds = _repeat_branch(text_embeds["negative_pooled_prompt_embeds"])
+    cond_latents_branch = _repeat_branch(cond_latents) if cond_latents is not None else None
+
+    # Prepare correspondence data for CAA
+    corr_lookups_branch = None
+    pos_delta_branch = None
+    if use_caa:
+        corr_f2l = preprocessed["corr_f2l"]  # (M, K) where M = num_views * token_hw^2
+        pos_delta = preprocessed["pos_delta"]  # (M, K, 3)
+        
+        if corr_f2l is not None and pos_delta is not None:
+            # For dual branch, duplicate correspondence data
+            if use_dual_branch:
+                # corr_f2l needs to be adjusted for dual branch
+                # Each branch has its own set of indices
+                M, K = corr_f2l.shape
+                corr_branch_list = []
+                for b in range(branch_factor):
+                    corr_b = corr_f2l + (b * M)  # Offset indices for each branch
+                    corr_branch_list.append(corr_b)
+                corr_lookups_branch = torch.cat(corr_branch_list, dim=0)  # (branch_factor * M, K)
+                pos_delta_branch = pos_delta.repeat(branch_factor, 1, 1)  # (branch_factor * M, K, 3)
+            else:
+                corr_lookups_branch = corr_f2l
+                pos_delta_branch = pos_delta
+
+    latents = generate_latents(
+        transformer=transformer,
+        noise_scheduler=scheduler,
+        prompt_embeds=prompt_embeds,
+        pooled_prompt_embeds=pooled_prompt_embeds,
+        negative_prompt_embeds=negative_prompt_embeds,
+        negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
+        height=height,
+        width=width,
+        num_inference_steps=settings["steps"],
+        guidance_scale=settings["guidance_scale"],
+        weight_dtype=dtype,
+        device=device,
+        condition_channels=condition_channels,
+        condition_latents=cond_latents_branch,
+        corr_lookups=corr_lookups_branch,
+        pos_delta=pos_delta_branch,
+        progress=True,
+    )
+
+    inv = (latents / vae_scale) + vae_shift
+
+    if use_dual_branch:
+        decoded = vae.decode(inv.to(device=vae.device, dtype=vae.dtype)).sample
+        decoded = decoded.view(branch_factor, num_views, 3, height, width)
+        albedo_pred = decoded[0]
+        orm_pred_full = decoded[1]
+        combined = torch.cat([albedo_pred, orm_pred_full[:, 1:, :, :]], dim=1)
+        combined_flat = combined.reshape(num_views, 5, height, width)
+    else:
+        inv_mc = inv.to(device=mcvae.device, dtype=mcvae.dtype)
+        decoded = mcvae.decode_aug(inv_mc).sample
+        combined_flat = decoded.reshape(num_views, 5, height, width)
+        albedo_pred = combined_flat[:, :3]
+        orm_pred_full = combined_flat[:, 3:]
+
+    # Compute c-PSNR if correspondence data is available
+    cpsnr_metrics = None
+    if preprocessed.get("corr_f2l_highres") is not None:
+        corr_high = preprocessed["corr_f2l_highres"]  # (1, V*H*W, K)
+        
+        # Convert to global indices (similar to training)
+        B, VHW, K = corr_high.shape
+        base = torch.arange(B, device=corr_high.device).view(B, 1, 1) * VHW
+        corr_high_global = torch.where(corr_high >= 0, corr_high + base, corr_high)
+        corr_high_global = corr_high_global.reshape(B * VHW, K)  # (V*H*W, K)
+        
+        # Prepare predictions in (B, C, H, W) format
+        pred_rgb = combined_flat[:, :3].unsqueeze(0)  # (1, V, 3, H, W) -> need (V, 3, H, W)
+        pred_rgb = pred_rgb.squeeze(0)  # (V, 3, H, W)
+        pred_mr = combined_flat[:, 3:].unsqueeze(0).squeeze(0)  # (V, 2, H, W)
+        
+        # Compute c-PSNR for each component
+        albedo_psnr, _, num_elements = correspondence_psnr(pred_rgb, corr_high_global, data_range=2.0)
+        roughness_psnr, _, _ = correspondence_psnr(pred_mr[:, 0:1], corr_high_global, data_range=2.0)
+        metallic_psnr, _, _ = correspondence_psnr(pred_mr[:, 1:2], corr_high_global, data_range=2.0)
+        
+        # Combined 5-channel c-PSNR
+        pred_combined = combined_flat.unsqueeze(0).squeeze(0)  # (V, 5, H, W)
+        total_psnr, _, _ = correspondence_psnr(pred_combined, corr_high_global, data_range=2.0)
+        
+        cpsnr_metrics = {
+            "albedo": float(albedo_psnr.item()),
+            "roughness": float(roughness_psnr.item()),
+            "metallic": float(metallic_psnr.item()),
+            "total": float(total_psnr.item()),
+            "num_elements": num_elements,
+        }
+
+    dec_albedo = albedo_pred
+    if use_dual_branch:
+        dec_orm = torch.cat([
+            torch.full_like(orm_pred_full[:, :1], fill_value=-1.0),
+            orm_pred_full[:, 1:, :, :],
+        ], dim=1)
+    else:
+        dec_orm = torch.cat([
+            torch.full_like(combined_flat[:, :1], fill_value=-1.0),
+            combined_flat[:, (3, 4)],
+        ], dim=1)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    if keep_strips:
+        albedo_path = os.path.join(output_dir, f"{gid}_albedo_strip.png")
+        orm_path = os.path.join(output_dir, f"{gid}_orm_strip.png")
+        pos = preprocessed["cond_values"][:, :3].clone()
+        normal = preprocessed["cond_values"][:, 3:].clone()
+        cond_values_path = os.path.join(output_dir, f"{gid}_cond_values_strip.png")
+        cond_values_strip = torch.cat([(pos + 1.0) * 0.5, (normal + 1.0) * 0.5], dim=0).to("cpu")
+        _save_strip(cond_values_strip, cond_values_path, nrow=2)
+    else:
+        albedo_fd, albedo_path = tempfile.mkstemp(suffix="_albedo_strip.png")
+        orm_fd, orm_path = tempfile.mkstemp(suffix="_orm_strip.png")
+        os.close(albedo_fd)
+        os.close(orm_fd)
+
+    dec_albedo_cpu = dec_albedo.detach().to("cpu")
+    dec_orm_cpu = dec_orm.detach().to("cpu")
+
+    _save_strip(dec_albedo_cpu, albedo_path)
+    _save_strip(dec_orm_cpu, orm_path)
+
+    unproj_backend = settings.get("unproj_backend", "mvadapter")
+    
+    if unproj_backend == "materialmvp":
+        # MaterialMVP backend: use MeshRenderer + ViewProcessor
+        # Convert strips to individual view images
+        albedo_strip_img = Image.open(albedo_path)
+        orm_strip_img = Image.open(orm_path)
+        
+        strip_width = albedo_strip_img.width
+        strip_height = albedo_strip_img.height
+        view_width = strip_width // num_views
+        
+        albedo_views = []
+        mr_views = []
+        
+        for i in range(num_views):
+            left = i * view_width
+            right = (i + 1) * view_width
+            
+            # Extract albedo view
+            albedo_view = albedo_strip_img.crop((left, 0, right, strip_height))
+            albedo_views.append(albedo_view)
+            
+            # Extract MR from ORM (channels 1 and 2)
+            orm_view = orm_strip_img.crop((left, 0, right, strip_height))
+            mr_views.append(orm_view)
+        
+        output_path = unproject_with_materialmvp(
+            mesh_path=mesh_path,
+            output_dir=output_dir,
+            gid=gid,
+            albedo_images=albedo_views,
+            mr_images=mr_views,
+            render_size=height,
+            texture_size=settings["uv_size"],
+            realesrgan_ckpt=settings["realesrgan_ckpt"],
+            bake_exp=2,
+        )
+        
+        # Clean up temp files if needed
+        if not keep_strips:
+            for path in (albedo_path, orm_path):
+                if path and os.path.exists(path):
+                    try:
+                        os.remove(path)
+                    except OSError:
+                        pass
+    
+    else:  # mvadapter (default)
+        tex_pipeline = TexturePipeline(
+            upscaler_ckpt_path=settings["realesrgan_ckpt"],
+            inpaint_ckpt_path=settings["lama_ckpt"],
+            device=device,
+        )
+
+        try:
+            result = tex_pipeline(
+                mesh_path=mesh_path,
+                save_dir=output_dir,
+                save_name=gid,
+                uv_unwarp=True,
+                preprocess_mesh=False,
+                move_to_center=True,
+                uv_size=settings["uv_size"],
+                base_color_path=albedo_path,
+                orm_path=orm_path,
+                base_color_process_config=ModProcessConfig(view_upscale=True, inpaint_mode="view"),
+                orm_process_config=ModProcessConfig(view_upscale=True, inpaint_mode="view"),
+                camera_elevation_deg=ELEV_DEG,
+                camera_azimuth_deg=AZIM_DEG,
+            )
+            output_path = result.pbr_model_save_path
+        finally:
+            if not keep_strips:
+                for path in (albedo_path, orm_path):
+                    if path and os.path.exists(path):
+                        try:
+                            os.remove(path)
+                        except OSError:
+                            pass
+
+    # Save c-PSNR metrics if computed
+    if cpsnr_metrics is not None:
+        cpsnr_json_path = os.path.join(output_dir, "cpsnr.json")
+        _update_cpsnr_json(cpsnr_json_path, gid, cpsnr_metrics)
+
+    return output_path
+
+
+def build_inference_settings(args, cfg) -> Dict[str, Any]:
+    """Build inference settings from config file and CLI overrides.
+    
+    Priority order (highest to lowest):
+    1. CLI arguments (--num-views, --resolution, etc.) - for backwards compatibility
+    2. Config file with CLI overrides (key=value format)
+    
+    Args:
+        args: Parsed argparse namespace with script-specific arguments
+        cfg: OmegaConf config loaded with base-variant inheritance and CLI overrides
+    """
+    model_cfg = cfg.model
+    
+    # Apply CLI argument overrides to config (backwards compatibility)
+    # These take precedence over --opts to maintain expected behavior
+    if args.num_views is not None:
+        model_cfg.num_views = args.num_views
+    if args.resolution is not None:
+        model_cfg.resolution = args.resolution
+    if args.sd_vae_path is not None:
+        model_cfg.sd_vae_path = args.sd_vae_path
+    if args.mcvae_config is not None:
+        model_cfg.mcvae_config = args.mcvae_config
+    if args.mcvae_ckpt is not None:
+        model_cfg.mcvae_ckpt = args.mcvae_ckpt
+
+    dtype_map = {
+        "fp16": torch.float16,
+        "bf16": torch.bfloat16,
+        "fp32": torch.float32,
+    }
+    dtype = dtype_map.get(args.precision.lower(), DTYPE)
+
+    settings = {
+        "device": args.device,
+        "dtype": dtype,
+        "resolution": int(model_cfg.resolution),
+        "num_views": int(model_cfg.num_views),
+        "use_caa": bool(getattr(model_cfg, "use_caa", True)),
+        "use_rope": bool(getattr(model_cfg, "use_rope", False)),
+        "use_global_token": bool(getattr(model_cfg, "use_global_token", False)),
+        "use_global_pos": bool(getattr(model_cfg, "use_global_pos", False)),
+        "use_dual_branch": bool(getattr(model_cfg, "use_dual_branch", False)),
+        "corr_dilate_iterations": int(getattr(model_cfg, "corr_dilate_iterations", 2)),
+        "condition_channels_cfg": int(getattr(model_cfg, "condition_channels", 0)),
+        "base_model": model_cfg.pretrained_model_name_or_path,
+        "model_cfg": model_cfg,
+        "weights_path": args.weights or TRANSFORMER_PARTIAL_WEIGHTS,
+        "sd_vae_path": model_cfg.sd_vae_path,
+        "mcvae_config_path": model_cfg.mcvae_config,
+        "mcvae_ckpt_path": model_cfg.mcvae_ckpt or MCVAE_CKPT_PATH,
+        "mcvae_offset_mode": bool(getattr(model_cfg, "mcvae_offset_mode", True)),
+        "negative_prompt": args.negative_prompt,
+        "steps": args.steps,
+        "guidance_scale": args.guidance,
+        "realesrgan_ckpt": args.realesrgan_ckpt,
+        "lama_ckpt": args.lama_ckpt,
+        "uv_size": args.uv_size,
+        "unproj_backend": args.unproj_backend,
+        "config": cfg,
+    }
+
+    return settings
+
+
+# =============================================================================
+# CLI Entry Point
+# =============================================================================
+
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Mesh + Prompt → Textured GLB",
+        epilog="""
+Additional config overrides can be provided as key=value arguments:
+  python inference.py --mesh model.glb --prompt "..." model.num_views=8 model.use_caa=false
+        """
+    )
+    parser.add_argument("--mesh", required=True, help="Path to input mesh (.glb or .obj)")
+    parser.add_argument("--prompt", required=True, help="Text prompt for texture generation")
+    parser.add_argument("--out", default="./temp_outputs", help="Output directory")
+    parser.add_argument("--keep-strips", action="store_true", help="Keep intermediate albedo/ORM strip images")
+    parser.add_argument("--guidance", type=float, default=GUIDANCE, help=f"Guidance scale (default: {GUIDANCE})")
+    parser.add_argument("--steps", type=int, default=STEPS, help=f"Number of denoising steps (default: {STEPS})")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed (default: 42)")
+    parser.add_argument("--negative-prompt", default=NEGATIVE_PROMPT, help="Negative prompt text")
+    parser.add_argument("--device", default=DEVICE, help="Torch device to run inference on")
+    parser.add_argument("--precision", default="fp16", choices=["fp16", "bf16", "fp32"], help="Computation precision")
+    parser.add_argument("--num-views", type=int, default=None, help="Override number of camera views")
+    parser.add_argument("--resolution", type=int, default=None, help="Override render resolution")
+    parser.add_argument("--sd-vae-path", default=None, help="Override base SD VAE path")
+    parser.add_argument("--mcvae-config", default=None, help="Override mcVAE config path")
+    parser.add_argument("--mcvae-ckpt", default=None, help="Override mcVAE checkpoint path")
+    parser.add_argument("--weights", default=None, help="Path to trained transformer weights (dir or file)")
+    parser.add_argument("--realesrgan-ckpt", default="./checkpoints/RealESRGAN_x4plus.pth", help="RealESRGAN checkpoint path (x4plus for materialmvp, x2plus for mvadapter)")
+    parser.add_argument("--lama-ckpt", default="./checkpoints/big-lama.pt", help="LaMa inpainting checkpoint path")
+    parser.add_argument("--uv-size", type=int, default=4096, help="Final UV texture resolution")
+    parser.add_argument("--config", default="configs/mcdiff/default.yaml", help="Config file (supports base-variant inheritance)")
+    parser.add_argument("--unproj-backend", default="materialmvp", choices=["mvadapter", "materialmvp"], 
+                        help="Unprojection backend: 'mvadapter' (default, uses TexturePipeline) or 'materialmvp' (uses MeshRenderer+ViewProcessor)")
+    
+    # Parse known args (script-specific flags), unknown args will be config overrides (key=value)
+    args, unknown = parser.parse_known_args()
+    
+    # Load config with base-variant inheritance and CLI overrides
+    cfg = load_config(args.config, cli_overrides=unknown)
+    
+    # Build settings with both argparse args and loaded config
+    settings = build_inference_settings(args, cfg)
+
+    output_path = run(
+        mesh_path=args.mesh,
+        prompt=args.prompt,
+        output_dir=args.out,
+        settings=settings,
+        keep_strips=args.keep_strips,
+        seed=args.seed,
+    )
+
+    print(f"✓ Saved: {output_path}")
+
+
+'''
+python inference.py --keep-strips \
+--mesh /home/aaaaa/data/Arb-Objaverse/data/glb/000-132/21ec37b286474fedb43307f6f289269e.glb \
+--prompt "A wooden stool with a pink cushion and shiny, dark wood finish, detailed with tufting and decorative white buttons, suitable for interior design visualizations." \
+--config configs/mcdiff/dual_full.yaml \
+--weights outputs/mcdiff_v.dual_full/checkpoint-40000/transformer/diffusion_pytorch_model.safetensors \
+--out removethis/dual_full
+
+python inference.py --keep-strips \
+--mesh /home/aaaaa/data/Arb-Objaverse/data/glb/000-132/21ec37b286474fedb43307f6f289269e.glb \
+--prompt "A wooden stool with a pink cushion and shiny, dark wood finish, detailed with tufting and decorative white buttons, suitable for interior design visualizations." \
+--config configs/mcdiff/single_caa.yaml \
+--weights outputs/mcdiff_v.single_caa/checkpoint-35000/transformer/diffusion_pytorch_model.safetensors \
+--out removethis/single_caa
+
+
+python inference.py --keep-strips \
+--mesh /home/aaaaa/data/Arb-Objaverse/data/glb/000-132/21ec37b286474fedb43307f6f289269e.glb \
+--prompt "A wooden stool with a pink cushion and shiny, dark wood finish, detailed with tufting and decorative white buttons, suitable for interior design visualizations." \
+--config configs/mcdiff/single_caa_global.yaml \
+--weights outputs/mcdiff_v.single_caa_global/checkpoint-5000/transformer/diffusion_pytorch_model.safetensors \
+--out removethis/single_caa_global
+
+# With MaterialMVP unprojection backend:
+python inference.py --keep-strips \
+--mesh /home/aaaaa/data/Arb-Objaverse/data/glb/000-132/21ec37b286474fedb43307f6f289269e.glb \
+--prompt "A wooden stool with a pink cushion and shiny, dark wood finish, detailed with tufting and decorative white buttons, suitable for interior design visualizations." \
+--config configs/mcdiff/single_caa.yaml \
+--weights outputs/mcdiff_v.single_caa/checkpoint-35000/transformer/diffusion_pytorch_model.safetensors \
+--out removethis/single_caa_materialmvp \
+--unproj-backend materialmvp
+'''

home/ubuntu/aaaaa/data/rgbmr/inference_batch.py

@@ -0,0 +1,658 @@
+#!/usr/bin/env python3
+"""
+run_infer_batch.py
+
+Parallel runner for inference.py using queued GPU assignment.
+- Reads GLB paths from a text file (one path per line; lines starting with '#' ignored).
+- Reads GLB id (file stem) -> prompt mapping from a CSV file.
+- For each GLB, looks up its stem in the CSV to get a text prompt.
+- Schedules processes across provided CUDA devices with a fair queue.
+- Applies a per-process timeout.
+
+"""
+
+import os
+import sys
+import csv
+import shlex
+import argparse
+import asyncio
+from typing import Dict, List, Tuple
+
+# -----------------------------------------------------------------------------
+# print utils (robust import with fallbacks)
+# -----------------------------------------------------------------------------
+from mcgen.utils.print_utils import (
+    print_header,
+    print_footer,
+    print_info,
+    print_error,
+    print_warning,
+)
+
+# -----------------------------------------------------------------------------
+# Try to import shared helpers from the reference script; provide fallbacks if needed
+# -----------------------------------------------------------------------------
+from tools.render_eval_batch import (
+    print_box,
+    read_list_file,
+    ensure_exists,
+    quote,
+    run_tests,
+    deterministic_hdr_index,
+    build_blender_command,
+    default_script_path as default_render_script_path,
+)
+
+# -----------------------------------------------------------------------------
+# Script-specific utilities
+# -----------------------------------------------------------------------------
+
+def default_infer_script_path() -> str:
+    here = os.path.dirname(os.path.abspath(__file__))
+    return os.path.join(here, "inference.py")
+
+
+def default_infer_list_script_path() -> str:
+    here = os.path.dirname(os.path.abspath(__file__))
+    return os.path.join(here, "inference_list.py")
+
+
+def stem_of(path: str) -> str:
+    return os.path.splitext(os.path.basename(path))[0]
+
+
+def read_prompt_csv(path: str) -> Dict[str, str]:
+    """Read headered CSV with columns: id, prompt."""
+    p = os.path.expanduser(path)
+    if not os.path.exists(p):
+        raise FileNotFoundError(f"Prompt CSV not found: {p}")
+
+    mapping: Dict[str, str] = {}
+    with open(p, "r", encoding="utf-8", newline="") as f:
+        for row in csv.DictReader(f):
+            rid = (row.get("id") or "").strip()
+            prompt = (row.get("prompt") or "").replace("\n", " ").strip()
+            if not rid:
+                continue
+            if not prompt:
+                print_warning(f"Empty prompt for id: {rid}; skipping")
+                continue
+            if rid in mapping:
+                print_warning(f"Duplicate id in CSV; last wins: {rid}")
+            mapping[rid] = prompt
+    return mapping
+
+
+def build_infer_command(
+    python_exec: str,
+    script: str,
+    glb_path: str,
+    prompt: str,
+    out_dir: str,
+    extra_args: List[str] | None = None,
+) -> str:
+    """Build a shell command:
+        python_exec script --mesh GLB --prompt PROMPT --out OUT [extras...]
+    """
+    parts = [
+        quote(python_exec),
+        quote(script),
+        "--mesh", quote(glb_path),
+        "--prompt", quote(prompt),
+        "--out", quote(out_dir),
+    ]
+    if extra_args:
+        parts.extend(extra_args)
+    return " ".join(parts)
+
+
+def build_infer_list_command(
+    python_exec: str,
+    script: str,
+    glb_paths: List[str],
+    prompts: List[str],
+    out_dir: str,
+    extra_args: List[str] | None = None,
+) -> str:
+    """Build a shell command for inference_list.py:
+        python_exec script --mesh GLB1 GLB2 ... --prompt P1 P2 ... --out OUT [extras...]
+    """
+    parts = [
+        quote(python_exec),
+        quote(script),
+        "--mesh",
+    ]
+    parts.extend([quote(p) for p in glb_paths])
+    parts.append("--prompt")
+    parts.extend([quote(p) for p in prompts])
+    parts.extend(["--out", quote(out_dir)])
+    if extra_args:
+        parts.extend(extra_args)
+    return " ".join(parts)
+
+
+# -----------------------------------------------------------------------------
+# CLI & main
+# -----------------------------------------------------------------------------
+
+def default_evaluate_script_path() -> str:
+    here = os.path.dirname(os.path.abspath(__file__))
+    return os.path.join(here, "tools", "evaluate.py")
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Parallel runner for inference.py (GLB generation) + rendering + evaluation")
+    p.add_argument("--glb_list", required=True, help="TXT file with GLB paths (one per line)")
+    p.add_argument("--prompt_csv", required=True, help="CSV file mapping GLB stem -> text prompt")
+    p.add_argument("--output_dir", required=True, help="Base output directory (passed to --out)")
+
+    # Parallel processing controls
+    p.add_argument("--devices", nargs="+", required=True, help="List of CUDA devices (e.g., 0 1 2)")
+    p.add_argument("--timeout", type=int, default=999999, help="Maximum runtime per command (seconds)")
+
+    # Optional QoL flags for inference
+    p.add_argument(
+        "--python_exec",
+        default=os.environ.get("PYTHON_EXEC", sys.executable),
+        help="Python interpreter to run inference (default: current Python or $PYTHON_EXEC)",
+    )
+    p.add_argument(
+        "--script",
+        default=default_infer_script_path(),
+        help="Path to inference.py (default: alongside this runner)",
+    )
+    p.add_argument(
+        "--extra_inference",
+        default="",
+        help="Extra args appended verbatim to the inference command",
+    )
+    p.add_argument(
+        "--group_inference",
+        action="store_true",
+        help="Use inference_list.py to process meshes in groups of 16 (faster due to shared model loading)",
+    )
+    p.add_argument(
+        "--group_size",
+        type=int,
+        default=16,
+        help="Number of meshes to process per group when --group_inference is enabled (default: 16)",
+    )
+    
+    # Rendering options (required)
+    p.add_argument("--hdr_list", required=True, help="TXT file with HDR/HDRI paths (one per line) for rendering")
+    p.add_argument("--salt", default="", help="Salt string for deterministic HDR mapping (default: empty)")
+    p.add_argument(
+        "--blender",
+        default="/home/dbsghd363/blender-4.5.3-linux-x64/blender",
+        help="Path to Blender executable (default: /home/dbsghd363/blender-4.5.3-linux-x64/blender)",
+    )
+    p.add_argument(
+        "--render_script",
+        default=default_render_script_path(),
+        help="Path to render_eval.py (default: tools/render_eval.py)",
+    )
+    p.add_argument(
+        "--extra_render",
+        default="",
+        help="Extra args appended verbatim to the render command",
+    )
+    
+    # Evaluation options (required)
+    p.add_argument("--ref_root", required=True, help="Reference root directory for evaluation")
+    p.add_argument(
+        "--evaluate_script",
+        default=default_evaluate_script_path(),
+        help="Path to evaluate.py (default: tools/evaluate.py)",
+    )
+    
+    # Optional processing control flags
+    p.add_argument(
+        "--skip-vis",
+        action="store_true",
+        help="Skip visualization rendering (only perform inference, evaluation rendering, and metrics computation)",
+    )
+    
+    return p.parse_args()
+
+
+async def main_async():
+    args = parse_args()
+
+    # Inputs
+    glb_paths = ensure_exists(read_list_file(args.glb_list), "GLB")
+    if not glb_paths:
+        print_error("No valid GLB paths found.")
+        sys.exit(1)
+
+    prompt_map = read_prompt_csv(args.prompt_csv)
+    if not prompt_map:
+        print_error("No valid (id -> prompt) entries found in CSV.")
+        sys.exit(1)
+
+    # Prepare output
+    out_dir = os.path.expanduser(args.output_dir)
+    os.makedirs(out_dir, exist_ok=True)
+    
+    # Create subdirectories for organized structure
+    glbs_dir = os.path.join(out_dir, "glbs")
+    eval_dir = os.path.join(out_dir, "eval")
+    vis_dir = os.path.join(out_dir, "vis")
+    os.makedirs(glbs_dir, exist_ok=True)
+    os.makedirs(eval_dir, exist_ok=True)
+    os.makedirs(vis_dir, exist_ok=True)
+
+    # Load HDR list for rendering
+    hdrs = ensure_exists(read_list_file(args.hdr_list), "HDR")
+    if not hdrs:
+        print_error("No valid HDR paths found.")
+        sys.exit(1)
+
+    # Build commands
+    infer_commands: List[str] = []
+    render_commands: List[str] = []
+    vis_commands: List[str] = []
+    extra_infer_args = [x for x in args.extra_inference.split() if x] if args.extra_inference else []
+    extra_render_args = [x for x in args.extra_render.split() if x] if args.extra_render else []
+
+    missing_prompts = 0
+    skip_vis = args.skip_vis
+    
+    # Prepare data structures for group inference
+    pending_infer_items: List[Tuple[str, str]] = []  # [(glb_path, prompt), ...]
+    
+    for glb in glb_paths:
+        sid = stem_of(glb)
+        output_glb_path = os.path.join(glbs_dir, f"{sid}.glb")
+
+        prompt = prompt_map.get(sid)
+        if not prompt:
+            print_warning(f"No prompt found for GLB stem '{sid}' (path: {glb}); skipping")
+            missing_prompts += 1
+            continue
+        
+        # Build render command (output to eval_dir)
+        hdr_idx = deterministic_hdr_index(output_glb_path, len(hdrs), args.salt)
+        hdr = hdrs[hdr_idx]
+        render_cmd = build_blender_command(
+            blender=args.blender,
+            script=args.render_script,
+            glb_path=output_glb_path,
+            hdr_path=hdr,
+            out_dir=eval_dir,
+            extra_args=extra_render_args,
+        )
+        
+        # Build visualization command (output to vis_dir)
+        vis_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools", "render_vis.py")
+        vis_cmd = build_blender_command(
+            blender=args.blender,
+            script=vis_script,
+            glb_path=output_glb_path,
+            hdr_path=hdr,
+            out_dir=vis_dir,
+            extra_args=[],  # No extra args for vis rendering
+        )
+        
+        # if the output for this GLB already exists, skip it
+        if not os.path.exists(output_glb_path):
+            pending_infer_items.append((glb, prompt))
+        
+        # Check if rendering is already complete (20 PNG files in each subdir of eval_dir/gid/)
+        eval_gid_dir = os.path.join(eval_dir, sid)
+        render_complete = False
+        if os.path.exists(eval_gid_dir):
+            subdirs = [d for d in os.listdir(eval_gid_dir) if os.path.isdir(os.path.join(eval_gid_dir, d))]
+            if subdirs:
+                # Check if all subdirs have 20 PNG files
+                all_complete = True
+                for subdir in subdirs:
+                    subdir_path = os.path.join(eval_gid_dir, subdir)
+                    png_files = [f for f in os.listdir(subdir_path) if f.endswith('.png')]
+                    if len(png_files) < 20:
+                        all_complete = False
+                        break
+                render_complete = all_complete
+        
+        if not render_complete:
+            render_commands.append(render_cmd)
+        
+        # Check if visualization is already complete (gid.mp4 exists in vis_dir)
+        # Only add vis commands if --skip-vis is not set
+        if not skip_vis:
+            vis_mp4_path = os.path.join(vis_dir, f"{sid}.mp4")
+            if not os.path.exists(vis_mp4_path):
+                vis_commands.append(vis_cmd)
+        
+        # Informative mapping line (truncate very long prompts when printing)
+        p_preview = (prompt[:16] + "…") if len(prompt) > 16 else prompt
+        print_info(f"Mapped GLB -> Prompt: {glb}  ==>  \"{p_preview}\" -> Render with HDR[{hdr_idx}]")
+    
+    # Build inference commands based on group_inference flag
+    if args.group_inference and pending_infer_items:
+        # Use inference_list.py with grouping
+        list_script = default_infer_list_script_path()
+        group_size = args.group_size
+        
+        for i in range(0, len(pending_infer_items), group_size):
+            group = pending_infer_items[i:i + group_size]
+            group_glbs = [item[0] for item in group]
+            group_prompts = [item[1] for item in group]
+            
+            infer_cmd = build_infer_list_command(
+                python_exec=args.python_exec,
+                script=list_script,
+                glb_paths=group_glbs,
+                prompts=group_prompts,
+                out_dir=glbs_dir,
+                extra_args=extra_infer_args,
+            )
+            infer_commands.append(infer_cmd)
+        
+        print_info(f"Using grouped inference: {len(pending_infer_items)} meshes in {len(infer_commands)} group(s) of up to {group_size}")
+    else:
+        # Use individual inference.py calls
+        for glb, prompt in pending_infer_items:
+            infer_cmd = build_infer_command(
+                python_exec=args.python_exec,
+                script=args.script,
+                glb_path=glb,
+                prompt=prompt,
+                out_dir=glbs_dir,
+                extra_args=extra_infer_args,
+            )
+            infer_commands.append(infer_cmd)
+        
+        if not args.group_inference:
+            print_info(f"Using individual inference: {len(infer_commands)} separate job(s)")
+
+    # Summary box
+    salt_info = f"Salt: '{args.salt}'\n" if args.salt else ""
+    vis_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools", "render_vis.py")
+    vis_info = f"Total vis jobs: {len(vis_commands)}\n" if not skip_vis else "Visualization: SKIPPED (--skip-vis)\n"
+    vis_script_info = f"Visualization script: {vis_script}\n" if not skip_vis else ""
+    
+    # Group inference info
+    if args.group_inference:
+        infer_mode = f"Grouped inference (inference_list.py, group size: {args.group_size})\n"
+        infer_script_info = f"Inference script: {default_infer_list_script_path()}\n"
+    else:
+        infer_mode = "Individual inference (inference.py)\n"
+        infer_script_info = f"Inference script: {args.script}\n"
+    
+    summary_text = (
+        f"Total inference jobs: {len(infer_commands)}\n"
+        + infer_mode +
+        f"Total render jobs: {len(render_commands)}\n"
+        + vis_info +
+        f"Devices: {args.devices}\n"
+        f"Timeout per job: {args.timeout}s\n"
+        f"Output dir (--out): {out_dir}\n"
+        f"Python: {args.python_exec}\n"
+        + infer_script_info +
+        f"Rendering: {len(hdrs)} HDRs\n"
+        f"Render script: {args.render_script}\n"
+        + vis_script_info +
+        f"Blender: {args.blender}\n"
+        + salt_info +
+        f"Evaluation ref root: {args.ref_root}\n"
+        f"Evaluation script: {args.evaluate_script}\n"
+        + (f"GLBs missing prompts: {missing_prompts}\n" if missing_prompts else "")
+    )
+    print_box(summary_text, title="Batch Configuration")
+
+    # Execute inference commands with queued device allocation
+    await run_tests(infer_commands, args.devices, args.timeout)
+
+    # Retry inference for failed GLBs (second attempt)
+    print_header("Checking for missing GLBs and retrying if needed")
+    retry_infer_items: List[Tuple[str, str]] = []
+    
+    for glb in glb_paths:
+        sid = stem_of(glb)
+        output_glb_path = os.path.join(glbs_dir, f"{sid}.glb")
+        
+        # Check if GLB was not created
+        if not os.path.exists(output_glb_path):
+            prompt = prompt_map.get(sid)
+            if prompt:
+                retry_infer_items.append((glb, prompt))
+                print_warning(f"GLB not found, will retry: {output_glb_path}")
+    
+    if retry_infer_items:
+        retry_infer_commands: List[str] = []
+        
+        if args.group_inference:
+            # Use inference_list.py with grouping for retry
+            list_script = default_infer_list_script_path()
+            group_size = min(args.group_size, 2)  # Use smaller groups for retry
+            
+            for i in range(0, len(retry_infer_items), group_size):
+                group = retry_infer_items[i:i + group_size]
+                group_glbs = [item[0] for item in group]
+                group_prompts = [item[1] for item in group]
+                
+                infer_cmd = build_infer_list_command(
+                    python_exec=args.python_exec,
+                    script=list_script,
+                    glb_paths=group_glbs,
+                    prompts=group_prompts,
+                    out_dir=glbs_dir,
+                    extra_args=extra_infer_args,
+                )
+                retry_infer_commands.append(infer_cmd)
+        else:
+            # Use individual inference.py calls for retry
+            for glb, prompt in retry_infer_items:
+                infer_cmd = build_infer_command(
+                    python_exec=args.python_exec,
+                    script=args.script,
+                    glb_path=glb,
+                    prompt=prompt,
+                    out_dir=glbs_dir,
+                    extra_args=extra_infer_args,
+                )
+                retry_infer_commands.append(infer_cmd)
+        
+        print_info(f"Retrying {len(retry_infer_items)} failed inference item(s) in {len(retry_infer_commands)} job(s)")
+        await run_tests(retry_infer_commands, args.devices, args.timeout)
+    else:
+        print_info("All GLBs generated successfully on first attempt")
+    print_footer()
+
+    # Execute render commands
+    print_header("Starting rendering phase")
+    await run_tests(render_commands, args.devices, args.timeout)
+    print_footer()
+
+    # Execute visualization commands (only if not skipped)
+    if not skip_vis:
+        print_header("Starting visualization rendering phase")
+        await run_tests(vis_commands, args.devices, args.timeout)
+        print_footer()
+    else:
+        print_info("Skipping visualization rendering (--skip-vis enabled)")
+
+    # After inference and rendering, collect all GLB files from glbs_dir and write their absolute paths
+    print_header("Collecting output GLB files")
+    glb_files = []
+    for root, dirs, files in os.walk(glbs_dir):
+        for file in files:
+            if file.endswith('.glb'):
+                abs_path = os.path.abspath(os.path.join(root, file))
+                glb_files.append(abs_path)
+    
+    glb_files.sort()  # Sort for consistency
+    print_footer()
+    
+    # Write to glbs.txt
+    glbs_txt_path = os.path.join(out_dir, "glbs.txt")
+    with open(glbs_txt_path, 'w', encoding='utf-8') as f:
+        for glb_path in glb_files:
+            f.write(f"{glb_path}\n")
+    
+    print_info(f"Found {len(glb_files)} GLB file(s)")
+    print_info(f"GLB paths written to: {glbs_txt_path}")
+
+    # Run evaluation (using eval_dir as method_root)
+    print_header("Starting evaluation phase")
+    metrics_csv_path = os.path.join(out_dir, "metrics.csv")
+    eval_cmd = " ".join([
+        quote(args.python_exec),
+        quote(args.evaluate_script),
+        "--ref_root", quote(args.ref_root),
+        "--method_root", quote(eval_dir),
+        "--prompts_csv", quote(args.prompt_csv),
+        "--out_csv", quote(metrics_csv_path),
+    ])
+    
+    # Set CUDA_VISIBLE_DEVICES to the user-specified GPU range
+    eval_env = os.environ.copy()
+    eval_env["CUDA_VISIBLE_DEVICES"] = ",".join(args.devices)
+    
+    print_info(f"Running evaluation command with CUDA_VISIBLE_DEVICES={eval_env['CUDA_VISIBLE_DEVICES']}: {eval_cmd}")
+    eval_process = await asyncio.create_subprocess_shell(eval_cmd, env=eval_env)
+    await eval_process.wait()
+    print_footer()
+    
+    if eval_process.returncode == 0:
+        print_info(f"Evaluation completed successfully")
+        print_info(f"Metrics saved to: {metrics_csv_path}")
+    else:
+        print_error(f"Evaluation failed with return code {eval_process.returncode}")
+    
+    # Move cpsnr.json from glbs_dir to out_dir and process it
+    print_header("Processing CPSNR metrics")
+    cpsnr_source = os.path.join(glbs_dir, "cpsnr.json")
+    cpsnr_dest = os.path.join(out_dir, "cpsnr.json")
+    
+    if os.path.exists(cpsnr_source):
+        import shutil
+        import json
+        import math
+        
+        # Copy the cpsnr.json file
+        shutil.copyfile(cpsnr_source, cpsnr_dest)
+        print_info(f"Copied cpsnr.json from {cpsnr_source} to {cpsnr_dest}")
+
+        # Read and process cpsnr.json
+        with open(cpsnr_dest, 'r', encoding='utf-8') as f:
+            cpsnr_data = json.load(f)
+        
+        # Calculate averages for each metric, excluding NaN values
+        # Also calculate weighted averages based on num_elements
+        metric_sums = {}
+        metric_counts = {}
+        metric_weighted_sums = {}
+        metric_total_weights = {}
+        
+        for gid, metrics in cpsnr_data.items():
+            # Extract num_elements for this sample (used as weight)
+            num_elements = metrics.get("num_elements", None)
+            
+            for metric_name, value in metrics.items():
+                # Skip num_elements itself in metric calculations
+                if metric_name == "num_elements":
+                    continue
+                    
+                # Check if value is a valid number (not NaN, not None, not inf)
+                if value is not None and isinstance(value, (int, float)) and math.isfinite(value):
+                    # Arithmetic mean (unweighted)
+                    if metric_name not in metric_sums:
+                        metric_sums[metric_name] = 0.0
+                        metric_counts[metric_name] = 0
+                    metric_sums[metric_name] += value
+                    metric_counts[metric_name] += 1
+                    
+                    # Weighted mean (weighted by num_elements)
+                    if num_elements is not None and isinstance(num_elements, (int, float)) and num_elements > 0:
+                        if metric_name not in metric_weighted_sums:
+                            metric_weighted_sums[metric_name] = 0.0
+                            metric_total_weights[metric_name] = 0.0
+                        metric_weighted_sums[metric_name] += value * num_elements
+                        metric_total_weights[metric_name] += num_elements
+        
+        # Calculate averages
+        cpsnr_averages = {}
+        
+        # Arithmetic mean
+        for metric_name in metric_sums:
+            if metric_counts[metric_name] > 0:
+                avg_value = metric_sums[metric_name] / metric_counts[metric_name]
+                cpsnr_averages[f"cpsnr_{metric_name}"] = avg_value
+                print_info(f"cpsnr_{metric_name}: {avg_value:.4f} (from {metric_counts[metric_name]} valid values)")
+        
+        # Weighted mean
+        for metric_name in metric_weighted_sums:
+            if metric_total_weights[metric_name] > 0:
+                weighted_avg_value = metric_weighted_sums[metric_name] / metric_total_weights[metric_name]
+                cpsnr_averages[f"cpsnr_weighted_{metric_name}"] = weighted_avg_value
+                print_info(f"cpsnr_weighted_{metric_name}: {weighted_avg_value:.4f} (weighted by num_elements)")
+        
+        # Append cpsnr averages to metrics.csv in (metric, value) format
+        if os.path.exists(metrics_csv_path) and cpsnr_averages:
+            # Append new cpsnr metrics as new rows
+            with open(metrics_csv_path, 'a', encoding='utf-8', newline='') as f:
+                writer = csv.writer(f)
+                for cpsnr_key, cpsnr_value in sorted(cpsnr_averages.items()):
+                    writer.writerow([cpsnr_key, cpsnr_value])
+            
+            print_info(f"Added {len(cpsnr_averages)} CPSNR metric(s) to {metrics_csv_path}")
+        else:
+            print_warning(f"Could not update metrics.csv with CPSNR data (file exists: {os.path.exists(metrics_csv_path)}, has data: {bool(cpsnr_averages)})")
+    else:
+        print_warning(f"cpsnr.json not found at {cpsnr_source}, skipping CPSNR processing")
+    
+    print_footer()
+
+def main():
+    try:
+        asyncio.run(main_async())
+    except KeyboardInterrupt:
+        print_warning("Interrupted by user (Ctrl+C). Exiting.")
+
+
+if __name__ == "__main__":
+    main()
+
+"""
+EXAMPLE USAGE:
+
+# Basic usage (individual inference.py calls):
+METHOD=single_caa; ITER=40000; \
+python inference_batch.py \
+  --glb_list /home/aaaaa/projects/cvpr2026/glbs_eval_ref.txt \
+  --prompt_csv /home/aaaaa/projects/cvpr2026/prompts_bs.csv \
+  --hdr_list /home/aaaaa/data/envmaps/hdr_list.txt \
+  --ref_root outputs_eval_omega/ref/ \
+  --output_dir ./outputs_eval_omega/glbs_${METHOD}_${ITER}/ \
+  --extra_inference "--guidance 4.0 --steps 30 --weights outputs/mcdiff_v.${METHOD}/checkpoint-${ITER}/transformer/diffusion_pytorch_model.safetensors --config configs/mcdiff/${METHOD}.yaml" \
+  --devices 0 --skip-vis
+
+# Grouped inference (faster - uses inference_list.py with groups of 16):
+METHOD=single_caa; ITER=40000; \
+python inference_batch.py \
+  --glb_list /home/aaaaa/projects/cvpr2026/glbs_eval_ref.txt \
+  --prompt_csv /home/aaaaa/projects/cvpr2026/prompts_bs.csv \
+  --hdr_list /home/aaaaa/data/envmaps/hdr_list.txt \
+  --ref_root outputs_eval_omega/ref/ \
+  --output_dir ./outputs_eval_omega/glbs_${METHOD}_${ITER}/ \
+  --extra_inference "--guidance 4.0 --steps 30 --weights outputs/mcdiff_v.${METHOD}/checkpoint-${ITER}/transformer/diffusion_pytorch_model.safetensors --config configs/mcdiff/${METHOD}.yaml" \
+  --devices 0 --skip-vis \
+  --group_inference
+
+# Grouped inference with custom group size:
+METHOD=dual_full; ITER=40000; \
+python inference_batch.py \
+  --glb_list /home/aaaaa/projects/cvpr2026/glbs_eval_ref.txt \
+  --prompt_csv /home/aaaaa/projects/cvpr2026/prompts_bs.csv \
+  --hdr_list /home/aaaaa/data/envmaps/hdr_list.txt \
+  --ref_root outputs_eval_omega/ref/ \
+  --output_dir ./outputs_eval_zenith/glbs_${METHOD}_${ITER}/ \
+  --extra_inference "--guidance 4.0 --steps 30 --weights outputs/mcdiff_v.${METHOD}/checkpoint-${ITER}/transformer/diffusion_pytorch_model.safetensors --config configs/mcdiff/${METHOD}.yaml" \
+  --devices 0 --skip-vis \
+  --group_inference
+"""
+
+# 40000 30000 20000 15000 10000 5000
+# ours baseline1 baseline2

home/ubuntu/aaaaa/data/rgbmr/inference_list.py

@@ -0,0 +1,1270 @@
+"""
+Mesh-to-Textured-Mesh Batch Inference Pipeline
+Multiple (mesh + prompt) pairs -> multiple textured .glb files
+
+This script efficiently processes N mesh-prompt pairs by loading models once
+and reusing them for all generations, avoiding redundant model loading overhead.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Tuple, Dict, Any, Optional, List
+import math
+import json
+import filelock
+import hashlib
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from diffusers import FlowMatchEulerDiscreteScheduler, SD3Transformer2DModel, AutoencoderKL
+from torchvision.transforms import ToPILImage
+from PIL import Image
+from omegaconf import OmegaConf
+from peft import set_peft_model_state_dict
+from safetensors.torch import load_file
+
+from mcgen.utils.model_utils import load_offset_autoencoder, initialize_transformer_weights
+from mcgen.mcdiff.attention_processor_lora import LoRAMessagePassingAttnProcessor
+from mcgen.mcdiff.attention_utils import apply_custom_processors
+from mcgen.utils.text_encoder_utils import load_text_ctx, encode_prompt
+from mcgen.mcdiff.latents import generate_latents
+from mcgen.utils.pipeline_texture import TexturePipeline, ModProcessConfig
+from mcgen.utils.correspondence import build_corr_pairs, downscale_pairs_to_f2l, dilate_f2l, correspondence_psnr
+from mcgen.utils.config import load_config
+from tools.utils.mesh_utils import load_mesh, get_orthogonal_camera, NVDiffRastContextWrapper, render
+from mcgen.utils.image_super_utils import imageSuperNet
+from mcgen.utils.pipeline_utils import ViewProcessor
+from mcgen.utils.uvwrap_utils import mesh_uv_wrap
+from mcgen.utils.geometry_inpaint_utils import texture_inpaint
+from DifferentiableRenderer.MeshRender import MeshRender
+import trimesh
+import copy
+
+# =============================================================================
+# Configuration
+# =============================================================================
+
+# Model paths
+SD35_REPO = "stabilityai/stable-diffusion-3.5-medium"
+TRANSFORMER_PARTIAL_WEIGHTS = "outputs/mcdiff_v1.9.5/checkpoint-40000/transformer/diffusion_pytorch_model.safetensors"
+SD_VAE_PATH = "./vae_sd35"
+MCVAE_CONFIG_PATH = "./configs/mcvae/config.json"
+MCVAE_CKPT_PATH = "./outputs/mcvae_v1.8.1.pt"
+
+# Device & precision
+DEVICE = "cuda"
+DTYPE = torch.float16
+
+# Image & view settings
+HEIGHT = WIDTH = 512
+TOKEN_HW = HEIGHT // 16
+NUM_VIEWS = 6
+ELEV_DEG = [0.0, 0.0, 0.0, 0.0, 89.99, -89.99]
+AZIM_DEG = [0.0, 90.0, 180.0, 270.0, 0.0, 0.0]
+
+# MaterialMVP azimuth convention (90 degree offset from mvadapter)
+AZIM_DEG_MATERIALMVP = [angle + 90 for angle in AZIM_DEG]
+
+# Inference defaults
+GUIDANCE = 4.0
+STEPS = 30
+NEGATIVE_PROMPT = ""
+
+
+# =============================================================================
+# Utility Functions
+# =============================================================================
+
+def seed_everything(seed: int = 42):
+    """Seed all random number generators for reproducibility."""
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def _resize_to_pm1(x: torch.Tensor, *, height: int, width: int) -> torch.Tensor:
+    """Resize to target resolution and normalize to [-1, 1]."""
+    x = F.interpolate(x, size=(height, width), mode="bilinear", align_corners=False)
+    return x * 2.0 - 1.0
+
+
+def _expand_embeddings_for_views(pe: torch.Tensor, pooled: torch.Tensor, *, num_views: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Expand text embeddings from [1, seq, dim] to [num_views, seq, dim]."""
+    pe = pe.expand(1, -1, -1).unsqueeze(1).expand(-1, num_views, -1, -1).reshape(-1, pe.shape[1], pe.shape[2])
+    pooled = pooled.expand(1, -1).unsqueeze(1).expand(-1, num_views, -1).reshape(-1, pooled.shape[-1])
+    return pe, pooled
+
+
+@torch.no_grad()
+def _save_strip(tensor_bchw: torch.Tensor, path: str, nrow: int = 1) -> str:
+    """Save grid of images from batched tensors in [-1, 1] range.
+    
+    Args:
+        tensor_bchw: Batch of images in BCHW format, range [-1, 1]
+        path: Output path for saved image
+        nrow: Number of rows in grid. If 1, creates horizontal strip.
+    """
+    
+    to_pil = ToPILImage()
+    b, c, h, w = tensor_bchw.shape
+    
+    nrow = max(1, nrow)
+    ncol = math.ceil(b / nrow)
+    
+    canvas = Image.new('RGB', (ncol * w, nrow * h))
+    for i in range(b):
+        row = i // ncol
+        col = i % ncol
+        img = to_pil((tensor_bchw[i].clamp(-1, 1) * 0.5 + 0.5))
+        canvas.paste(img, (col * w, row * h))
+    
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    canvas.save(path)
+    return path
+
+
+def _update_cpsnr_json(json_path: str, gid: str, metrics: Dict[str, float]) -> None:
+    """Thread-safe update of cpsnr.json file using file locking.
+    
+    Args:
+        json_path: Path to cpsnr.json file
+        gid: Geometry ID (mesh filename stem)
+        metrics: Dictionary containing 'albedo', 'roughness', 'metallic', 'total' keys
+    """
+    lock_path = json_path + ".lock"
+    lock = filelock.FileLock(lock_path, timeout=60)
+    
+    try:
+        with lock:
+            # Read existing data
+            if os.path.exists(json_path):
+                with open(json_path, "r") as f:
+                    data = json.load(f)
+            else:
+                data = {}
+            
+            # Update with new metrics
+            data[gid] = metrics
+            
+            # Write back atomically using temp file + rename
+            temp_path = json_path + ".tmp"
+            with open(temp_path, "w") as f:
+                json.dump(data, f, indent=2)
+            os.replace(temp_path, json_path)
+    finally:
+        # Clean up lock file if it exists and we can remove it
+        try:
+            if os.path.exists(lock_path):
+                os.remove(lock_path)
+        except OSError:
+            pass
+
+
+# =============================================================================
+# Reusable Model Context (loaded once, used for all meshes)
+# =============================================================================
+
+class UnprojectionContext:
+    """Manages reusable models for unprojection to avoid repeated loading."""
+    
+    def __init__(
+        self,
+        *,
+        render_size: int = 512,
+        texture_size: int = 4096,
+        realesrgan_ckpt: str,
+        device: str = "cuda",
+    ):
+        self.render_size = render_size
+        self.texture_size = texture_size
+        self.device = device
+        
+        # Load super-resolution model once
+        self.super_model = imageSuperNet(realesrgan_ckpt)
+        
+    def unproject_with_materialmvp(
+        self,
+        mesh_path: str,
+        output_dir: str,
+        gid: str,
+        albedo_images: List[Image.Image],
+        mr_images: List[Image.Image],
+        *,
+        bake_exp: int = 2,
+        selected_view_weights: Optional[List[float]] = None,
+    ) -> str:
+        """Unproject multi-view images to textured mesh using MaterialMVP approach.
+        
+        Uses pre-loaded super-resolution model from context.
+        
+        Args:
+            mesh_path: Path to input mesh
+            output_dir: Output directory
+            gid: Geometry ID (mesh filename stem)
+            albedo_images: List of albedo views (6 images)
+            mr_images: List of metallic-roughness views (6 images, ORM format)
+            bake_exp: Baking exponent for view weighting
+            selected_view_weights: Optional list of per-view weights
+            
+        Returns:
+            Path to saved GLB file
+        """
+        # Initialize renderer (lightweight, can be created per mesh)
+        render_obj = MeshRender(
+            default_resolution=self.render_size,
+            texture_size=self.texture_size,
+            bake_mode="back_sample",
+            raster_mode="cr",
+        )
+        
+        # Load and prepare mesh
+        mesh = trimesh.load(mesh_path)
+        mesh = mesh_uv_wrap(mesh)
+        render_obj.load_mesh(mesh=mesh)
+        
+        # Initialize view processor
+        view_processor = ViewProcessor(bake_exp, render_obj)
+        
+        # Use MaterialMVP azimuth convention (90-degree offset)
+        selected_camera_azims = AZIM_DEG_MATERIALMVP
+        selected_camera_elevs = ELEV_DEG
+        
+        if selected_view_weights is None:
+            selected_view_weights = [1, 1, 1, 1, 0.5, 0.5]
+        
+        # Prepare images dictionary
+        multiviews_pbr = {
+            "albedo": albedo_images,
+            "mr": mr_images,
+        }
+        
+        # Enhance images using pre-loaded super model
+        enhance_images = {
+            "albedo": copy.deepcopy(multiviews_pbr["albedo"]),
+            "mr": copy.deepcopy(multiviews_pbr["mr"]),
+        }
+        
+        for i in range(len(enhance_images["albedo"])):
+            enhance_images["albedo"][i] = self.super_model(enhance_images["albedo"][i])
+            enhance_images["mr"][i] = self.super_model(enhance_images["mr"][i])
+        
+        # Resize to double render size for better quality
+        for i in range(len(enhance_images["albedo"])):
+            enhance_images["albedo"][i] = enhance_images["albedo"][i].resize(
+                (self.render_size * 2, self.render_size * 2), Image.LANCZOS
+            )
+            enhance_images["mr"][i] = enhance_images["mr"][i].resize(
+                (self.render_size * 2, self.render_size * 2), Image.LANCZOS
+            )
+        
+        # Bake albedo texture
+        texture, mask = view_processor.bake_from_multiview(
+            enhance_images["albedo"],
+            selected_camera_elevs,
+            selected_camera_azims,
+            selected_view_weights
+        )
+        
+        # Bake metallic-roughness texture
+        texture_mr, mask_mr = view_processor.bake_from_multiview(
+            enhance_images["mr"],
+            selected_camera_elevs,
+            selected_camera_azims,
+            selected_view_weights
+        )
+        
+        # Convert baked masks to boolean tensors
+        mask_bool = (mask.squeeze(-1) > 0.5).to(torch.bool)
+        mask_mr_bool = (mask_mr.squeeze(-1) > 0.5).to(torch.bool)
+        
+        # Apply geometry-aware inpainting for albedo texture
+        texture_inpainted = texture_inpaint(
+            texture,
+            mask_bool,
+            render_obj,
+            uv_mask_erode_iters=10,
+            baked_mask_erode_iters=2,
+            vertex_merge_tolerance=1e-5,
+            vertex_color_K=11,
+        )
+        render_obj.set_texture(texture_inpainted, force_set=True)
+        
+        # Apply geometry-aware inpainting for metallic-roughness texture
+        texture_mr_inpainted = texture_inpaint(
+            texture_mr,
+            mask_mr_bool,
+            render_obj,
+            uv_mask_erode_iters=10,
+            baked_mask_erode_iters=2,
+            vertex_merge_tolerance=1e-5,
+            vertex_color_K=11,
+        )
+        render_obj.set_texture_mr(texture_mr_inpainted)
+        
+        # Save mesh
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f"{gid}.glb")
+        render_obj.save_mesh(output_path, downsample=False)
+        
+        return output_path
+
+
+class InferenceContext:
+    """Manages all pre-loaded models for efficient batch inference."""
+    
+    def __init__(self, settings: Dict[str, Any]):
+        self.settings = settings
+        self.device = settings["device"]
+        self.dtype = settings["dtype"]
+        
+        # Load VAE models once
+        self.vae, self.mcvae = self._load_vae_models()
+        self.vae_shift = self.vae.config.shift_factor
+        self.vae_scale = self.vae.config.scaling_factor
+        
+        # Load transformer and scheduler once
+        self.transformer, self.scheduler = self._setup_transformer()
+        
+        # Load text encoders once
+        self.text_ctx = self._load_text_ctx()
+        
+        # Initialize unprojection context if using materialmvp backend
+        self.unproj_ctx = None
+        if settings.get("unproj_backend") == "materialmvp":
+            self.unproj_ctx = UnprojectionContext(
+                render_size=settings["resolution"],
+                texture_size=settings["uv_size"],
+                realesrgan_ckpt=settings["realesrgan_ckpt"],
+                device=self.device,
+            )
+        
+        # Initialize texture pipeline if using mvadapter backend
+        self.tex_pipeline = None
+        if settings.get("unproj_backend") == "mvadapter":
+            self.tex_pipeline = TexturePipeline(
+                upscaler_ckpt_path=settings["realesrgan_ckpt"],
+                inpaint_ckpt_path=settings["lama_ckpt"],
+                device=self.device,
+            )
+    
+    def _load_vae_models(self):
+        """Load VAE and optionally mcVAE."""
+        use_dual_branch = self.settings["use_dual_branch"]
+        
+        if use_dual_branch:
+            vae = AutoencoderKL.from_pretrained(self.settings["sd_vae_path"])
+            vae = vae.to(device=self.device, dtype=self.dtype).eval().requires_grad_(False)
+            return vae, None
+        
+        vae, mcvae = load_offset_autoencoder(
+            sd_vae_path=self.settings["sd_vae_path"],
+            mcvae_config_path=self.settings["mcvae_config_path"],
+            mcvae_ckpt_path=self.settings["mcvae_ckpt_path"],
+            offset_mode=self.settings.get("mcvae_offset_mode", True),
+        )
+        vae = vae.to(device=self.device, dtype=self.dtype).eval().requires_grad_(False)
+        mcvae = mcvae.to(device=self.device, dtype=self.dtype).eval().requires_grad_(False)
+        return vae, mcvae
+    
+    def _setup_transformer(self):
+        """Setup transformer with structural modifications and load weights."""
+        transformer = SD3Transformer2DModel.from_pretrained(
+            self.settings["base_model"],
+            subfolder="transformer"
+        )
+        
+        model_cfg = self.settings["model_cfg"]
+        num_views = self.settings["num_views"]
+        use_caa = self.settings["use_caa"]
+        use_rope = self.settings["use_rope"]
+        use_global_token = self.settings["use_global_token"]
+        use_dual_branch = self.settings["use_dual_branch"]
+        condition_channels = self.settings["condition_channels_cfg"]
+        
+        num_domains = 2 if use_dual_branch else 1
+        print(f'use_dual_branch: {use_dual_branch}, use_caa: {use_caa}, use_rope: {use_rope}, use_global_token: {use_global_token}, num_views: {num_views}, num_domains: {num_domains}')
+        
+        # Apply LoRA processors
+        self._apply_lora_processors(
+            transformer,
+            model_cfg,
+            use_caa=use_caa,
+            use_rope=use_rope,
+            use_global_token=use_global_token,
+            num_views=num_views,
+            num_domains=num_domains,
+        )
+        
+        # Extend position embedding input channels if needed
+        if condition_channels > 0:
+            self._extend_pos_embed_in(transformer, condition_channels)
+        
+        # Load weights
+        self._load_transformer_weights(
+            transformer,
+            self.settings["weights_path"],
+            condition_channels=condition_channels,
+        )
+        
+        transformer = transformer.to(device=self.device, dtype=self.dtype).eval().requires_grad_(False)
+        
+        scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
+            self.settings["base_model"],
+            subfolder="scheduler"
+        )
+        
+        return transformer, scheduler
+    
+    def _apply_lora_processors(
+        self,
+        transformer: SD3Transformer2DModel,
+        model_cfg,
+        *,
+        use_caa: bool,
+        use_rope: bool,
+        use_global_token: bool,
+        num_views: int,
+        num_domains: int,
+    ) -> None:
+        """Attach LoRA message-passing processors."""
+        lcfg = getattr(model_cfg, "attn_lora", None)
+        if not lcfg or not getattr(lcfg, "enabled", False):
+            return
+
+        select = {"joint": True, "self": bool(getattr(lcfg, "apply_to_self", False))}
+        limits = {}
+        if getattr(lcfg, "limit_joint", None) is not None:
+            limits["joint"] = lcfg.limit_joint
+        if getattr(lcfg, "limit_self", None) is not None:
+            limits["self"] = lcfg.limit_self
+
+        def processor_factory(_name, _mod, query_dim, inner_dim, out_dim, num_heads, kind="joint"):
+            return LoRAMessagePassingAttnProcessor(
+                r_q=int(getattr(lcfg, "r_q", 8)),
+                r_k=int(getattr(lcfg, "r_k", 8)),
+                r_v=int(getattr(lcfg, "r_v", 8)),
+                alpha_q=float(getattr(lcfg, "alpha_q", getattr(lcfg, "r_q", 8))),
+                alpha_k=float(getattr(lcfg, "alpha_k", getattr(lcfg, "r_k", 8))),
+                alpha_v=float(getattr(lcfg, "alpha_v", getattr(lcfg, "r_v", 8))),
+                query_dim=query_dim,
+                inner_dim=inner_dim,
+                out_dim=out_dim,
+                num_heads=num_heads,
+                num_views=num_views,
+                num_domains=num_domains,
+                use_caa=use_caa,
+                use_rope=use_rope,
+                use_global_token=use_global_token,
+                kind=kind,
+            )
+
+        apply_custom_processors(
+            transformer,
+            model_cfg,
+            processor_factory,
+            select=select,
+            limits=limits if limits else None,
+            as_factory=True,
+        )
+    
+    def _extend_pos_embed_in(self, transformer: SD3Transformer2DModel, extra_channels: int) -> None:
+        """Extend transformer's pos_embed input channels."""
+        conv = transformer.pos_embed.proj
+        new_conv = nn.Conv2d(
+            in_channels=conv.in_channels + extra_channels,
+            out_channels=conv.out_channels,
+            kernel_size=conv.kernel_size, stride=conv.stride, padding=conv.padding,
+            dilation=conv.dilation, groups=conv.groups, padding_mode=conv.padding_mode,
+            device=conv.weight.device, dtype=conv.weight.dtype,
+        )
+        with torch.no_grad():
+            new_conv.weight.zero_()
+            new_conv.weight[:, :conv.in_channels].copy_(conv.weight)
+            new_conv.bias.copy_(conv.bias)
+        transformer.pos_embed.proj = new_conv
+    
+    def _load_conditioning_conv(self, transformer: SD3Transformer2DModel, cond_path: Path) -> None:
+        """Load conditioning convolution weights if available."""
+        if not cond_path.exists():
+            return
+        state = load_file(str(cond_path))
+        weight_key = "pos_embed.proj.weight"
+        bias_key = "pos_embed.proj.bias"
+        pe_proj = transformer.pos_embed.proj
+        if weight_key in state:
+            pe_proj.weight.data.copy_(state[weight_key].to(pe_proj.weight.device, dtype=pe_proj.weight.dtype))
+        if bias_key in state:
+            pe_proj.bias.data.copy_(state[bias_key].to(pe_proj.bias.device, dtype=pe_proj.bias.dtype))
+    
+    def _load_transformer_weights(
+        self,
+        transformer: SD3Transformer2DModel,
+        weights_path: Optional[str],
+        *,
+        condition_channels: int,
+    ) -> None:
+        """Load transformer weights from checkpoint."""
+        if not weights_path:
+            return
+        path = Path(weights_path)
+
+        if path.is_dir():
+            full_dir = path / "transformer"
+            lora_path = path / "pytorch_lora_weights.safetensors"
+            cond_path = path / "pytorch_cond_conv_weights.safetensors"
+
+            if full_dir.is_dir():
+                initialize_transformer_weights(transformer, str(full_dir))
+            elif lora_path.exists():
+                lora_state = load_file(str(lora_path))
+                set_peft_model_state_dict(transformer, lora_state, adapter_name="default")
+            else:
+                initialize_transformer_weights(transformer, str(path))
+
+            if condition_channels > 0:
+                self._load_conditioning_conv(transformer, cond_path)
+            return
+
+        initialize_transformer_weights(transformer, str(path))
+    
+    def _load_text_ctx(self):
+        """Load text encoding context (tokenizers and encoders)."""
+        return load_text_ctx(
+            device=self.device,
+            dtype=self.dtype,
+            sd_model_name=self.settings["base_model"]
+        )
+    
+    def encode_text_prompts(self, prompt: str, negative_prompt: str) -> Dict[str, torch.Tensor]:
+        """Encode text prompts using pre-loaded text context."""
+        num_views = self.settings["num_views"]
+        
+        pe, pooled = encode_prompt(
+            self.text_ctx["encoders"],
+            self.text_ctx["tokenizers"],
+            prompt,
+            max_sequence_length=77
+        )
+        npe, npooled = encode_prompt(
+            self.text_ctx["encoders"],
+            self.text_ctx["tokenizers"],
+            negative_prompt,
+            max_sequence_length=77
+        )
+        
+        # Move to device and expand for all views
+        pe, pooled = pe.to(device=self.device, dtype=self.dtype), pooled.to(device=self.device, dtype=self.dtype)
+        npe, npooled = npe.to(device=self.device, dtype=self.dtype), npooled.to(device=self.device, dtype=self.dtype)
+        
+        pe, pooled = _expand_embeddings_for_views(pe, pooled, num_views=num_views)
+        npe, npooled = _expand_embeddings_for_views(npe, npooled, num_views=num_views)
+        
+        return {
+            "prompt_embeds": pe,
+            "pooled_prompt_embeds": pooled,
+            "negative_prompt_embeds": npe,
+            "negative_pooled_prompt_embeds": npooled,
+        }
+    
+    def encode_conditions(self, cond_values: torch.Tensor) -> torch.Tensor:
+        """Encode 6-channel condition values into latent space."""
+        height = self.settings["resolution"]
+        width = self.settings["resolution"]
+        
+        cond_values = cond_values.to(device=self.vae.device, dtype=self.vae.dtype)
+        lat_chunks = []
+        for c in range(0, cond_values.shape[1], 3):
+            posterior = self.vae.encode(cond_values[:, c:c+3]).latent_dist
+            lat_chunks.append(posterior.mean)
+        
+        cond_latents = torch.cat(lat_chunks, dim=1)
+        cond_latents = (cond_latents - self.vae_shift) * self.vae_scale
+        Cc = cond_latents.shape[1]
+        cond_latents = cond_latents.reshape(-1, Cc, height // 8, width // 8)
+        return cond_latents.to(dtype=self.dtype)
+
+
+# =============================================================================
+# Rendering & Preprocessing
+# =============================================================================
+
+@torch.no_grad()
+def render_views(
+    mesh_path: str,
+    *,
+    num_views: int,
+    height: int,
+    width: int,
+    device: str = DEVICE,
+) -> Dict[str, Any]:
+    """Render multi-view geometry attributes from mesh."""
+    ctx = NVDiffRastContextWrapper(device=device, context_type="cuda")
+    mesh = load_mesh(str(mesh_path), rescale=True, move_to_center=True, flip_uv=True, device=device)
+    if len(ELEV_DEG) != num_views or len(AZIM_DEG) != num_views:
+        raise ValueError("ELEV_DEG and AZIM_DEG presets must match num_views.")
+    
+    cams = get_orthogonal_camera(
+        elevation_deg=ELEV_DEG,
+        azimuth_deg=AZIM_DEG,
+        distance=[1.0] * num_views,
+        left=-0.55,
+        right=0.55,
+        bottom=-0.55,
+        top=0.55,
+        device=device, dtype=torch.float32,
+    )
+
+    # Build 5-channel texture override: [rgb, roughness(0), roughness, metallic]
+    tex_ovr = torch.cat([mesh.texture, torch.zeros_like(mesh.roughness), mesh.roughness, mesh.metallic], dim=-1)
+    
+    out = render(ctx, mesh, cams, height=height, width=width, render_attr=True, texture_override=tex_ovr)
+    
+    # Extract and normalize geometry attributes
+    attr = out.attr
+    rgb = attr[..., :3].contiguous()
+    orm = attr[..., 3:6].contiguous()
+    orm[..., 0] = (orm[..., 0] < 0.25).float()  # Binary occupancy mask
+    
+    return {
+        "albedo": rgb,
+        "orm": orm,
+        "pos": out.pos + 0.5,                    # [-0.5, 0.5] -> [0, 1]
+        "normal": (out.normal + 1.0) * 0.5,      # [-1, 1] -> [0, 1]
+        "depth": out.raw_depth,
+        "c2w": cams.c2w,
+        "scale": torch.tensor(1.1, device=device),
+    }
+
+
+def preprocess_geometry(
+    rend: Dict[str, Any],
+    *,
+    device: str,
+    dtype: torch.dtype,
+    height: int,
+    width: int,
+    token_hw: int,
+    num_views: int,
+    use_caa: bool,
+    corr_dilate_iterations: int = 1,
+    use_global_pos: bool = False,
+) -> Dict[str, torch.Tensor]:
+    """Preprocess rendered geometry into model-ready format."""
+    # Convert to channel-first
+    albedo = rend["albedo"].permute(0, 3, 1, 2).contiguous()
+    orm = rend["orm"].permute(0, 3, 1, 2).contiguous()
+    pos = rend["pos"].permute(0, 3, 1, 2).contiguous()
+    normal = rend["normal"].permute(0, 3, 1, 2).contiguous()
+    depth = rend["depth"]
+    c2w = rend["c2w"]
+    scale = rend["scale"]
+    
+    V, _, H_raw, W_raw = albedo.shape
+    assert V == num_views, f"Expected {num_views} views, got {V}"
+    
+    # Normal in [-1, 1] for correspondence computation
+    normal_fullres = normal * 2.0 - 1.0
+    
+    # Mask from occupancy channel
+    mask = orm[:, 0, :, :] > 0.5
+    depth = depth.clone()
+    depth[~mask] = float("nan")
+    
+    # Position tokens via weighted averaging at token grid
+    pos_raw = pos - 0.5  # Convert to [-0.5, 0.5]
+    df = H_raw // token_hw
+    mask_f = mask.float().unsqueeze(1)
+    pos_sum = F.avg_pool2d(pos_raw * mask_f, kernel_size=df, stride=df, divisor_override=1)
+    cnt = F.avg_pool2d(mask_f, kernel_size=df, stride=df, divisor_override=1)
+    pos_token = (pos_sum / cnt.clamp_min(1.0)).to(device=device, dtype=dtype)
+    
+    # Resize and normalize to [-1, 1]
+    albedo_r = _resize_to_pm1(albedo, height=height, width=width)
+    orm_r = _resize_to_pm1(orm, height=height, width=width)
+    pos_r = _resize_to_pm1(pos, height=height, width=width)
+    normal_r = _resize_to_pm1(normal, height=height, width=width)
+    
+    # Condition values: position + normal (6 channels)
+    cond_values = torch.cat([pos_r, normal_r], dim=1)
+    
+    # World-to-camera transformation
+    w2c = torch.linalg.inv(c2w).to(device=device, dtype=dtype)
+    
+    corr_f2l = None
+    corr_f2l_highres = None
+    pos_delta = None
+
+    # Build correspondence pairs
+    corr_pairs = build_corr_pairs(
+        c2w, scale, depth, nor_w=normal_fullres.permute(0, 2, 3, 1),
+        depth_tol=0.01, angle_tol=10, angle_cam_tol=80,
+    )
+    
+    # High resolution correspondence for c-PSNR evaluation
+    corr_high = downscale_pairs_to_f2l(corr_pairs, out_hw=height, device=device)
+    corr_f2l_highres = corr_high.unsqueeze(0)  # (1, V*H*W, K) for later use
+    
+    # Downscale to token resolution
+    corr_low = downscale_pairs_to_f2l(corr_pairs, out_hw=token_hw, device=device)
+    for _ in range(corr_dilate_iterations):
+        corr_low = dilate_f2l(corr_low, V=num_views, out_hw=token_hw)
+    
+    # Convert to global indices (single batch)
+    corr_f2l = corr_low.unsqueeze(0)  # (1, Lq, K)
+    B, Lq, K = corr_f2l.shape
+    X = Lq
+    base = torch.arange(B, device=corr_f2l.device).view(B, 1, 1) * X
+    corr_f2l = torch.where(corr_f2l >= 0, corr_f2l + base, corr_f2l)
+    corr_f2l = corr_f2l.reshape(B * Lq, K)  # (M, K) where M = num_views * token_hw * token_hw
+    
+    # Compute position deltas
+    M = num_views * token_hw * token_hw
+    
+    # pos_token: (V, 3, token_hw, token_hw) -> (M, 3)
+    pos_w_flat = pos_token.view(num_views, 3, -1).permute(0, 2, 1).reshape(M, 3)  # (M, 3)
+    
+    # Get camera transforms for each query token
+    batch_ids = torch.arange(num_views, device=device).repeat_interleave(token_hw * token_hw)  # (M,)
+    
+    # Use identity matrix for global frame, or w2c for local query frame
+    if use_global_pos:
+        # Global frame: use identity matrix (no transformation)
+        Tq = torch.eye(4, device=device, dtype=w2c.dtype).unsqueeze(0).expand(M, -1, -1)  # (M, 4, 4)
+    else:
+        # Local query frame: use w2c transformation
+        Tq = w2c[batch_ids]  # (M, 4, 4)
+    
+    # Transform query positions to camera space
+    ones_M = torch.ones(M, 1, device=device, dtype=pos_w_flat.dtype)
+    pq_h = torch.cat([pos_w_flat, ones_M], dim=-1).unsqueeze(-1)  # (M, 4, 1)
+    pq_cam = (Tq @ pq_h).squeeze(-1)[..., :3]  # (M, 3)
+    
+    # Gather key positions and transform to camera space
+    gather_idx = corr_f2l.clamp(min=0, max=M - 1).reshape(-1)  # (M*K,)
+    pk_world = pos_w_flat.index_select(0, gather_idx).view(M, K, 3)  # (M, K, 3)
+    ones_MK = torch.ones(M, K, 1, device=device, dtype=pk_world.dtype)
+    pk_h = torch.cat([pk_world, ones_MK], dim=-1).unsqueeze(-1)  # (M, K, 4, 1)
+    pk_cam = (Tq[:, None, :, :] @ pk_h).squeeze(-1)[..., :3]  # (M, K, 3)
+    
+    # Compute delta
+    pos_delta = pk_cam - pq_cam[:, None, :]  # (M, K, 3)
+    
+    return {
+        "cond_values": cond_values,
+        "pos_token": pos_token,
+        "w2c": w2c,
+        "corr_f2l": corr_f2l,
+        "corr_f2l_highres": corr_f2l_highres,
+        "pos_delta": pos_delta,
+        "decoded_albedo": albedo_r,
+        "decoded_orm": orm_r,
+    }
+
+
+# =============================================================================
+# Main Inference Function (using pre-loaded models)
+# =============================================================================
+
+@torch.no_grad()
+def run_single(
+    mesh_path: str,
+    prompt: str,
+    output_dir: str,
+    context: InferenceContext,
+    *,
+    keep_strips: bool = False,
+    seed: int = 42,
+) -> str:
+    """Run inference on a single mesh using pre-loaded models from context.
+    
+    This function produces identical results to running inference.py individually,
+    but reuses models from the context to avoid repeated loading.
+    """
+    gid = Path(mesh_path).stem
+    settings = context.settings
+    
+    # Generate deterministic seed per mesh
+    hash_input = f"{gid}_{seed}".encode('utf-8')
+    combined_seed = int(hashlib.md5(hash_input).hexdigest(), 16) % (2**32)
+    seed_everything(combined_seed)
+
+    device = settings["device"]
+    dtype = settings["dtype"]
+    height = settings["resolution"]
+    width = settings["resolution"]
+    num_views = settings["num_views"]
+    token_hw = height // 16
+    use_caa = settings["use_caa"]
+    use_rope = settings["use_rope"]
+    use_global_token = settings["use_global_token"]
+    use_global_pos = settings.get("use_global_pos", False)
+    use_dual_branch = settings["use_dual_branch"]
+    branch_factor = 2 if use_dual_branch else 1
+
+    # Render and preprocess geometry
+    rend = render_views(mesh_path, num_views=num_views, height=height, width=width, device=device)
+    preprocessed = preprocess_geometry(
+        rend,
+        device=device,
+        dtype=dtype,
+        height=height,
+        width=width,
+        token_hw=token_hw,
+        num_views=num_views,
+        use_caa=use_caa,
+        corr_dilate_iterations=settings["corr_dilate_iterations"],
+        use_global_pos=use_global_pos,
+    )
+
+    # Encode conditions if needed
+    cond_latents = None
+    condition_channels = 0
+    if settings.get("condition_channels_cfg", 0) > 0:
+        cond_latents = context.encode_conditions(preprocessed["cond_values"])
+        condition_channels = cond_latents.shape[1]
+
+    # Encode text prompts using pre-loaded text context
+    text_embeds = context.encode_text_prompts(prompt, settings["negative_prompt"])
+
+    def _repeat_branch(tensor: Optional[torch.Tensor]) -> Optional[torch.Tensor]:
+        if tensor is None:
+            return None
+        first_dim = tensor.shape[0]
+        if first_dim == num_views:
+            tensor = tensor.reshape(1, num_views, *tensor.shape[1:])
+        elif first_dim == 1:
+            tensor = tensor.reshape(1, *tensor.shape[1:]).unsqueeze(1)
+        else:
+            return tensor
+        tensor = tensor.repeat(branch_factor, 1, *[1] * (tensor.dim() - 2))
+        return tensor.reshape(branch_factor * num_views, *tensor.shape[2:])
+
+    prompt_embeds = _repeat_branch(text_embeds["prompt_embeds"])
+    pooled_prompt_embeds = _repeat_branch(text_embeds["pooled_prompt_embeds"])
+    negative_prompt_embeds = _repeat_branch(text_embeds["negative_prompt_embeds"])
+    negative_pooled_prompt_embeds = _repeat_branch(text_embeds["negative_pooled_prompt_embeds"])
+    cond_latents_branch = _repeat_branch(cond_latents) if cond_latents is not None else None
+
+    # Prepare correspondence data for CAA
+    corr_lookups_branch = None
+    pos_delta_branch = None
+    if use_caa:
+        corr_f2l = preprocessed["corr_f2l"]
+        pos_delta = preprocessed["pos_delta"]
+        
+        if corr_f2l is not None and pos_delta is not None:
+            if use_dual_branch:
+                M, K = corr_f2l.shape
+                corr_branch_list = []
+                for b in range(branch_factor):
+                    corr_b = corr_f2l + (b * M)
+                    corr_branch_list.append(corr_b)
+                corr_lookups_branch = torch.cat(corr_branch_list, dim=0)
+                pos_delta_branch = pos_delta.repeat(branch_factor, 1, 1)
+            else:
+                corr_lookups_branch = corr_f2l
+                pos_delta_branch = pos_delta
+
+    # Generate latents using pre-loaded transformer
+    latents = generate_latents(
+        transformer=context.transformer,
+        noise_scheduler=context.scheduler,
+        prompt_embeds=prompt_embeds,
+        pooled_prompt_embeds=pooled_prompt_embeds,
+        negative_prompt_embeds=negative_prompt_embeds,
+        negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
+        height=height,
+        width=width,
+        num_inference_steps=settings["steps"],
+        guidance_scale=settings["guidance_scale"],
+        weight_dtype=dtype,
+        device=device,
+        condition_channels=condition_channels,
+        condition_latents=cond_latents_branch,
+        corr_lookups=corr_lookups_branch,
+        pos_delta=pos_delta_branch,
+        progress=True,
+    )
+
+    # Decode using pre-loaded VAE/mcVAE
+    inv = (latents / context.vae_scale) + context.vae_shift
+
+    if use_dual_branch:
+        decoded = context.vae.decode(inv.to(device=context.vae.device, dtype=context.vae.dtype)).sample
+        decoded = decoded.view(branch_factor, num_views, 3, height, width)
+        albedo_pred = decoded[0]
+        orm_pred_full = decoded[1]
+        combined = torch.cat([albedo_pred, orm_pred_full[:, 1:, :, :]], dim=1)
+        combined_flat = combined.reshape(num_views, 5, height, width)
+    else:
+        inv_mc = inv.to(device=context.mcvae.device, dtype=context.mcvae.dtype)
+        decoded = context.mcvae.decode_aug(inv_mc).sample
+        combined_flat = decoded.reshape(num_views, 5, height, width)
+        albedo_pred = combined_flat[:, :3]
+        orm_pred_full = combined_flat[:, 3:]
+
+    # Compute c-PSNR metrics
+    cpsnr_metrics = None
+    if preprocessed.get("corr_f2l_highres") is not None:
+        corr_high = preprocessed["corr_f2l_highres"]
+        
+        B, VHW, K = corr_high.shape
+        base = torch.arange(B, device=corr_high.device).view(B, 1, 1) * VHW
+        corr_high_global = torch.where(corr_high >= 0, corr_high + base, corr_high)
+        corr_high_global = corr_high_global.reshape(B * VHW, K)
+        
+        pred_rgb = combined_flat[:, :3].unsqueeze(0).squeeze(0)
+        pred_mr = combined_flat[:, 3:].unsqueeze(0).squeeze(0)
+        
+        albedo_psnr, _, num_elements = correspondence_psnr(pred_rgb, corr_high_global, data_range=2.0)
+        roughness_psnr, _, _ = correspondence_psnr(pred_mr[:, 0:1], corr_high_global, data_range=2.0)
+        metallic_psnr, _, _ = correspondence_psnr(pred_mr[:, 1:2], corr_high_global, data_range=2.0)
+        
+        pred_combined = combined_flat.unsqueeze(0).squeeze(0)
+        total_psnr, _, _ = correspondence_psnr(pred_combined, corr_high_global, data_range=2.0)
+        
+        cpsnr_metrics = {
+            "albedo": float(albedo_psnr.item()),
+            "roughness": float(roughness_psnr.item()),
+            "metallic": float(metallic_psnr.item()),
+            "total": float(total_psnr.item()),
+            "num_elements": num_elements,
+        }
+
+    dec_albedo = albedo_pred
+    if use_dual_branch:
+        dec_orm = torch.cat([
+            torch.full_like(orm_pred_full[:, :1], fill_value=-1.0),
+            orm_pred_full[:, 1:, :, :],
+        ], dim=1)
+    else:
+        dec_orm = torch.cat([
+            torch.full_like(combined_flat[:, :1], fill_value=-1.0),
+            combined_flat[:, (3, 4)],
+        ], dim=1)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Save or create temporary strips
+    if keep_strips:
+        albedo_path = os.path.join(output_dir, f"{gid}_albedo_strip.png")
+        orm_path = os.path.join(output_dir, f"{gid}_orm_strip.png")
+        pos = preprocessed["cond_values"][:, :3].clone()
+        normal = preprocessed["cond_values"][:, 3:].clone()
+        cond_values_path = os.path.join(output_dir, f"{gid}_cond_values_strip.png")
+        cond_values_strip = torch.cat([(pos + 1.0) * 0.5, (normal + 1.0) * 0.5], dim=0).to("cpu")
+        _save_strip(cond_values_strip, cond_values_path, nrow=2)
+    else:
+        albedo_fd, albedo_path = tempfile.mkstemp(suffix="_albedo_strip.png")
+        orm_fd, orm_path = tempfile.mkstemp(suffix="_orm_strip.png")
+        os.close(albedo_fd)
+        os.close(orm_fd)
+
+    dec_albedo_cpu = dec_albedo.detach().to("cpu")
+    dec_orm_cpu = dec_orm.detach().to("cpu")
+
+    _save_strip(dec_albedo_cpu, albedo_path)
+    _save_strip(dec_orm_cpu, orm_path)
+
+    # Unprojection
+    unproj_backend = settings.get("unproj_backend", "mvadapter")
+    
+    if unproj_backend == "materialmvp":
+        # Use pre-loaded unprojection context
+        albedo_strip_img = Image.open(albedo_path)
+        orm_strip_img = Image.open(orm_path)
+        
+        strip_width = albedo_strip_img.width
+        strip_height = albedo_strip_img.height
+        view_width = strip_width // num_views
+        
+        albedo_views = []
+        mr_views = []
+        
+        for i in range(num_views):
+            left = i * view_width
+            right = (i + 1) * view_width
+            
+            albedo_view = albedo_strip_img.crop((left, 0, right, strip_height))
+            albedo_views.append(albedo_view)
+            
+            orm_view = orm_strip_img.crop((left, 0, right, strip_height))
+            mr_views.append(orm_view)
+        
+        output_path = context.unproj_ctx.unproject_with_materialmvp(
+            mesh_path=mesh_path,
+            output_dir=output_dir,
+            gid=gid,
+            albedo_images=albedo_views,
+            mr_images=mr_views,
+            bake_exp=2,
+        )
+        
+        if not keep_strips:
+            for path in (albedo_path, orm_path):
+                if path and os.path.exists(path):
+                    try:
+                        os.remove(path)
+                    except OSError:
+                        pass
+    
+    else:  # mvadapter (default)
+        try:
+            result = context.tex_pipeline(
+                mesh_path=mesh_path,
+                save_dir=output_dir,
+                save_name=gid,
+                uv_unwarp=True,
+                preprocess_mesh=False,
+                move_to_center=True,
+                uv_size=settings["uv_size"],
+                base_color_path=albedo_path,
+                orm_path=orm_path,
+                base_color_process_config=ModProcessConfig(view_upscale=True, inpaint_mode="view"),
+                orm_process_config=ModProcessConfig(view_upscale=True, inpaint_mode="view"),
+                camera_elevation_deg=ELEV_DEG,
+                camera_azimuth_deg=AZIM_DEG,
+            )
+            output_path = result.pbr_model_save_path
+        finally:
+            if not keep_strips:
+                for path in (albedo_path, orm_path):
+                    if path and os.path.exists(path):
+                        try:
+                            os.remove(path)
+                        except OSError:
+                            pass
+
+    # Save c-PSNR metrics
+    if cpsnr_metrics is not None:
+        cpsnr_json_path = os.path.join(output_dir, "cpsnr.json")
+        _update_cpsnr_json(cpsnr_json_path, gid, cpsnr_metrics)
+
+    return output_path
+
+
+# =============================================================================
+# Batch Processing
+# =============================================================================
+
+def run_batch(
+    mesh_paths: List[str],
+    prompts: List[str],
+    output_dir: str,
+    settings: Dict[str, Any],
+    *,
+    keep_strips: bool = False,
+    seed: int = 42,
+) -> List[str]:
+    """Process multiple mesh-prompt pairs efficiently.
+    
+    Models are loaded once and reused for all pairs.
+    
+    Args:
+        mesh_paths: List of paths to input meshes
+        prompts: List of text prompts (must match length of mesh_paths)
+        output_dir: Output directory for all results
+        settings: Inference settings dictionary
+        keep_strips: Whether to keep intermediate strip images
+        seed: Base random seed
+        
+    Returns:
+        List of output GLB paths
+    """
+    if len(mesh_paths) != len(prompts):
+        raise ValueError(f"Number of meshes ({len(mesh_paths)}) must match number of prompts ({len(prompts)})")
+    
+    print(f"Starting batch inference for {len(mesh_paths)} mesh-prompt pairs...")
+    print(f"Loading models once for reuse...")
+    
+    # Initialize context with all pre-loaded models
+    context = InferenceContext(settings)
+    
+    print(f"✓ Models loaded successfully")
+    print()
+    
+    output_paths = []
+    
+    for idx, (mesh_path, prompt) in enumerate(zip(mesh_paths, prompts), 1):
+        print(f"[{idx}/{len(mesh_paths)}] Processing: {Path(mesh_path).name}")
+        print(f"  Prompt: {prompt}")
+        
+        try:
+            output_path = run_single(
+                mesh_path=mesh_path,
+                prompt=prompt,
+                output_dir=output_dir,
+                context=context,
+                keep_strips=keep_strips,
+                seed=seed,
+            )
+            output_paths.append(output_path)
+            print(f"  ✓ Saved: {output_path}")
+        except Exception as e:
+            print(f"  ✗ Error: {e}")
+            output_paths.append(None)
+        
+        print()
+    
+    # Summary
+    successful = sum(1 for p in output_paths if p is not None)
+    print(f"Batch processing complete: {successful}/{len(mesh_paths)} successful")
+    
+    return output_paths
+
+
+def build_inference_settings(args, cfg) -> Dict[str, Any]:
+    """Build inference settings from config file and CLI overrides."""
+    model_cfg = cfg.model
+    
+    # Apply CLI argument overrides
+    if args.num_views is not None:
+        model_cfg.num_views = args.num_views
+    if args.resolution is not None:
+        model_cfg.resolution = args.resolution
+    if args.sd_vae_path is not None:
+        model_cfg.sd_vae_path = args.sd_vae_path
+    if args.mcvae_config is not None:
+        model_cfg.mcvae_config = args.mcvae_config
+    if args.mcvae_ckpt is not None:
+        model_cfg.mcvae_ckpt = args.mcvae_ckpt
+
+    dtype_map = {
+        "fp16": torch.float16,
+        "bf16": torch.bfloat16,
+        "fp32": torch.float32,
+    }
+    dtype = dtype_map.get(args.precision.lower(), DTYPE)
+
+    settings = {
+        "device": args.device,
+        "dtype": dtype,
+        "resolution": int(model_cfg.resolution),
+        "num_views": int(model_cfg.num_views),
+        "use_caa": bool(getattr(model_cfg, "use_caa", True)),
+        "use_rope": bool(getattr(model_cfg, "use_rope", False)),
+        "use_global_token": bool(getattr(model_cfg, "use_global_token", False)),
+        "use_global_pos": bool(getattr(model_cfg, "use_global_pos", False)),
+        "use_dual_branch": bool(getattr(model_cfg, "use_dual_branch", False)),
+        "corr_dilate_iterations": int(getattr(model_cfg, "corr_dilate_iterations", 2)),
+        "condition_channels_cfg": int(getattr(model_cfg, "condition_channels", 0)),
+        "base_model": model_cfg.pretrained_model_name_or_path,
+        "model_cfg": model_cfg,
+        "weights_path": args.weights or TRANSFORMER_PARTIAL_WEIGHTS,
+        "sd_vae_path": model_cfg.sd_vae_path,
+        "mcvae_config_path": model_cfg.mcvae_config,
+        "mcvae_ckpt_path": model_cfg.mcvae_ckpt or MCVAE_CKPT_PATH,
+        "mcvae_offset_mode": bool(getattr(model_cfg, "mcvae_offset_mode", True)),
+        "negative_prompt": args.negative_prompt,
+        "steps": args.steps,
+        "guidance_scale": args.guidance,
+        "realesrgan_ckpt": args.realesrgan_ckpt,
+        "lama_ckpt": args.lama_ckpt,
+        "uv_size": args.uv_size,
+        "unproj_backend": args.unproj_backend,
+        "config": cfg,
+    }
+
+    return settings
+
+
+# =============================================================================
+# CLI Entry Point
+# =============================================================================
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Batch Mesh + Prompt → Textured GLB (efficient multi-sample processing)",
+        epilog="""
+Examples:
+  # Single mesh-prompt pair (same as inference.py)
+  python inference_list.py --mesh model.glb --prompt "wooden chair"
+  
+  # Multiple mesh-prompt pairs
+  python inference_list.py --mesh 1.glb 2.glb 3.glb --prompt "p1" "p2" "p3"
+  
+Additional config overrides can be provided as key=value arguments:
+  python inference_list.py --mesh a.glb b.glb --prompt "p1" "p2" model.num_views=8
+        """
+    )
+    parser.add_argument("--mesh", nargs="+", required=True, help="Path(s) to input mesh(es) (.glb or .obj)")
+    parser.add_argument("--prompt", nargs="+", required=True, help="Text prompt(s) for texture generation (must match number of meshes)")
+    parser.add_argument("--out", default="./temp_outputs", help="Output directory")
+    parser.add_argument("--keep-strips", action="store_true", help="Keep intermediate albedo/ORM strip images")
+    parser.add_argument("--guidance", type=float, default=GUIDANCE, help=f"Guidance scale (default: {GUIDANCE})")
+    parser.add_argument("--steps", type=int, default=STEPS, help=f"Number of denoising steps (default: {STEPS})")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed (default: 42)")
+    parser.add_argument("--negative-prompt", default=NEGATIVE_PROMPT, help="Negative prompt text")
+    parser.add_argument("--device", default=DEVICE, help="Torch device to run inference on")
+    parser.add_argument("--precision", default="fp16", choices=["fp16", "bf16", "fp32"], help="Computation precision")
+    parser.add_argument("--num-views", type=int, default=None, help="Override number of camera views")
+    parser.add_argument("--resolution", type=int, default=None, help="Override render resolution")
+    parser.add_argument("--sd-vae-path", default=None, help="Override base SD VAE path")
+    parser.add_argument("--mcvae-config", default=None, help="Override mcVAE config path")
+    parser.add_argument("--mcvae-ckpt", default=None, help="Override mcVAE checkpoint path")
+    parser.add_argument("--weights", default=None, help="Path to trained transformer weights (dir or file)")
+    parser.add_argument("--realesrgan-ckpt", default="./checkpoints/RealESRGAN_x2plus.pth", help="RealESRGAN checkpoint path")
+    parser.add_argument("--lama-ckpt", default="./checkpoints/big-lama.pt", help="LaMa inpainting checkpoint path")
+    parser.add_argument("--uv-size", type=int, default=4096, help="Final UV texture resolution")
+    parser.add_argument("--config", default="configs/mcdiff/default.yaml", help="Config file (supports base-variant inheritance)")
+    parser.add_argument("--unproj-backend", default="mvadapter", choices=["mvadapter", "materialmvp"], 
+                        help="Unprojection backend")
+    
+    args, unknown = parser.parse_known_args()
+    
+    # Validate mesh and prompt counts match
+    if len(args.mesh) != len(args.prompt):
+        parser.error(f"Number of --mesh arguments ({len(args.mesh)}) must match number of --prompt arguments ({len(args.prompt)})")
+    
+    # Load config
+    cfg = load_config(args.config, cli_overrides=unknown)
+    
+    # Build settings
+    settings = build_inference_settings(args, cfg)
+
+    # Run batch processing
+    output_paths = run_batch(
+        mesh_paths=args.mesh,
+        prompts=args.prompt,
+        output_dir=args.out,
+        settings=settings,
+        keep_strips=args.keep_strips,
+        seed=args.seed,
+    )
+    
+    print("\n" + "="*60)
+    print("Final Results:")
+    print("="*60)
+    for mesh_path, prompt, output_path in zip(args.mesh, args.prompt, output_paths):
+        status = "✓" if output_path else "✗"
+        print(f"{status} {Path(mesh_path).name}")
+        if output_path:
+            print(f"  → {output_path}")
+    print("="*60)
+
+
+'''
+# Single mesh (backward compatible with inference.py)
+python inference_list.py \
+--mesh /home/aaaaa/data/Arb-Objaverse/data/glb/000-132/21ec37b286474fedb43307f6f289269e.glb \
+--prompt "A wooden stool with a pink cushion" \
+--config configs/mcdiff/single_caa.yaml \
+--weights outputs/mcdiff_v.single_caa/checkpoint-35000/transformer/diffusion_pytorch_model.safetensors \
+--out temp_outputs_list
+
+# Multiple meshes (efficient batch processing)
+python inference_list.py \
+--mesh mesh1.glb mesh2.glb mesh3.glb \
+--prompt "prompt 1" "prompt 2" "prompt 3" \
+--config configs/mcdiff/single_caa.yaml \
+--weights outputs/mcdiff_v.single_caa/checkpoint-35000/transformer/diffusion_pytorch_model.safetensors \
+--out temp_outputs_list_batch
+'''