#!/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()