Upload app.py

app.py

@@ -4,141 +4,193 @@ Created on Mon Apr  7 10:50:35 2025
 
 @author: camaac
 """
-
-# import streamlit as st
-# import os
-# from PIL import Image
-# import random
-# import json
-
-# st.set_page_config(page_title="Test perceptuel bois IA", layout="centered")
-
-# st.title("Test perceptuel : IA ou réel ?")
-
-# st.markdown("""
-# Vous allez voir **deux images de surface de bois**.  
-# Votre mission :  
-# - Choisissez **celle qui semble la plus réaliste** (meilleure qualité visuelle).
-# - Dites ensuite si vous pensez que l'image la plus réaliste est **générée par IA** ou **réelle**.
-# """)
-
-# image_folder = "images"
-# result_file = "results.json"
-
-# if not os.path.exists(image_folder):
-#     st.error("Dossier d'images introuvable.")
-#     st.stop()
-
-# # Trouver toutes les paires dispo
-# all_pairs = sorted(set(f.split("_")[1] for f in os.listdir(image_folder) if f.endswith(".png")))
-# random.shuffle(all_pairs)
-
-# # Afficher une seule paire par session utilisateur
-# if "current_index" not in st.session_state:
-#     st.session_state.current_index = 0
-# if st.session_state.current_index >= len(all_pairs):
-#     st.success("Merci ! Vous avez terminé toutes les paires d'images ")
-#     st.stop()
-
-# pair_id = all_pairs[st.session_state.current_index]
-# img_a_path = os.path.join(image_folder, f"img_{pair_id}_a.png")
-# img_b_path = os.path.join(image_folder, f"img_{pair_id}_b.png")
-
-# # Mélanger l'ordre
-# order = ["a", "b"]
-# random.shuffle(order)
-
-# cols = st.columns(2)
-# for i, col in enumerate(cols):
-#     img_path = os.path.join(image_folder, f"img_{pair_id}_{order[i]}.png")
-#     with col:
-#         st.image(Image.open(img_path), caption=f"Image {i+1}")
-
-# # Choix utilisateur
-# choice = st.radio("Quelle image est la plus réaliste ?", ["Image 1", "Image 2"])
-# is_real = st.radio("L'image choisie est-elle réelle ou générée par IA ?", ["Réelle", "IA"])
-# submit = st.button("Soumettre")
-
-# if submit:
-#     # Enregistrer le résultat
-#     data = {
-#         "pair_id": pair_id,
-#         "image1": f"img_{pair_id}_{order[0]}.png",
-#         "image2": f"img_{pair_id}_{order[1]}.png",
-#         "chosen": choice,
-#         "user_thinks": is_real
-#     }
-#     if os.path.exists(result_file):
-#         with open(result_file, "r") as f:
-#             results = json.load(f)
-#     else:
-#         results = []
-
-#     results.append(data)
-#     with open(result_file, "w") as f:
-#         json.dump(results, f, indent=2)
-
-#     st.success("Merci ! Réponse enregistrée.")
-#     st.session_state.current_index += 1
-#     st.experimental_rerun()
-    
-    
-    
 import streamlit as st
 import os
 import random
+import pandas as pd
+import base64
+from io import BytesIO
 from PIL import Image
 
