update

DDJ_real2render/create_grid_template.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import sys
+
+import numpy as np
+from PIL import Image, ImageColor
+
+try:
+    from .create_template import VIEW_NAMES, parse_bg_color, resolve_renderer_path
+except ImportError:
+    from create_template import VIEW_NAMES, parse_bg_color, resolve_renderer_path
+
+
+DEFAULT_SIZE = "344x768"
+
+
+def parse_rgb_color(color):
+    if isinstance(color, str):
+        return ImageColor.getrgb(color)
+    if isinstance(color, (tuple, list)) and len(color) >= 3:
+        return tuple(int(channel) for channel in color[:3])
+    raise ValueError(f"Invalid RGB color: {color!r}")
+
+
+def render_visible_grid(mapping_path, skin_alpha, fill_color, grid_color):
+    import torch
+
+    mapping = torch.load(mapping_path, map_location="cpu")
+    required_keys = ("geometry_uv_layers", "geometry_masks", "geometry_sort_indices")
+    missing_keys = [key for key in required_keys if key not in mapping]
+    if missing_keys:
+        raise KeyError(
+            f"Geometry visibility data missing from {mapping_path}: {', '.join(missing_keys)}"
+        )
+
+    geometry_uv = mapping["geometry_uv_layers"].cpu().numpy()
+    geometry_masks = mapping["geometry_masks"].cpu().numpy().astype(bool)
+    sort_indices = mapping["geometry_sort_indices"].cpu().numpy().astype(np.intp)
+    if geometry_uv.shape[0] == 0:
+        raise ValueError(f"No geometry layers found in mapping: {mapping_path}")
+
+    layer_count, height, width = geometry_masks.shape
+    u = geometry_uv[..., 0].astype(np.intp)
+    v = geometry_uv[..., 1].astype(np.intp)
+    valid_uv = (u >= 0) & (u < 64) & (v >= 0) & (v < 64)
+    safe_u = np.clip(u, 0, 63)
+    safe_v = np.clip(v, 0, 63)
+    layer_visible = geometry_masks & valid_uv & (skin_alpha[safe_v, safe_u] > 0)
+
+    # The sort order is back-to-front, matching DifferentiableRenderer's
+    # compositing order. Pick only the nearest visible geometry at every pixel.
+    sorted_visible = np.take_along_axis(layer_visible, sort_indices, axis=0)
+    has_visible_surface = sorted_visible.any(axis=0)
+    nearest_from_front = np.argmax(sorted_visible[::-1], axis=0)
+    nearest_position = layer_count - 1 - nearest_from_front
+    nearest_geometry = np.take_along_axis(
+        sort_indices,
+        nearest_position[np.newaxis, ...],
+        axis=0,
+    )[0]
+
+    rows, columns = np.indices((height, width))
+    selected_u = u[nearest_geometry, rows, columns]
+    selected_v = v[nearest_geometry, rows, columns]
+
+    # A grid edge is a boundary between visible UV texels/geometries, or the
+    # silhouette between visible geometry and the transparent background.
+    grid_edges = np.zeros((height, width), dtype=bool)
+
+    left_visible = has_visible_surface[:, :-1]
+    right_visible = has_visible_surface[:, 1:]
+    horizontal_change = (left_visible != right_visible) | (
+        left_visible
+        & right_visible
+        & (
+            (nearest_geometry[:, :-1] != nearest_geometry[:, 1:])
+            | (selected_u[:, :-1] != selected_u[:, 1:])
+            | (selected_v[:, :-1] != selected_v[:, 1:])
+        )
+    )
+    grid_edges[:, :-1] |= horizontal_change & left_visible
+    grid_edges[:, 1:] |= horizontal_change & ~left_visible & right_visible
+
+    top_visible = has_visible_surface[:-1, :]
+    bottom_visible = has_visible_surface[1:, :]
+    vertical_change = (top_visible != bottom_visible) | (
+        top_visible
+        & bottom_visible
+        & (
+            (nearest_geometry[:-1, :] != nearest_geometry[1:, :])
+            | (selected_u[:-1, :] != selected_u[1:, :])
+            | (selected_v[:-1, :] != selected_v[1:, :])
+        )
+    )
+    grid_edges[:-1, :] |= vertical_change & top_visible
+    grid_edges[1:, :] |= vertical_change & ~top_visible & bottom_visible
+
+    grid_edges[0, :] |= has_visible_surface[0, :]
+    grid_edges[-1, :] |= has_visible_surface[-1, :]
+    grid_edges[:, 0] |= has_visible_surface[:, 0]
+    grid_edges[:, -1] |= has_visible_surface[:, -1]
+
+    output = np.zeros((height, width, 4), dtype=np.uint8)
+    output[has_visible_surface, :3] = fill_color
+    output[has_visible_surface, 3] = 255
+    output[grid_edges, :3] = grid_color
+    output[grid_edges, 3] = 255
+    return Image.fromarray(output, mode="RGBA")
+
+
+def create_grid_template(
+    skin_path,
+    output_path,
+    renderer_path,
+    size=DEFAULT_SIZE,
+    bg_color="black",
+    fill_color="white",
+    grid_color="black",
+):
+    """Render four visible-surface Minecraft texel grids into one horizontal image."""
+    if not os.path.exists(skin_path):
+        raise FileNotFoundError(f"Skin image '{skin_path}' does not exist.")
+
+    dmr_path = resolve_renderer_path(renderer_path)
+    if dmr_path not in sys.path:
+        sys.path.insert(0, dmr_path)
+
+    from config import parse_sizes
+
+    if isinstance(size, str):
+        target_size = parse_sizes(size)[0]
+    elif isinstance(size, (tuple, list)) and len(size) == 2:
+        target_size = (int(size[0]), int(size[1]))
+    else:
+        target_size = tuple(int(value) for value in DEFAULT_SIZE.split("x"))
+
+    skin_img = Image.open(skin_path).convert("RGBA")
+    if skin_img.size != (64, 64):
+        raise ValueError(
+            f"Minecraft grid rendering requires a 64x64 skin, "
+            f"got {skin_img.size[0]}x{skin_img.size[1]}."
+        )
+
+    skin_np = np.array(skin_img)
+    alpha = skin_np[..., 3]
+    semi_transparent = (alpha > 0) & (alpha < 255)
+    skin_np[semi_transparent, 3] = 255
+
+    fill_rgb = parse_rgb_color(fill_color)
+    grid_rgb = parse_rgb_color(grid_color)
+    mappings_dir = os.path.join(dmr_path, f"mappings_{target_size[0]}x{target_size[1]}")
+    if not os.path.isdir(mappings_dir):
+        raise FileNotFoundError(
+            f"Differentiable renderer mappings not found for size "
+            f"{target_size[0]}x{target_size[1]}: {mappings_dir}"
+        )
+
+    rendered_images = []
+    for view_name in VIEW_NAMES:
+        print(f"Rendering visible grid view: {view_name} (Size: {target_size})...")
+        mapping_path = os.path.join(mappings_dir, f"{view_name}_mapping.pt")
+        if not os.path.isfile(mapping_path):
+            raise FileNotFoundError(f"View mapping not found: {mapping_path}")
+        rendered_image = render_visible_grid(
+            mapping_path=mapping_path,
+            skin_alpha=skin_np[..., 3],
+            fill_color=fill_rgb,
+            grid_color=grid_rgb,
+        )
+        if rendered_image.size != target_size:
+            raise ValueError(
+                f"Mapping size for {view_name} is {rendered_image.size}, expected {target_size}."
+            )
+        rendered_images.append(rendered_image)
+
+    widths, heights = zip(*(image.size for image in rendered_images))
+    merged_img = Image.new("RGBA", (sum(widths), max(heights)))
+    x_offset = 0
+    for image in rendered_images:
+        merged_img.paste(image, (x_offset, 0))
+        x_offset += image.width
+
+    parsed_bg = parse_bg_color(bg_color)
+    if parsed_bg is not None:
+        background = Image.new("RGBA", merged_img.size, parsed_bg)
+        merged_img = Image.alpha_composite(background, merged_img)
+
+    output_dir = os.path.dirname(os.path.abspath(output_path))
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    merged_img.save(output_path)
+    print(f"Successfully generated grid template: {output_path} (Size: {merged_img.size})")
+    return output_path
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Create a horizontal visible-surface grid for the front-left, "
+            "front-right, back-left, and back-right Minecraft views."
+        )
+    )
+    parser.add_argument(
+        "--skin",
+        "--skin_path",
+        dest="skin_path",
+        required=True,
+        help="Path to the input 64x64 Minecraft skin.",
+    )
+    parser.add_argument(
+        "--output",
+        "--output_path",
+        dest="output_path",
+        required=True,
+        help="Path to save the merged grid image.",
+    )
+    parser.add_argument(
+        "--renderer_path",
+        "--renderer",
+        dest="renderer_path",
+        required=True,
+        help="Path to the differentiable_minecraft_renderer directory.",
+    )
+    parser.add_argument(
+        "--size",
+        "--resolution",
+        default=DEFAULT_SIZE,
+        help=(
+            f"Resolution per view (default: {DEFAULT_SIZE}; four horizontal "
+            "views produce 1376x768)."
+        ),
+    )
+    parser.add_argument(
+        "--bg_color",
+        "--bg-color",
+        "--background",
+        dest="bg_color",
+        default="black",
+        help="Output background color (default: black); use 'transparent' for transparency.",
+    )
+    parser.add_argument(
+        "--fill_color",
+        "--fill-color",
+        dest="fill_color",
+        default="white",
+        help="Visible surface fill color behind the black grid (default: white).",
+    )
+    parser.add_argument(
+        "--grid_color",
+        "--grid-color",
+        dest="grid_color",
+        default="black",
+        help="Grid line color (default: black).",
+    )
+
+    args = parser.parse_args()
+    create_grid_template(
+        skin_path=args.skin_path,
+        output_path=args.output_path,
+        renderer_path=args.renderer_path,
+        size=args.size,
+        bg_color=args.bg_color,
+        fill_color=args.fill_color,
+        grid_color=args.grid_color,
+    )
+
+
+if __name__ == "__main__":
+    main()

