🍄 Fungal Colony Image Analysis Pipeline

End-to-end analysis pipeline for Magnaporthe (and other fungal) colony morphometry on 90 mm petri-dish images.

▶ Try the live demo — upload images, run inference, see overlays & growth charts in your browser.

Designed for Apple Silicon Mac (M1/M2/M3 Pro/Max, MPS backend, float32). Also works on CPU (Linux/Windows).

Model

Weights: rotsl/grayleafspot-segmentation/grayleafspot.pt

Property	Value
Architecture	`smp.Unet(encoder_name="resnet34")` via segmentation-models-pytorch
Parameters	24.4M
Input	256×256 RGB
Output	1-channel sigmoid mask (threshold 0.5)
Dish detection	OpenCV `HoughCircles` on Gaussian-blurred grayscale
MPS compatible	✅ Pure PyTorch — no custom CUDA kernels

Pipeline Overview

input.py                                pipeline.py / app.py (Space)
┌──────────────────┐                    ┌──────────────────────────────────────┐
│  Gradio GUI      │                    │  Read image_metadata.csv             │
│  - Scan folder   │  image_metadata.   │  Load smp.Unet (thread-local)       │
│  - Tag metadata  │──── csv/json ─────▶│  For each image:                     │
│  - Export CSV    │                    │    1. OpenCV HoughCircles → dish     │
│  - Export ICS    │                    │    2. U-Net → colony mask            │
└──────────────────┘                    │    3. Crack detection (adaptive)     │
                                        │    4. Hyphae (Frangi + Meijering)    │
                                        │    5. Morphometrics (mm/mm²)         │
                                        │  6 overlay panels per image          │
                                        │  Growth charts (≥2 images)           │
                                        │  Output: analysis_full.csv/json      │
                                        └──────────────────────────────────────┘

Visualisation Outputs

6 Overlay Panels Per Image

Panel	Colour	Shows
Raw + Dish	Green circle, red contour	Detected dish boundary + colony outline
Colony Mask	White on black	Binary segmentation mask
Colony Overlay	Red 50% blend	Colony area highlighted on raw image
Cracks	Yellow	Detected cracks inside colony (dilated for visibility)
Hyphae	Cyan	Hyphae skeleton (Frangi + Meijering hybrid filter)
All Combined	Red + yellow + cyan	Colony + cracks + hyphae together

Growth Charts (when ≥2 images)

Colony Area (mm²) vs days — with fill + data labels
Diameter (mm) over time
Relative Growth Rate (RGR) — bar chart per interval
Crack Coverage (%) over time
Hyphae Network Length (mm) over time
Morphology — eccentricity + edge roughness dual panel

All charts are included as PNGs in the download zip.

Installation (Local)

Prerequisites

Python 3.10+
macOS with Apple Silicon recommended (MPS acceleration) — also works on CPU
~100 MB disk for model weights (cached in ~/.cache/huggingface)

Setup

# 1. Clone
git clone https://huggingface.co/rotsl/fungal-colony-pipeline
cd fungal-colony-pipeline

# 2. Virtual environment
python3 -m venv .venv
source .venv/bin/activate

# 3. Install
pip install -r requirements.txt

# 4. (Optional) Pre-download model
python -c "
from huggingface_hub import hf_hub_download
p = hf_hub_download('rotsl/grayleafspot-segmentation', 'grayleafspot.pt')
print(f'Downloaded to: {p}')
"

Usage (Local)

Step 1: Tag Images with Metadata

python input.py

Open http://localhost:7860
Paste image folder path → 📂 Scan
Fill experiment details (name, start date, user, plates count)
Click thumbnails → edit per-image dates → 💾 Save
📥 Export → writes image_metadata.csv, .json, reminders.ics to your folder

Step 2: Run Analysis

IMG_DIR=./data python pipeline.py

Variable	Default	Description
`IMG_DIR`	`.`	Folder with `image_metadata.csv` + images
`MAX_WORKERS`	`2`	Parallel threads (hard cap 2 for 16 GB)
`MODEL_REPO`	`rotsl/grayleafspot-segmentation`	HF model repo
`MODEL_FILE`	`grayleafspot.pt`	Weight file

Outputs: analysis_full.csv + analysis_full.json in IMG_DIR

Usage via HF API (Programmatic Access)

You can run the full pipeline remotely via the Gradio Client without installing anything locally. The Space exposes five API endpoints.

Install

pip install gradio_client

Quick Start — Upload + Run Pipeline

from gradio_client import Client, handle_file

client = Client("rotsl/fungal-colony-input")

