v73

.gitignore

@@ -0,0 +1,2 @@
+preserved
+__pycache__

alice_to_steve.py

@@ -0,0 +1,18 @@
+from PIL import Image
+
+def alice_to_steve(alice):
+    for arm_loc, decor_offset in [((40, 16), (0,16)), ((32,48),(16,0))]:
+        for (size, loc, offset_x) in [
+            # Top and bottom
+            ((5,4),(arm_loc[0]+4+1, arm_loc[1]), 1),# Duplicate the middle pixel once
+            ((2,4),(arm_loc[0]+4+4+1, arm_loc[1]), 1),
+
+            # Front and back
+            ((9,12),(arm_loc[0]+4+1, arm_loc[1]+4), 1),
+            ((2,12),(arm_loc[0]+4+4+4+1, arm_loc[1]+4), 1),
+        ]:
+            for x in range(loc[0]+size[0]-1, loc[0]-1, -1):
+                for y in range(loc[1], loc[1]+size[1]):
+                    alice.putpixel((x+offset_x, y), alice.getpixel((x, y)))
+                    alice.putpixel((x+offset_x+decor_offset[0], y+decor_offset[1]), alice.getpixel((x+decor_offset[0], y+decor_offset[1])))
+    return alice

build_target_img.py

@@ -0,0 +1,300 @@
+import argparse
+import uuid
+import concurrent.futures
+from alice_to_steve import alice_to_steve
+from PIL import Image
+import os
+import numpy as np
+import asyncio
+import mc_render
+import random
+from mc_voxel_texture_resolver import resolve_voxel_consistency
+
+SCALING_RATIO = 12
+
+IMAGE_WIDTH  = 768
+IMAGE_HEIGHT = 768
+
+SCALING_RATIO = 12*IMAGE_HEIGHT/768
+
+SKIN_MASK = "skin-mask.png"
+SKIN_DECOR_MASK = "skin-decor-mask.png"
+
+bg = (128,128,128)
+
+def create_mask():
+    if os.path.exists(SKIN_MASK) and os.path.exists(SKIN_DECOR_MASK):
+        return
+
+    # 64*64
+
+    mask = Image.new('RGBA', (64, 64), (0, 0, 0, 0))
+    decor_mask = Image.new('RGBA', (64, 64), (0, 0, 0, 0))
+    for (size, offset, decor_offset) in [
+        # head
+        [(8,8),(0,8),(32,0)],
+        [(8,8),(8,8),(32,0)],
+        [(8,8),(8,0),(32,0)],
+        [(8,8),(16,8),(32,0)],
+        [(8,8),(16,0),(32,0)],
+        [(8,8),(24,8),(32,0)],
+
+        #left arm
+        [(4,12),(32,52),(16,0)],
+        [(4,12),(32+4,52),(16,0)],
+        [(4,12),(32+8,52),(16,0)],
+        [(4,12),(32+12,52),(16,0)],
+        [(4,4),(32+4,48),(16,0)],
+        [(4,4),(32+8,48),(16,0)],
+
+        #right arm
+        [(4,12),(40,20),(0,16)],
+        [(4,12),(40+4,20),(0,16)],
+        [(4,12),(40+8,20),(0,16)],
+        [(4,12),(40+12,20),(0,16)],
+        [(4,4),(40+4,16),(0,16)],
+        [(4,4),(40+8,16),(0,16)],
+
+        #body
+        [(8,4),(20,16),(0,16)],
+        [(8,4),(20+8,16),(0,16)],
+        [(8,12),(20,20),(0,16)],
+        [(8,12),(20+12,20),(0,16)],
+        [(4,12),(16,20),(0,16)],
+        [(4,12),(28,20),(0,16)],
+
+        #left leg
+        [(4,12),(16,52),(-16,0)],
+        [(4,12),(16+4,52),(-16,0)],
+        [(4,12),(16+8,52),(-16,0)],
+        [(4,12),(16+12,52),(-16,0)],
+        [(4,4),(16+4,48),(-16,0)],
+        [(4,4),(16+8,48),(-16,0)],
+
+        #right leg
+        [(4,12),(0,20),(0,16)],
+        [(4,12),(0+4,20),(0,16)],
+        [(4,12),(0+8,20),(0,16)],
+        [(4,12),(0+12,20),(0,16)],
+        [(4,4),(0+4,16),(0,16)],
+        [(4,4),(0+8,16),(0,16)],
+    ]:
+        mask.paste(Image.new('RGBA', size, (bg[0], bg[1], bg[2], 255)), offset)
+        decor_mask.paste(Image.new('RGBA', size, (bg[0], bg[1], bg[2], 255)), (offset[0]+decor_offset[0],offset[1]+decor_offset[1]))
+    
+    mask.save(SKIN_MASK)
+    decor_mask.save(SKIN_DECOR_MASK)
+
+create_mask()
+
+def apply_mask(skin_image, skin_mask):
+    skin_image = Image.composite(skin_image, skin_mask, skin_mask)
+    return skin_image
+
+def create_training_image(skin_image):
+
+    # Mask out any areas not directly mapping to the head, arm, leg, or
+    # torso portion of the character.
+    skin_image_first_layer = apply_mask(skin_image,Image.open(SKIN_MASK))
+    skin_image_second_layer = apply_mask(skin_image,Image.open(SKIN_DECOR_MASK))
+    
+    
+    training_image = Image.new('RGBA', (IMAGE_WIDTH, IMAGE_HEIGHT), (*bg, 255))
+    scaled_skin_image = skin_image.resize((int(32 * SCALING_RATIO), int(32 * SCALING_RATIO)),
+                                          resample=Image.BOX)
+    #scaled_first_layer = skin_image_first_layer.resize((int(32 * SCALING_RATIO), int(32 * SCALING_RATIO)),
+    #                                      resample=Image.BOX)
+    #scaled_second_layer = skin_image_second_layer.resize((int(32 * SCALING_RATIO), int(32 * SCALING_RATIO)),
+    #                                      resample=Image.BOX)
+                        
+    training_image.paste(scaled_skin_image, (0,0)) 
+    #training_image.paste(scaled_first_layer, (0,0)) 
+    #training_image.paste(scaled_second_layer, (int(32 * SCALING_RATIO),0)) 
+
+    # Optimized: Use NumPy for transparency and dot drawing
+    tr_arr = np.array(training_image)
+    
+    # Fill transparent background areas
+    tr_arr[tr_arr[..., 3] == 0] = [*bg, 255]
+    
+    # Draw white dots for skin transparency
+    skin_arr = np.array(skin_image)
+    y_indices, x_indices = np.where(skin_arr[..., 3] == 0)
+    
+    for x, y in zip(x_indices, y_indices):
+        cx = int(int(x * SCALING_RATIO / 2) + SCALING_RATIO // 4)
+        cy = int(int(y * SCALING_RATIO / 2) + SCALING_RATIO // 4)
+        # Apply 2x2 white dot
+        tr_arr[cy-1:cy+1, cx-1:cx+1] = [255, 255, 255, 255]
+        
+    training_image = Image.fromarray(tr_arr)
+
+    # skin_image -> np.ndarray
+
+    r_scale1 = 0.22
+    r_scale2 = 0.28
+    r_scale3 = 0.09
+    r_scale4 = 0.25
+    full_part = ['head','body','left_arm','right_arm','left_leg','right_leg']
+
+    limbs_offset = 0.8
+    default_pos_args = {
+        'head': (0, 28, 0),
+        'body': (0, 18, 0),
+        'right_arm': (-6 - limbs_offset, 18, 0),
+        'left_arm': (6 + limbs_offset, 18, 0),
+        'right_leg': (-2 - limbs_offset, 6, 0),
+        'left_leg': (2 + limbs_offset, 6, 0),
+            }
+
+    pos_args2 = {
+        'head': (0, 28, 0),
+        'body': (0, 18, 0),
+        'right_arm': (-6, 18 , 0),
+        'left_arm': (6, 18 , 0),
+        'right_leg': (-2, 6, 0),
+        'left_leg': (2, 6, 0),
+            }
+    for (ortho, s, look_at_y, core_display, decor_display, cam_front, offset,render_size, zoom, pos_args, walk) in [
+        (False, skin_image,12, full_part, full_part, (0.3, 0.4, 0.5), (int(IMAGE_WIDTH/2), 0), (int(IMAGE_WIDTH/2),int(IMAGE_HEIGHT/2*1.2)), r_scale1, default_pos_args, True),
+
+        (False, skin_image,12,full_part,full_part,  (0.0, 0, 0.5),(0, int(IMAGE_HEIGHT/2)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), 0.35, pos_args2, False),
+        (False, skin_image,12,full_part,full_part,  (-0.0, -0.0, -0.5),(0, int(IMAGE_HEIGHT*3/4)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), 0.35, pos_args2, False),
+
+        (False,skin_image_first_layer,12, full_part, full_part, (0.3, 0.4, 0.5), (int(IMAGE_WIDTH/5), int(IMAGE_HEIGHT/2)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), r_scale2,default_pos_args, False),
+        (False,skin_image_first_layer,12, full_part, full_part, (-0.5, -0.4, -0.5), (int(IMAGE_WIDTH/5), int(IMAGE_HEIGHT*3/4)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), r_scale2,default_pos_args, False),
+
+        #left
+        (False,skin_image,12, full_part, full_part, (0.3, 0.4, 0.5), (int(IMAGE_WIDTH*2/5), int(IMAGE_HEIGHT/2)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), r_scale2,default_pos_args, False),
+        (False,skin_image,12, full_part, full_part, (-0.5, -0.4, -0.5), (int(IMAGE_WIDTH*2/5), int(IMAGE_HEIGHT*3/4)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), r_scale2,default_pos_args, False),
+
+        # right
+        (False,skin_image, 12,full_part, full_part, (0.3, -0.4, 0.5),(int(IMAGE_WIDTH*3/5), int(IMAGE_HEIGHT/2)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), r_scale2,default_pos_args, False),
+        (False,skin_image, 12,full_part, full_part, (-0.5, 0.4, -0.5),(int(IMAGE_WIDTH*3/5), int(IMAGE_HEIGHT*3/4)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/3)), r_scale2,default_pos_args, False),
+
+        # head
+        (False,skin_image,28, ['head'], ['head'], (-0.3, -0.4, 0.5),(int(IMAGE_WIDTH*4/5), int(IMAGE_HEIGHT/2)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/8)), r_scale3,default_pos_args, False),
+        (False,skin_image,28, ['head'], ['head'], (0.3, -0.4, 0.5),(int(IMAGE_WIDTH*4/5), int(IMAGE_HEIGHT/2 + IMAGE_HEIGHT/8)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/8)), r_scale3,default_pos_args, False),
+        (False,skin_image,28, ['head'], ['head'], (-0.5, -0.4, -0.5),(int(IMAGE_WIDTH*4/5), int(IMAGE_HEIGHT/2+ IMAGE_HEIGHT*2/8)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/8)), r_scale3,default_pos_args, False),
+        (False,skin_image,28, ['head'], ['head'], (0.5, -0.4, -0.5),(int(IMAGE_WIDTH*4/5), int(IMAGE_HEIGHT/2+ IMAGE_HEIGHT*3/8)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/8)), r_scale3,default_pos_args, False),
+
+        (False,skin_image,12, ['body'], ['body'], (0.3, 0.4, 0.5), (int(IMAGE_WIDTH*3/4*1.05), int(IMAGE_HEIGHT*1/5)), (int(IMAGE_WIDTH/4),int(IMAGE_HEIGHT/2)), r_scale4,default_pos_args, False),
+        (False,skin_image,12, ['body'], ['body'], (-0.3, 0.4, 0.5), (int(IMAGE_WIDTH*3/4*1.05), int(-IMAGE_HEIGHT*1/8)), (int(IMAGE_WIDTH/4),int(IMAGE_HEIGHT/2)), r_scale4,default_pos_args, False),
+        
+        (False,skin_image,22, [], ['head'], (0.3, 0.3, 0), (int(IMAGE_WIDTH*1/2*0.95), int(IMAGE_HEIGHT*1/60)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/4.5)), r_scale4,default_pos_args, False),
+        (False,skin_image,22, [], ['head'], (-0.3, 0.3, 0), (int(IMAGE_WIDTH*1/2*0.95), int(IMAGE_HEIGHT*20/60)), (int(IMAGE_WIDTH/5),int(IMAGE_HEIGHT/4.5)), r_scale4,default_pos_args, False),
+
+    ]:
+        # Optimized: Get image directly from memory instead of UUID-named temp files
+        img_np = mc_render.render_skin(
+            skin=np.array(s),
+            output_size=render_size,
+            cam_front=cam_front,
+            look_at_y=look_at_y,
+            use_voxels=True,
+            ortho=ortho,
+            core_display=core_display,
+            decor_display=decor_display,
+            show_wireframe=False,
+            pos_args=pos_args,
+            rot_args={
+            'rot_head': (0,0,0),
+            'rot_arm_right': (-30,0,0),
+            'rot_arm_left': (30,0,0),
+            'rot_leg_right': (30,0,0),
+            'rot_leg_left': (-30,0,0),
+            } if walk else {
+            'rot_head': (0,0,0),
+            'rot_arm_right': (0,0,0),
+            'rot_arm_left': (0,0,0),
+            'rot_leg_right': (0,0,0),
+            'rot_leg_left': (0,0,0),
+            },save_path=None, transparent_background=True, zoom=zoom, light=True)
+        
+        if img_np is not None:
+            x = Image.fromarray(img_np)
+            training_image.paste(x, offset, x)
+
+    return training_image
+
+def check_skin(img):
+    is_alex = False
+    if img.size != (64, 64):
+        print('size invalid')
+        return False,is_alex
+    skin_image_first_layer = apply_mask(img,Image.open(SKIN_MASK))
+    # Calculate the total number of opaque pixels
+    count = 0
+    count2 = 0
+    for x in range(64):
+        for y in range(64):
+            if img.getpixel((x, y))[3] == 255:
+                count2 +=1
+            if skin_image_first_layer.getpixel((x, y))[3] == 255:
+                count += 1
+    
+    if count == 1632 - 4*2*2-12*2*2:
+        is_alex = True
+
+    if count != 1632 and (not is_alex):
+        print('count invalid', count)
+        return False,is_alex
+
+    if count2 == 64*64 and (not is_alex):
+        print('count2 invalid')
+        return False,is_alex
+
+    return True,is_alex
+
+def ensure_valid_skin(skin_image):
+    skin_image_first_layer = Image.open(SKIN_MASK)
+    skin_image_second_layer = Image.open(SKIN_DECOR_MASK)
+
+    # Convert all semi-transparent to opaque
+    for x in range(skin_image.width):
+        for y in range(skin_image.height):
+            if skin_image.getpixel((x, y))[3] != 0 and skin_image.getpixel((x, y))[3] != 255:
+                skin_image.putpixel((x, y), (skin_image.getpixel((x, y))[0], skin_image.getpixel((x, y))[1], skin_image.getpixel((x, y))[2], 255))
+            # Ignore other pixels in the 1st and 2nd layers of the skin
+            if skin_image_first_layer.getpixel((x, y))[3] != 255 and skin_image_second_layer.getpixel((x, y))[3] != 255:
+                skin_image.putpixel((x, y), (bg[0],bg[1],bg[2], 255))
+    return skin_image
+
+def build_target_img(input_path, output_path):
+    # This might fail if dirs not created yet
+    # But main process creates them
+    try:
+        if not os.path.exists(input_path):
+            print('not exists', input_path)
+            return
+
+        # Ensure subdir exists in output
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        if os.path.exists(output_path):
+            print('exists target', output_path)
+            return
+
+        print(f"Processing {input_path}")
+        skin_image = Image.open(input_path)
+        skin_image = skin_image.convert('RGBA')
+        valid,is_alex = check_skin(skin_image)
+        if not valid:
+            print('invalid', input_path)
+            return
+        if is_alex:
+            skin_image = alice_to_steve(skin_image)
+
+        skin_image = ensure_valid_skin(skin_image)
+        skin_image = resolve_voxel_consistency(skin_image)
+        training_image = create_training_image(skin_image)
+        training_image.save(output_path)
+    except Exception as e:
+        print(f"Error processing {input_path}: {e}")
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Process a single Minecraft skin to a target image")
+    parser.add_argument("input_path", help="Path to input skin image")
+    parser.add_argument("output_path", help="Path to output target image")
+    args = parser.parse_args()
+    build_target_img(args.input_path, args.output_path)