DDJ_real2render/create_template.py

@@ -2,10 +2,12 @@
 import os
 import sys
 import argparse
-from pathlib import Path
 from PIL import Image
 import numpy as np
 
+VIEW_NAMES = ("front_left", "front_right", "back_left", "back_right")
+
+
 def resolve_renderer_path(renderer_path):
     if not renderer_path or not os.path.exists(renderer_path):
         raise FileNotFoundError(f"Renderer directory '{renderer_path}' does not exist.")
@@ -26,15 +28,15 @@ def parse_bg_color(bg_color):
         return bg_color
     return bg_color
 
-def create_template(skin_path, output_path, renderer_path, size="512x1024", bg_color="black"):
+def create_template(skin_path, output_path, renderer_path, size="256x576", bg_color="black"):
     """
-    Renders front1 and back1 views for a given skin
-    using PyVista, merges them horizontally, adds background color, and saves the result to output_path.
+    Renders front-left, front-right, back-left, and back-right views for a given
+    skin using the differentiable renderer, then merges them into one horizontal image.
 
     :param skin_path: Path to the input skin PNG image.
     :param output_path: Destination path for the merged output template image.
     :param renderer_path: Path to differentiable_minecraft_renderer directory (required).
-    :param size: Resolution tuple (W, H) or string (e.g. "512x1024"). Default is "512x1024".
+    :param size: Resolution tuple (W, H) or string (e.g. "256x576"). Default is "256x576".
     :param bg_color: Background color for the output template image (default: "black"). Set to None or "transparent" for transparent background.
     :return: Path to generated output file.
     """
