feat: implement gpt_image module, skin rendering pipelines, legacy converter, and auto batch generator

convert_skin.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import argparse
+from PIL import Image
+
+def copy_mirrored_limb(img, new_img, src_x, src_y, dst_x, dst_y):
+    """
+    Mirror a 16x16 limb block from source (src_x, src_y) to destination (dst_x, dst_y).
+    """
+    # Top face
+    top = img.crop((src_x + 4, src_y, src_x + 8, src_y + 4))
+    new_img.paste(top.transpose(Image.FLIP_LEFT_RIGHT), (dst_x + 4, dst_y))
+    
+    # Bottom face
+    bottom = img.crop((src_x + 8, src_y, src_x + 12, src_y + 4))
+    new_img.paste(bottom.transpose(Image.FLIP_LEFT_RIGHT), (dst_x + 8, dst_y))
+    
+    # Front face
+    front = img.crop((src_x + 4, src_y + 4, src_x + 8, src_y + 16))
+    new_img.paste(front.transpose(Image.FLIP_LEFT_RIGHT), (dst_x + 4, dst_y + 4))
+    
+    # Back face
+    back = img.crop((src_x + 12, src_y + 4, src_x + 16, src_y + 16))
+    new_img.paste(back.transpose(Image.FLIP_LEFT_RIGHT), (dst_x + 12, dst_y + 4))
+    
+    # Right (Outer) face -> Left (Outer) face
+    right_face = img.crop((src_x, src_y + 4, src_x + 4, src_y + 16))
+    new_img.paste(right_face.transpose(Image.FLIP_LEFT_RIGHT), (dst_x + 8, dst_y + 4))
+    
+    # Left (Inner) face -> Right (Inner) face
+    left_face = img.crop((src_x + 8, src_y + 4, src_x + 12, src_y + 16))
+    new_img.paste(left_face.transpose(Image.FLIP_LEFT_RIGHT), (dst_x, dst_y + 4))
+
+def convert_skin_64x32_to_64x64(input_path, output_path):
+    print(f"[*] Loading skin: {input_path}")
+    img = Image.open(input_path).convert("RGBA")
+    
+    # Verify dimensions
+    if img.size == (64, 64):
+        print(f"[*] Skin '{input_path}' is already 64x64. No conversion needed.")
+        if input_path != output_path:
+            img.save(output_path)
+            print(f"[+] Saved copy to: {output_path}")
+        return
+        
+    if img.size != (64, 32):
+        raise ValueError(f"Unsupported skin dimensions: {img.size}. Expected 64x32 legacy skin.")
+        
+    print("[*] Converting legacy 64x32 skin to modern 64x64 format...")
+    # Create empty 64x64 transparent canvas
+    new_img = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
+    
+    # Paste old skin onto the top 32 pixels of the new canvas
+    new_img.paste(img, (0, 0))
+    
+    # Mirror Right Leg (0, 16) to Left Leg (16, 48)
+    copy_mirrored_limb(img, new_img, src_x=0, src_y=16, dst_x=16, dst_y=48)
+    
+    # Mirror Right Arm (40, 16) to Left Arm (32, 48)
+    copy_mirrored_limb(img, new_img, src_x=40, src_y=16, dst_x=32, dst_y=48)
+    
+    # Save the output image
+    new_img.save(output_path)
+    print(f"[+] Converted successfully. Modern 64x64 skin saved to: {output_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert legacy 64x32 Minecraft skins to modern 64x64 format.")
+    parser.add_argument("input_skin", help="Path to the legacy 64x32 Minecraft skin image.")
+    parser.add_argument("-o", "--output", help="Output path for the converted skin. Defaults to input_name_64x64.png.")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input_skin):
+        print(f"Error: Input file '{args.input_skin}' does not exist.")
+        sys.exit(1)
+
+    output_path = args.output
+    if not output_path:
+        base, ext = os.path.splitext(args.input_skin)
+        output_path = f"{base}_64x64{ext or '.png'}"
+
+    try:
+        convert_skin_64x32_to_64x64(args.input_skin, output_path)
+    except Exception as e:
+        print(f"[!] Error: {e}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

force_resize_control_imgs.py

@@ -9,9 +9,9 @@ import uvicorn
 
 import os
 
-for i in os.listdir('control_imgs'):
+for i in os.listdir('control_imgs/lowpoly'):
     if i.endswith('.png'):
-        img_path = f'control_imgs/{i}'
+        img_path = f'control_imgs/lowpoly/{i}'
         img = Image.open(img_path)
         w, h = img.width, img.height
         if w != 1024 or h != 1024:

gpt_image.py

@@ -61,7 +61,7 @@ def generate_image(s3_urls, prompt):
             "quality": "auto",
             "resolution": "1K",
             "response_format": "url",
-            "size": "auto"
+            "size": "1024x1024"
         },
         "prompt": prompt
     }
