Upload app.py

app.py

@@ -9,8 +9,8 @@ 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.models.controlnets.multicontrolnet import MultiControlNetModel
+from diffusers import ControlNetModel
+from diffusers.pipelines import StableDiffusionXLInstantIDPipeline
 
 # ==============================================================================
 # 1. SETUP E INIZIALIZZAZIONE GLOBALE
@@ -25,72 +25,69 @@ def download_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.")
-    # Insightface aggiunge in automatico "/models/antelopev2" alla root che gli passiamo.
-    # Quindi la root corretta da passargli è "./", così cercherà in "./models/antelopev2".
     return "./"
 
 model_root = download_antelopev2()
 
-app = FaceAnalysis(name='antelopev2', root=model_root, providers=['CPUExecutionProvider'])
-app.prepare(ctx_id=0, det_size=(640, 640))
+face_app = FaceAnalysis(name='antelopev2', root=model_root, providers=['CPUExecutionProvider'])
+face_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"
+# Scarica il file ip-adapter.bin di InstantID
+face_adapter = hf_hub_download(repo_id="InstantX/InstantID", filename="ip-adapter.bin")
 
-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, 
-    subfolder="ControlNetModel", 
-    torch_dtype=dtype, 
+# Carica il ControlNet (IdentityNet) di InstantID
+print("Caricamento ControlNet InstantID...")
+controlnet = ControlNetModel.from_pretrained(
+    "InstantX/InstantID",
+    subfolder="ControlNetModel",
+    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,
+# Carica la pipeline dedicata InstantID (NON quella generica ControlNet)
+print("Caricamento Pipeline SDXL InstantID...")
+pipe = StableDiffusionXLInstantIDPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0",
     controlnet=controlnet,
     torch_dtype=dtype,
     use_safetensors=True
 )
-pipe.to(device)
 
+# Carica il Face Adapter con il metodo specifico di InstantID
 print("Caricamento Face Adapter InstantID...")
-pipe.load_ip_adapter("InstantX/InstantID", subfolder="", weight_name="ip-adapter.bin")
+pipe.load_ip_adapter_instantid(face_adapter)
+pipe.to(device)
+
+print("Pipeline pronta!")
 
 
 # ==============================================================================
-# 2. CONFIGURAZIONE STILI (Uso di Modelli Hugging Face Pubblici)
+# 2. CONFIGURAZIONE STILI
 # ==============================================================================
 
-# 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", 
+        "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", 
+        "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", 
+        "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
+        "repo_id": None,
         "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"
@@ -102,7 +99,7 @@ STYLES = {
 # ==============================================================================
 
 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."""
+    """Genera l'immagine dei keypoints per la ControlNet di InstantID."""
     stickwidth = 4
     limbSeq = np.array([[0, 2], [1, 2], [3, 2], [4, 2]])
     kps = np.array(kps)
@@ -127,59 +124,71 @@ def draw_kps(image_pil, kps, color_list=[(255,0,0), (0,255,0), (0,0,255), (255,2
 
     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)
+def apply_logo_overlay(generated_image, logo_image, style_name):
+    """
+    Applica il logo sull'immagine generata come una "spilla" o "toppa",
+    adattandone l'aspetto in base allo stile scelto.
+    """
+    logo = logo_image.copy().convert("RGBA")
+
+    # Ridimensiona il logo per farlo sembrare una spilla (circa 15% dell'immagine)
+    logo_size = int(generated_image.width * 0.15)
+    logo = logo.resize((logo_size, logo_size), Image.LANCZOS)
+
+    # Applica filtri stilistici al logo in base allo stile
+    logo_np = np.array(logo)
+
+    if "Bit-Builder" in style_name:
+        # Effetto pixelato: rimpicciolisci e riallarga
+        small = cv2.resize(logo_np, (16, 16), interpolation=cv2.INTER_NEAREST)
+        logo_np = cv2.resize(small, (logo_size, logo_size), interpolation=cv2.INTER_NEAREST)
+    elif "Rinascimentale" in style_name:
+        # Effetto dipinto a olio: sfocatura leggera
+        logo_np[:, :, :3] = cv2.bilateralFilter(logo_np[:, :, :3], 9, 75, 75)
+    elif "Architetto" in style_name:
+        # Effetto geometrico: aumento contrasto
+        logo_np[:, :, :3] = np.clip(logo_np[:, :, :3].astype(np.float32) * 1.3, 0, 255).astype(np.uint8)
+    # Pop-Art: logo invariato (già vivace di suo)
+
+    logo_styled = Image.fromarray(logo_np)
+
+    # Posiziona il logo in basso a sinistra (zona petto)
+    x_pos = int(generated_image.width * 0.15)
+    y_pos = int(generated_image.height * 0.70)
+
+    # Componi sul risultato finale
+    result = generated_image.convert("RGBA")
+    result.paste(logo_styled, (x_pos, y_pos), logo_styled)
+
+    return result.convert("RGB")
 
 @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)
+    faces = face_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
+    face_kps = face.kps
+
+    # Ridimensioniamo l'immagine utente a 1024x1024 (standard SDXL)
     user_image_resized = user_image.resize((1024, 1024))
-    faces_resized = app.get(cv2.cvtColor(np.array(user_image_resized), cv2.COLOR_RGB2BGR))
+    faces_resized = face_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
+
+    # 2. Gestione LoRA
     style_config = STYLES[selected_style]
     repo_id = style_config["repo_id"]
-    
+
     if repo_id:
         try:
             print(f"Scaricamento/Caricamento LoRA {repo_id}...")
@@ -187,30 +196,32 @@ def generate_avatar(user_image, logo_image, selected_style):
         except Exception as e:
             print(f"Errore caricamento LoRA da HF: {e}")
 
-    # 4. Generazione immagine
+    # 3. Generazione immagine con InstantID
     prompt = style_config["prompt"]
     negative_prompt = style_config["negative_prompt"]
-    
-    print("Inizio generazione MultiControlNet...")
+
+    print("Inizio generazione InstantID...")
+    pipe.set_ip_adapter_scale(0.8)
     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,
+        image=kps_image,
+        controlnet_conditioning_scale=0.8,
         num_inference_steps=30,
         guidance_scale=5.0,
     ).images[0]
-    
+
     if repo_id:
         try:
             pipe.unload_lora_weights()
         except:
             pass
-            
+
+    # 4. Sovrapposizione del logo stilizzato (se fornito)
+    if logo_image is not None:
+        image = apply_logo_overlay(image, logo_image, selected_style)
+
     return image
 
 # ==============================================================================
@@ -234,12 +245,12 @@ 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)")
-                
+                logo_image = gr.Image(type="pil", label="2. Carica il Logo (opzionale, PNG a colori)")
+
             with gr.Column(scale=1):
                 style_selector = gr.Radio(
                     choices=list(STYLES.keys()),
@@ -248,10 +259,10 @@ with gr.Blocks(css=custom_css, theme=theme) as demo:
                 )
                 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],