Upload folder using huggingface_hub

config.json

@@ -0,0 +1,6 @@
+{
+    "prompt": "A beautiful landscape",
+    "style_name": "Fantasy art",
+    "seed": 42,
+    "val_r": 0.4
+}

gradio_sketch2image.py

@@ -379,4 +379,4 @@ with gr.Blocks(css="style.css") as demo:
     image.change(run, inputs=inputs, outputs=outputs, queue=False, api_name=False)
 
 if __name__ == "__main__":
-    demo.queue().launch(debug=True)
+    demo.queue().launch(debug=True)

i2i_sk.py

@@ -0,0 +1,124 @@
+from flask import Flask, request, jsonify
+from io import BytesIO
+import base64
+from PIL import Image
+import torch
+import torchvision.transforms.functional as F
+from torch.cuda.amp import autocast
+from flask_cors import CORS  # Import CORS
+
+from src.pix2pix_turbo import Pix2Pix_Turbo
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+
+# Configuration Variables
+model_type = "sketch_to_image_stochastic"
+output_format = "PNG"
+desired_size = (768, 768)  # Increased resolution for better quality
+
+# Load the model when the app starts
+print("Loading model...")
+model = Pix2Pix_Turbo(model_type)
+print("Model loaded successfully.")
+
+# Example styles list (update this with your actual styles)
+style_list = [
+    {"name": "Cinematic", "prompt": "cinematic still {prompt} . emotional, harmonious, vignette, highly detailed, high budget, bokeh, cinemascope, moody, epic, gorgeous, film grain, grainy"},
+    {"name": "3D Model", "prompt": "professional 3d model {prompt} . octane render, highly detailed, volumetric, dramatic lighting"},
+    {"name": "Anime", "prompt": "anime artwork {prompt} . anime style, key visual, vibrant, studio anime,  highly detailed"},
+    {"name": "Digital Art", "prompt": "concept art {prompt} . digital artwork, illustrative, painterly, matte painting, highly detailed"},
+    {"name": "Photographic", "prompt": "cinematic photo {prompt} . 35mm photograph, film, bokeh, professional, 4k, highly detailed"},
+    {"name": "Pixel art", "prompt": "pixel-art {prompt} . low-res, blocky, pixel art style, 8-bit graphics"},
+    {"name": "Fantasy art", "prompt": "ethereal fantasy concept art of  {prompt} . magnificent, celestial, ethereal, painterly, epic, majestic, magical, fantasy art, cover art, dreamy"},
+    {"name": "Neonpunk", "prompt": "neonpunk style {prompt} . cyberpunk, vaporwave, neon, vibes, vibrant, stunningly beautiful, crisp, detailed, sleek, ultramodern, magenta highlights, dark purple shadows, high contrast, cinematic, ultra detailed, intricate, professional"},
+    {"name": "Manga", "prompt": "manga style {prompt} . vibrant, high-energy, detailed, iconic, Japanese comic style"},
+]
+
+styles = {k["name"]: k["prompt"] for k in style_list}
+
+def process_image(image, prompt, prompt_template, style_name, seed, val_r):
+    image = image.convert("RGB")
+    
+    # Convert image to tensor and threshold, then convert to float
+    image_t = F.to_tensor(image) > 0.5
+    image_t = image_t.float()
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    with torch.no_grad(), autocast():
+        # Move the tensor to the appropriate device
+        c_t = image_t.unsqueeze(0).to(device).float()
+        torch.manual_seed(seed)
+        B, C, H, W = c_t.shape
+        noise = torch.randn((1, 4, H // 8, W // 8), device=device)  # Ensure noise is on the same device
+        
+        # Pass through the model
+        output_image = model(c_t, prompt, deterministic=False, r=val_r, noise_map=noise)
+        
+    output_pil = F.to_pil_image(output_image[0].cpu() * 0.5 + 0.5)
+    return output_pil
+
+@app.route('/process-image', methods=['POST'])
+def process_image_route():
+    data = request.get_json()
+
+    # Debugging: Print the raw received data
+    print("Received JSON data:", data)
+
+    if not data or 'image' not in data:
+        print("Error: No image provided")
+        return jsonify({"error": "No image provided"}), 400
+
+    # Decode the base64 image (remove the prefix 'data:image/png;base64,' if present)
+    image_data = data['image']
+    print("Received base64 image data (truncated):", image_data[:100])  # Print first 100 chars of base64 data
+
+    if image_data.startswith('data:image/png;base64,'):
+        image_data = image_data.split(",")[1]
+    
+    try:
+        image_bytes = base64.b64decode(image_data)
+        image = Image.open(BytesIO(image_bytes))
+    except Exception as e:
+        print("Error decoding base64 image:", str(e))
+        return jsonify({"error": "Invalid image data"}), 400
+
+    # Retrieve other parameters
+    prompt = data.get('prompt', 'a cat')
+    style_name = data.get('style_name', 'Fantasy art').strip()  # Strip any leading/trailing whitespace
+    seed = int(data.get('seed', 42))
+    val_r = float(data.get('val_r', 0.8))
+
+    # Debug: print available styles
+    print(f"Available styles: {list(styles.keys())}")
+    print(f"Received style name: {style_name}")
+
+    # Case-insensitive lookup
+    style_name = next((key for key in styles if key.lower() == style_name.lower()), None)
+    if not style_name:
+        print(f"Error: Style '{data.get('style_name')}' not found")
+        return jsonify({"error": f"Style '{data.get('style_name')}' not found"}), 400
+
+    prompt_template = styles[style_name]
+
+    print(f"Using style: {style_name} with prompt: {prompt}")
+
+    # Process the image
+    try:
+        processed_image = process_image(image, prompt, prompt_template, style_name, seed, val_r)
+    except Exception as e:
+        print("Error processing image:", str(e))
+        return jsonify({"error": "Failed to process image"}), 500
+
+    # Convert the processed image to base64
+    img_io = BytesIO()
+    processed_image.save(img_io, format=output_format)
+    img_io.seek(0)
+    img_base64 = base64.b64encode(img_io.getvalue()).decode('utf-8')
+
+    print("Processed image successfully, sending back to client")
+    return jsonify({"image": img_base64})
+
+if __name__ == "__main__":
+    app.run(host='0.0.0.0', port=5000)

image_base64.txt

@@ -0,0 +1 @@
+data:image/png;base64,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