statistics

app.py

@@ -2,55 +2,83 @@ import gradio as gr
 import pandas as pd
 from PIL import Image
 import os
-from collections import Counter
 
-# --- App Configuration ---
-
-# Define your sections and labels
+# ---------------------------
+# Label Definitions & Layout
+# ---------------------------
 SECTION_LABELS = {
     "Oil Pore Related Issues": [
-        "Very Large Pores (Not Red)", "Whiteheads (Clogged Pores)", "Blackheads (Clogged Pores)",
-        "Shinny Skin", "Sebaceous Filaments (Sebum)"
+        "Very Large Pores (Not Red)",
+        "Whiteheads (Clogged Pores)",
+        "Blackheads (Clogged Pores)",
+        "Shinny Skin",
+        "Sebaceous Filaments (Sebum)"
     ],
     "Acne and Blemishes": [
-        "Pustules", "Papules", "Nodules", "Cysts", "Acne", "Rosacea",
-        "Telangiectasia", "Milia", "Scars", "Ice Berg Scars",
+        "Pustules",
+        "Papules",
+        "Nodules",
+        "Cysts",
+        "Acne",
+        "Rosacea",
+        "Telangiectasia",
+        "Milia",
+        "Scars",
+        "Ice Berg Scars",
+    ],
+    "Redness and Irritation": [
+        "Redness",
+        "Irritation",
+    ],
+    "Dryness and Texture Issues": [
+        "Dryness",
+        "Fine Lines / Wrinkles",
+        "Skin Flakes"
+    ],
+    "Aging and Elasticity Issues": [
+        "Loose Skin",
+        "Deep Wrinkles"
+    ],
+    "Pigmentation Issues": [
+        "Dark Spots",
+        "Melasma",
+        "Freckles"
     ],
-    "Redness and Irritation": ["Redness", "Irritation"],
-    "Dryness and Texture Issues": ["Dryness", "Fine Lines / Wrinkles", "Skin Flakes"],
-    "Aging and Elasticity Issues": ["Loose Skin", "Deep Wrinkles"],
-    "Pigmentation Issues": ["Dark Spots", "Melasma", "Freckles"],
     "Rosacea": [
-        "Erythematotelangiectatic Rosacea", "Papulopustular Rosacea",
-        "Phymatous Rosacea", "Ocular Rosacea"
+        "Erythematotelangiectatic Rosacea",
+        "Papulopustular Rosacea",
+        "Phymatous Rosacea",
+        "Ocular Rosacea"
     ],
-    "Eczema": ["Deborrheic Dermatitis"]
+    "Eczema": [
+        "Deborrheic Dermatitis"
+    ]
 }
 
-# Define the sections for each column to control UI layout
 column1_sections = ["Oil Pore Related Issues", "Dryness and Texture Issues"]
 column2_sections = ["Acne and Blemishes"]
 column3_sections = ["Redness and Irritation", "Pigmentation Issues", "Aging and Elasticity Issues"]
 column4_sections = ["Rosacea", "Eczema"]
-
-# Combine all section lists to define the exact UI order
 UI_ORDERED_SECTIONS = column1_sections + column2_sections + column3_sections + column4_sections
 
-# Flattened labels list, created in the SAME order as the UI checkboxes will be.
 ALL_LABELS = [
     label
     for section_name in UI_ORDERED_SECTIONS
     for label in SECTION_LABELS.get(section_name, [])
 ]
 
-# --- Global State ---
-images = []
-current_index = 0
-results = []
-annotations = {}
-
-# --- Core Annotation Functions ---
+# ---------------------------
+# Global State
+# ---------------------------
+images = []            # list of image paths
+current_index = 0      # index of current image
+results = []           # list of {'image': fname, 'labels': '...'}
+annotations = {}       # {img_idx: [bool, ...]} aligned to ALL_LABELS
+label_counts = {lbl: 0 for lbl in ALL_LABELS}  # used in statistics mode
 
+# ---------------------------
+# Core Functions
+# ---------------------------
 def display_image(idx):
     """Displays the image at the given index and its saved annotations."""
     if images:
@@ -75,171 +103,292 @@ def submit(*selections):
     """Saves the current annotations to the state and writes to a CSV file."""
     if not images:
         return "No image to label", None
+
+    # Save selections to our annotations dictionary
     annotations[current_index] = list(selections)
     fname = os.path.basename(images[current_index])
     chosen_labels = [lbl for lbl, sel in zip(ALL_LABELS, selections) if sel]
 
     global results
+    # Remove any previous entry for this image to avoid duplicates
     results = [r for r in results if r['image'] != fname]
     results.append({'image': fname, 'labels': ', '.join(chosen_labels)})
+
+    # Write the updated results to a CSV file
     df = pd.DataFrame(results)
     df.to_csv('image_labels.csv', index=False)
+
     return "Labels saved!", 'image_labels.csv'
 
 def upload_images(files):
-    """Handles image uploads, resetting the annotation state."""
+    """Handles image uploads, resetting the application state."""
     global images, current_index, results, annotations
+    if not files:
+        return [None, "No images uploaded"] + [False] * len(ALL_LABELS) + [
+            gr.update(visible=True),   # image_upload stays visible if nothing came
+            gr.update(visible=False),  # csv_upload hidden
+            gr.update(visible=False)   # stats_csv_upload hidden
+        ]
+
+    # Gradio File returns temp files with .name path
     images = [f.name for f in files]
     current_index = 0
     results = []
     annotations = {}
     outputs = display_image(0)
-    # Hide the uploader component after a successful upload
-    return outputs + [gr.update(visible=False), gr.update(visible=True)]
+
+    # Hide the image uploader after a successful upload; show per-image CSV upload
+    return outputs + [
+        gr.update(visible=False),   # image_upload
+        gr.update(visible=True),    # csv_upload
+        gr.update(visible=False)    # stats_csv_upload
+    ]
 
 def load_annotations(csv_file):
-    """Loads annotations from an uploaded CSV file."""
+    """Loads annotations from an uploaded CSV file (annotation mode)."""
     global annotations, results
     if csv_file is None or not images:
+        # If no CSV is uploaded or no images are loaded, do nothing.
         return display_image(current_index)
+
     try:
         df = pd.read_csv(csv_file.name)
+        # Create a quick lookup map from filename to its index in the `images` list
         image_map = {os.path.basename(name): i for i, name in enumerate(images)}
+
+        # Reset existing annotations and results
         annotations = {}
         results = df.to_dict('records')
+
         for _, row in df.iterrows():
-            fname = row['image']
+            fname = row.get('image', '')
             if fname in image_map:
                 img_idx = image_map[fname]
-                saved_labels = set(l.strip() for l in row['labels'].split(',')) if pd.notna(row['labels']) else set()
+                # Handle cases where labels might be empty (NaN)
+                if pd.notna(row.get('labels', None)):
+                    saved_labels = set(l.strip() for l in str(row['labels']).split(',') if l.strip())
+                else:
+                    saved_labels = set()
+                # Create the boolean state list for the checkboxes
                 states = [label in saved_labels for label in ALL_LABELS]
                 annotations[img_idx] = states
     except Exception as e:
         print(f"Error loading annotations: {e}")
+        # In case of error, just refresh the current view without changes
+        return display_image(current_index)
+
+    # After loading, refresh the view to show the annotations for the current image
     return display_image(current_index)
 
-# --- Statistics and Mode-Switching Functions ---
+# ---------- Statistics Mode Helpers ----------
+def aggregate_label_counts(files):
+    """Read multiple CSVs of annotations and aggregate per-label counts."""
+    counts = {lbl: 0 for lbl in ALL_LABELS}
+    file_ct = 0
+    rows_ct = 0
 
-def calculate_statistics(files):
-    """Reads multiple CSVs and calculates the frequency of each label."""
     if not files:
-        return [gr.update() for _ in ALL_LABELS] # No change
+        return counts, file_ct, rows_ct
 
-    label_counts = Counter()
-    for file_obj in files:
+    for f in files:
         try:
