#!/usr/bin/env python3 import os import sys import argparse 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.") return os.path.abspath(renderer_path) def parse_bg_color(bg_color): if bg_color is None: return None if isinstance(bg_color, str): cleaned = bg_color.strip().lower() if cleaned in ("none", "transparent", ""): return None if cleaned.startswith("(") and cleaned.endswith(")"): cleaned = cleaned[1:-1] if "," in cleaned: parts = [int(p.strip()) for p in cleaned.split(",")] return tuple(parts) return bg_color return bg_color def create_template(skin_path, output_path, renderer_path, size="256x576", bg_color="black"): """ 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. "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. """ 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) import torch from config import parse_sizes from differentiable_renderer import DifferentiableRenderer if isinstance(size, str): parsed = parse_sizes(size) target_size = parsed[0] elif isinstance(size, (tuple, list)) and len(size) == 2: target_size = (int(size[0]), int(size[1])) else: 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 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}" ) 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)}" ) 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: bg = Image.new("RGBA", merged_img.size, parsed_bg) merged_img = Image.alpha_composite(bg, merged_img) out_dir = os.path.dirname(os.path.abspath(output_path)) if out_dir: os.makedirs(out_dir, exist_ok=True) merged_img.save(output_path) print(f"Successfully generated merged template: {output_path} (Size: {merged_img.size})") return output_path def main(): parser = argparse.ArgumentParser( 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="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() create_template( skin_path=args.skin_path, output_path=args.output_path, renderer_path=args.renderer_path, size=args.size, bg_color=args.bg_color, ) if __name__ == "__main__": main()