# Step 1: Upload images
result = client.predict(
    files=[
        handle_file("plate_d01.jpg"),
        handle_file("plate_d03.jpg"),
        handle_file("plate_d05.jpg"),
    ],
    api_name="/on_upload",
)
# result = (gallery_items, status_markdown)

# Step 2: Run the full analysis pipeline
analysis = client.predict(
    en="MagExp01",                # experiment name
    ed="2025-04-01",              # experiment start date
    un="YourName",                # user name
    pc=1,                         # plates count
    api_name="/on_run",
)
# analysis is a tuple:
#   [0] status message (str)
#   [1] overlay gallery — list of dicts with 'image' paths (6 panels per input image)
#   [2] growth chart gallery — list of dicts with 'image' paths
#   [3] results dataframe (dict with 'headers' and 'data')
#   [4] path to analysis_full.zip

status_msg    = analysis[0]
overlays      = analysis[1]   # list of {image: filepath, caption: str}
charts        = analysis[2]   # list of {image: filepath, caption: str}
results_table = analysis[3]   # {"headers": [...], "data": [[...], ...]}
zip_path      = analysis[4]   # local path to downloaded analysis_full.zip

print(status_msg)
print(f"Overlays: {len(overlays)} panels")
print(f"Charts:   {len(charts)}")
print(f"Results:  {len(results_table['data'])} rows × {len(results_table['headers'])} cols")
print(f"Download: {zip_path}")

Export Metadata Only (no inference)

meta = client.predict(
    en="MagExp01",
    ed="2025-04-01",
    un="YourName",
    pc=1,
    api_name="/on_export",
)
# meta[0] = status message
# meta[1] = metadata dataframe
# meta[2] = path to image_metadata.zip

Available API Endpoints

Endpoint	Description	Key Parameters
`/on_upload`	Upload images → gallery	`files`: list of filepaths
`/on_sel`	Select image in gallery	`ed`: experiment date
`/on_save`	Save per-image date/reminder	`nd`: date, `nr`: reminder, `ed`: exp date
`/on_export`	Export metadata CSV/JSON/ICS	`en`, `ed`, `un`, `pc`
`/on_run`	Run full pipeline (segmentation + morphometrics + charts)	`en`, `ed`, `un`, `pc`

cURL Example

# Upload images and run pipeline via REST API
# (Gradio uses a session-based API — the Python client is recommended)

curl -X POST https://rotsl-fungal-colony-input.hf.space/gradio_api/call/on_upload \
  -H "Content-Type: application/json" \
  -d '{
    "data": [
      [{"path": "https://your-server.com/plate_d01.jpg"}]
    ]
  }'

Note: For multi-step workflows (upload → run), use the Python gradio_client which handles session state automatically. Direct REST calls require managing the session hash between requests.

Batch Processing Script

"""Process a folder of petri dish images via the HF Space API."""
from pathlib import Path
from gradio_client import Client, handle_file

IMAGE_DIR = Path("./my_experiment")
EXPERIMENT = "MagExp01"
START_DATE = "2025-04-01"

client = Client("rotsl/fungal-colony-input")

# Collect all images
images = sorted(
    p for p in IMAGE_DIR.rglob("*")
    if p.suffix.lower() in {".jpg", ".jpeg", ".png", ".tif", ".bmp", ".webp"}
)
print(f"Found {len(images)} images")

# Upload
client.predict(
    files=[handle_file(str(p)) for p in images],
    api_name="/on_upload",
)

# Run pipeline
status, overlays, charts, table, zip_path = client.predict(
    en=EXPERIMENT,
    ed=START_DATE,
    un="BatchUser",
    pc=1,
    api_name="/on_run",
)

print(status)
print(f"Results zip: {zip_path}")

# Access results as a DataFrame
import pandas as pd
df = pd.DataFrame(table["data"], columns=table["headers"])
print(df[["image_path", "area_mm2", "diameter_mm", "crack_coverage_pct"]].to_string())

Output Columns

Metadata

Column	Description
`image_path`	Relative path from IMG_DIR
`experiment_name`	Experiment identifier
`experiment_date`	Start date (YYYY-MM-DD)
`image_date`	Auto-detected capture date
`day_code`	d01, d02, …
`user_name`	Researcher
`plates_count`	Number of plates

Calibration

Column	Unit	Description
`dish_cx`, `dish_cy`	px	Dish centre
`dish_radius_px`	px	Dish radius
`px_to_mm`	mm/px	Scale factor
`calibration_diameter_mm`	mm	Should be ≈90.0
`calibration_error_pct`	%	Target <2%

Colony Morphometry