-            df = pd.read_csv(file_obj.name)
-            if 'labels' in df.columns:
-                df.dropna(subset=['labels'], inplace=True)
-                for label_str in df['labels']:
-                    labels = [l.strip() for l in label_str.split(',')]
-                    label_counts.update(labels)
+            df = pd.read_csv(f.name)
         except Exception as e:
-            print(f"Could not process file {file_obj.name}: {e}")
+            print(f"Failed reading {getattr(f, 'name', 'file')}: {e}")
             continue
+        file_ct += 1
+
+        if 'labels' not in df.columns:
+            continue
+
+        for raw in df['labels'].dropna().astype(str):
+            rows_ct += 1
+            items = [s.strip() for s in raw.split(',') if s.strip()]
+            for item in items:
+                if item in counts:
+                    counts[item] += 1
+                # silently ignore labels not in ALL_LABELS
 
-    updated_checkboxes = [gr.update(label=f"{label} (Count: {label_counts.get(label, 0)})") for label in ALL_LABELS]
-    return updated_checkboxes
+    return counts, file_ct, rows_ct
+
+def upload_stats_csvs(files):
+    """Handles CSV upload in statistics mode; updates checkbox labels to show counts."""
+    global label_counts
+    label_counts, file_ct, rows_ct = aggregate_label_counts(files)
+
+    # Create updates for every checkbox: label "(count)", disabled & unchecked
+    checkbox_updates = [
+        gr.update(label=f"{lbl} ({label_counts.get(lbl, 0)})", value=False, interactive=False)
+        for lbl in ALL_LABELS
+    ]
+    note = f"Statistics mode: loaded {file_ct} file(s), counted {rows_ct} annotation row(s)."
+    return checkbox_updates + [note]
+
+def make_checkbox_updates_for_mode(is_stats):
+    """Return a list of gr.update for all checkboxes depending on mode."""
+    if is_stats:
+        # Show counts & disable
+        return [
+            gr.update(label=f"{lbl} ({label_counts.get(lbl, 0)})", value=False, interactive=False)
+            for lbl in ALL_LABELS
+        ]
+    else:
+        # Restore original labels & interactivity; set values to current image's saved state
+        states = annotations.get(current_index, [False] * len(ALL_LABELS))
+        return [
+            gr.update(label=lbl, value=val, interactive=True)
+            for lbl, val in zip(ALL_LABELS, states)
+        ]
 
 def toggle_mode(current_mode):
-    """Switches the UI between Annotation and Statistics modes."""
-    if current_mode == "Annotation":
-        new_mode = "Statistics"
-        btn_text = "Switch to Annotation Mode"
-        anno_upload_visible = False
-        stats_upload_visible = True
-        viewer_visible = False
-    else: # Current mode is "Statistics"
-        new_mode = "Annotation"
-        btn_text = "Switch to Statistics Mode"
-        anno_upload_visible = True
-        stats_upload_visible = False
-        viewer_visible = True
-
-    # Reset labels back to their original names
-    label_updates = [gr.update(label=lbl) for lbl in ALL_LABELS]
-
-    return [
+    """
+    Toggle between 'annotate' and 'stats' modes.
+    Returns updates for:
+      - mode_state
+      - image_upload (visible)
+      - csv_upload (visible)
+      - stats_csv_upload (visible)
+      - img (visible)
+      - caption (visible)
+      - prev_btn (visible)
+      - next_btn (visible)
+      - submit_btn (interactive)
+      - csv_downloader (visible)
+      - status (value)
+      - all checkboxes (labels/value/interactive)
+    """
+    new_mode = 'stats' if current_mode == 'annotate' else 'annotate'
+    is_stats = (new_mode == 'stats')
+
+    # Visibility & interactivity updates
+    img_vis = not is_stats
+    nav_vis = not is_stats
+    submit_interactive = not is_stats
+    downloader_vis = not is_stats
+
+    # Uploaders
+    image_upload_vis = not is_stats
+    csv_upload_vis = not is_stats  # allow annotation CSV in annotate mode
+    stats_csv_upload_vis = is_stats
+
+    status_text = (
+        "Statistics mode: upload CSV files to compute per-label counts."
+        if is_stats
+        else "Annotation mode: select labels and submit. (Optional: load a CSV for existing annotations.)"
+    )
+
+    checkbox_updates = make_checkbox_updates_for_mode(is_stats)
+
+    return (
         new_mode,
-        gr.update(value=btn_text),
-        gr.update(visible=anno_upload_visible),
-        gr.update(visible=stats_upload_visible),
-        gr.update(visible=viewer_visible)
-    ] + label_updates
+        gr.update(visible=image_upload_vis),    # image_upload
+        gr.update(visible=csv_upload_vis),      # csv_upload
+        gr.update(visible=stats_csv_upload_vis),# stats_csv_upload
+        gr.update(visible=img_vis),             # img
+        gr.update(visible=img_vis),             # caption
+        gr.update(visible=nav_vis),             # prev_btn
+        gr.update(visible=nav_vis),             # next_btn
+        gr.update(interactive=submit_interactive), # submit_btn
+        gr.update(visible=downloader_vis),      # csv_downloader
+        status_text,                            # status (value)
+        *checkbox_updates
+    )
 
