Update app.py

app.py

@@ -2,109 +2,76 @@ import streamlit as st
 import numpy as np
 from PIL import Image
 import random
-import time
 import io
 
-# Configuration de la page Streamlit
-st.title("Générateur d'images d'animaux")
-st.write("Choisissez un animal pour générer une image ou téléchargez une image à déchiffrer.")
+# Initialisation des données pour éviter les erreurs répétées
+error_data = {}
 
-# Initialisation des variables
-validation_data = {}
-auto_training_data = {}
-rejected_pixel_data = {}
+# 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 créer une image aléatoire basée sur les données de pixels de l'image importée
-def create_image_from_data(base_data, label):
+# Fonction pour générer une image basée sur les pixels environnants
+def generate_image_based_on_pixels(base_pixels, label, avoid_data=None):
     width, height = 300, 300
-    image = np.zeros((height, width, 3), dtype=np.uint8)
+    generated_image = np.zeros((height, width, 3), dtype=np.uint8)
 
+    # Parcourir les pixels pour générer l'image
     for i in range(height):
         for j in range(width):
-            # Utilisation des gradients de couleurs autour de pixels voisins
-            if (i, j) in base_data:
-                avg_color = base_data[(i, j)]
+            # Choisir des valeurs de pixels similaires aux pixels environnants de l'image importée
+            if i > 0 and j > 0:
+                # Prendre en compte le pixel précédent, celui au-dessus et en diagonale
+                avg_pixel = (
+                    base_pixels[i-1, j] + base_pixels[i, j-1] + base_pixels[i-1, j-1]
+                ) // 3
             else:
-                # Génère une couleur aléatoire proche du thème
-                avg_color = [random.randint(100, 200), random.randint(100, 200), random.randint(100, 200)]
-                
-            # Appliquer les valeurs du dégradé en fonction de la proximité des pixels rejetés
-            if (i, j) in rejected_pixel_data:
-                avg_color = np.clip(np.array(avg_color) * 0.8, 0, 255)
-
-            image[i, j] = avg_color
+                # Premier pixel arbitraire
+                avg_pixel = base_pixels[i, j]
 
-    return Image.fromarray(image.astype(np.uint8))
+            # Éviter les valeurs problématiques des erreurs enregistrées
+            if avoid_data and (i, j) in avoid_data:
+                avg_pixel = (avg_pixel + np.array([random.randint(0, 50) for _ in range(3)])) % 255
 
-# Fonction pour extraire les données de pixels de l'image téléchargée
-def extract_pixel_data(image):
-    width, height = image.size
-    pixels = image.load()
-    pixel_data = {}
-
-    for i in range(width):
-        for j in range(height):
-            pixel_data[(i, j)] = pixels[i, j]  # Enregistrer la couleur du pixel
-
-    return pixel_data
+            generated_image[i, j] = avg_pixel
 
-# Fonction pour traiter l'image téléchargée
-def process_uploaded_image(uploaded_file):
-    image = Image.open(uploaded_file).resize((300, 300))
-    return extract_pixel_data(image)
+    return Image.fromarray(generated_image)
 
-# Fonction pour gérer la validation des images
-def validate_image(is_valid, label, base_data):
-    if is_valid:
-        validation_data[label] = base_data
-    else:
-        rejected_pixel_data.update(base_data)  # Enregistre les pixels de l'image rejetée
+# 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
-animal = st.radio("Sélectionnez un animal :", ("chat", "chien", "cheval"))
-uploaded_file = st.file_uploader("Ou téléchargez une image (JPG, PNG)", type=["jpg", "jpeg", "png"])
+# 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 à partir de données de pixels de l'image importée
+# Génération d'image selon la référence téléchargée
 if uploaded_file:
-    base_data = process_uploaded_image(uploaded_file)
-    st.image(Image.fromarray(np.array([[base_data.get((i, j), (255, 255, 255)) for i in range(300)] for j in range(300)], dtype=np.uint8)), caption="Image importée décryptée", use_column_width=True)
-else:
-    base_data = None
-
-if st.button("Générer une image"):
-    if base_data:
-        img = create_image_from_data(base_data, animal)
-    else:
-        st.warning("Veuillez d'abord importer une image pour guider la génération.")
-        img = create_image_from_data({}, animal)  # Génération aléatoire si aucune image n'est importée
-    
-    st.image(img, caption=f"Image générée pour un {animal}", use_column_width=True)
-
-    # Boutons de validation
-    if st.button("Oui"):
-        validate_image(True, animal, base_data)
-        st.success("Image validée!")
-    elif st.button("Non"):
-        validate_image(False, animal, base_data)
-        st.error("Image rejetée et données enregistrées pour améliorer la génération future!")
-
-# Bouton pour réinitialiser le processus
-if st.button("Réinitialiser"):
-    validation_data.clear()
-    rejected_pixel_data.clear()
-    st.success("Le processus a été réinitialisé.")
-
-# Champ de texte pour données manuelles
-if st.button("Don"):
-    don_text = st.text_area("Entrez vos données :", "")
-    if st.button("Envoyer"):
-        if don_text:
-            auto_training_data['data'] = don_text
-            st.success("Données envoyées!")
-        else:
-            st.error("Le champ de texte ne peut pas être vide.")
-
-# Démarrer le processus automatiquement après 3 secondes si le champ 'Don' n'est pas rempli
-if 'data' not in auto_training_data:
-    time.sleep(3)
-    st.success("Démarrage automatique du processus d'apprentissage...")
+    # Traiter l'image téléchargée et afficher l'aperçu
+    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)
+
+    # 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"])
+    if st.button("Générer une image"):
+        generated_image = generate_image_based_on_pixels(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)
+
+        # Options de validation de l'image générée
+        if st.button("Oui"):
+            st.success("Image validée!")
+        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!")
+
+# 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.")