File size: 3,797 Bytes
d9d911b
0829863
78bf11f
d9d911b
0829863
 
9d66e5c
9a49ef0
c0f52c1
1ffc013
ae92ac0
928ad22
 
ff463d8
9d66e5c
5e97f0c
 
928ad22
 
 
 
 
 
 
 
 
 
ae92ac0
1ffc013
928ad22
 
ae92ac0
1ffc013
928ad22
1ffc013
 
ae92ac0
 
1ffc013
 
0829863
1ffc013
0829863
 
ae92ac0
0829863
d9d911b
 
 
 
 
78bf11f
5e97f0c
 
 
 
0829863
 
5e97f0c
0829863
 
 
 
5e97f0c
0829863
 
5e97f0c
 
0829863
5e97f0c
0829863
5e97f0c
0829863
 
d9d911b
5e97f0c
0829863
d9d911b
 
5e97f0c
d9d911b
78bf11f
0829863
9a49ef0
 
 
5e97f0c
9a49ef0
5e97f0c
 
 
 
0829863
5e97f0c
 
928ad22
0829863
5e97f0c
 
 
78bf11f
d9d911b
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import requests
import streamlit as st
from PIL import Image
from io import BytesIO
import numpy as np
import cv2

# Configuration de l'API Hugging Face (Inpainting model)
API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-inpainting"

 
# Fonction pour redimensionner l'image
def resize_image(image, max_size=(512, 512)):
    return image.resize(max_size, Image.LANCZOS)

# Fonction pour appeler l'API Hugging Face et générer une image avec inpainting
def inpaint_image(prompt, image, mask):
    # Convertir l'image et le masque en JPEG pour réduire la taille des données
    image = Image.fromarray(image)
    mask = Image.fromarray(mask)

    # Redimensionner pour éviter les problèmes de taille
    image = resize_image(image)
    mask = resize_image(mask)

    # Convertir en bytes
    buffered_image = BytesIO()
    image.save(buffered_image, format="PNG")
    buffered_image.seek(0)  # Rewind the BytesIO object

    buffered_mask = BytesIO()
    mask.save(buffered_mask, format="PNG")
    buffered_mask.seek(0)  # Rewind the BytesIO object

    # Envoyer la requête avec l'image et le masque en multipart/form-data
    files = {
        'image': ('image.png', buffered_image, 'image/png'),
        'mask': ('mask.png', buffered_mask, 'image/png')
    }
    
    data = {
        'prompt': prompt
    }
    
    response = requests.post(API_URL,   files=files, data=data)
    
    if response.status_code == 200:
        return response.content
    else:
        st.error(f"Erreur : {response.status_code}, {response.text}")
        return None

# Fonction pour détecter et générer le masque du visage
def detect_face_and_create_mask(uploaded_image):
    # Convertir l'image uploadée en format OpenCV
    image = np.array(Image.open(uploaded_image).convert('RGB'))
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Utiliser le modèle de détection de visages de OpenCV
    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

    if len(faces) == 0:
        st.error("Aucun visage détecté dans l'image téléchargée.")
        return None, None
    
    # Créer un masque pour le visage détecté
    mask = np.zeros_like(image)
    for (x, y, w, h) in faces:
        mask[y:y + h, x:x + w] = [255, 255, 255]  # Zone du visage à remplacer en blanc

    return image, mask

# Interface principale
def main():
    st.title("Fusion réaliste du visage dans une image générée")

    prompt = st.text_input(
        "Entrez une description pour générer une image :",
        "A professional LinkedIn profile picture of a person in business attire."
    )

    # Télécharger l'image de l'utilisateur
    uploaded_image = st.file_uploader("Téléchargez une photo de votre visage (JPEG/PNG)", type=["jpg", "jpeg", "png"])

    if uploaded_image is not None:
        st.image(uploaded_image, caption="Votre photo téléchargée", use_column_width=True)
        
        # Détecter le visage et créer le masque
        image, mask = detect_face_and_create_mask(uploaded_image)
        if image is not None and mask is not None:
            st.image(mask, caption="Masque généré pour le visage", use_column_width=True)

            if st.button("Générer et remplacer le visage"):
                # Utiliser le modèle d'inpainting pour remplacer le visage
                result = inpaint_image(prompt, image, mask)
                
                if result:
                    final_image = Image.open(BytesIO(result))
                    st.image(final_image, caption="Image finale avec le visage remplacé", use_column_width=True)

if __name__ == "__main__":
    main()