-# --- Gradio UI Definition ---
+# ---------------------------
+# Gradio UI
+# ---------------------------
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Dermatology Annotation & Statistics Tool")
+    gr.Markdown("## Dermatology Annotation Tool")
 
-    app_mode = gr.State("Annotation")
-
-    # --- TOP ROW CONTROLS (Uploaders and Mode Switch) ---
     with gr.Row():
-        mode_toggle_btn = gr.Button("Switch to Statistics Mode")
-        # Annotation Uploaders (Visible by default)
-        with gr.Row(visible=True) as annotation_upload_row:
-            image_upload = gr.File(label="1. Upload Images", file_count="multiple", file_types=["image"])
-            csv_upload = gr.File(label="2. (Optional) Upload Annotations CSV", file_types=[".csv"], visible=False)
-        # Statistics Uploader (Hidden by default)
-        with gr.Row(visible=False) as statistics_upload_row:
-            stats_csv_upload = gr.File(label="Upload one or more annotation CSV files", file_count="multiple", file_types=[".csv"])
-    
-    gr.Markdown("---")
-
-    # --- MAIN UI ROW (Checkboxes on Left, Image Viewer on Right) ---
+        image_upload = gr.File(label="1. Upload Images", file_count="multiple", file_types=["image"])
+        # Annotation CSV (per-image) — hidden until an image set is uploaded
+        csv_upload = gr.File(label="2. (Optional) Upload Annotations CSV", file_types=[".csv"], visible=False)
+        # Statistics CSV uploader (multi) — hidden by default; shown in stats mode
+        stats_csv_upload = gr.File(label="Upload Annotation CSVs (Statistics Mode)", file_types=[".csv"], file_count="multiple", visible=False)
+
     checkbox_components = []
+
+    with gr.Row():  # Main row for the four columns of labels
+        # Column 1
+        with gr.Column(scale=1, min_width=0):
+            for section_name in column1_sections:
+                if section_name in SECTION_LABELS:
+                    with gr.Group():
+                        gr.Markdown(f"### {section_name}")
+                        for lbl in SECTION_LABELS[section_name]:
+                            cb = gr.Checkbox(label=lbl)
+                            checkbox_components.append(cb)
+        # Column 2
+        with gr.Column(scale=1, min_width=0):
+            for section_name in column2_sections:
+                if section_name in SECTION_LABELS:
+                    with gr.Group():
+                        gr.Markdown(f"### {section_name}")
+                        for lbl in SECTION_LABELS[section_name]:
+                            cb = gr.Checkbox(label=lbl)
+                            checkbox_components.append(cb)
+        # Column 3
+        with gr.Column(scale=1, min_width=0):
+            for section_name in column3_sections:
+                if section_name in SECTION_LABELS:
+                    with gr.Group():
+                        gr.Markdown(f"### {section_name}")
+                        for lbl in SECTION_LABELS[section_name]:
+                            cb = gr.Checkbox(label=lbl)
+                            checkbox_components.append(cb)
+        # Column 4
+        with gr.Column(scale=1, min_width=0):
+            for section_name in column4_sections:
+                if section_name in SECTION_LABELS:
+                    with gr.Group():
+                        gr.Markdown(f"### {section_name}")
+                        for lbl in SECTION_LABELS[section_name]:
+                            cb = gr.Checkbox(label=lbl)
+                            checkbox_components.append(cb)
+
+    # Image display and controls
     with gr.Row():