@@ -85,7 +85,7 @@ def generate_image(s3_urls, prompt):
     print(f"[+] Task created successfully. Task ID: {task_id}")
     return task_id
 
-def poll_task_status(task_id, timeout_seconds=120, poll_interval=5):
+def poll_task_status(task_id, timeout_seconds=220, poll_interval=10):
     """
     Polls the task status with a timeout.
     """

gpt_skin2real.py

@@ -16,7 +16,7 @@ def main():
     parser = argparse.ArgumentParser(description="Render Minecraft skin to 3D views, upload to S3, and call img2img model.")
     parser.add_argument("skin", help="Path to local Minecraft skin image file.")
     parser.add_argument("-o", "--output", help="Output path for the generated image. Defaults to 'result_<timestamp>.png'.")
-    parser.add_argument("-p", "--prompt", default="生成ta的真人照片，再生成ta的背面放在图片右边", help="Prompt for the img2img model.")
+    parser.add_argument("-p", "--prompt", default="生成ta的全身真人照片，再生成ta的背面放在图片右边", help="Prompt for the img2img model.")
     parser.add_argument("-r", "--render-only", action="store_true", help="Only render the 3D front and back views locally, without calling the S3/img2img pipeline.")
     args = parser.parse_args()
 

gpt_skin2real_auto.py

@@ -0,0 +1,71 @@
+import os
+import sys
+import subprocess
+from PIL import Image
+
+# Import skin conversion logic
+from convert_skin import convert_skin_64x32_to_64x64
+
+def main():
+    skins_dir = "skins/lowpoly"
+    control_imgs_dir = "control_imgs/lowpoly"
+
+    if not os.path.exists(skins_dir):
+        print(f"Error: Skins directory '{skins_dir}' does not exist.")
+        sys.exit(1)
+
+    os.makedirs(control_imgs_dir, exist_ok=True)
+
+    # List all PNG files in skins/lowpoly
+    skin_files = [f for f in os.listdir(skins_dir) if f.lower().endswith(".png")]
+    skin_files.sort()
+
+    print(f"[*] Found {len(skin_files)} skin files in {skins_dir}.")
+
+    skipped = 0
+    processed = 0
+
+    for skin_file in skin_files:
+        skin_path = os.path.join(skins_dir, skin_file)
+        output_path = os.path.join(control_imgs_dir, skin_file)
+
+        # Check if the output control image already exists
+        if os.path.exists(output_path):
+            skipped += 1
+            continue
+
+        print("="*60)
+        print(f"[*] Processing: {skin_file}")
+
+        # Check skin size and auto-convert to 64x64 in-place if legacy format
+        try:
+            with Image.open(skin_path) as img:
+                width, height = img.size
+                if (width, height) == (64, 32):
+                    print(f"[*] Detected legacy 64x32 skin format for {skin_file}. Auto-converting to 64x64...")
+                    convert_skin_64x32_to_64x64(skin_path, skin_path)
+                elif (width, height) != (64, 64):
+                    print(f"[!] Warning: Skin '{skin_file}' has unexpected dimensions {img.size}. Skipping.")
+                    continue
+        except Exception as e:
+            print(f"[!] Error checking skin size: {e}")
+            continue
+
+        # Invoke gpt_skin2real.py using subprocess
+        cmd = [sys.executable, "gpt_skin2real.py", skin_path, "-o", output_path]
+        print(f"[*] Running command: {' '.join(cmd)}")
+        try:
+            # We run the command and check for success. If it fails, we output the error but continue to other skins.
+            subprocess.run(cmd, check=True)
+            print(f"[+] Completed: {skin_file} -> {output_path}")
+            processed += 1
+        except subprocess.CalledProcessError as e:
+            print(f"[!] Command failed for {skin_file}: {e}")
+        except Exception as e:
+            print(f"[!] Error running pipeline for {skin_file}: {e}")
+
+    print("="*60)
+    print(f"[*] Batch run completed. Processed: {processed}, Skipped (Already existed): {skipped}.")
+
+if __name__ == "__main__":
+    main()