-# Titre de l'app
-st.title("Test perceptuel : image réelle ou générée ?")
-
-# Récupération des fichiers
-image_dir = "images"
-gt_images = sorted([f for f in os.listdir(image_dir) if f.endswith(".png") and "_gen" not in f])
-
-# Index courant
-index = st.session_state.get("index", 0)
-
-if index >= len(gt_images):
-    st.success("Merci ! Vous avez terminé l'évaluation.")
-else:
-    # Fichiers pour l'image courante
-    gt_file = gt_images[index]
-    base_name = gt_file.replace(".png", "")
-    gen_file = base_name + "_gen0.png"
-
-    gt_path = os.path.join(image_dir, gt_file)
-    gen_path = os.path.join(image_dir, gen_file)
-
-    try:
-        img_gt = Image.open(gt_path)
-        img_gen = Image.open(gen_path)
-
-        # Mélanger l'ordre des images
-        images = [("Réelle", img_gt), ("Générée", img_gen)]
-        random.shuffle(images)
-
-        # Affichage
-        st.write(f"Image {index + 1} sur {len(gt_images)}")
-        cols = st.columns(2)
-        for i, (label, img) in enumerate(images):
-            with cols[i]:
-                st.image(img, caption=f"Image {i + 1}", use_column_width=True)
-
-        choice = st.radio(
-            "Selon vous, laquelle est l'image réelle ?",
-            options=["Image 1", "Image 2"],
-            key=f"choice_{index}"
-        )
-
-        if st.button("Valider"):
-            # Sauvegarde des résultats (à adapter si tu veux un fichier ou DB)
-            correct = images[int(choice[-1]) - 1][0] == "Réelle"
-            st.session_state[f"result_{index}"] = {"choice": choice, "correct": correct}
-
-            # Passer à la suivante
-            st.session_state["index"] = index + 1
-            st.rerun()
-
-    except Exception as e:
-        st.error(f"Erreur lors du chargement des images : {e}")
+# --- Global parameters ---
+IMAGE_DIR = "images"              # Dossier contenant les images.
+# Naming convention: ground truth image: "00001.png", generated image: "00001_gen0.png"
+NUM_PAIRS = 50                    # Nombre de paires à évaluer.
+RESULTS_FILE = "results.csv"      # Fichier où sauvegarder les résultats.
+
+# --- Fonctions utilitaires ---
+
+def load_image_pair(index):
+    """Retourne le chemin de la ground truth et du generated pour un index donné.
+       Les index sont des entiers convertis en chaînes à 5 chiffres.
+    """
+    idx_str = str(index).zfill(5)
+    gt_path = os.path.join(IMAGE_DIR, f"{idx_str}.png")
+    pred_path = os.path.join(IMAGE_DIR, f"{idx_str}_gen0.png")
+    return gt_path, pred_path
+
+def load_and_open_image(path):
+    """Charge l'image depuis le chemin et retourne un objet PIL.Image."""
+    return Image.open(path)
+
+def get_shuffled_pair(index):
+    """Charge la paire d'images, puis renvoie une liste contenant tuples (label, image)
+       dans un ordre aléatoire. Le label est "GT" pour ground truth et "Pred" pour generated.
+    """
+    gt_path, pred_path = load_image_pair(index)
+    img_gt = load_and_open_image(gt_path)
+    img_pred = load_and_open_image(pred_path)
+    pair = [("GT", img_gt), ("Pred", img_pred)]
+    random.shuffle(pair)
+    return pair
+
+def image_to_base64(image, width=300):
+    """Convertit une image PIL en code base64, pour l'inclure dans du HTML."""
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode()
+    html_code = f'<a href="?selected={{}}"><img src="data:image/png;base64,{img_str}" width="{width}"></a>'
+    return html_code
+
+# --- Gestion de la navigation entre pages via st.session_state ---
+
+if "page" not in st.session_state:
+    st.session_state.page = "intro"
+if "user_name" not in st.session_state:
+    st.session_state.user_name = ""
+if "current_index" not in st.session_state:
+    st.session_state.current_index = 1
+if "results" not in st.session_state:
+    st.session_state.results = []
+if "pair_order" not in st.session_state:
+    st.session_state.pair_order = {}
+
+# --- Page d'introduction ---
+if st.session_state.page == "intro":
+    st.title("Wood Surface Evaluation Study")
+    st.markdown("""
+    **Welcome!**
+
+    In this study, you will be shown pairs of wood surface images.
+    One image is a real photograph (Ground Truth) and the other is generated by AI.
+    Your task is to select, by clicking on the image, the one you believe is **real**.
+    
+    Please enter your name below and click "Start Evaluation" to begin.
+    """)
+    name = st.text_input("Enter your name:")
+    if st.button("Start Evaluation") and name:
+        st.session_state.user_name = name
+        st.session_state.page = "evaluation"
+        st.experimental_rerun()
+    st.stop()
+
+# --- Page d'évaluation ---
+if st.session_state.page == "evaluation":
+    st.title("Wood Surface Evaluation")
+    st.write(f"User: **{st.session_state.user_name}**")
+    
+    if st.session_state.current_index > NUM_PAIRS:
+        st.success("Thank you for completing the evaluation!")
+        # Exporter les résultats sous forme de CSV
+        results_df = pd.DataFrame(st.session_state.results)
+        results_df.to_csv(RESULTS_FILE, index=False)
+        st.write("Results saved in:", RESULTS_FILE)
+        st.stop()
+    
+    st.write(f"Image Pair {st.session_state.current_index} of {NUM_PAIRS}")
+    
+    # Charger et mélanger la paire pour l'index courant
+    pair = get_shuffled_pair(st.session_state.current_index)
+    st.session_state.pair_order[st.session_state.current_index] = [label for label, _ in pair]
+    
+    # Afficher les deux images dans deux colonnes, en les rendant cliquables via HTML
+    col1, col2 = st.columns(2)
+    with col1:
+        # On prépare le HTML avec un placeholder pour la clé "1"
+        img_html = image_to_base64(pair[0][1])
+        # On injecte le code HTML en remplaçant {} par "1"
+        st.markdown(img_html.format("1"), unsafe_allow_html=True)
+        st.caption("Image 1")
+    with col2:
+        img_html = image_to_base64(pair[1][1])
+        st.markdown(img_html.format("2"), unsafe_allow_html=True)
+        st.caption("Image 2")
+    
+    st.markdown("**Click on the image you believe is real.**")
+    
+    # Récupérer les paramètres de la requête
+    query_params = st.experimental_get_query_params()
+    if "selected" in query_params:
+        selected = query_params["selected"][0]  # "1" ou "2"
+        selected_label = pair[int(selected) - 1][0]  # "GT" ou "Pred"
+        st.write(f"You selected: **Image {selected}** (label: **{selected_label}**)")
+        # Enregistrer le résultat pour cette paire
+        st.session_state.results.append({
+            "pair_index": st.session_state.current_index,
+            "pair_order": st.session_state.pair_order[st.session_state.current_index],
+            "selected": selected_label,
+        })
+        # Nettoyer les query params pour éviter la sélection persistante
+        st.experimental_set_query_params()
+        # Passer à la paire suivante
+        st.session_state.current_index += 1
+        st.rerun()
+    
+# import streamlit as st
+# import os
+# import random
+# from PIL import Image
+
+# # Titre de l'app
+# st.title("Test perceptuel : image réelle ou générée ?")
+
+# # Récupération des fichiers
+# image_dir = "images"
+# gt_images = sorted([f for f in os.listdir(image_dir) if f.endswith(".png") and "_gen" not in f])
+
+# # Index courant
+# index = st.session_state.get("index", 0)
+
+# if index >= len(gt_images):
+#     st.success("Merci ! Vous avez terminé l'évaluation.")
+# else:
+#     # Fichiers pour l'image courante
+#     gt_file = gt_images[index]
+#     base_name = gt_file.replace(".png", "")
+#     gen_file = base_name + "_gen0.png"
+
+#     gt_path = os.path.join(image_dir, gt_file)
+#     gen_path = os.path.join(image_dir, gen_file)
+
+#     try:
+#         img_gt = Image.open(gt_path)
+#         img_gen = Image.open(gen_path)
+
+#         # Mélanger l'ordre des images
+#         images = [("Réelle", img_gt), ("Générée", img_gen)]
+#         random.shuffle(images)
+
+#         # Affichage
+#         st.write(f"Image {index + 1} sur {len(gt_images)}")
+#         cols = st.columns(2)
+#         for i, (label, img) in enumerate(images):
+#             with cols[i]:
+#                 st.image(img, caption=f"Image {i + 1}", use_column_width=True)
+
+#         choice = st.radio(
+#             "Selon vous, laquelle est l'image réelle ?",
+#             options=["Image 1", "Image 2"],
+#             key=f"choice_{index}"
+#         )
+
+#         if st.button("Valider"):
+#             # Sauvegarde des résultats (à adapter si tu veux un fichier ou DB)
+#             correct = images[int(choice[-1]) - 1][0] == "Réelle"
+#             st.session_state[f"result_{index}"] = {"choice": choice, "correct": correct}
+
+#             # Passer à la suivante
+#             st.session_state["index"] = index + 1
+#             st.rerun()
+
+#     except Exception as e:
+#         st.error(f"Erreur lors du chargement des images : {e}")