initial_test

app.py

@@ -0,0 +1,167 @@
+import os, random, json
+from datetime import datetime
+from PIL import Image, ImageOps
+import numpy as np
+import gradio as gr
+
+# -------- Configuration --------
+folder_ai    = "/images/ai"
+folder_real  = "/images/real"
+now = datetime.now()
+history_file = now.strftime("history_state_%Y-%m-%d_%H-%M-%S.json")
+# --------------------------------
+
+def load_history():
+    if os.path.exists(history_file):
+        with open(history_file, "r") as f:
+            return json.load(f)
+    return {"corrects": [], "wrongs": [], "attempts": [], "times": []}
+
+def save_history(hist):
+    with open(history_file, "w") as f:
+        json.dump(hist, f)
+
+def get_new_grid(state=None):
+    """
+    - Called on first load and on Refresh Grid.
+    - If state is None or doesn't have 'session_start', set session_start = now.
+    - Otherwise, preserve session_start.
+    - Always shuffle 16 images (4–12 AI + rest real) and return thumbs, resets, updated state.
+    """
+    ai_files   = [
+        os.path.join(folder_ai, f)
+        for f in os.listdir(folder_ai)
+        if f.lower().endswith((".png", ".tif", ".tiff"))
+    ]
+    real_files = [
+        os.path.join(folder_real, f)
+        for f in os.listdir(folder_real)
+        if f.lower().endswith((".png", ".tif", ".tiff"))
+    ]
+    t = random.randint(4, 12)  # between 4 and 12 AI images
+    sel_ai   = random.sample(ai_files, t)
+    sel_real = random.sample(real_files, 16 - t)
+    combined = [(p, False) for p in sel_ai] + [(p, True) for p in sel_real]
+    random.shuffle(combined)
+    paths = [p for p, _ in combined]
+    truth = [lbl for _, lbl in combined]
+    thumbs = [np.array(Image.open(p).convert("RGB")) for p in paths]
+
+    # Set or preserve session_start
+    if (state is None) or ("session_start" not in state):
+        session_start = datetime.now().isoformat()
+    else:
+        session_start = state["session_start"]
+
+    new_state = {"paths": paths, "truth": truth, "session_start": session_start}
+    resets = [False] * 16
+    return (*thumbs, *resets, new_state)
+
+def evaluate(
+    sel0, sel1, sel2, sel3,
+    sel4, sel5, sel6, sel7,
+    sel8, sel9, sel10, sel11,
+    sel12, sel13, sel14, sel15,
+    state
+):
+    """
+    Compare each of the 16 checkbox selections to truth.
+    Update history JSON with correct count, wrong filenames, and attempt number.
+    Return 16 bordered images + unchanged state.
+    """
+    sels  = [
+        sel0, sel1, sel2, sel3,
+        sel4, sel5, sel6, sel7,
+        sel8, sel9, sel10, sel11,
+        sel12, sel13, sel14, sel15
+    ]
+    paths = state["paths"]
+    truth = state["truth"]
+    bordered, wrong_list, correct_count = [], [], 0
+
+    for i, chosen in enumerate(sels):
+        img     = Image.open(paths[i]).convert("RGB")
+        is_real = truth[i]
+        if chosen == is_real:
+            color, correct_count = "green", correct_count + 1
+        else:
+            wrong_list.append(os.path.basename(paths[i]))
+            color = "red"
+        bordered.append(np.array(ImageOps.expand(img, border=5, fill=color)))
+
+    hist = load_history()
+    attempt_no = len(hist["attempts"]) + 1
+    hist["corrects"].append(correct_count)
+    hist["wrongs"].append(wrong_list)
+    hist["attempts"].append(attempt_no)
+    save_history(hist)
+
+    return (*bordered, state)
+
+def done_now(state):
+    """
+    Compute total time from the very first grid load (session_start) until now.
+    Append that elapsed to history JSON and return a friendly message.
+    """
+    start = datetime.fromisoformat(state["session_start"])
+    elapsed = (datetime.now() - start).total_seconds()
+    minutes = int(elapsed // 60)
+    seconds = int(elapsed % 60)
+
+    hist = load_history()
+    hist["times"].append(elapsed)
+    save_history(hist)
+
+    return f"Total time spent on the task: {minutes} minutes {seconds} seconds"
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        "## Real vs AI (4×4 Grid)\n"
+        "Click **Refresh Grid** whenever you want a new mix (4–12 AI images). "
+        "Your timer starts as soon as you first see the grid, and stops when you click “I am done now.”\n"
+        "Tick “Real?” under each thumbnail and click **Submit** to get feedback."
+    )
+
+    state = gr.State(None)
+    image_components = []
+    checkbox_components = []
+    for row in range(4):
+        with gr.Row():
+            for col in range(4):
+                idx = row * 4 + col
+                with gr.Column():
+                    img = gr.Image(type="numpy", interactive=False, show_label=False)
+                    cb  = gr.Checkbox(label="Real?", elem_id=f"cb_{idx}")
+                    image_components.append(img)
+                    checkbox_components.append(cb)
+
+    submit_btn  = gr.Button("Submit")
+    refresh_btn = gr.Button("Refresh Grid")
+    done_btn    = gr.Button("I am done now")
+    done_out    = gr.Textbox(interactive=False)
+
+    # On first load or when Refresh is clicked: generate new grid + reset checkboxes
+    demo.load(
+        fn=get_new_grid,
+        outputs=[*image_components, *checkbox_components, state]
+    )
+    refresh_btn.click(
+        fn=get_new_grid,
+        outputs=[*image_components, *checkbox_components, state]
+    )
+
+    # On Submit: evaluate selections (session_start remains intact)
+    submit_btn.click(
+        fn=evaluate,
+        inputs=[*checkbox_components, state],
+        outputs=[*image_components, state]
+    )
+
+    # On “I am done now”: calculate and display total elapsed time
+    done_btn.click(
+        fn=done_now,
+        inputs=[state],
+        outputs=[done_out]
+    )
+
+demo.launch()