README

README.md

@@ -47,6 +47,18 @@ Along with the dataset assets, it contains the complete automated pipeline for d
 * **📐 Conditioning Image Formatting (`force_resize_control_imgs.py`)**
   - Automatically resamples and centers control images inside a standard `1024x1024` alpha-transparent canvas utilizing Lanczos interpolation, ensuring compatibility with advanced ControlNet training frameworks.
 
+* **🔄 Skin UV & View Port Horizontal Flipping (`ext_flip_img.py`)**
+  - Performs horizontal flipping of character front/back views in control images and correctly flips the corresponding 64x64 skin UV map.
+  - Specifically handles 3D voxel box flipping (swapping left and right faces, horizontally flipping each face, and swapping left/right limbs/sleeves/pants/legs for Steve and Alex models).
+
+* **✂️ Front-View Dataset Slicing (`make_half_dataset.py`)**
+  - Generates a front-view-only subset by horizontally splitting composite layout/control images in half, retaining only the left (front) side.
+  - Automatically copies and standardizes associated files (PNG images, txt descriptions, and control maps) prefixing them with `half_`.
+
+* **🧬 Skin Merging Utility (`merge_skins.py`)**
+  - Combines two skins by extracting the head and head decoration (decor) layers from Skin A and copying them onto the body and limbs of Skin B.
+  - Utilizes head mapping coordinates matching standard UV layouts.
+
 ---
 
 ## 📂 Project Structure
@@ -60,11 +72,15 @@ Sking/
 ├── build_target_imgs.py          # Concurrent batch rendering pipeline
 ├── extract_skin.py               # Skin UV map extraction CLI & FastAPI server
 ├── force_resize_control_imgs.py  # Control map resampling & canvas standardization (1024x1024)
+├── ext_flip_img.py               # Flip front/back views and horizontally mirror skin UV layouts
+├── make_half_dataset.py          # Create front-view subset by slicing images in half horizontally
+├── merge_skins.py                # Combine head of skin A with body/limbs of skin B
 ├── skin-mask.png                 # Pixel-level spatial mapping mask for Core layer
 ├── skin-decor-mask.png           # Pixel-level spatial mapping mask for Decor layer
 ├── skins/                        # Directory for raw input skins (.png)
 ├── target_imgs_v73/              # Output directory for baked multi-view layouts