@@ -45,12 +47,9 @@ def create_template(skin_path, output_path, renderer_path, size="512x1024", bg_c
     if dmr_path not in sys.path:
         sys.path.insert(0, dmr_path)
 
-    from mc_skin_utils import mc_render
-    from config import get_views, walk_rot, static_rot, walk_offset, static_offset, parse_sizes
-    try:
-        from merge_views import merge
-    except ImportError:
-        merge = None
+    import torch
+    from config import parse_sizes
+    from differentiable_renderer import DifferentiableRenderer
 
     if isinstance(size, str):
         parsed = parse_sizes(size)
@@ -58,60 +57,70 @@ def create_template(skin_path, output_path, renderer_path, size="512x1024", bg_c
     elif isinstance(size, (tuple, list)) and len(size) == 2:
         target_size = (int(size[0]), int(size[1]))
     else:
-        target_size = (512, 1024)
+        target_size = (256, 576)
 
     print(f"Loading skin image from: {skin_path}")
     skin_img = Image.open(skin_path).convert("RGBA")
     skin_np = np.array(skin_img)
 
+    if skin_img.size != (64, 64):
+        raise ValueError(
+            f"DifferentiableRenderer requires a 64x64 skin, got {skin_img.size[0]}x{skin_img.size[1]}."
+        )
+
     # Clean semi-transparency to match build_target_img preprocessing
     alpha = skin_np[..., 3]
     semi_transparent = (alpha > 0) & (alpha < 255)
     skin_np[semi_transparent, 3] = 255
-    clean_skin_img = Image.fromarray(skin_np)
-
-    views_config = get_views(target_size)
-
-    view_names = ["front1", "back1"]
-    rendered_images = {}
-
-    for view_name in view_names:
-        if view_name not in views_config:
-            raise KeyError(f"View '{view_name}' not found in renderer config.")
-        params = views_config[view_name]
-        rot_args = walk_rot if params["walk"] else static_rot
-        offset_args = walk_offset if params["walk"] else static_offset
-
-        print(f"Rendering view with PyVista: {view_name} (Size: {params['output_size']})...")
-        pv_render = mc_render.render_skin(
-            skin=clean_skin_img,
-            output_size=params["output_size"],
-            cam_front=params["cam_front"],
-            zoom=params["zoom"],
-            look_at_y=params["look_at_y"],
-            use_voxels=False,
-            light=False,
-            transparent_background=True,
-            core_display=params["core_display"],
-            decor_display=params["decor_display"],
-            rot_args=rot_args,
-            offset_args=offset_args,
-            ortho=params.get("ortho", False),
-            off_screen=True
+    skin_tensor = (
+        torch.from_numpy(skin_np)
+        .permute(2, 0, 1)
+        .unsqueeze(0)
+        .to(dtype=torch.float32)
+        / 255.0
+    )
+
+    mappings_dir = os.path.join(dmr_path, f"mappings_{target_size[0]}x{target_size[1]}")
+    if not os.path.isdir(mappings_dir):
+        raise FileNotFoundError(
+            f"Differentiable renderer mappings not found for size "
+            f"{target_size[0]}x{target_size[1]}: {mappings_dir}"
         )
-        rendered_images[view_name] = Image.fromarray(pv_render)
 
-    front_img = rendered_images["front1"]
-    back_img = rendered_images["back1"]
+    renderer = DifferentiableRenderer(mappings_dir=mappings_dir, bg_color=(0.0, 0.0, 0.0))
+    missing_views = [view_name for view_name in VIEW_NAMES if view_name not in renderer.views]
+    if missing_views:
+        raise KeyError(
+            f"Views missing from renderer mappings: {', '.join(missing_views)}. "
+            f"Available views: {', '.join(renderer.views)}"
+        )
 
-    if merge is not None:
-        merged_img = merge(front_img, back_img, direction="horizontal")
-    else:
-        w1, h1 = front_img.size
-        w2, h2 = back_img.size
-        merged_img = Image.new("RGBA", (w1 + w2, max(h1, h2)))
-        merged_img.paste(front_img, (0, 0))
-        merged_img.paste(back_img, (w1, 0))
+    rendered_images = []
+    with torch.inference_mode():
+        for view_name in VIEW_NAMES:
+            print(
+                f"Rendering view with DifferentiableRenderer: {view_name} "
+                f"(Size: {target_size})..."
+            )
+            rendered = renderer.forward_view(skin_tensor, view_name)
+            rendered_np = (
+                rendered.squeeze(0)
+                .permute(1, 2, 0)
+                .clamp(0.0, 1.0)
+                .mul(255.0)
+                .round()
+                .to(torch.uint8)
+                .cpu()
+                .numpy()
+            )
+            rendered_images.append(Image.fromarray(rendered_np, mode="RGBA"))
+
+    widths, heights = zip(*(image.size for image in rendered_images))
+    merged_img = Image.new("RGBA", (sum(widths), max(heights)))
+    x_offset = 0
+    for image in rendered_images:
+        merged_img.paste(image, (x_offset, 0))
+        x_offset += image.width
 
     parsed_bg = parse_bg_color(bg_color)
     if parsed_bg is not None:
@@ -128,12 +137,20 @@ def create_template(skin_path, output_path, renderer_path, size="512x1024", bg_c
 
 def main():
     parser = argparse.ArgumentParser(
-        description="Create merged front & back orthographic reference template image from a Minecraft skin."
+        description=(
+            "Create a horizontal front-left, front-right, back-left, and back-right "
+            "16:9 reference template using the differentiable renderer."
+        )
     )
     parser.add_argument("--skin", "--skin_path", dest="skin_path", required=True, help="Path to input skin image file.")
     parser.add_argument("--output", "--output_path", dest="output_path", required=True, help="Path to save the merged output template image.")
     parser.add_argument("--renderer_path", "--renderer", dest="renderer_path", required=True, help="Path to differentiable_minecraft_renderer directory.")
-    parser.add_argument("--size", "--resolution", default="512x1024", help="Resolution per view (default: 512x1024).")
+    parser.add_argument(
+        "--size",
+        "--resolution",
+        default="344x768",
+        help="Resolution per view (default: 344x768; four horizontal views produce 1376x768).",
+    )
     parser.add_argument("--bg_color", "--bg-color", "--background", dest="bg_color", default="black", help="Background color for the output template image (default: black). Set to 'none' or 'transparent' for transparency.")
 
     args = parser.parse_args()

DDJ_real2render/real2render.py

@@ -12,7 +12,7 @@ DEFAULT_TEMPLATE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)),
 # Default prompt for real-to-render Minecraft character generation
 DEFAULT_PROMPT = """生成[图1]中角色的Minecraft形象
 
-- 人物模型必须与minecraft的玩家模型相同，且为包含内层/外层贴图的双图层模型，不能有额外元素。texture不能高于Minecraft所支持的分辨率。模型参考[图2]和[图3]
+- 人物模型必须与minecraft的玩家模型相同，且为包含内层/外层贴图的双图层模型，不能有额外元素。texture不能高于Minecraft所支持的分辨率。模型参考[图2]
 
 - 生成的minecraft角色的尺寸、朝向、姿势与[图2]完全一致，且必须包含正面图与背面图，并排放置。
 
@@ -73,10 +73,10 @@ def main():
     parser.add_argument("-t2", "--template2", default=None, help="Path to second reference template image (Graph 3).")
     parser.add_argument("-o", "--output", help="Output path for the generated image.")
     parser.add_argument("-p", "--prompt", default=DEFAULT_PROMPT, help="Prompt for image generation.")
-    parser.add_argument("-a", "--aspect-ratio", default="1:1", 
+    parser.add_argument("-a", "--aspect-ratio", default="16:9", 
                         choices=["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"], 
-                        help="Aspect ratio (default: 1:1).")
-    parser.add_argument("-s", "--image-size", default="1K", choices=["1K", "2K", "4K"], help="Resolution size (default: 1K).")
+                        help="Aspect ratio.")
+    parser.add_argument("-s", "--image-size", default="2K", choices=["1K", "2K", "4K"], help="Resolution size (default: 2K).")
     args = parser.parse_args()
 
     try: