Upload 2 files

app.py

@@ -0,0 +1,255 @@
+import os
+import cv2
+import math
+import torch
+import numpy as np
+import gradio as gr
+import spaces
+from PIL import Image
+
+from huggingface_hub import hf_hub_download, snapshot_download
+from insightface.app import FaceAnalysis
+from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel
+from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel
+
+# ==============================================================================
+# 1. SETUP E INIZIALIZZAZIONE GLOBALE
+# ==============================================================================
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+
+def download_antelopev2():
+    """Scarica automaticamente i modelli di InsightFace se non sono presenti."""
+    model_dir = "./models/antelopev2"
+    if not os.path.exists(model_dir) or len(os.listdir(model_dir)) < 5:
+        print("Scaricamento dei modelli antelopev2 in corso...")
+        os.makedirs(model_dir, exist_ok=True)
+        # Scarica da un repository pubblico affidabile
+        snapshot_download(repo_id="DIAMONIK7777/antelopev2", local_dir=model_dir)
+        print("Scaricamento completato.")
+    return "./models"
+
+model_root = download_antelopev2()
+
+app = FaceAnalysis(name='antelopev2', root=model_root, providers=['CPUExecutionProvider'])
+app.prepare(ctx_id=0, det_size=(640, 640))
+
+base_model_path = "stabilityai/stable-diffusion-xl-base-1.0"
+instantid_path = "InstantX/InstantID"
+canny_path = "diffusers/controlnet-canny-sdxl-1.0"
+
+print("Caricamento ControlNet InstantID e Canny (per il Logo)...")
+# Usiamo MultiControlNet per unire il riconoscimento facciale (InstantID) e la forma del logo (Canny)
+controlnet_identity = ControlNetModel.from_pretrained(instantid_path, torch_dtype=dtype, use_safetensors=True)
+controlnet_logo = ControlNetModel.from_pretrained(canny_path, torch_dtype=dtype, use_safetensors=True)
+controlnet = MultiControlNetModel([controlnet_identity, controlnet_logo])
+
+print("Caricamento Pipeline SDXL...")
+pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+    base_model_path,
+    controlnet=controlnet,
+    torch_dtype=dtype,
+    use_safetensors=True
+)
+pipe.to(device)
+
+print("Caricamento Face Adapter InstantID...")
+pipe.load_ip_adapter("InstantX/InstantID", subfolder="models", weight_name="ip-adapter.bin")
+
+
+# ==============================================================================
+# 2. CONFIGURAZIONE STILI (Uso di Modelli Hugging Face Pubblici)
+# ==============================================================================
+
+# Invece di file locali, usiamo i repo ID di modelli pubblici gratuiti su Hugging Face
+STYLES = {
+    "Stile 1: Bit-Builder (8-Bit/Pixel Art)": {
+        "repo_id": "nerijs/pixel-art-xl", 
+        "weight_name": "pixel-art-xl.safetensors",
+        "prompt": "pixelart style, Pixel art portrait of a tech builder, indie hacker typing on a retro mechanical keyboard. He is wearing a jacket with a small green, white, and red square patch on the chest. Cyberpunk desk setup, glowing monitors displaying code. High quality, 8-bit game style.",
+        "negative_prompt": "ugly, deformed, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, watermark, text"
+    },
+    "Stile 2: Il Costruttore Rinascimentale": {
+        "repo_id": "davidmoref/sdxl-lora-adapter-renaissance", 
+        "weight_name": "pytorch_lora_weights.safetensors",
+        "prompt": "renaissance oil painting, A masterpiece renaissance oil painting of an Italian genius inventor in the style of Leonardo da Vinci. The man is holding a wooden prototype. He is wearing elegant renaissance dark clothes with a subtle green, white and red enameled pin on the lapel. Architectural blueprints on a rustic wooden table. Chiaroscuro lighting.",
+        "negative_prompt": "ugly, deformed, modern, photography, bad anatomy, worst quality, low quality, watermark, text"
+    },
+    "Stile 3: L'Architetto del Futuro (Design Geometrico)": {
+        "repo_id": "goofyai/flat_illustration_sdxl", 
+        "weight_name": "flat_illustration_sdxl.safetensors",
+        "prompt": "flat vector art, Modern flat vector illustration of a tech architect holding a smartphone. He wears a minimalist grey suit jacket featuring a small geometric green, white, and red enamel badge. Clean geometric lines, industrial design background, minimalistic.",
+        "negative_prompt": "ugly, deformed, photorealistic, 3d render, bad anatomy, worst quality, low quality, watermark, text"
+    },
+    "Stile 4: Genio Creativo (Pop-Art)": {
+        "repo_id": None, # SDXL di base gestisce molto bene la pop-art senza LoRA
+        "weight_name": None,
+        "prompt": "vintage pop art, Comic book style pop-art portrait of a creative maker. Vibrant colors. He wears a trendy jacket adorned with an 'Italian Builders' custom patch in green, white and red. Halftone dots, vintage poster aesthetic.",
+        "negative_prompt": "ugly, deformed, photorealistic, bad anatomy, worst quality, low quality, watermark, extra text"
+    }
+}
+
+# ==============================================================================
+# 3. PIPELINE DI GENERAZIONE
+# ==============================================================================
+
+def draw_kps(image_pil, kps, color_list=[(255,0,0), (0,255,0), (0,0,255), (255,255,0), (255,0,255)]):
+    """Genera keypoints per InstantID."""
+    stickwidth = 4
+    limbSeq = np.array([[0, 2], [1, 2], [3, 2], [4, 2]])
+    kps = np.array(kps)
+    w, h = image_pil.size
+    out_img = np.zeros([h, w, 3])
+
+    for i in range(len(limbSeq)):
+        index = limbSeq[i]
+        color = color_list[index[0]]
+        x = kps[index][:, 0]
+        y = kps[index][:, 1]
+        length = ((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2) ** 0.5
+        angle = math.degrees(math.atan2(y[0] - y[1], x[0] - x[1]))
+        polygon = cv2.ellipse2Poly((int(np.mean(x)), int(np.mean(y))), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
+        cv2.fillConvexPoly(out_img, polygon, color)
+    out_img = (out_img * 0.6).astype(np.uint8)
+
+    for idx, kp in enumerate(kps):
+        color = color_list[idx]
+        x, y = kp
+        cv2.circle(out_img, (int(x), int(y)), 10, color, -1)
+
+    return Image.fromarray(out_img.astype(np.uint8))
+
+def process_logo_canny(logo_img):
+    """Estrae i bordi (Canny) dal logo per guidare l'AI sulla forma, ignorando i colori originali."""
+    logo_cv = cv2.cvtColor(np.array(logo_img), cv2.COLOR_RGB2GRAY)
+    edges = cv2.Canny(logo_cv, 100, 200)
+    edges_3c = np.stack([edges]*3, axis=-1)
+    
+    # Crea un'immagine vuota della grandezza finale (es. 1024x1024)
+    canvas = np.zeros((1024, 1024, 3), dtype=np.uint8)
+    
+    # Ridimensiona il logo per farlo diventare una spilla/toppa (es. 200x200 pixel)
+    logo_resized = cv2.resize(edges_3c, (200, 200))
+    
+    # Posiziona il logo in basso a destra (es. sul petto o nell'angolo)
+    y_offset = 700
+    x_offset = 200
+    canvas[y_offset:y_offset+200, x_offset:x_offset+200] = logo_resized
+    
+    return Image.fromarray(canvas)
+
+@spaces.GPU(duration=120)
+def generate_avatar(user_image, logo_image, selected_style):
+    if user_image is None:
+        raise gr.Error("Per favore, carica un'immagine del volto.")
+    if logo_image is None:
+        raise gr.Error("Per favore, carica l'immagine del logo.")
+
+    # 1. Analisi del volto
+    cv_image = cv2.cvtColor(np.array(user_image), cv2.COLOR_RGB2BGR)
+    faces = app.get(cv_image)
+    if len(faces) == 0:
+        raise gr.Error("Nessun volto rilevato. Riprova con un'altra foto in cui il volto sia ben visibile.")
+    
+    face = sorted(faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
+    face_emb = face.normed_embedding
+    
+    # Ridimensioniamo l'immagine utente a 1024x1024 (standard SDXL) prima di estrarre i keypoints
+    user_image_resized = user_image.resize((1024, 1024))
+    faces_resized = app.get(cv2.cvtColor(np.array(user_image_resized), cv2.COLOR_RGB2BGR))
+    if len(faces_resized) > 0:
+        face_kps = sorted(faces_resized, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1].kps
+    else:
+        face_kps = face.kps * (1024 / max(user_image.size)) # Approssimazione se fallisce il resize
+        
+    kps_image = draw_kps(user_image_resized, face_kps)
+    
+    # 2. Elaborazione del Logo
+    # Il colore originale viene ignorato, prendiamo solo la sagoma (Canny edges)
+    logo_canny_image = process_logo_canny(logo_image)
+    
+    # 3. Gestione LoRA dinamico da Hugging Face
+    style_config = STYLES[selected_style]
+    repo_id = style_config["repo_id"]
+    
+    if repo_id:
+        try:
+            print(f"Scaricamento/Caricamento LoRA {repo_id}...")
+            pipe.load_lora_weights(repo_id, weight_name=style_config["weight_name"])
+        except Exception as e:
+            print(f"Errore caricamento LoRA da HF: {e}")
+
+    # 4. Generazione immagine
+    prompt = style_config["prompt"]
+    negative_prompt = style_config["negative_prompt"]
+    
+    print("Inizio generazione MultiControlNet...")
+    image = pipe(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        image_embeds=face_emb,
+        # Passiamo le due immagini di controllo: [Volto, Forma del Logo]
+        image=[kps_image, logo_canny_image],
+        # Bilanciamo l'influenza: 0.8 per il volto, 0.4 per il logo (abbastanza per imprimere la forma ma fuso)
+        controlnet_conditioning_scale=[0.8, 0.4],
+        ip_adapter_scale=0.8,
+        num_inference_steps=30,
+        guidance_scale=5.0,
+    ).images[0]
+    
+    if repo_id:
+        try:
+            pipe.unload_lora_weights()
+        except:
+            pass
+            
+    return image
+
+# ==============================================================================
+# 4. INTERFACCIA GRADIO (FRONTEND)
+# ==============================================================================
+
+custom_css = """
+.container { max-width: 1000px; margin: auto; padding-top: 2rem; }
+.header-title { text-align: center; color: #1e3a8a; font-family: 'Inter', sans-serif; font-weight: 800; font-size: 2.5rem; margin-bottom: 0.5rem; }
+.header-subtitle { text-align: center; color: #4b5563; font-size: 1.1rem; margin-bottom: 2rem; }
+.generate-btn { background: linear-gradient(90deg, #10b981 0%, #3b82f6 100%) !important; color: white !important; font-weight: bold !important; font-size: 1.2rem !important; border: none !important; transition: transform 0.2s ease; }
+.generate-btn:hover { transform: scale(1.02); }
+"""
+
+theme = gr.themes.Soft(primary_hue="blue", secondary_hue="emerald").set(
+    button_primary_background_fill="*primary_500",
+    button_primary_background_fill_hover="*primary_600",
+)
+
+with gr.Blocks(css=custom_css, theme=theme) as demo:
+    with gr.Column(elem_classes="container"):
+        gr.HTML("<h1 class='header-title'>🇮🇹 Italian Builders Avatar Generator 🇮🇹</h1>")
+        gr.HTML("<p class='header-subtitle'>Trasforma il tuo selfie. Il tuo brand, la tua identità.</p>")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_image = gr.Image(type="pil", label="1. Carica il tuo Selfie")
+                logo_image = gr.Image(type="pil", label="2. Carica il Logo (es. PNG a colori)")
+                
+            with gr.Column(scale=1):
+                style_selector = gr.Radio(
+                    choices=list(STYLES.keys()),
+                    label="3. Scegli il tuo Stile",
+                    value=list(STYLES.keys())[0]
+                )
+                gr.Markdown("<br>")
+                generate_button = gr.Button("Genera il tuo Avatar 🚀", elem_classes="generate-btn", variant="primary")
+                
+            with gr.Column(scale=1):
+                output_image = gr.Image(label="Il tuo Avatar Builder", interactive=False)
+                
+        generate_button.click(
+            fn=generate_avatar,
+            inputs=[input_image, logo_image, style_selector],
+            outputs=output_image
+        )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,10 @@
+gradio>=4.0.0
+spaces
+torch
+diffusers>=0.26.0
+transformers
+accelerate
+insightface
+onnxruntime
+opencv-python
+huggingface-hub