-└── control_imgs/                 # Processing directory for conditioning control maps
+├── control_imgs/                 # Processing directory for conditioning control maps
+└── control_imgs_v2/              # Directory for multi-view layout control maps
 ```
 
 ---
@@ -144,6 +160,32 @@ The microservice launches locally on `http://0.0.0.0:10010`.
     }
     ```
 
+### E. Horizontal Flipping of Views and UV Maps
+This script horizontally flips character front and back views separately for a ControlNet image, and mirrors the 64x64 skin UV map by swapping and mirroring corresponding limbs and details.
+```bash
+python ext_flip_img.py <original_id> <new_id>
+```
+- Processes `control_imgs_v2/{original_id}.png` to generate flipped version at `control_imgs_v2/{new_id}.png`.
+- Flips `img_label/{original_id}.png` (UV map) to generate `img_label/{new_id}.png`.
+- Copies the corresponding text description from `img_label/{original_id}.txt` to `img_label/{new_id}.txt`.
+
+### F. Front-View Dataset Slicing
+This script processes the dataset by horizontally cutting all layout/control images in half (keeping only the left half, which corresponds to the character's front view) to create a front-view-only training subset.
+```bash
+python make_half_dataset.py
+```
+- Automatically processes files in `img_label/` and `control_imgs_v2/`.
+- Saves sliced files with the prefix `half_` (e.g. `half_{original_name}.png`, `half_{original_name}.txt`).
+- Proactively skips already processed files.
+
+### G. Skin Merging Utility (Head of A + Body/Limbs of B)
+This script merges two skins by taking the head and hat decoration layers from Skin A and the body and limbs from Skin B.
+```bash
+python merge_skins.py <path_to_skin_a> <path_to_skin_b> -o <output_path>
+```
+- Extracts head region UVs (including outer decors) from skin A.
+- Pastes them over skin B's head region, outputting the newly combined skin.
+
 ---
 
 ## 📄 License

ext_flip_img.py

@@ -0,0 +1,149 @@
+import os
+import argparse
+import shutil
+from PIL import Image
+
+def flip_box(img, x, y, w, h, d):
+    """
+    Horizontally flips a 3D box in the Minecraft skin UV map.
+    This includes swapping the left and right faces, and horizontally flipping all faces.
+    """
+    # Create a temporary image to store the box area (2w+2d, h+d)
+    res = Image.new("RGBA", (2*w + 2*d, h + d))
+    
+    # Crop each face
+    # Layout: [Right] [Front] [Left] [Back]
+    top = img.crop((x + d, y, x + d + w, y + d)).transpose(Image.FLIP_LEFT_RIGHT)
+    bottom = img.crop((x + d + w, y, x + d + 2*w, y + d)).transpose(Image.FLIP_LEFT_RIGHT)
+    
+    right = img.crop((x, y + d, x + d, y + d + h)).transpose(Image.FLIP_LEFT_RIGHT)
+    front = img.crop((x + d, y + d, x + d + w, y + d + h)).transpose(Image.FLIP_LEFT_RIGHT)
+    left = img.crop((x + d + w, y + d, x + 2*d + w, y + d + h)).transpose(Image.FLIP_LEFT_RIGHT)
+    back = img.crop((x + 2*d + w, y + d, x + 2*d + 2*w, y + d + h)).transpose(Image.FLIP_LEFT_RIGHT)
+    
+    # Paste back to the flipped positions
+    # The new right face is the old left face, and the new left face is the old right face
+    res.paste(top, (d, 0))
+    res.paste(bottom, (d + w, 0))
+    res.paste(left, (0, d))       # New Right (0) <- Old Left
+    res.paste(front, (d, d))      # Front (d)
+    res.paste(right, (d + w, d))   # New Left (d+w) <- Old Right
+    res.paste(back, (2*d + w, d))  # Back (2d+w)
+    
+    return res
+
+def process_uvmap(img_id, new_id):
+    """
+    Flips the UV Map of img_label/{id}.png.
+    Requires swapping left and right limbs, and flipping the textures of each component.
+    """
+    dir_name = "img_label"
+    input_path = f"{dir_name}/{img_id}.png"
+    output_path = f"{dir_name}/{new_id}.png"
+    
+    if not os.path.exists(input_path):
+        print(f"Warning: {input_path} does not exist, skipping UV Map flipping.")
+        return
+
+    img = Image.open(input_path).convert("RGBA")
+    # Unify to 64x64 format
+    if img.size == (64, 32):
+        new_img = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
+        new_img.paste(img, (0, 0))
+        img = new_img
+    elif img.size != (64, 64):
+        print(f"Error: Unsupported image size {img.size}")
+        return
+        
+    # Determine if it is a slim (Alex) skin
+    is_slim = img.getpixel((47, 52))[3] == 0
+    w_arm = 3 if is_slim else 4
+    
+    flipped_img = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
+    
+    # 1. Flip head and hat (symmetrical components)
+    flipped_img.paste(flip_box(img, 0, 0, 8, 8, 8), (0, 0))   # Head
+    flipped_img.paste(flip_box(img, 32, 0, 8, 8, 8), (32, 0)) # Hat
+    
+    # 2. Flip torso and jacket (symmetrical components)
+    flipped_img.paste(flip_box(img, 16, 16, 8, 12, 4), (16, 16)) # Body
+    flipped_img.paste(flip_box(img, 16, 32, 8, 12, 4), (16, 32)) # Jacket
+    
+    # 3. Swap and flip left and right limbs
+    # Right Arm (40, 16) <-> Left Arm (32, 48)
+    flipped_img.paste(flip_box(img, 40, 16, w_arm, 12, 4), (32, 48)) # Old Right -> New Left
+    flipped_img.paste(flip_box(img, 32, 48, w_arm, 12, 4), (40, 16)) # Old Left -> New Right
+    
+    # Right Leg (0, 16) <-> Left Leg (16, 48)
+    flipped_img.paste(flip_box(img, 0, 16, 4, 12, 4), (16, 48)) # Old Right -> New Left
+    flipped_img.paste(flip_box(img, 16, 48, 4, 12, 4), (0, 16)) # Old Left -> New Right
+    
+    # 4. Flip overlay layers (Sleeves & Pants)
+    # Right Sleeve (40, 32) <-> Left Sleeve (48, 48)
+    flipped_img.paste(flip_box(img, 40, 32, w_arm, 12, 4), (48, 48)) # Old Right -> New Left
+    flipped_img.paste(flip_box(img, 48, 48, w_arm, 12, 4), (40, 32)) # Old Left -> New Right
+    
+    # Right Pants (0, 32) <-> Left Pants (0, 48)
+    flipped_img.paste(flip_box(img, 0, 32, 4, 12, 4), (0, 48)) # Old Right -> New Left
+    flipped_img.paste(flip_box(img, 0, 48, 4, 12, 4), (0, 32)) # Old Left -> New Right
+    
+    flipped_img.save(output_path)
+    print(f"Successfully saved flipped UV Map to {output_path}")
+
+    # Process description files at the same time
+    txt_input = f"{dir_name}/{img_id}.txt"
+    txt_output = f"{dir_name}/{new_id}.txt"
+    if os.path.exists(txt_input):
+        shutil.copy(txt_input, txt_output)
+        print(f"Copied description file to {txt_output}")
+
+
+# Input image id, new_id
+# Read control_imgs_v2/{id}.png
+
+# Copy control_imgs_v2/{id}.png to control_imgs_v2/{new_id}.png
+# Each image consists of front and back photos of the character (split in the middle, left-right layout, left is front, right is back).
+# Now we need to flip the left and right parts horizontally and splice them into a new image.
+
+def process_image(img_id, new_id):
+    dir_name = "control_imgs_v2"
+    
+    input_path = f"{dir_name}/{img_id}.png"
+    output_path = f"{dir_name}/{new_id}.png"
+    
+    if not os.path.exists(input_path):
+        print(f"Error: {input_path} does not exist.")
+        return
+
+    # Read image
+    img = Image.open(input_path)
+    width, height = img.size
+    
+    # Split into left and right parts (split in the middle)
+    # Left is front, right is back
+    left_part = img.crop((0, 0, width // 2, height))
+    right_part = img.crop((width // 2, 0, width, height))
+    
+    # Horizontally flip the left and right parts respectively
+    left_flipped = left_part.transpose(Image.FLIP_LEFT_RIGHT)
+    right_flipped = right_part.transpose(Image.FLIP_LEFT_RIGHT)
+    
+    # Splice into a new image
+    new_img = Image.new('RGBA', (width, height))
+    new_img.paste(left_flipped, (0, 0))
+    new_img.paste(right_flipped, (width // 2, 0))
+    
+    # Save the new image
+    new_img.save(output_path)
+    print(f"Successfully saved flipped image to {output_path}")
+    
+    # Process UV Map flipping
+    process_uvmap(img_id, new_id)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Horizontally flip the front and back views of a character and splice them back together.")
+    parser.add_argument("id", type=str, help="Original image ID")
+    parser.add_argument("new_id", type=str, help="New image ID")
+    
+    args = parser.parse_args()
+    process_image(args.id, args.new_id)

make_half_dataset.py

@@ -0,0 +1,91 @@
+import os
+import shutil
+from PIL import Image
+
+def process_and_crop(img_path, output_path):
+    """
+    Read image, horizontally crop in half (left/right), keep only the left half, and save to output_path.
+    """
+    if not os.path.exists(img_path):
+        print(f"File does not exist: {img_path}")
+        return False
+    
+    try:
+        with Image.open(img_path) as img:
+            width, height = img.size
+            # Crop in half horizontally, keep only the left half
+            left_half = img.crop((0, 0, width // 2, height))
+            left_half.save(output_path)
+        print(f"Successfully saved the cropped left-half image: {output_path}")
+        return True
+    except Exception as e:
+        print(f"Error processing image {img_path}: {e}")
+        return False
+
+def main():
+    img_label_dir = "skins"
+    control_dir = "control_imgs"
+    
+    if not os.path.exists(img_label_dir):
+        print(f"Error: Directory {img_label_dir} does not exist.")
+        return
+        
+    # Get all png files in the img_label directory
+    png_files = sorted([f for f in os.listdir(img_label_dir) if f.lower().endswith(".png")])
+    
+    processed_count = 0
+    skipped_count = 0
+    
+    for filename in png_files:
+        if filename.startswith("half_"):
+            # Skip files that already start with half_
+            continue
+            
+        # Target filename
+        half_filename = f"half_{filename}"
+        
+        # Define source and destination paths
+        src_img_label = os.path.join(img_label_dir, filename)
+        dst_img_label = os.path.join(img_label_dir, half_filename)
+        
+        base_name, _ = os.path.splitext(filename)
+        
+        src_control = os.path.join(control_dir, filename)
+        dst_control = os.path.join(control_dir, half_filename)
+        
+        # Check if all corresponding target files already exist
+        has_control = os.path.exists(src_control)
+        
+        img_label_exists = os.path.exists(dst_img_label)
+        control_exists = not has_control or os.path.exists(dst_control)
+        
+        if img_label_exists and control_exists:
+            skipped_count += 1
+            continue
+            
+        print(f"\nProcessing {filename}...")
+        processed_count += 1
+        
+        # 1. Process PNG image
+        if img_label_exists:
+            print(f"  [Skip] Image {dst_img_label} already exists.")
+        else:
+            try:
+                shutil.copy(src_img_label, dst_img_label)
+                print(f"  [Success] Copied image to {dst_img_label}")
+            except Exception as e:
+                print(f"  [Error] Failed to copy image to {dst_img_label}: {e}")
+                
+        # 2. Process corresponding image
+        if has_control:
+            if control_exists:
+                print(f"  [Skip] Cropped image {dst_control} already exists.")
+            else:
+                process_and_crop(src_control, dst_control)
+        else:
+            print(f"  [Note] No corresponding image {src_control} in control_imgs directory")
+
+    print(f"\nProcessing complete! Newly processed {processed_count} pairs, skipped {skipped_count} existing pairs.")
+
+if __name__ == "__main__":
+    main()

merge_skins.py

@@ -0,0 +1,72 @@
+import argparse
+from PIL import Image
+
+def get_head_uvs():
+    """
+    Returns the (x, y, w, h) of each 2D texture block of the head.
+    """
+    head_uvs = []
+    
+    # [ [ [size, offset], ... ], decor_offset ]
+    part = [
+        [
+            [(8,8,8),(8,8)],  # front
+            [(8,8,8),(24,8)], # back
+            [(8,8,8),(16,8)], # left
+            [(8,8,8),(0,8)],  # right
+            [(8,8,8),(8,0)],  # top
+            [(8,8,8),(16,0)], # bottom
+        ], (32,0)
+    ]
+    
+    decor_offset = part[1]
+    
+    for size_info, offset in part[0]:
+        # Take the first two values from the 3D size (dx, dy, dz) as the width and height of the 2D texture map
+        w, h = size_info[0], size_info[1]
+        
+        # Base head area
+        head_uvs.append((offset[0], offset[1], w, h))
+        
+        # Head decoration (decor) area
+        decor_x = offset[0] + decor_offset[0]
+        decor_y = offset[1] + decor_offset[1]
+        head_uvs.append((decor_x, decor_y, w, h))
+        
+    return head_uvs
+
+def merge_skins(skin_a_path, skin_b_path, output_path):
+    # Open images and ensure they have an alpha channel
+    img_a = Image.open(skin_a_path).convert("RGBA")
+    img_b = Image.open(skin_b_path).convert("RGBA")
+    
+    # Check if dimensions are compatible
+    if img_a.size != img_b.size:
+        print(f"Warning: Skin A ({img_a.size}) and Skin B ({img_b.size}) sizes do not match.")
+    
+    # Use B (provides body and limbs) as the base background
+    img_c = img_b.copy()
+    
+    # Get head regions that need to be copied from A
+    head_uvs = get_head_uvs()
+    
+    for x, y, w, h in head_uvs:
+        box = (x, y, x + w, y + h)
+        
+        # Crop the corresponding head block from A
+        region_a = img_a.crop(box)
+        
+        # Paste onto C. Do not use mask to ensure complete coverage (including transparent pixels covering B's original pixels)
+        img_c.paste(region_a, box)
+
+    img_c.save(output_path)
+    print(f"Successfully merged: A's head ({skin_a_path}) + B's body/limbs ({skin_b_path}) -> {output_path}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Combine skins: Take the head of Skin A and the body and limbs of Skin B.")
+    parser.add_argument("skin_a", help="Path to Skin A (provides the head)")
+    parser.add_argument("skin_b", help="Path to Skin B (provides the body and limbs)")
+    parser.add_argument("-o", "--output", default="skin_c.png", help="Output path for Skin C")
+    args = parser.parse_args()
+    
+    merge_skins(args.skin_a, args.skin_b, args.output)