Support multiple image uploads for CV and TPD analysis

Both image tabs now accept multiple files (one per scan rate / heating
rate) via gr.File with file_count="multiple", matching the CSV tab
pattern. Each image is independently digitized with per-image OCR axis
detection, then all curves are fed to the model together.

This enables multi-scan-rate image analysis, which dramatically
improves classification accuracy (e.g. BV vs MHC disambiguation).

Made-with: Cursor

app.py

@@ -145,100 +145,119 @@ def analyze_cv(files, scan_rates_text, E0_V, T_K, A_cm2,
     return _run_ec_analysis(potentials, fluxes, sigmas_list, n_samples, preproc_text=preproc_info)
 
 
-def analyze_cv_image(image, scan_rate_text, E0_V, threshold, n_samples,
+def analyze_cv_image(files, scan_rate_text, E0_V, threshold, n_samples,
                      x_min, x_max, y_min, y_max):
-    """Analyze CV from an uploaded plot image.
+    """Analyze CV from uploaded plot images (one per scan rate).
 
-    Extracts the CV curve via image digitization, then nondimensionalizes
+    Extracts CV curves via image digitization, then nondimensionalizes
     and runs inference identically to the CSV path.
-    Axis bounds are auto-detected via OCR if not provided.
+    Axis bounds are auto-detected via OCR — override in Advanced if needed.
     """
-    if image is None:
-        return _ec_error("Please upload an image.")
+    if not files:
+        return _ec_error("Please upload at least one image.")
 
     try:
         from digitizer import digitize_plot, auto_detect_axis_bounds
+        from PIL import Image as PILImage
     except ImportError:
-        return _ec_error("OpenCV not available for image digitization.")
+        return _ec_error("Required libraries not available for image digitization.")
 
     scan_rate_text = scan_rate_text.strip() if scan_rate_text else ""
     if not scan_rate_text:
-        return _ec_error("Please enter the scan rate (V/s).")
+        return _ec_error("Please enter the scan rate(s) (V/s), comma-separated.")
     try:
-        v_Vs = float(scan_rate_text)
+        scan_rates = [float(s.strip()) for s in scan_rate_text.split(",")]
     except ValueError:
-        return _ec_error("Invalid scan rate. Enter a number in V/s.")
+        return _ec_error("Invalid scan rates. Enter comma-separated numbers in V/s.")
 
-    img_arr = np.array(image)
+    if len(files) != len(scan_rates):
+        return _ec_error(
+            f"Number of images ({len(files)}) must match number of "
+            f"scan rates ({len(scan_rates)}).")
 
-    # Determine axis bounds: user overrides take priority, else auto-detect
     has_user_bounds = all(
         v is not None and v != 0 for v in [x_min, x_max, y_min, y_max]
     )
-    if has_user_bounds:
-        bounds = {
-            "x_min": float(x_min), "x_max": float(x_max),
-            "y_min": float(y_min), "y_max": float(y_max),
-        }
-        bounds_source = "user"
-    else:
-        bounds = auto_detect_axis_bounds(img_arr)
-        if bounds is None:
-            return _ec_error(
-                "Could not auto-detect axis bounds from the image. "
-                "Please enter E min, E max, I min, I max under "
-                "'Advanced: axis overrides'.")
-        bounds_source = "auto"
-
-    try:
-        E_V, I_raw = digitize_plot(
-            img_arr, bounds["x_min"], bounds["x_max"],
-            bounds["y_min"], bounds["y_max"],
-            threshold=int(threshold),
-        )
-    except Exception as e:
-        return _ec_error(f"Digitization failed: {e}")
-
-    # Convert current units: OCR reads axis labels so I_raw is in the
-    # display unit (µA, mA, A). Assume A unless values are large.
-    i_max = np.max(np.abs(I_raw))
-    if i_max > 100:
-        i_A = I_raw * 1e-6  # likely µA
-        i_unit_guess = "µA"
-    elif i_max > 0.1:
-        i_A = I_raw * 1e-3  # likely mA
-        i_unit_guess = "mA"
-    else:
-        i_A = I_raw
-        i_unit_guess = "A"
 
-    if E0_V is not None and E0_V != 0:
-        e0 = float(E0_V)
-        e0_source = "user"
-    else:
-        e0 = float(estimate_E0(E_V, i_A))
-        e0_source = "auto"
+    potentials, fluxes, sigmas_list = [], [], []
+    preproc_parts = []
 
     D = 1e-5
     T = 298.15
     A = 0.0707
     C_molcm3 = 1e-6
     n = 1
+    e0 = None
+    e0_source = None
 
-    theta, flux, sigma = nondimensionalize_cv(
-        E_V, i_A, v_Vs, e0, T, A, C_molcm3, D, n
-    )
+    if E0_V is not None and E0_V != 0:
+        e0 = float(E0_V)
+        e0_source = "user"
+
+    for idx, f in enumerate(files):
+        img_arr = np.array(PILImage.open(f.name).convert("RGB"))
+        v_Vs = scan_rates[idx]
+
+        if has_user_bounds:
+            bounds = {
+                "x_min": float(x_min), "x_max": float(x_max),
+                "y_min": float(y_min), "y_max": float(y_max),
+            }
+            bounds_source = "user"
+        else:
+            bounds = auto_detect_axis_bounds(img_arr)
+            if bounds is None:
+                return _ec_error(
+                    f"Could not auto-detect axis bounds for image {idx + 1}. "
+                    "Please enter E min, E max, I min, I max under "
+                    "'Axis overrides'.")
+            bounds_source = "auto"
+
+        try:
+            E_V, I_raw = digitize_plot(
+                img_arr, bounds["x_min"], bounds["x_max"],
+                bounds["y_min"], bounds["y_max"],
+                threshold=int(threshold),
+            )
+        except Exception as exc:
+            return _ec_error(f"Digitization failed for image {idx + 1}: {exc}")
+
+        i_max = np.max(np.abs(I_raw))
+        if i_max > 100:
+            i_A = I_raw * 1e-6
+            i_unit = "µA"
+        elif i_max > 0.1:
+            i_A = I_raw * 1e-3
+            i_unit = "mA"
+        else:
+            i_A = I_raw
+            i_unit = "A"
 
-    preproc_info = "**Preprocessing (image):** "
-    preproc_info += f"Scan rate: {v_Vs*1000:.1f} mV/s (σ={sigma:.2f}). "
-    preproc_info += f"Axis bounds ({bounds_source}): E=[{bounds['x_min']:.3f}, {bounds['x_max']:.3f}] V, "
-    preproc_info += f"I=[{bounds['y_min']:.2f}, {bounds['y_max']:.2f}] {i_unit_guess}. "
+        if e0 is None:
+            e0 = float(estimate_E0(E_V, i_A))
+            e0_source = "auto"
+
+        theta, flux, sigma = nondimensionalize_cv(
+            E_V, i_A, v_Vs, e0, T, A, C_molcm3, D, n
+        )
+        potentials.append(theta)
+        fluxes.append(flux)
+        sigmas_list.append(sigma)
+
+        preproc_parts.append(
+            f"{v_Vs*1000:.1f} mV/s (σ={sigma:.2f}, "
+            f"bounds {bounds_source}: E=[{bounds['x_min']:.3f}, {bounds['x_max']:.3f}] V, "
+            f"I=[{bounds['y_min']:.2f}, {bounds['y_max']:.2f}] {i_unit})"
+        )
+
+    preproc_info = f"**Preprocessing ({len(files)} image{'s' if len(files) > 1 else ''}):** "
+    preproc_info += "; ".join(preproc_parts) + ". "
     if e0_source == "auto":
         preproc_info += f"E₀ auto-estimated as {e0:.4f} V."
     else:
         preproc_info += f"E₀ = {e0:.4f} V (user-provided)."
 
-    return _run_ec_analysis([theta], [flux], [sigma], n_samples, preproc_text=preproc_info)
+    return _run_ec_analysis(potentials, fluxes, sigmas_list, n_samples, preproc_text=preproc_info)
 
 
 def _ec_error(msg=""):
@@ -364,59 +383,74 @@ def analyze_tpd(files, heating_rates_text, n_samples):
     return _run_tpd_analysis(temperatures, rates, betas, n_samples, preproc_text=preproc_info)
 
 
-def analyze_tpd_image(image, heating_rates_text, threshold, n_samples,
+def analyze_tpd_image(files, heating_rates_text, threshold, n_samples,
                       x_min, x_max, y_min, y_max):
-    """Analyze TPD from an uploaded plot image.
+    """Analyze TPD from uploaded plot images (one per heating rate).
 
-    Axis bounds are auto-detected via OCR if not provided.
+    Axis bounds are auto-detected via OCR — override in Advanced if needed.
     """
-    if image is None:
-        return _tpd_error("Please upload an image.")
+    if not files:
+        return _tpd_error("Please upload at least one image.")
 
     try:
         from digitizer import digitize_plot, auto_detect_axis_bounds
+        from PIL import Image as PILImage
     except ImportError:
-        return _tpd_error("OpenCV not available for image digitization.")
+        return _tpd_error("Required libraries not available for image digitization.")
 
     heating_rates_text = heating_rates_text.strip() if heating_rates_text else ""
     if not heating_rates_text:
         return _tpd_error(
-            "Please enter the heating rate (β in K/s). "
+            "Please enter the heating rate(s) (β in K/s), comma-separated. "
             "This value is critical for correct inference.")
     try:
         betas = [float(s.strip()) for s in heating_rates_text.split(",")]
     except ValueError:
-        return _tpd_error("Invalid heating rates.")
+        return _tpd_error("Invalid heating rates. Enter comma-separated numbers in K/s.")
 
-    img_arr = np.array(image)
+    if len(files) != len(betas):
+        return _tpd_error(
+            f"Number of images ({len(files)}) must match number of "
+            f"heating rates ({len(betas)}).")
 
     has_user_bounds = all(
         v is not None and v != 0 for v in [x_min, x_max, y_min, y_max]
     )
-    if has_user_bounds:
-        bounds = {
-            "x_min": float(x_min), "x_max": float(x_max),
-            "y_min": float(y_min), "y_max": float(y_max),
-        }
-    else:
-        bounds = auto_detect_axis_bounds(img_arr)
-        if bounds is None:
-            return _tpd_error(
-                "Could not auto-detect axis bounds from the image. "
-                "Please enter T min, T max, Signal min, Signal max "
-                "under 'Advanced: axis overrides'.")
 
-    try:
-        x_data, y_data = digitize_plot(
-            img_arr, bounds["x_min"], bounds["x_max"],
-            bounds["y_min"], bounds["y_max"],
-            threshold=int(threshold),
-        )
-    except Exception as e:
-        return _tpd_error(f"Digitization failed: {e}")
+    temperatures, rates = [], []
+    for idx, f in enumerate(files):
+        img_arr = np.array(PILImage.open(f.name).convert("RGB"))
 
-    preproc_info = f"**Preprocessing (image):** Heating rate β = {betas[0]:.2f} K/s."
-    return _run_tpd_analysis([x_data], [y_data], betas[:1], n_samples, preproc_text=preproc_info)
+        if has_user_bounds:
+            bounds = {
+                "x_min": float(x_min), "x_max": float(x_max),
+                "y_min": float(y_min), "y_max": float(y_max),
+            }
+        else:
+            bounds = auto_detect_axis_bounds(img_arr)
+            if bounds is None:
+                return _tpd_error(
+                    f"Could not auto-detect axis bounds for image {idx + 1}. "
+                    "Please enter T min, T max, Signal min, Signal max "
+                    "under 'Axis overrides'.")
+
+        try:
+            x_data, y_data = digitize_plot(
+                img_arr, bounds["x_min"], bounds["x_max"],
+                bounds["y_min"], bounds["y_max"],
+                threshold=int(threshold),
+            )
+        except Exception as exc:
+            return _tpd_error(f"Digitization failed for image {idx + 1}: {exc}")
+
+        temperatures.append(x_data)
+        rates.append(y_data)
+
+    beta_strs = [f"β = {b:.2f} K/s" for b in betas]
+    preproc_info = f"**Preprocessing ({len(files)} image{'s' if len(files) > 1 else ''}):** "
+    preproc_info += f"Heating rates: {', '.join(beta_strs)}."
+
+    return _run_tpd_analysis(temperatures, rates, betas, n_samples, preproc_text=preproc_info)
 
 
 def _tpd_error(msg=""):
@@ -694,14 +728,20 @@ def build_app():
                     # --- Image mode ---
                     with gr.Tab("From Image"):
                         gr.Markdown(
-                            "Upload an image of a CV plot (potential in V on x-axis, "
-                            "current in A/mA/µA on y-axis). Axis bounds are "
-                            "**auto-detected** via OCR — override in Advanced if needed."
+                            "Upload plot images of CVs (potential in V on x-axis, "
+                            "current in A/mA/µA on y-axis). **One image per scan rate.** "
+                            "For best accuracy, upload multiple scan rates.\n\n"
+                            "Axis bounds are **auto-detected** via OCR — "
+                            "override in Advanced if needed."
+                        )
+                        cv_img_files = gr.File(
+                            label="Plot images (one per scan rate)",
+                            file_count="multiple",
+                            file_types=["image"],
                         )
-                        cv_img = gr.Image(label="Plot image", type="numpy")
                         cv_img_scan_rate = gr.Textbox(
-                            label="Scan rate (V/s)",
-                            placeholder="e.g., 0.1",
+                            label="Scan rates (V/s), comma-separated",
+                            placeholder="e.g., 0.01, 0.1, 1.0",
                             value="",
                         )
                         with gr.Accordion("Advanced parameters", open=False):
@@ -717,8 +757,9 @@ def build_app():
                                 )
                         with gr.Accordion("Axis overrides", open=False):
                             gr.Markdown(
-                                "Leave at 0 to auto-detect from the image. "
-                                "Override if OCR detection is inaccurate."
+                                "Leave at 0 to auto-detect from each image. "
+                                "Override if OCR detection is inaccurate. "
+                                "Overrides apply to **all** images."
                             )
                             with gr.Row():
                                 cv_img_xmin = gr.Number(label="E min (V)", value=None)
@@ -744,7 +785,7 @@ def build_app():
                         cv_img_btn.click(
                             analyze_cv_image,
                             inputs=[
-                                cv_img, cv_img_scan_rate, cv_img_E0,
+                                cv_img_files, cv_img_scan_rate, cv_img_E0,
                                 cv_img_threshold, cv_img_nsamples,
                                 cv_img_xmin, cv_img_xmax,
                                 cv_img_ymin, cv_img_ymax,
@@ -811,14 +852,20 @@ def build_app():
                     # --- Image mode ---
                     with gr.Tab("From Image"):
                         gr.Markdown(
-                            "Upload an image of a TPD plot (temperature in K on "
-                            "x-axis, signal on y-axis). Axis bounds are "
-                            "**auto-detected** via OCR — override in Advanced if needed."
+                            "Upload plot images of TPD curves (temperature in K on "
+                            "x-axis, signal on y-axis). **One image per heating rate.** "
+                            "For best accuracy, upload multiple heating rates.\n\n"
+                            "Axis bounds are **auto-detected** via OCR — "
+                            "override in Advanced if needed."
+                        )
+                        tpd_img_files = gr.File(
+                            label="Plot images (one per heating rate)",
+                            file_count="multiple",
+                            file_types=["image"],
                         )
-                        tpd_img = gr.Image(label="Plot image", type="numpy")
                         tpd_img_betas = gr.Textbox(
-                            label="Heating rate β (K/s)",
-                            placeholder="e.g., 5.0",
+                            label="Heating rates β (K/s), comma-separated",
+                            placeholder="e.g., 0.3, 2.6, 22.1",
                             value="",
                         )
                         with gr.Accordion("Advanced parameters", open=False):
@@ -829,8 +876,9 @@ def build_app():
                                 )
                         with gr.Accordion("Axis overrides", open=False):
                             gr.Markdown(
-                                "Leave at 0 to auto-detect from the image. "
-                                "Override if OCR detection is inaccurate."
+                                "Leave at 0 to auto-detect from each image. "
+                                "Override if OCR detection is inaccurate. "
+                                "Overrides apply to **all** images."
                             )
                             with gr.Row():
                                 tpd_img_xmin = gr.Number(label="T min (K)", value=None)
@@ -855,7 +903,7 @@ def build_app():
                         tpd_img_btn.click(
                             analyze_tpd_image,
                             inputs=[
-                                tpd_img, tpd_img_betas,
+                                tpd_img_files, tpd_img_betas,
                                 tpd_img_threshold, tpd_img_nsamples,
                                 tpd_img_xmin, tpd_img_xmax,
                                 tpd_img_ymin, tpd_img_ymax,

requirements.txt

@@ -6,3 +6,4 @@ gradio==5.29.0
 opencv-python-headless>=4.8
 easyocr>=1.7
 tqdm>=4.65
+Pillow>=9.0