Column	Unit	Description
`area_mm2`	mm²	Colony area
`diameter_mm`	mm	Equivalent circular diameter
`perimeter_mm`	mm	Colony perimeter
`eccentricity`	–	0=circle, 1=line
`edge_roughness`	–	Perimeter / equivalent circle perimeter
`centre_delta_mm`	mm	Colony centre to dish centre

Texture

Column	Description
`entropy`	Shannon entropy
`texture_std`	Pixel intensity σ

Cracks

Column	Unit	Description
`crack_px`	px	Total crack pixels
`crack_area_mm2`	mm²	Total crack area
`crack_coverage_pct`	%	Crack / colony area × 100
`crack_count`	–	Distinct crack count

Hyphae

Column	Unit	Description
`hyph_frangi_mm`	mm	Frangi vesselness skeleton length
`hyph_meijering_mm`	mm	Meijering neuriteness skeleton length
`hyph_hybrid_mm`	mm	Union of both

Time-Series

Column	Unit	Description
`days_since_start`	days	From first image
`rgr_per_day`	day⁻¹	(ln A₂ − ln A₁) / Δdays
`relative_growth_per_day`	mm²/day	(A₂ − A₁) / Δdays

R Studio Integration

library(readr)
library(dplyr)
library(ggplot2)

df <- read_csv("analysis_full.csv")

# Growth curve
df %>%
  filter(is.na(error) | error == "") %>%
  ggplot(aes(x = days_since_start, y = area_mm2, color = experiment_name)) +
  geom_line() + geom_point() +
  labs(x = "Days", y = "Colony Area (mm²)", title = "Magnaporthe Growth") +
  theme_minimal()

# Morphology summary
df %>%
  filter(is.na(error) | error == "") %>%
  group_by(experiment_name) %>%
  summarise(
    n = n(),
    mean_area = mean(area_mm2, na.rm = TRUE),
    mean_roughness = mean(edge_roughness, na.rm = TRUE),
    mean_crack_pct = mean(crack_coverage_pct, na.rm = TRUE),
    total_hyphae = sum(hyph_hybrid_mm, na.rm = TRUE)
  )

# RGR
df %>%
  filter(!is.na(rgr_per_day) & rgr_per_day != "") %>%
  mutate(rgr_per_day = as.numeric(rgr_per_day)) %>%
  ggplot(aes(x = days_since_start, y = rgr_per_day)) +
  geom_col(fill = "steelblue") +
  facet_wrap(~ experiment_name) +
  labs(x = "Days", y = "RGR (day⁻¹)") +
  theme_minimal()

library(jsonlite)
df <- fromJSON("analysis_full.json")
meta <- read_csv("image_metadata.csv")

Technical Notes

Segmentation Strategy

Dish detection: OpenCV GaussianBlur → HoughCircles (HOUGH_GRADIENT, dp=1.2)
Colony segmentation: Resize full image to 256×256 → smp.Unet(resnet34) → sigmoid → threshold 0.5
Resize mask back to original resolution (nearest-neighbour)
Restrict to dish interior (95% of detected radius)
Cleanup: OpenCV morphological close/open, keep largest connected component

Crack Detection

Local adaptive thresholding inside colony mask
Filter by elongation (aspect ratio > 2.5 or eccentricity > 0.85)
Edge artefacts removed via erosion

Hyphae Detection

Frangi filter: multi-scale vesselness (σ = 1–4)
Meijering filter: neuriteness (σ = 1–4)
Hybrid: union of both skeletonised responses
Analysis region extends 20 px beyond colony boundary

Memory Management

Max 2 parallel threads — prevents OOM on 16 GB
torch.mps.empty_cache() after each image
Thread-local model loading
Float32 throughout

File Structure

your_image_folder/
├── subdir_a/
│   ├── mag01_20250401_01.jpg
│   └── mag01_20250402_01.jpg
├── image_metadata.csv          ← input.py
├── image_metadata.json         ← input.py
├── reminders.ics               ← input.py (if reminders)
├── analysis_full.csv           ← pipeline.py
└── analysis_full.json          ← pipeline.py

Troubleshooting

Issue	Fix
`torch.mps not available`	macOS 13+ and PyTorch 2.1+ required
OOM on 16 GB	`MAX_WORKERS=1`
Model download fails	Check internet + HF_TOKEN for gated repo
Dish not detected	Full rim must be visible, avoid heavy shadows
Colony not detected	Verify image has visible colony contrast against agar

Citation

@misc{rohan_r_2026,
    author       = { rohan r },
    title        = { fungal-colony-pipeline (Revision e51373b) },
    year         = 2026,
    url          = { https://huggingface.co/rotsl/fungal-colony-pipeline },
    doi          = { 10.57967/hf/8570 },
    publisher    = { Hugging Face }
}

License

Apache License 2.0

Downloads last month: 1