Upload folder using huggingface_hub

README.md

@@ -1,12 +1,49 @@
 ---
-title: Microscopy Cv Toolkit
-emoji: ⚡
-colorFrom: yellow
-colorTo: purple
+title: Microscopy CV Toolkit
+emoji: "\U0001F52C"
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: "5.0"
 app_file: app.py
-pinned: false
+pinned: true
+license: apache-2.0
+tags:
+- microscopy
+- computer-vision
+- image-quality
+- opencv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Microscopy CV Toolkit
+
+I needed a quick way to check if my microscopy images are in focus before feeding them into ML pipelines. Couldn't find anything lightweight that just does the basics without pulling in a 2GB model, so I built this. Pure OpenCV, no models, runs instant.
+
+## What it does
+
+Four tools in one space:
+
+**Focus Quality** - Runs Tenengrad, Laplacian variance, normalized variance, and Vollath F4 on your image. Generates a heatmap overlay so you can see which regions are sharp and which are mush. I use this to filter out bad acquisitions before they waste training time.
+
+**Illumination Analysis** - Checks brightness distribution, detects clipping (blown highlights / crushed blacks), measures dynamic range, and flags vignetting. Splits the image into a 3x3 zone grid so you can see if your Kohler illumination is actually aligned or if you've been lying to yourself.
+
+**Microscopy Type Detection** - Tries to figure out if you're looking at brightfield, darkfield, phase contrast, fluorescence, or polarized light. It's histogram-based, not magic. Works surprisingly well for standard preparations but don't expect miracles on weird edge cases.
+
+**Image Enhancement** - CLAHE, unsharp mask, non-local means denoising, and auto white balance. Side-by-side before/after so you can see what each one does. Good for quick previews before you commit to a processing pipeline. The CLAHE configration is tuned for typical microscopy contrast ranges but you can adjust the parameters.
+
+## How it works
+
+Everything is classical CV. Focus metrics are computed on grayscale using gradient operators and statistical measures. Illumination analysis uses histogram statistics and zone-based sampling. Type detection looks at histogram shape, mean intensity, contrast ratios, and edge density to classify teh imaging modality. Enhancement is standard OpenCV stuff.
+
+No GPU needed. No model downloads. Should run in under a second for most images.
+
+## Running locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## License
+
+Apache 2.0. Do whatever you want with it.

app.py

