README

README.md

@@ -1,3 +1,151 @@
-## License
+# Sking: Minecraft Skin 3D Rendering & Dataset Preprocessing Pipeline
+
+This repository is the official home of the **Sking Model Dataset** (hosted on [Hugging Face Datasets](https://huggingface.co/datasets/EntropyDrop/Sking)), which is utilized for training and fine-tuning the **Sking Model** ([Hugging Face Model](https://huggingface.co/EntropyDrop/Sking)). 
+
+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](https://huggingface.co/datasets/EntropyDrop/Sking)
+* **🧠 Trained Model**: [Hugging Face Sking Model](https://huggingface.co/EntropyDrop/Sking)
+* **📝 Technical Report**: [SkinGen Governance & Technical Architecture](https://entropydrop.com/skin/open/article/skingen)
+* **🌐 Online Demo**: [EntropyDrop Web Portal](https://entropydrop.com)
+
+---
+
+## 🚀 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.
+
+---
+
+## 📂 Project Structure
+
+```bash
+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)
+├── 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
+```
+
+---
+
+## 🛠️ System Requirements & Installation
+
+### 1. Prerequisites
+- Python 3.8 or higher.
+- A virtual environment configuration is highly recommended.
+
+### 2. Installation
+Install all required packages:
+```bash
+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
+```bash
+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
+```bash
+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:
+```bash
+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**:
+  ```bash
+  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
+```bash
+python extract_skin.py --img target_imgs_v73/steve.png --output restored_steve.png
+```
+#### API Server Mode
+Run the FastAPI microservice:
+```bash
+python extract_skin.py --server True
+```
+The microservice launches locally on `http://0.0.0.0:10010`.
+
+- **Endpoint**: `POST /extract`
+  - **Request Body Format**:
+    ```json
+    {
+      "img": "<base64_encoded_synthesized_image>"
+    }
+    ```
+  - **Response Body Format**:
+    ```json
+    {
+      "img": "<base64_encoded_64x64_restored_skin_png>"
+    }
+    ```
+
+---
+
+## 📄 License
 
 This project is licensed under the GNU Affero General Public License v3.0 - see the [LICENSE](LICENSE) file for details.