build_target_imgs.py

@@ -0,0 +1,40 @@
+import os
+import sys
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+
+output_dir = 'target_imgs_v73'
+
+def process_skin(skin_id):
+    input_path = f'skins/{skin_id}.png'
+    output_path = f'{output_dir}/{skin_id}.png'
+    if not os.path.exists(output_path):
+        print(f"Starting process for skin: {skin_id}...")
+        # Run build_target_img.py as a separate subprocess using sys.executable
+        result = subprocess.run(
+            [sys.executable, 'build_target_img.py', input_path, output_path],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            print(f"Successfully processed: {skin_id}")
+        else:
+            print(f"Error processing skin {skin_id}:")
+            print(result.stderr or result.stdout)
+
+def main():
+    os.makedirs(output_dir, exist_ok=True)
+    iset = set()
+    for i in os.listdir('skins'):
+        if i.endswith('.png') and not i.startswith('.'):
+            iset.add(i.split('.')[0])
+            
+    # Process skins in parallel using a pool of subprocesses
+    # Using 4 workers for fast parallel rendering on Mac
+    max_workers = 4 
+    print(f"Processing {len(iset)} skins using {max_workers} parallel workers...")
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        executor.map(process_skin, sorted(list(iset)))
+
+if __name__ == '__main__':
+    main()