Update app.py

app.py

@@ -3,76 +3,78 @@ import numpy as np
 from PIL import Image
 import random
 
-# Initialisation des listes de paramètres
+# Listes pour stocker les pixels validés et non validés
 oe = []
 nn = []
 
-# Fonction pour générer une image en fonction des pixels environnants
-def generate_image_with_neighboring_pixels(base_pixels, avoid_data=None):
-    width, height = 300, 300
+# Fonction pour traiter et redimensionner l'image importée
+def process_uploaded_image(uploaded_file):
+    image = Image.open(uploaded_file).resize((300, 300))
+    pixel_data = np.array(image)
+    return pixel_data
+
+# Fonction pour générer une image en fonction des pixels voisins
+def generate_image_from_neighbors(base_pixels):
+    height, width, _ = base_pixels.shape
     generated_image = np.zeros((height, width, 3), dtype=np.uint8)
-    
-    for i in range(1, height - 1):
-        for j in range(1, width - 1):
-            # Obtenir les valeurs des pixels environnants (haut, bas, gauche, droite)
-            neighbors = [
-                base_pixels[i-1, j],  # haut
-                base_pixels[i+1, j],  # bas
-                base_pixels[i, j-1],  # gauche
-                base_pixels[i, j+1],  # droite
-            ]
-            
-            # Moyenne des pixels environnants pour la variation
-            mean_pixel = np.mean(neighbors, axis=0)
-            
-            # Ajustement aléatoire pour éviter la répétition
-            variation = np.array([random.randint(-15, 15) for _ in range(3)])
-            new_pixel = np.clip(mean_pixel + variation, 0, 255)
 
-            # Éviter les données précédemment refusées
-            if avoid_data and tuple(new_pixel) in avoid_data:
-                new_pixel = (new_pixel + np.array([random.randint(20, 40) for _ in range(3)])) % 255
+    # Itération sur chaque pixel de l'image
+    for i in range(height):
+        for j in range(width):
+            # Collecte des couleurs des pixels environnants
+            surrounding_pixels = []
+            for di in range(-1, 2):  # -1, 0, 1
+                for dj in range(-1, 2):  # -1, 0, 1
+                    if 0 <= i + di < height and 0 <= j + dj < width:
+                        surrounding_pixels.append(base_pixels[i + di, j + dj])
+            
+            # Calculer la moyenne des pixels environnants
+            surrounding_pixels = np.array(surrounding_pixels)
+            new_pixel_color = np.mean(surrounding_pixels, axis=0)
 
-            generated_image[i, j] = new_pixel
+            # Ajouter une petite variation aléatoire pour générer de l'unicité
+            variation = np.array([random.randint(-20, 20) for _ in range(3)])
+            new_pixel_color = np.clip(new_pixel_color + variation, 0, 255).astype(np.uint8)
+            generated_image[i, j] = new_pixel_color
 
     return Image.fromarray(generated_image)
 
-# Fonction pour traiter l'image importée
-def process_uploaded_image(uploaded_file):
-    # Ouvrir et redimensionner l'image importée
-    image = Image.open(uploaded_file).resize((300, 300))
-    # Convertir l'image en tableau de pixels pour analyse
-    pixel_data = np.array(image)
-    return pixel_data
+# Interface utilisateur pour télécharger et afficher l'image importée
+st.title("Générateur d'images d'animaux basé sur l'image importée")
+st.write("Choisissez un animal pour générer une image ou téléchargez une image comme référence.")
 
-# Interface utilisateur
-st.title("Générateur d'images basées sur pixels environnants")
+# Téléchargement de l'image importée
 uploaded_file = st.file_uploader("Téléchargez une image de référence (JPG ou PNG)", type=["jpg", "jpeg", "png"])
 
-# Génération de l'image
+# Génération d'image selon la référence téléchargée
 if uploaded_file:
-    # Traiter l'image téléchargée
     base_pixels = process_uploaded_image(uploaded_file)
-    st.image(Image.fromarray(base_pixels), caption="Image de référence", use_column_width=True)
+    st.image(Image.fromarray(base_pixels), caption="Image importée de référence", use_column_width=True)
 
-    # Bouton pour générer l'image
+    # Choisir l'animal et générer une nouvelle image basée sur cette référence
     if st.button("Générer une image"):
-        generated_image = generate_image_with_neighboring_pixels(base_pixels, avoid_data=set(nn))
+        generated_image = generate_image_from_neighbors(base_pixels)
         st.image(generated_image, caption="Image générée", use_column_width=True)
 
-        # Validation de l'image générée
+        # Options de validation de l'image générée
         if st.button("Oui"):
-            # Enregistrer les paramètres dans la liste 'oe'
-            oe.clear()
-            oe.append(base_pixels.tolist())
-            st.success("Image validée et paramètres enregistrés dans 'oe'!")
+            # Enregistrer les pixels de l'image générée dans la liste "oe"
+            oe.extend(generated_image.getdata())
+            oe = list(set(oe))  # Enlever les doublons
+            st.success("Image validée!")
+        
         elif st.button("Non"):
-            # Ajouter les paramètres dans la liste 'nn'
-            nn.append(generated_image.getdata().tolist())
-            st.error("Image rejetée et paramètres enregistrés dans 'nn'!")
+            # Enregistrer les pixels de l'image générée dans la liste "nn"
+            nn.extend(generated_image.getdata())
+            nn = list(set(nn))  # Enlever les doublons
+            st.error("Image rejetée!")
+
+    # Affichage des listes de pixels validés et non validés
+    st.write("Pixels validés (oe):", oe)
+    st.write("Pixels non validés (nn):", nn)
 
-# Afficher les listes 'oe' et 'nn'
-st.write("### Liste des paramètres validés ('oe'):")
-st.write(oe)
-st.write("### Liste des paramètres rejetés ('nn'):")
-st.write(nn)
+# Option pour réinitialiser les listes
+if st.button("Réinitialiser les listes"):
+    oe.clear()
+    nn.clear()
+    st.success("Les listes de pixels ont été réinitialisées.")