Update app.py

app.py

@@ -2,72 +2,77 @@ import streamlit as st
 import numpy as np
 from PIL import Image
 import random
-import io
 
-# Initialisation des données pour éviter les erreurs répétées
-error_data = {}
+# Initialisation des listes de paramètres
+oe = []
+nn = []
 
-# Fonction pour traiter et redimensionner 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
-
-# Fonction pour générer une image avec variations basées sur les pixels environnants
-def generate_image_with_variation(base_pixels, label, avoid_data=None):
+# 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
     generated_image = np.zeros((height, width, 3), dtype=np.uint8)
-
-    for i in range(height):
-        for j in range(width):
-            # Utiliser le pixel de référence et ajouter des variations aléatoires
-            base_pixel = base_pixels[i, j]
+    
+    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
+            ]
             
-            # Ajouter une variation aléatoire aux composants RGB
-            variation = np.array([random.randint(-20, 20) for _ in range(3)])
-            new_pixel = np.clip(base_pixel + variation, 0, 255)
-
-            # Éviter les combinaisons déjà marquées comme erreur
-            if avoid_data and (i, j) in avoid_data:
-                new_pixel = (new_pixel + np.array([random.randint(0, 50) for _ in range(3)])) % 255
+            # 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
+
             generated_image[i, j] = new_pixel
 
     return Image.fromarray(generated_image)
 
-# 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.")
+# 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
 
-# Téléchargement de l'image importée
+# Interface utilisateur
+st.title("Générateur d'images basées sur pixels environnants")
 uploaded_file = st.file_uploader("Téléchargez une image de référence (JPG ou PNG)", type=["jpg", "jpeg", "png"])
 
-# Génération d'image selon la référence téléchargée
+# Génération de l'image
 if uploaded_file:
-    # Traiter l'image téléchargée et afficher l'aperçu
+    # Traiter l'image téléchargée
     base_pixels = process_uploaded_image(uploaded_file)
-    st.image(Image.fromarray(base_pixels), caption="Image importée de référence", use_column_width=True)
+    st.image(Image.fromarray(base_pixels), caption="Image de référence", use_column_width=True)
 
-    # Choisir l'animal et générer une nouvelle image basée sur cette référence
-    animal = st.selectbox("Sélectionnez un animal :", ["chat", "chien", "cheval"])
+    # Bouton pour générer l'image
     if st.button("Générer une image"):
-        generated_image = generate_image_with_variation(base_pixels, animal, avoid_data=error_data.get(animal))
-        st.image(generated_image, caption=f"Image générée pour un {animal}", use_column_width=True)
+        generated_image = generate_image_with_neighboring_pixels(base_pixels, avoid_data=set(nn))
+        st.image(generated_image, caption="Image générée", use_column_width=True)
 
-        # Options de validation de l'image générée
+        # Validation de l'image générée
         if st.button("Oui"):
-            st.success("Image validée!")
+            # 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'!")
         elif st.button("Non"):
-            # Enregistrer les données d'erreurs pour les prochains essais
-            error_data[animal] = error_data.get(animal, set())
-            for i in range(300):
-                for j in range(300):
-                    error_data[animal].add((i, j))
-            st.error("Image rejetée et erreurs enregistrées!")
+            # 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'!")
 
-# Bouton pour réinitialiser les erreurs
-if st.button("Réinitialiser les erreurs"):
-    error_data.clear()
-    st.success("Les erreurs précédentes ont été réinitialisées.")
+# 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)