petrilya 0.0.1__py3-none-any.whl

petrilya/__init__.py

@@ -0,0 +1,3 @@
+"""Petrilya — AI colony counter for biology labs."""
+
+__version__ = "0.0.1"

petrilya/cli.py

@@ -0,0 +1,61 @@
+"""Command-line interface for Petrilya."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+import click
+import numpy as np
+from PIL import Image
+from rich.console import Console
+
+from petrilya.export.csv_writer import write_csv
+from petrilya.inference.engine import CellposeEngine
+from petrilya.metrics.colony import compute_colony_metrics
+
+console = Console()
+
+
+@click.command()
+@click.argument("image_path", type=click.Path(exists=True, path_type=Path))
+@click.option("--output", "-o", type=click.Path(path_type=Path), default=None)
+@click.option("--gpu/--no-gpu", default=False, help="Use CUDA if available.")
+@click.option(
+    "--diameter",
+    type=float,
+    default=None,
+    help="Approximate colony diameter in pixels (auto if omitted).",
+)
+def main(
+    image_path: Path,
+    output: Path | None,
+    gpu: bool,
+    diameter: float | None,
+) -> None:
+    """Analyze a petri dish image and export colony metrics."""
+    output = output or image_path.with_suffix(".csv")
+
+    console.print(f"[cyan]Loading[/] {image_path}")
+    image = np.array(Image.open(image_path).convert("L"))
+    console.print(f"  shape={image.shape} dtype={image.dtype}")
+
+    console.print(f"[cyan]Initializing Cellpose[/] (gpu={gpu})")
+    engine = CellposeEngine(use_gpu=gpu)
+
+    t0 = time.perf_counter()
+    masks, diam = engine.segment(image, diameter=diameter)
+    elapsed = time.perf_counter() - t0
+
+    metrics = compute_colony_metrics(masks)
+    write_csv(metrics, output)
+
+    console.print(
+        f"[green]OK[/] Found [bold]{len(metrics)}[/] colonies "
+        f"(diam~{diam:.1f}px) in [bold]{elapsed:.2f}s[/]"
+    )
+    console.print(f"[green]OK[/] Saved {output}")
+
+
+if __name__ == "__main__":
+    main()

petrilya/export/csv_writer.py

@@ -0,0 +1,34 @@
+"""CSV export for colony metrics."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+
+BASE_HEADERS = [
+    "id",
+    "area_px",
+    "centroid_y",
+    "centroid_x",
+    "equivalent_diameter_px",
+    "eccentricity",
+    "solidity",
+]
+PHYSICAL_HEADERS = ["area_um2", "equivalent_diameter_um"]
+
+
+def write_csv(metrics: list[dict], output_path: Path) -> None:
+    """Write a list of metric dicts to CSV.
+
+    Auto-detects whether physical-unit columns (um2, um) are present
+    and includes them only if so.
+    """
+    headers = list(BASE_HEADERS)
+    if metrics and "area_um2" in metrics[0]:
+        headers.extend(PHYSICAL_HEADERS)
+
+    with output_path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=headers, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(metrics)

petrilya/export/json_manifest.py