-        # --- LEFT SIDE: CHECKBOXES ---
-        with gr.Column(scale=2):
-            with gr.Row():
-                for col_sections in [column1_sections, column2_sections, column3_sections, column4_sections]:
-                    with gr.Column(scale=1, min_width=220):
-                        for section_name in col_sections:
-                            if section_name in SECTION_LABELS:
-                                with gr.Group():
-                                    gr.Markdown(f"### {section_name}")
-                                    for lbl in SECTION_LABELS[section_name]:
-                                        cb = gr.Checkbox(label=lbl)
-                                        checkbox_components.append(cb)
-        
-        # --- RIGHT SIDE: IMAGE VIEWER AND CONTROLS (for Annotation Mode) ---
-        with gr.Column(scale=1, visible=True) as image_viewer_col:
+        with gr.Column(scale=2):  # Image display column
             img = gr.Image(label="Image")
             caption = gr.Label(value="No images uploaded")
             with gr.Row():
                 prev_btn = gr.Button("⬅️ Previous")
                 next_btn = gr.Button("Next ➡️")
+
+        with gr.Column(scale=1):  # Controls and download column
+            # --- TOGGLE BUTTON placed just above Submit Labels ---
+            mode_state = gr.State("annotate")  # 'annotate' or 'stats'
+            toggle_btn = gr.Button("🔀 Switch to Statistics Mode", variant="secondary")  # sits above Submit
             submit_btn = gr.Button("Submit Labels")
             status = gr.Label()
             csv_downloader = gr.File(label="Download labels CSV")
 
     # --- Event Handling ---
 
-    # Mode switching
-    mode_toggle_btn.click(
-        fn=toggle_mode,
-        inputs=app_mode,
-        outputs=[app_mode, mode_toggle_btn, annotation_upload_row, statistics_upload_row, image_viewer_col] + checkbox_components
-    )
-    
-    # Statistics calculation
-    stats_csv_upload.upload(
-        fn=calculate_statistics,
-        inputs=stats_csv_upload,
-        outputs=checkbox_components
-    )
-
-    # Annotation functionality
+    # When images are uploaded (annotation mode)
     image_upload.upload(
         fn=upload_images,
         inputs=image_upload,
-        outputs=[img, caption] + checkbox_components + [image_upload, csv_upload]
+        outputs=[img, caption] + checkbox_components + [image_upload, csv_upload, stats_csv_upload]
     )
+
+    # Load per-image annotations CSV (annotation mode)
     csv_upload.upload(
         fn=load_annotations,
         inputs=csv_upload,
         outputs=[img, caption] + checkbox_components
     )
+
+    # Statistics CSVs upload (statistics mode)
+    # Updates all checkbox labels with counts & disables them, also sets status text
+    stats_csv_upload.upload(
+        fn=upload_stats_csvs,
+        inputs=stats_csv_upload,
+        outputs=checkbox_components + [status]
+    )
+
+    # Navigation
     prev_btn.click(
         fn=lambda: navigate(-1),
         outputs=[img, caption] + checkbox_components
@@ -248,11 +397,28 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         fn=lambda: navigate(1),
         outputs=[img, caption] + checkbox_components
     )
+
+    # Submit labels (annotation mode)
     submit_btn.click(
         fn=submit,
         inputs=checkbox_components,
         outputs=[status, csv_downloader]
     )
 
+    # Toggle mode (annotation <-> statistics)
+    toggle_btn.click(
+        fn=toggle_mode,
+        inputs=[mode_state],
+        outputs=[  # keep order in sync with toggle_mode return
+            mode_state,
+            image_upload, csv_upload, stats_csv_upload,
+            img, caption,
+            prev_btn, next_btn,
+            submit_btn, csv_downloader,
+            status,
+            *checkbox_components
+        ]
+    )
+
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)