@@ -0,0 +1,672 @@
+"""
+Microscopy CV Toolkit — classical computer-vision tools for microscopy image QC.
+No ML models, pure OpenCV + NumPy + SciPy.
+"""
+
+import cv2
+import numpy as np
+import gradio as gr
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize
+from scipy import ndimage
+from PIL import Image
+import io
+
+# ---------------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------------
+
+def _to_gray(img: np.ndarray) -> np.ndarray:
+    if len(img.shape) == 2:
+        return img
+    return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+
+
+def _fig_to_image(fig) -> np.ndarray:
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", bbox_inches="tight", dpi=120)
+    plt.close(fig)
+    buf.seek(0)
+    return np.array(Image.open(buf))
+
+
+# ---------------------------------------------------------------------------
+# Tab 1 — Focus Quality
+# ---------------------------------------------------------------------------
+
+def _tenengrad(gray: np.ndarray) -> float:
+    gx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    gy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+    return float(np.mean(gx ** 2 + gy ** 2))
+
+
+def _laplacian_variance(gray: np.ndarray) -> float:
+    lap = cv2.Laplacian(gray, cv2.CV_64F)
+    return float(lap.var())
+
+
+def _normalized_variance(gray: np.ndarray) -> float:
+    mean = gray.mean()
+    if mean < 1e-6:
+        return 0.0
+    return float(gray.astype(np.float64).var() / mean)
+
+
+def _vollath_f4(gray: np.ndarray) -> float:
+    g = gray.astype(np.float64)
+    h, w = g.shape
+    t1 = np.sum(g[:, :w - 1] * g[:, 1:w])
+    t2 = np.sum(g[:, :w - 2] * g[:, 2:w])
+    return float(t1 - t2)
+
+
+def _focus_heatmap(gray: np.ndarray, block: int = 64) -> np.ndarray:
+    h, w = gray.shape
+    rows = h // block
+    cols = w // block
+    hmap = np.zeros((rows, cols), dtype=np.float64)
+    for r in range(rows):
+        for c in range(cols):
+            patch = gray[r * block:(r + 1) * block, c * block:(c + 1) * block]
+            lap = cv2.Laplacian(patch, cv2.CV_64F)
+            hmap[r, c] = lap.var()
+    return hmap
+
+
+def _score_label(val: float, low: float, high: float) -> str:
+    if val >= high:
+        return "PASS (sharp)"
+    elif val >= low:
+        return "MARGINAL"
+    return "FAIL (blurry)"
+
+
+def analyze_focus(image: np.ndarray):
+    if image is None:
+        return None, "Upload an image first."
+
+    gray = _to_gray(image)
+
+    tenen = _tenengrad(gray)
+    lap_var = _laplacian_variance(gray)
+    norm_var = _normalized_variance(gray)
+    vollath = _vollath_f4(gray)
+
+    # Thresholds (heuristic, tuned for typical microscopy)
+    tenen_verdict = _score_label(tenen, 200, 1000)
+    lap_verdict = _score_label(lap_var, 50, 300)
+    norm_verdict = _score_label(norm_var, 5, 20)
+    vollath_verdict = _score_label(vollath, 1e5, 1e6)
+
+    overall_sharp = sum([
+        tenen >= 1000,
+        lap_var >= 300,
+        norm_var >= 20,
+        vollath >= 1e6,
+    ])
+    if overall_sharp >= 3:
+        overall = "PASS — image is in focus"
+    elif overall_sharp >= 1:
+        overall = "MARGINAL — some metrics indicate softness"
+    else:
+        overall = "FAIL — image appears out of focus"
+
+    report = (
+        f"## Focus Quality Report\n\n"
+        f"| Metric | Value | Verdict |\n"
+        f"|--------|-------|---------|\n"
+        f"| Tenengrad | {tenen:.1f} | {tenen_verdict} |\n"
+        f"| Laplacian Variance | {lap_var:.1f} | {lap_verdict} |\n"
+        f"| Normalized Variance | {norm_var:.2f} | {norm_verdict} |\n"
+        f"| Vollath F4 | {vollath:.0f} | {vollath_verdict} |\n\n"
+        f"**Overall: {overall}**"
+    )
+
+    # Heatmap overlay
+    hmap = _focus_heatmap(gray, block=max(32, min(gray.shape) // 16))
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    axes[0].imshow(cv2.cvtColor(image, cv2.COLOR_RGB2BGR) if len(image.shape) == 3 else gray, cmap="gray")
+    axes[0].set_title("Original", fontsize=12, fontweight="bold")
+    axes[0].axis("off")
+
+    im = axes[1].imshow(hmap, cmap="inferno", interpolation="bilinear")
+    axes[1].set_title("Focus Heatmap (Laplacian Var per block)", fontsize=12, fontweight="bold")
+    axes[1].axis("off")
+    fig.colorbar(im, ax=axes[1], fraction=0.046, pad=0.04, label="Sharpness")
+    fig.tight_layout()
+
+    overlay_img = _fig_to_image(fig)
+    return overlay_img, report
+
+
+# ---------------------------------------------------------------------------
+# Tab 2 — Illumination Analysis
+# ---------------------------------------------------------------------------
+
+def _nine_zone_map(gray: np.ndarray) -> np.ndarray:
+    h, w = gray.shape
+    rh, rw = h // 3, w // 3
+    zones = np.zeros((3, 3), dtype=np.float64)
+    for r in range(3):
+        for c in range(3):
+            patch = gray[r * rh:(r + 1) * rh, c * rw:(c + 1) * rw]
+            zones[r, c] = patch.mean()
+    return zones
+
+
+def analyze_illumination(image: np.ndarray):
+    if image is None:
+        return None, "Upload an image first."
+
+    gray = _to_gray(image)
+    h, w = gray.shape
+
+    mean_b = float(gray.mean())
+    std_b = float(gray.std())
+    min_b = int(gray.min())
+    max_b = int(gray.max())
+    dynamic_range = max_b - min_b
+
+    # Clipping detection
+    total_px = h * w
+    clipped_low = int(np.sum(gray <= 5))
+    clipped_high = int(np.sum(gray >= 250))
+    pct_low = 100.0 * clipped_low / total_px
+    pct_high = 100.0 * clipped_high / total_px
+
+    clip_warning = ""
+    if pct_low > 5:
+        clip_warning += f"  - {pct_low:.1f}% pixels crushed to black (underexposed regions)\n"
+    if pct_high > 5:
+        clip_warning += f"  - {pct_high:.1f}% pixels blown to white (overexposed regions)\n"
+    if not clip_warning:
+        clip_warning = "  - No significant clipping detected\n"
+
+    # Vignetting: compare center vs corners
+    cy, cx = h // 2, w // 2
+    r = min(h, w) // 8
+    center_mean = float(gray[cy - r:cy + r, cx - r:cx + r].mean())
+
+    corner_vals = []
+    for yr, xr in [(0, 0), (0, w - r * 2), (h - r * 2, 0), (h - r * 2, w - r * 2)]:
+        corner_vals.append(float(gray[yr:yr + r * 2, xr:xr + r * 2].mean()))
+    corner_mean = np.mean(corner_vals)
+
+    if center_mean > 1e-3:
+        vig_ratio = corner_mean / center_mean
+    else:
+        vig_ratio = 1.0
+
+    if vig_ratio < 0.75:
+        vig_verdict = f"SIGNIFICANT vignetting (corner/center = {vig_ratio:.2f})"
+    elif vig_ratio < 0.90:
+        vig_verdict = f"Mild vignetting (corner/center = {vig_ratio:.2f})"
+    else:
+        vig_verdict = f"No significant vignetting (corner/center = {vig_ratio:.2f})"
+
+    zones = _nine_zone_map(gray)
+
+    # Build figure: histogram + zone map
+    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
+
+    # Histogram
+    axes[0].hist(gray.ravel(), bins=256, range=(0, 256), color="#448AFF", alpha=0.85, edgecolor="none")
+    axes[0].axvline(mean_b, color="#FF1744", linestyle="--", linewidth=1.5, label=f"Mean={mean_b:.0f}")
+    axes[0].set_title("Brightness Histogram", fontsize=12, fontweight="bold")
+    axes[0].set_xlabel("Pixel value")
+    axes[0].set_ylabel("Count")
+    axes[0].legend()
+
+    # Zone brightness map
+    im = axes[1].imshow(zones, cmap="YlOrRd", vmin=0, vmax=255, interpolation="nearest")
+    for r in range(3):
+        for c in range(3):
+            axes[1].text(c, r, f"{zones[r, c]:.0f}", ha="center", va="center",
+                         fontsize=14, fontweight="bold",
+                         color="black" if zones[r, c] > 128 else "white")
+    axes[1].set_title("9-Zone Brightness Map", fontsize=12, fontweight="bold")
+    axes[1].set_xticks([0, 1, 2])
+    axes[1].set_xticklabels(["L", "C", "R"])
+    axes[1].set_yticks([0, 1, 2])
+    axes[1].set_yticklabels(["T", "M", "B"])
+    fig.colorbar(im, ax=axes[1], fraction=0.046, pad=0.04)
+
+    # Original image
+    axes[2].imshow(image if len(image.shape) == 3 else gray, cmap="gray")
+    axes[2].set_title("Original", fontsize=12, fontweight="bold")
+    axes[2].axis("off")
+
+    fig.tight_layout()
+    vis = _fig_to_image(fig)
+
+    report = (
+        f"## Illumination Analysis\n\n"
+        f"| Metric | Value |\n"
+        f"|--------|-------|\n"
+        f"| Mean Brightness | {mean_b:.1f} / 255 |\n"
+        f"| Std Dev | {std_b:.1f} |\n"
+        f"| Min / Max | {min_b} / {max_b} |\n"
+        f"| Dynamic Range | {dynamic_range} |\n"
+        f"| Clipped Low (<=5) | {clipped_low} px ({pct_low:.2f}%) |\n"
+        f"| Clipped High (>=250) | {clipped_high} px ({pct_high:.2f}%) |\n\n"
+        f"**Clipping:**\n{clip_warning}\n"
+        f"**Vignetting:** {vig_verdict}\n\n"
+        f"**Zone Brightness (3x3 grid):**\n"
+        f"```\n"
+        f"  {zones[0,0]:6.1f}  {zones[0,1]:6.1f}  {zones[0,2]:6.1f}\n"
+        f"  {zones[1,0]:6.1f}  {zones[1,1]:6.1f}  {zones[1,2]:6.1f}\n"
+        f"  {zones[2,0]:6.1f}  {zones[2,1]:6.1f}  {zones[2,2]:6.1f}\n"
+        f"```"
+    )
+
+    return vis, report
+
+
+# ---------------------------------------------------------------------------
+# Tab 3 — Microscopy Type Detection
+# ---------------------------------------------------------------------------
+
+def _histogram_features(gray: np.ndarray) -> dict:
+    hist = cv2.calcHist([gray], [0], None, [256], [0, 256]).ravel()
+    hist_norm = hist / hist.sum()
+
+    mean_int = float(gray.mean())
+    std_int = float(gray.std())
+    median_int = float(np.median(gray))
+
+    # Skewness
+    if std_int > 1e-6:
+        skew = float(np.mean(((gray.astype(np.float64) - mean_int) / std_int) ** 3))
+    else:
+        skew = 0.0
+
+    # Peak count (modes)
+    from scipy.signal import find_peaks
+    smoothed = ndimage.gaussian_filter1d(hist_norm, sigma=5)
+    peaks, props = find_peaks(smoothed, height=0.002, distance=20)
+    n_peaks = len(peaks)
+
+    # Edge density
+    edges = cv2.Canny(gray, 50, 150)
+    edge_density = float(np.sum(edges > 0)) / (gray.shape[0] * gray.shape[1])
+
+    # Fraction of dark pixels
+    dark_frac = float(np.sum(gray < 40)) / gray.size
+    bright_frac = float(np.sum(gray > 215)) / gray.size
+
+    return {
+        "mean": mean_int,
+        "std": std_int,
+        "median": median_int,
+        "skew": skew,
+        "n_peaks": n_peaks,
+        "edge_density": edge_density,
+        "dark_frac": dark_frac,
+        "bright_frac": bright_frac,
+        "hist_norm": hist_norm,
+    }
+
+
+_MODALITIES = ["Brightfield", "Darkfield", "Phase Contrast", "Fluorescence", "Polarized Light"]
+
+
+def _classify_modality(feats: dict) -> list[tuple[str, float]]:
+    scores = {m: 0.0 for m in _MODALITIES}
+
+    mean = feats["mean"]
+    std = feats["std"]
+    skew = feats["skew"]
+    dark_frac = feats["dark_frac"]
+    bright_frac = feats["bright_frac"]
+    edge_density = feats["edge_density"]
+    n_peaks = feats["n_peaks"]
+
+    # Brightfield: medium-high mean, moderate std, near-zero skew, low dark fraction
+    if 80 < mean < 200:
+        scores["Brightfield"] += 2.0
+    if std < 60:
+        scores["Brightfield"] += 1.0
+    if abs(skew) < 1.0:
+        scores["Brightfield"] += 1.0
+    if dark_frac < 0.15:
+        scores["Brightfield"] += 1.5
+
+    # Darkfield: low mean, high dark fraction, positive skew
+    if mean < 60:
+        scores["Darkfield"] += 2.5
+    if dark_frac > 0.5:
+        scores["Darkfield"] += 2.0
+    if skew > 1.0:
+        scores["Darkfield"] += 1.5
+    if bright_frac < 0.05:
+        scores["Darkfield"] += 0.5
+
+    # Phase contrast: bimodal histogram, halos (high edge density), medium mean
+    if n_peaks >= 2:
+        scores["Phase Contrast"] += 2.0
+    if edge_density > 0.08:
+        scores["Phase Contrast"] += 2.0
+    if 50 < mean < 160:
+        scores["Phase Contrast"] += 1.0
+    if std > 40:
+        scores["Phase Contrast"] += 0.5
+
+    # Fluorescence: very dark background, sparse bright spots, very high skew
+    if mean < 40:
+        scores["Fluorescence"] += 2.0
+    if dark_frac > 0.7:
+        scores["Fluorescence"] += 2.0
+    if skew > 2.0:
+        scores["Fluorescence"] += 2.5
+    if bright_frac > 0.001 and bright_frac < 0.15:
+        scores["Fluorescence"] += 1.0
+
+    # Polarized: high contrast, possible birefringence colors (high std in color)
+    if std > 50:
+        scores["Polarized Light"] += 1.0
+    if n_peaks >= 2:
+        scores["Polarized Light"] += 0.5
+    if 40 < mean < 140:
+        scores["Polarized Light"] += 0.5
+
+    total = sum(scores.values())
+    if total < 1e-6:
+        return [(m, 1.0 / len(_MODALITIES)) for m in _MODALITIES]
+
+    confidences = [(m, scores[m] / total) for m in _MODALITIES]
+    confidences.sort(key=lambda x: -x[1])
+    return confidences
+
+
+def detect_microscopy_type(image: np.ndarray):
+    if image is None:
+        return None, "Upload an image first."
+
+    gray = _to_gray(image)
+    feats = _histogram_features(gray)
+    confidences = _classify_modality(feats)
+
+    best_name, best_conf = confidences[0]
+
+    # Build histogram plot
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    axes[0].bar(range(256), feats["hist_norm"], color="#448AFF", width=1.0, edgecolor="none")
+    axes[0].set_title("Intensity Histogram", fontsize=12, fontweight="bold")
+    axes[0].set_xlabel("Pixel value")
+    axes[0].set_ylabel("Normalized frequency")
+
+    # Confidence bar chart
+    names = [c[0] for c in confidences]
+    vals = [c[1] * 100 for c in confidences]
+    colors = ["#00E676" if i == 0 else "#448AFF" for i in range(len(names))]
+    bars = axes[1].barh(names[::-1], vals[::-1], color=colors[::-1], edgecolor="none")
+    axes[1].set_title("Modality Confidence", fontsize=12, fontweight="bold")
+    axes[1].set_xlabel("Confidence (%)")
+    axes[1].set_xlim(0, 100)
+    for bar, v in zip(bars, vals[::-1]):
+        axes[1].text(bar.get_width() + 1, bar.get_y() + bar.get_height() / 2,
+                     f"{v:.1f}%", va="center", fontsize=10)
+
+    fig.tight_layout()
+    vis = _fig_to_image(fig)
+
+    report = (
+        f"## Microscopy Type Detection\n\n"
+        f"**Detected: {best_name}** (confidence: {best_conf * 100:.1f}%)\n\n"
+        f"| Modality | Confidence |\n"
+        f"|----------|------------|\n"
+    )
+    for name, conf in confidences:
+        marker = " <<" if name == best_name else ""
+        report += f"| {name} | {conf * 100:.1f}%{marker} |\n"
+
+    report += (
+        f"\n**Image Features:**\n"
+        f"- Mean intensity: {feats['mean']:.1f}\n"
+        f"- Std deviation: {feats['std']:.1f}\n"
+        f"- Skewness: {feats['skew']:.2f}\n"
+        f"- Histogram peaks: {feats['n_peaks']}\n"
+        f"- Edge density: {feats['edge_density']:.4f}\n"
+        f"- Dark pixel fraction: {feats['dark_frac']:.3f}\n"
+        f"- Bright pixel fraction: {feats['bright_frac']:.3f}\n"
+    )
+
+    return vis, report
+
+
+# ---------------------------------------------------------------------------
+# Tab 4 — Image Enhancement
+# ---------------------------------------------------------------------------
+
+def _apply_clahe(img: np.ndarray, clip_limit: float = 3.0, grid_size: int = 8) -> np.ndarray:
+    if len(img.shape) == 3:
+        lab = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(grid_size, grid_size))
+        lab[:, :, 0] = clahe.apply(lab[:, :, 0])
+        return cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+    else:
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(grid_size, grid_size))
+        return clahe.apply(img)
+
+
+def _apply_unsharp(img: np.ndarray, sigma: float = 2.0, strength: float = 1.5) -> np.ndarray:
+    blurred = cv2.GaussianBlur(img, (0, 0), sigma)
+    sharpened = cv2.addWeighted(img, 1.0 + strength, blurred, -strength, 0)
+    return np.clip(sharpened, 0, 255).astype(np.uint8)
+
+
+def _apply_denoise(img: np.ndarray, h: float = 10.0) -> np.ndarray:
+    if len(img.shape) == 3:
+        return cv2.fastNlMeansDenoisingColored(img, None, h, h, 7, 21)
+    else:
+        return cv2.fastNlMeansDenoising(img, None, h, 7, 21)
+
+
+def _apply_white_balance(img: np.ndarray) -> np.ndarray:
+    if len(img.shape) != 3:
+        return img
+    result = img.copy().astype(np.float64)
+    for c in range(3):
+        ch = result[:, :, c]
+        low = np.percentile(ch, 1)
+        high = np.percentile(ch, 99)
+        if high - low < 1:
+            continue
+        ch = (ch - low) / (high - low) * 255.0
+        result[:, :, c] = ch
+    return np.clip(result, 0, 255).astype(np.uint8)
+
+
+def enhance_image(image: np.ndarray, method: str,
+                  clahe_clip: float = 3.0, clahe_grid: int = 8,
+                  unsharp_sigma: float = 2.0, unsharp_strength: float = 1.5,
+                  denoise_h: float = 10.0):
+    if image is None:
+        return None, "Upload an image first."
+
+    if method == "CLAHE (Contrast Enhancement)":
+        enhanced = _apply_clahe(image, clip_limit=clahe_clip, grid_size=int(clahe_grid))
+        desc = f"CLAHE — clipLimit={clahe_clip}, gridSize={int(clahe_grid)}"
+    elif method == "Unsharp Mask (Sharpening)":
+        enhanced = _apply_unsharp(image, sigma=unsharp_sigma, strength=unsharp_strength)
+        desc = f"Unsharp Mask — sigma={unsharp_sigma}, strength={unsharp_strength}"
+    elif method == "NLM Denoising":
+        enhanced = _apply_denoise(image, h=denoise_h)
+        desc = f"Non-Local Means Denoising — h={denoise_h}"
+    elif method == "Auto White Balance":
+        enhanced = _apply_white_balance(image)
+        desc = "Auto White Balance (percentile stretch per channel)"
+    else:
+        enhanced = image
+        desc = "No method selected"
+
+    # Side-by-side
+    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+    axes[0].imshow(image)
+    axes[0].set_title("Before", fontsize=14, fontweight="bold")
+    axes[0].axis("off")
+    axes[1].imshow(enhanced)
+    axes[1].set_title("After", fontsize=14, fontweight="bold")
+    axes[1].axis("off")
+    fig.suptitle(desc, fontsize=12, y=0.02)
+    fig.tight_layout()
+    comparison = _fig_to_image(fig)
+
+    report = (
+        f"## Enhancement Applied\n\n"
+        f"**Method:** {desc}\n\n"
+        f"| Metric | Before | After |\n"
+        f"|--------|--------|-------|\n"
+    )
+
+    for label, a, b in [
+        ("Mean", image, enhanced),
+        ("Std", image, enhanced),
+    ]:
+        ga = _to_gray(a).astype(np.float64)
+        gb = _to_gray(b).astype(np.float64)
+        if label == "Mean":
+            report += f"| Mean Brightness | {ga.mean():.1f} | {gb.mean():.1f} |\n"
+        else:
+            report += f"| Std Dev | {ga.std():.1f} | {gb.std():.1f} |\n"
+
+    # Sharpness comparison
+    ga = _to_gray(image)
+    gb = _to_gray(enhanced)
+    lap_before = cv2.Laplacian(ga, cv2.CV_64F).var()
+    lap_after = cv2.Laplacian(gb, cv2.CV_64F).var()
+    report += f"| Laplacian Var (sharpness) | {lap_before:.1f} | {lap_after:.1f} |\n"
+
+    return comparison, enhanced, report
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+css = """
+.gr-block { border-radius: 12px !important; }
+footer { display: none !important; }
+"""
+
+with gr.Blocks(title="Microscopy CV Toolkit", css=css, theme=gr.themes.Base()) as demo:
+    gr.Markdown(
+        "# Microscopy CV Toolkit\n"
+        "Classical computer-vision tools for microscopy image quality analysis. "
+        "No ML models — pure OpenCV, NumPy, SciPy. Upload any microscopy image to get started."
+    )
+
+    with gr.Tabs():
+        # ---- Tab 1: Focus Quality ----
+        with gr.Tab("Focus Quality"):
+            gr.Markdown(
+                "Measures image sharpness using four complementary metrics. "
+                "The heatmap shows per-block focus quality across the field of view."
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    focus_input = gr.Image(label="Upload Image", type="numpy")
+                    focus_btn = gr.Button("Analyze Focus", variant="primary", size="lg")
+                with gr.Column(scale=2):
+                    focus_output = gr.Image(label="Focus Heatmap", type="numpy")
+                    focus_report = gr.Markdown(label="Report")
+
+            focus_btn.click(
+                fn=analyze_focus,
+                inputs=[focus_input],
+                outputs=[focus_output, focus_report],
+            )
+
+        # ---- Tab 2: Illumination Analysis ----
+        with gr.Tab("Illumination Analysis"):
+            gr.Markdown(
+                "Checks brightness distribution, clipping, dynamic range, vignetting, "
+                "and displays a 9-zone brightness map for Kohler illumination assessment."
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    illum_input = gr.Image(label="Upload Image", type="numpy")
+                    illum_btn = gr.Button("Analyze Illumination", variant="primary", size="lg")
+                with gr.Column(scale=2):
+                    illum_output = gr.Image(label="Analysis", type="numpy")
+                    illum_report = gr.Markdown(label="Report")
+
+            illum_btn.click(
+                fn=analyze_illumination,
+                inputs=[illum_input],
+                outputs=[illum_output, illum_report],
+            )
+
+        # ---- Tab 3: Microscopy Type Detection ----
+        with gr.Tab("Microscopy Type Detection"):
+            gr.Markdown(
+                "Auto-detects imaging modality based on histogram shape, intensity statistics, "
+                "contrast, and edge density. Works best on standard preparations."
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    type_input = gr.Image(label="Upload Image", type="numpy")
+                    type_btn = gr.Button("Detect Type", variant="primary", size="lg")
+                with gr.Column(scale=2):
+                    type_output = gr.Image(label="Analysis", type="numpy")
+                    type_report = gr.Markdown(label="Report")
+
+            type_btn.click(
+                fn=detect_microscopy_type,
+                inputs=[type_input],
+                outputs=[type_output, type_report],
+            )
+
+        # ---- Tab 4: Image Enhancement ----
+        with gr.Tab("Image Enhancement"):
+            gr.Markdown(
+                "Apply classical enhancement techniques. Adjust parameters and compare side-by-side."
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    enhance_input = gr.Image(label="Upload Image", type="numpy")
+                    enhance_method = gr.Radio(
+                        choices=[
+                            "CLAHE (Contrast Enhancement)",
+                            "Unsharp Mask (Sharpening)",
+                            "NLM Denoising",
+                            "Auto White Balance",
+                        ],
+                        value="CLAHE (Contrast Enhancement)",
+                        label="Enhancement Method",
+                    )
+                    with gr.Accordion("Parameters", open=False):
+                        clahe_clip = gr.Slider(0.5, 10.0, value=3.0, step=0.5, label="CLAHE Clip Limit")
+                        clahe_grid = gr.Slider(2, 16, value=8, step=1, label="CLAHE Grid Size")
+                        unsharp_sigma = gr.Slider(0.5, 5.0, value=2.0, step=0.5, label="Unsharp Sigma")
+                        unsharp_strength = gr.Slider(0.5, 5.0, value=1.5, step=0.5, label="Unsharp Strength")
+                        denoise_h = gr.Slider(1.0, 30.0, value=10.0, step=1.0, label="Denoise Strength (h)")
+                    enhance_btn = gr.Button("Enhance", variant="primary", size="lg")
+                with gr.Column(scale=2):
+                    enhance_comparison = gr.Image(label="Before / After", type="numpy")
+                    enhance_result = gr.Image(label="Enhanced Image (downloadable)", type="numpy")
+                    enhance_report = gr.Markdown(label="Report")
+
+            enhance_btn.click(
+                fn=enhance_image,
+                inputs=[enhance_input, enhance_method,
+                        clahe_clip, clahe_grid,
+                        unsharp_sigma, unsharp_strength,
+                        denoise_h],
+                outputs=[enhance_comparison, enhance_result, enhance_report],
+            )
+
+    gr.Markdown(
+        "<center style='color:#888;font-size:0.85em;'>"
+        "Microscopy CV Toolkit | Pure OpenCV, no ML models | "
+        "<a href='https://huggingface.co/spaces/Laborator/microscopy-cv-toolkit'>HuggingFace Space</a>"
+        "</center>"
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+opencv-python-headless
+numpy
+scipy
+matplotlib
+Pillow