Sking: Minecraft Skin 3D Rendering & Dataset Preprocessing Pipeline

This repository is utilized for training and fine-tuning the Sking Model (Hugging Face Model).

Along with the dataset assets, it contains the complete automated pipeline for dual-layer 3D voxel rendering, multi-view layout baking, automatic skin format conversion (Alex to Steve), voxel edge texture consistency resolution, and a RESTful FastAPI service for extracting the actual usable 64x64 RGBA skin UV map from composite training targets.

---

🔗 Resources

• 🗂️ Dataset: Hugging Face Sking Dataset
• 🧠 Trained Model: Hugging Face Sking Model
• 📝 Technical Report: Technical Architecture
• 🌐 Online Demo: EntropyDrop Web Portal

---

🚀 Key Features

• 🎮 3D Voxel Rendering (mc_render.py)

  • Powered by PyVista (VTK) to translate 2D skin textures into 3D voxel character meshes.
  • Supports dual-layer rendering: Core layer (base body) and Decor layer (jacket, sleeves, pants, hat).
  • Fully parameterizable limb articulation supporting rotation (Pitch/Yaw/Roll) and spatial offset configurations.
  • Interactive lighting mode with real-time viewport keyboard controls (W/S/A/D/Q/E for light position, R/F for intensity).
  • Supports orthographic and perspective projections, wireframe overlays, custom backgrounds, and alpha-transparent exports.

• 🧩 Voxel Texture Consistency Resolver (mc_voxel_texture_resolver.py)

  • Solves the visual gap artifact caused by transparent adjacent faces in dual-layer skins during 3D voxelization.
  • Implements a 3D voxel projection mapping algorithm that automatically fills missing/transparent adjacent faces according to a priority sequence (Front -> Back -> Top -> Bottom -> Left -> Right) for 3D renders.

• 🔄 Layout Standardization: Alex-to-Steve (alice_to_steve.py)

  • Automatically detects slim-armed (Alex, 3px arm width) skin formats.
  • Applies a pixel-column projection and replication mapping to expand slim arms to standard (Steve, 4px arm width) format to standardize features across the dataset.

• 📸 Multi-View Layout Baking (build_target_img.py)

  • Upsamples 64x64 flat textures via box filtering and injects 2x2 white indicators on background regions to represent alpha transparency values as conditioning cues for generative models.
  • Bakes a composite layout image at 768x768 resolution featuring the 2D skin texture along with 17 distinct, pre-configured 3D render viewports (incorporating walking, idle, back-view, close-ups, and layer-toggled angles).

• ⚡ Batch Processing Pipeline (build_target_imgs.py)

  • Leverages a multi-threaded execution pool (ThreadPoolExecutor) managing isolated sub-processes for batch rendering.
  • Supports parallel processing on multi-core systems.

• 🔓 Skin UV Map Extraction (extract_skin.py)

  • Extraction Engine: Crops and extracts the actual usable 64x64 skin UV map from the 2D layout area of synthesized training target images, resolving alpha transparency indicators to recover clean texture maps.
  • FastAPI Microservice: Exposes the UV map extractor as a REST API alongside its command-line execution mode.

• 📐 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

Sking/
├── mc_render.py                  # Core 3D engine (PyVista viewport & headless off-screen rendering)
├── mc_voxel_texture_resolver.py # Voxel texture patcher & visual difference analyzer
├── alice_to_steve.py             # Alex-to-Steve (3px-to-4px arm width) mapping algorithm
├── build_target_img.py           # Single-skin multi-view layout baker (generates 768x768 composite)
├── 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_v2/              # Directory for multi-view layout control maps

---

🛠️ System Requirements & Installation

1. Prerequisites

• Python 3.8 or higher.
• A virtual environment configuration is highly recommended.

2. Installation

Install all required packages:

pip install pyvista numpy pillow fastapi uvicorn opencv-python pydantic

Note for Headless Environments: Since PyVista utilizes VTK under the hood, running it on headless servers (e.g., Linux instances without GUI support) requires a virtual frame buffer configuration. Please wrap the execution using a utility like xvfb-run.

---

📖 Command Line & API Reference

A. Bake Multi-View Layout for a Single Skin

python build_target_img.py skins/steve.png target_imgs_v73/steve.png

This utility automatically executes the following pipeline sequence:

1. Validates texture dimension (64x64) and format integrity (RGBA).
2. Performs slim-arm check and converts Alex formats to Steve formats dynamically if needed.
3. Patches voxel edge-transparency conflicts.
4. Generates a 768x768 composite layout containing the 2D layout and 17 distinct 3D viewports.

B. Batch Processing

python build_target_imgs.py

Batch scans the skins/ directory and processes them concurrently using parallel workers, exporting the output files into target_imgs_v73/.

C. Interactive 3D Rendering & Viewing

To examine or visually debug the 3D rendering configuration of a specific skin:

python mc_render.py skins/my_skin.png --interact

• Real-Time Light Position & Intensity Keyboard Controls:
  • W / S: Translate light position along the Z-axis (Forward / Backward).
  • A / D: Translate light position along the X-axis (Left / Right).
  • Q / E: Translate light position along the Y-axis (Up / Down).
  • R / F: Increment / Decrement light intensity.
  • P: Print current light coordinate vector and intensity scalar to terminal output.
• Custom Articulation & Off-Screen Export Example:

  python mc_render.py skins/my_skin.png --rot-head 15 30 0 --rot-arm-right -45 0 0 --save output.png
  

D. Skin UV Map Extraction API

CLI Execution Mode

python extract_skin.py --img target_imgs_v73/steve.png --output restored_steve.png

API Server Mode

Run the FastAPI microservice:

python extract_skin.py --server True

The microservice launches locally on http://0.0.0.0:10010.

• Endpoint: POST /extract
  • Request Body Format:

    {
      "img": "<base64_encoded_synthesized_image>"
    }
    

  • Response Body Format:

    {
      "img": "<base64_encoded_64x64_restored_skin_png>"
    }
    

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.

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.

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.

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

This project is licensed under the GNU Affero General Public License v3.0 - see the LICENSE file for details.