feat: gpt skin2real

.gitignore

@@ -1,2 +1,3 @@
 preserved
 __pycache__
+.env

gpt_image.py

@@ -0,0 +1,208 @@
+import os
+import sys
+import time
+import uuid
+import requests
+import boto3
+import mimetypes
+from dotenv import load_dotenv
+
+# Load .env file from the current directory
+env_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '.env')
+load_dotenv(env_path)
+
+# Retrieve configuration details
+AWS_ACCESS_KEY_ID = os.getenv("AWS_S3_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_S3_SECRET_ACCESS_KEY")
+AWS_REGION = os.getenv("AWS_REGION")
+AWS_BUCKET_NAME = os.getenv("AWS_BUCKET_NAME")
+GPT_IMAGE_API_BASE_URL = os.getenv("GPT_IMAGE_API_BASE_URL")
+API_KEY = os.getenv("API_KEY")
+
+def upload_file_to_s3(local_path, bucket, key):
+    """
+    Upload a local file to S3 with ACL='public-read' so the external API can access it.
+    """
+    print(f"[*] Uploading '{local_path}' to S3 bucket '{bucket}' with key '{key}'...")
+    s3_client = boto3.client(
+        's3',
+        aws_access_key_id=AWS_ACCESS_KEY_ID,
+        aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+        region_name=AWS_REGION
+    )
+    
+    # Guess mime type or default to image/png
+    content_type, _ = mimetypes.guess_type(local_path)
+    if not content_type:
+        content_type = 'image/png'
+
+    s3_client.upload_file(
+        local_path,
+        bucket,
+        key,
+        ExtraArgs={'ACL': 'public-read', 'ContentType': content_type}
+    )
+    
+    s3_url = f"https://{bucket}.s3.{AWS_REGION}.amazonaws.com/{key}"
+    print(f"[+] Uploaded successfully. S3 public URL: {s3_url}")
+    return s3_url
+
+def generate_image(s3_urls, prompt):
+    """
+    Triggers the image-to-image task using the gpt-image-2 model.
+    """
+    url = f"{GPT_IMAGE_API_BASE_URL}/v1/media/generate"
+    payload = {
+        "model": "gpt-image-2",
+        "params": {
+            "aspect_ratio": "1:1",
+            "images": s3_urls,
+            "n": 1,
+            "quality": "auto",
+            "resolution": "1K",
+            "response_format": "url",
+            "size": "auto"
+        },
+        "prompt": prompt
+    }
+    
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["Authorization"] = f"Bearer {API_KEY}"
+        
+    print(f"[*] Sending image generation request to: {url}")
+    response = requests.post(url, json=payload, headers=headers)
+    response.raise_for_status()
+    res_json = response.json()
+    
+    # Try parsing task_id from root or nested "data" dictionary
+    task_id = res_json.get("task_id")
+    if not task_id and "data" in res_json and isinstance(res_json["data"], dict):
+        task_id = res_json["data"].get("task_id")
+        
+    if not task_id:
+        raise ValueError(f"Failed to obtain task_id from response: {res_json}")
+    print(f"[+] Task created successfully. Task ID: {task_id}")
+    return task_id
+
+def poll_task_status(task_id, timeout_seconds=120, poll_interval=5):
+    """
+    Polls the task status with a timeout.
+    """
+    status_url = f"{GPT_IMAGE_API_BASE_URL}/v1/media/status"
+    start_time = time.time()
+    print(f"[*] Polling task status (timeout={timeout_seconds}s, interval={poll_interval}s)...")
+    
+    while True:
+        elapsed = time.time() - start_time
+        if elapsed > timeout_seconds:
+            raise TimeoutError(f"Task {task_id} timed out after {timeout_seconds} seconds.")
+            
+        try:
+            headers = {}
+            if API_KEY:
+                headers["Authorization"] = f"Bearer {API_KEY}"
+            response = requests.get(status_url, params={"task_id": task_id}, headers=headers)
+            response.raise_for_status()
+            res_json = response.json()
+            
+            # Support both flat and nested responses for task status
+            data = res_json
+            if "data" in res_json and isinstance(res_json["data"], dict):
+                if any(k in res_json["data"] for k in ["state", "is_final", "result_url"]):
+                    data = res_json["data"]
+            
+            state = data.get("state")
+            is_final = data.get("is_final", False)
+            progress = data.get("progress", "0%")
+            print(f"[*] [Elapsed: {int(elapsed)}s] State: {state}, Progress: {progress}")
+            
+            if is_final:
+                if state == "success":
+                    result_url = data.get("result_url")
+                    if not result_url:
+                        raise ValueError("Task finished with success state, but result_url is empty.")
+                    return result_url
+                else:
+                    error_msg = data.get("error", "Unknown error")
+                    raise RuntimeError(f"Task failed with state '{state}': {error_msg}")
+                    
+        except Exception as e:
+            # Print error and retry during polling
+            print(f"[!] Error querying task status: {e}")
+            
+        time.sleep(poll_interval)
+
+def download_image(url, output_path):
+    """
+    Downloads the final image from the given URL and saves it locally.
+    """
+    print(f"[*] Downloading result image from: {url}")
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with open(output_path, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            f.write(chunk)
+    print(f"[+] Image saved successfully to: {output_path}")
+
+def delete_file_from_s3(bucket, key):
+    """
+    Cleans up the uploaded file from S3.
+    """
+    print(f"[*] Cleaning up temporary file from S3: {key}")
+    try:
+        s3_client = boto3.client(
+            's3',
+            aws_access_key_id=AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+            region_name=AWS_REGION
+        )
+        s3_client.delete_object(Bucket=bucket, Key=key)
+        print("[+] Temporary file deleted from S3 successfully.")
+    except Exception as e:
+        print(f"[!] Failed to delete temporary S3 object: {e}")
+
+def generate_img2img(local_image_paths, prompt, output_path=None):
+    """
+    High-level API that does:
+    1. S3 uploads
+    2. Model task trigger
+    3. Status polling
+    4. Saving result locally
+    5. Clean up S3 temporary files
+    """
+    if not AWS_ACCESS_KEY_ID or not AWS_SECRET_ACCESS_KEY:
+        raise ValueError("AWS_S3_ACCESS_KEY_ID or AWS_S3_SECRET_ACCESS_KEY is not configured in .env.")
+
+    # Validate that all input files exist
+    for img_path in local_image_paths:
+        if not os.path.exists(img_path):
+            raise FileNotFoundError(f"Local file '{img_path}' does not exist.")
+
+    s3_uploaded_keys = []
+    s3_urls = []
+    try:
+        # 1. Upload the local images to S3
+        for img_path in local_image_paths:
+            file_ext = os.path.splitext(img_path)[1] or ".png"
+            s3_temp_key = f"temp/{uuid.uuid4()}{file_ext}"
+            s3_url = upload_file_to_s3(img_path, AWS_BUCKET_NAME, s3_temp_key)
+            s3_uploaded_keys.append(s3_temp_key)
+            s3_urls.append(s3_url)
+        
+        # 2. Invoke the image-to-image model
+        task_id = generate_image(s3_urls, prompt)
+        
+        # 3. Poll for the task status with a 2-minute timeout
+        result_url = poll_task_status(task_id)
+        
+        # 4. Save the result to the output path
+        if not output_path:
+            output_path = f"result_{int(time.time())}.png"
+        download_image(result_url, output_path)
+        return output_path
+        
+    finally:
+        # 5. Clean up S3 temporary files
+        for key in s3_uploaded_keys:
+            delete_file_from_s3(AWS_BUCKET_NAME, key)

gpt_sim2real.py

@@ -0,0 +1,23 @@
+import sys
+import argparse
+import gpt_image
+
+def main():
+    parser = argparse.ArgumentParser(description="Upload reference images to S3, call img2img model, poll for result, and cleanup temporary files.")
+    parser.add_argument("images", nargs="+", help="Paths to local reference images.")
+    parser.add_argument("-o", "--output", help="Output path for the generated image. Defaults to 'result_<timestamp>.png' in current directory.")
+    parser.add_argument("-p", "--prompt", default="生成ta的真人照片，再生成ta的背面放在图片右边", help="Prompt for the img2img model.")
+    args = parser.parse_args()
+
+    try:
+        gpt_image.generate_img2img(
+            local_image_paths=args.images,
+            prompt=args.prompt,
+            output_path=args.output
+        )
+    except Exception as e:
+        print(f"[!] Execution failed: {e}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

gpt_skin2real.py

@@ -0,0 +1,130 @@
+import os
+import sys
+import uuid
+import time
+import argparse
+import numpy as np
+from PIL import Image
+
+import mc_render
+import gpt_image
+from build_target_img import check_skin, ensure_valid_skin
+from alice_to_steve import alice_to_steve
+from mc_voxel_texture_resolver import resolve_voxel_consistency
+
+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("-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()
+
+    # 1. Validate skin path
+    if not os.path.exists(args.skin):
+        print(f"Error: Skin file '{args.skin}' does not exist.")
+        sys.exit(1)
+
+    # 2. Process/Validate the skin image (Alex/Steve conversion, validity, consistency)
+    try:
+        print(f"[*] Processing skin file: {args.skin}")
+        skin_image = Image.open(args.skin).convert('RGBA')
+        valid, is_alex = check_skin(skin_image)
+        if not valid:
+            print(f"Error: Skin '{args.skin}' fails validation.")
+            sys.exit(1)
+        if is_alex:
+            print("[*] Detected Alex skin. Converting to Steve...")
+            skin_image = alice_to_steve(skin_image)
+        
+        skin_image = ensure_valid_skin(skin_image)
+        skin_image = resolve_voxel_consistency(skin_image)
+    except Exception as e:
+        print(f"[!] Skin processing failed: {e}")
+        sys.exit(1)
+
+    # 3. Generate front and back 3D renders using mc_render
+    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),
+    }
+
+    # Determine output filenames for renders
+    if args.render_only:
+        if args.output:
+            base, ext = os.path.splitext(args.output)
+            temp_front_path = f"{base}_front{ext or '.png'}"
+            temp_back_path = f"{base}_back{ext or '.png'}"
+        else:
+            temp_front_path = "render_front.png"
+            temp_back_path = "render_back.png"
+    else:
+        # Generate unique filenames for temp renders
+        unique_id = uuid.uuid4()
+        temp_front_path = f"temp_front_{unique_id}.png"
+        temp_back_path = f"temp_back_{unique_id}.png"
+
+    try:
+        print("[*] Rendering skin 3D front view...")
+        mc_render.render_skin(
+            skin=np.array(skin_image),
+            output_size=(768, 768),
+            cam_front=(0.25, 0.25, 0.25),
+            use_voxels=False,
+            ortho=False,
+            save_path=temp_front_path,
+            transparent_background=True,
+            zoom=0.3,
+            look_at_y=18,
+            pos_args=pos_args2,
+            off_screen=True
+        )
+
+        print("[*] Rendering skin 3D back view...")
+        mc_render.render_skin(
+            skin=np.array(skin_image),
+            output_size=(768, 768),
+            cam_front=(-0.25, 0.25, -0.25),
+            use_voxels=False,
+            ortho=False,
+            save_path=temp_back_path,
+            transparent_background=True,
+            zoom=0.3,
+            look_at_y=18,
+            pos_args=pos_args2,
+            off_screen=True
+        )
+
+        if args.render_only:
+            print(f"[+] Render-only mode active. Views saved to:\n  - {temp_front_path}\n  - {temp_back_path}")
+            return
+
+        # 4. Invoke gpt_image.generate_img2img
+        print("[*] Invoking image-to-image pipeline via gpt_image...")
+        output_file = gpt_image.generate_img2img(
+            local_image_paths=[temp_front_path, temp_back_path],
+            prompt=args.prompt,
+            output_path=args.output
+        )
+        print(f"[+] Pipeline completed successfully. Output saved to: {output_file}")
+
+    except Exception as e:
+        print(f"[!] Execution failed: {e}")
+        sys.exit(1)
+    finally:
+        # Clean up local temporary files if not in render-only mode
+        if not args.render_only:
+            for temp_file in [temp_front_path, temp_back_path]:
+                if os.path.exists(temp_file):
+                    print(f"[*] Removing local temporary file: {temp_file}")
+                    try:
+                        os.remove(temp_file)
+                    except Exception as e:
+                        print(f"[!] Failed to remove local file {temp_file}: {e}")
+
+if __name__ == '__main__':
+    main()