@@ -0,0 +1,69 @@
+"""Run manifest JSON for reproducibility.
+
+Captures every parameter that affected a run so the result can be
+reproduced or audited later (important for scientific publication
+and GMP-relevant workflows).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+from datetime import datetime, timezone
+from pathlib import Path
+
+from petrilya import __version__
+
+
+def file_sha256(path: Path, chunk: int = 1 << 20) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        while True:
+            buf = f.read(chunk)
+            if not buf:
+                break
+            h.update(buf)
+    return h.hexdigest()
+
+
+def build_manifest(
+    *,
+    image_path: Path,
+    masks_shape: tuple[int, int],
+    n_objects: int,
+    elapsed_seconds: float,
+    engine_name: str,
+    engine_params: dict,
+    scale_um_per_px: float | None = None,
+) -> dict:
+    return {
+        "schema_version": 1,
+        "petrilya_version": __version__,
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "platform": {
+            "system": platform.system(),
+            "release": platform.release(),
+            "python": platform.python_version(),
+        },
+        "input": {
+            "path": str(image_path),
+            "filename": image_path.name,
+            "sha256": file_sha256(image_path),
+            "size_bytes": image_path.stat().st_size,
+        },
+        "engine": {
+            "name": engine_name,
+            "params": engine_params,
+        },
+        "result": {
+            "n_objects": n_objects,
+            "masks_shape": list(masks_shape),
+            "elapsed_seconds": round(elapsed_seconds, 4),
+            "scale_um_per_px": scale_um_per_px,
+        },
+    }
+
+
+def write_manifest(manifest: dict, output_path: Path) -> None:
+    output_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")

petrilya/export/pdf_report.py

@@ -0,0 +1,153 @@
+"""Generate a one-page PDF report for a single image analysis."""
+
+from __future__ import annotations
+
+import io
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.lib.units import cm
+from reportlab.platypus import (
+    Image as RLImage,
+    Paragraph,
+    SimpleDocTemplate,
+    Spacer,
+    Table,
+    TableStyle,
+)
+
+
+def _composite_preview(image: np.ndarray, masks: np.ndarray) -> Image.Image:
+    """Compose grayscale image + colored mask overlay into a PIL image."""
+    if image.ndim == 2:
+        rgb = np.stack([image] * 3, axis=-1)
+    else:
+        rgb = image.copy()
+
+    overlay = np.zeros_like(rgb)
+    rng = np.random.default_rng(0)
+    n = int(masks.max()) + 1
+    if n > 1:
+        palette = rng.integers(60, 230, size=(n, 3), dtype=np.uint8)
+        palette[0] = 0
+        overlay = palette[masks].astype(np.uint8)
+
+    blended = (0.6 * rgb + 0.4 * overlay).clip(0, 255).astype(np.uint8)
+    blended[masks == 0] = rgb[masks == 0]
+    return Image.fromarray(blended)
+
+
+def _histogram_png(
+    areas: list[float],
+    label: str,
+    bins: int = 30,
+) -> io.BytesIO:
+    """Render a histogram of areas as PNG bytes (uses matplotlib lazily)."""
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots(figsize=(6, 3), dpi=110)
+    ax.hist(areas, bins=bins, color="#5388c8", edgecolor="white")
+    ax.set_xlabel(label)
+    ax.set_ylabel("count")
+    ax.set_title("Colony size distribution")
+    fig.tight_layout()
+
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png")
+    plt.close(fig)
+    buf.seek(0)
+    return buf
+
+
+def write_pdf_report(
+    output_path: Path,
+    *,
+    image: np.ndarray,
+    masks: np.ndarray,
+    metrics: list[dict],
+    image_name: str,
+    elapsed_seconds: float,
+    engine_name: str,
+    scale_um_per_px: float | None = None,
+) -> None:
+    """Render a one-page PDF report and write it to ``output_path``."""
+    styles = getSampleStyleSheet()
+    doc = SimpleDocTemplate(
+        str(output_path),
+        pagesize=A4,
+        leftMargin=1.5 * cm,
+        rightMargin=1.5 * cm,
+        topMargin=1.5 * cm,
+        bottomMargin=1.5 * cm,
+        title=f"Petrilya report — {image_name}",
+    )
+    story = []
+
+    story.append(Paragraph("<b>Petrilya — Colony Analysis Report</b>", styles["Title"]))
+    story.append(Spacer(1, 0.3 * cm))
+
+    meta_rows = [
+        ["Image", image_name],
+        ["Generated", datetime.now().strftime("%Y-%m-%d %H:%M:%S")],
+        ["Engine", engine_name],
+        ["Inference time", f"{elapsed_seconds:.2f} s"],
+        ["Colonies found", str(len(metrics))],
+    ]
+    if scale_um_per_px:
+        meta_rows.append(["Scale", f"{scale_um_per_px:.4f} um/px"])
+
+    meta_table = Table(meta_rows, colWidths=[4 * cm, 12 * cm])
+    meta_table.setStyle(
+        TableStyle(
+            [
+                ("FONTNAME", (0, 0), (-1, -1), "Helvetica"),
+                ("FONTSIZE", (0, 0), (-1, -1), 9),
+                ("BACKGROUND", (0, 0), (0, -1), colors.lightgrey),
+                ("GRID", (0, 0), (-1, -1), 0.25, colors.grey),
+                ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+                ("LEFTPADDING", (0, 0), (-1, -1), 6),
+                ("RIGHTPADDING", (0, 0), (-1, -1), 6),
+            ]
+        )
+    )
+    story.append(meta_table)
+    story.append(Spacer(1, 0.5 * cm))
+
+    # preview
+    preview = _composite_preview(image, masks)
+    preview.thumbnail((1200, 1200))
+    preview_buf = io.BytesIO()
+    preview.save(preview_buf, format="PNG")
+    preview_buf.seek(0)
+    story.append(RLImage(preview_buf, width=16 * cm, height=16 * cm * preview.size[1] / preview.size[0]))
+    story.append(Spacer(1, 0.4 * cm))
+
+    # histogram
+    if metrics:
+        if scale_um_per_px and "area_um2" in metrics[0]:
+            areas = [m["area_um2"] for m in metrics]
+            label = "Area (um^2)"
+        else:
+            areas = [m["area_px"] for m in metrics]
+            label = "Area (px)"
+        hist = _histogram_png(areas, label)
+        story.append(RLImage(hist, width=14 * cm, height=7 * cm))
+
+    story.append(Spacer(1, 0.3 * cm))
+    story.append(
+        Paragraph(
+            "<font size=8 color='grey'>Generated by Petrilya. "
+            "Open-source: github.com/petrilya-app/petrilya-core</font>",
+            styles["Normal"],
+        )
+    )
+
+    doc.build(story)

petrilya/inference/engine.py

@@ -0,0 +1,28 @@
+"""Cellpose-based segmentation engine for colony counting."""
+
+from __future__ import annotations
+
+import numpy as np
+from cellpose import models
+
+
+class CellposeEngine:
+    """Wrapper around Cellpose for colony segmentation."""
+
+    def __init__(self, model_type: str = "cyto3", use_gpu: bool = False) -> None:
+        self.use_gpu = use_gpu
+        self.model_type = model_type
+        self.model = models.Cellpose(gpu=use_gpu, model_type=model_type)
+
+    def segment(
+        self,
+        image: np.ndarray,
+        diameter: float | None = None,
+    ) -> tuple[np.ndarray, float]:
+        """Run segmentation. Returns (masks, estimated_diameter)."""
+        masks, _flows, _styles, diams = self.model.eval(
+            image,
+            diameter=diameter,
+            channels=[0, 0],
+        )
+        return masks, float(diams) if np.isscalar(diams) else float(diams[0])

petrilya/metrics/colony.py

@@ -0,0 +1,38 @@
+"""Compute per-colony metrics from segmentation masks."""
+
+from __future__ import annotations
+
+import numpy as np
+from skimage import measure
+
+
+def compute_colony_metrics(
+    masks: np.ndarray,
+    scale_um_per_px: float | None = None,
+) -> list[dict]:
+    """Compute area, centroid, equivalent diameter for each colony.
+
+    If ``scale_um_per_px`` is provided, also report area_um2 and
+    equivalent_diameter_um in physical units.
+    """
+    if masks.max() == 0:
+        return []
+    props = measure.regionprops(masks)
+    out: list[dict] = []
+    for p in props:
+        rec = {
+            "id": int(p.label),
+            "area_px": int(p.area),
+            "centroid_y": float(p.centroid[0]),
+            "centroid_x": float(p.centroid[1]),
+            "equivalent_diameter_px": float(p.equivalent_diameter_area),
+            "eccentricity": float(p.eccentricity),
+            "solidity": float(p.solidity),
+        }
+        if scale_um_per_px is not None and scale_um_per_px > 0:
+            rec["area_um2"] = float(p.area) * scale_um_per_px**2
+            rec["equivalent_diameter_um"] = (
+                float(p.equivalent_diameter_area) * scale_um_per_px
+            )
+        out.append(rec)
+    return out

petrilya/ui/__init__.py

@@ -0,0 +1 @@
+"""Petrilya desktop UI (PySide6)."""

petrilya/ui/app.py

@@ -0,0 +1,38 @@
+"""UI entry point: ``petrilya-ui`` command."""
+
+from __future__ import annotations
+
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from petrilya.ui.main_window import MainWindow
+
+
+def main() -> None:
+    app = QApplication(sys.argv)
+    app.setApplicationName("Petrilya")
+    app.setStyle("Fusion")
+
+    # simple dark palette
+    from PySide6.QtGui import QColor, QPalette
+
+    palette = QPalette()
+    palette.setColor(QPalette.ColorRole.Window, QColor(45, 45, 45))
+    palette.setColor(QPalette.ColorRole.WindowText, QColor(220, 220, 220))
+    palette.setColor(QPalette.ColorRole.Base, QColor(30, 30, 30))
+    palette.setColor(QPalette.ColorRole.AlternateBase, QColor(45, 45, 45))
+    palette.setColor(QPalette.ColorRole.Text, QColor(220, 220, 220))
+    palette.setColor(QPalette.ColorRole.Button, QColor(60, 60, 60))
+    palette.setColor(QPalette.ColorRole.ButtonText, QColor(220, 220, 220))
+    palette.setColor(QPalette.ColorRole.Highlight, QColor(80, 130, 200))
+    palette.setColor(QPalette.ColorRole.HighlightedText, QColor(255, 255, 255))
+    app.setPalette(palette)
+
+    window = MainWindow()
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()