pysternblot 1.0.0__py3-none-any.whl

pysternblot/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pysternblot/__main__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+main()

pysternblot/app.py

@@ -0,0 +1,23 @@
+# Pystern Blot
+# SPDX-License-Identifier: GPL-3.0-only
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+
+from __future__ import annotations
+from PySide6.QtWidgets import QApplication
+from pathlib import Path
+from .storage import Workspace
+from .ui.main_window import MainWindow
+
+def default_workspace() -> Path:
+    return Path.home() / ".pysternblot"
+
+def run():
+    app = QApplication([])
+    ws = Workspace(default_workspace())
+    ws.ensure()
+    win = MainWindow(ws)
+    win.show()
+    app.exec()

pysternblot/image_utils.py

@@ -0,0 +1,249 @@
+# Pystern Blot
+# SPDX-License-Identifier: GPL-3.0-only
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Literal
+
+import numpy as np
+from PIL import Image
+from PySide6.QtGui import QImage, QPixmap
+from PySide6.QtCore import Qt
+
+
+def load_image_uint16(path: str | Path) -> np.ndarray:
+    """
+    Load an image as native grayscale uint16.
+
+    Strict rules:
+    - accepts only native 16-bit grayscale images
+    - rejects 8-bit, RGB, RGBA, palette, and other modes
+    - performs no bit-depth promotion and no color conversion
+    """
+    path = str(path)
+
+    with Image.open(path) as im:
+        if im.mode not in ("I;16", "I;16L", "I;16B"):
+            raise ValueError(
+                f"Unsupported image mode {im.mode!r} for {path}. "
+                "Only native 16-bit grayscale images are accepted."
+            )
+
+        arr = np.array(im, dtype=np.uint16)
+
+    if arr.ndim != 2:
+        raise ValueError(
+            f"Expected a 2D grayscale image for {path}, got shape {arr.shape}."
+        )
+
+    return np.ascontiguousarray(arr)
+
+
+def apply_levels_uint16(
+    img: np.ndarray,
+    black: int,
+    white: int,
+    gamma: float,
+    invert: bool,
+) -> np.ndarray:
+    """
+    Apply black/white/gamma/invert in 16-bit space.
+    Returns uint16.
+    """
+    if img.dtype != np.uint16:
+        raise TypeError(f"Expected uint16 image, got {img.dtype}")
+
+    black = int(black)
+    white = int(white)
+    gamma = float(gamma)
+
+    if white <= black:
+        white = black + 1
+    if gamma <= 0:
+        gamma = 1.0
+
+    arr = img.astype(np.float32)
+    arr = (arr - black) / float(white - black)
+    arr = np.clip(arr, 0.0, 1.0)
+
+    inv_gamma = 1.0 / gamma
+    arr = np.power(arr, inv_gamma)
+
+    if invert:
+        arr = 1.0 - arr
+
+    out = np.round(arr * 65535.0).astype(np.uint16)
+    return np.ascontiguousarray(out)
+
+
+def rotate_uint16(
+    img: np.ndarray,
+    rotation_deg: float,
+    expand: bool = False,
+) -> np.ndarray:
+    """
+    Rotate a uint16 grayscale image while preserving high bit depth.
+
+    Uses Pillow in 32-bit integer mode ("I") for the transform, then clips
+    back to uint16. No 8-bit conversion is involved.
+
+    Parameters
+    ----------
+    img : np.ndarray
+        2D uint16 grayscale image.
+    rotation_deg : float
+        Rotation angle in degrees.
+    expand : bool
+        If True, Pillow expands the output canvas to contain the whole rotated
+        image. If False, the output canvas keeps the original width/height and
+        overflowing corners are clipped.
+    """
+    if img.dtype != np.uint16:
+        raise TypeError(f"Expected uint16 image, got {img.dtype}")
+
+    if abs(float(rotation_deg)) < 1e-6:
+        return np.ascontiguousarray(img)
+
+    pil = Image.fromarray(img.astype(np.int32), mode="I")
+
+    rotated = pil.rotate(
+        float(rotation_deg),
+        resample=Image.Resampling.BICUBIC,
+        expand=bool(expand),
+        fillcolor=0,
+    )
+
+    arr = np.array(rotated, dtype=np.int32)
+    arr = np.clip(arr, 0, 65535).astype(np.uint16)
+
+    return np.ascontiguousarray(arr)
+
+
+def crop_uint16(img: np.ndarray, x: int, y: int, w: int, h: int) -> np.ndarray:
+    """
+    Crop a uint16 image with clamping.
+    """
+    ih, iw = img.shape[:2]
+
+    x = max(0, min(int(x), max(0, iw - 1)))
+    y = max(0, min(int(y), max(0, ih - 1)))
+    w = max(1, min(int(w), iw - x))
+    h = max(1, min(int(h), ih - y))
+
+    return np.ascontiguousarray(img[y:y + h, x:x + w])
+
+
+def save_uint16_tiff(img: np.ndarray, path: str | Path) -> None:
+    """
+    Save uint16 grayscale TIFF.
+    """
+    if img.dtype != np.uint16:
+        raise TypeError(f"Expected uint16 image, got {img.dtype}")
+
+    h, w = img.shape
+    pil = Image.frombuffer("I;16", (w, h), img.tobytes(), "raw", "I;16", 0, 1)
+    pil.save(str(path), format="TIFF")
+
+
+def uint16_to_qimage(img: np.ndarray) -> QImage:
+    """
+    Wrap a uint16 grayscale NumPy array as QImage.Format_Grayscale16.
+    Caller must keep the NumPy array alive while the QImage is in use.
+    """
+    if img.dtype != np.uint16:
+        raise TypeError(f"Expected uint16 image, got {img.dtype}")
+    if img.ndim != 2:
+        raise ValueError(f"Expected 2D grayscale image, got shape {img.shape}")
+
+    h, w = img.shape
+    bytes_per_line = w * 2
+
+    qimg = QImage(
+        img.data,
+        w,
+        h,
+        bytes_per_line,
+        QImage.Format_Grayscale16,
+    )
+    return qimg
+
+
+def detect_tiff_channel_encoding(
+    path: str | Path,
+) -> Literal["multipage", "rgb_interleaved", "single"]:
+    """
+    Inspect a TIFF and return how its channels are encoded.
+
+    - "multipage"       — multiple frames, one channel per frame (LI-COR Odyssey style)
+    - "rgb_interleaved" — single-frame RGB/RGBA (some composite exports)
+    - "single"          — single-frame grayscale (ECL, single-channel NIR)
+    """
+    with Image.open(str(path)) as im:
+        n_frames = getattr(im, "n_frames", 1)
+        if n_frames > 1:
+            return "multipage"
+        if im.mode in ("RGB", "RGBA"):
+            return "rgb_interleaved"
+        return "single"
+
+
+def load_multichannel_tiff(path: str | Path) -> list[np.ndarray]:
+    """
+    Load a TIFF and return one uint16 ndarray per channel.
+
+    Dispatch is based on detect_tiff_channel_encoding:
+    - "multipage"       — one array per frame
+    - "rgb_interleaved" — R and G bands returned as two arrays (NIR dual-channel)
+    - "single"          — delegates to load_image_uint16; returns a one-element list
+    """
+    encoding = detect_tiff_channel_encoding(path)
+    path_str = str(path)
+
+    if encoding == "multipage":
+        channels: list[np.ndarray] = []
+        with Image.open(path_str) as im:
+            for i in range(im.n_frames):
+                im.seek(i)
+                arr = np.array(im, dtype=np.uint16)
+                channels.append(np.ascontiguousarray(arr))
+        return channels
+
+    if encoding == "rgb_interleaved":
+        with Image.open(path_str) as im:
+            bands = im.split()
+        return [
+            np.ascontiguousarray(np.array(b, dtype=np.uint16))
+            for b in bands[:2]
+        ]
+
+    # "single"
+    return [load_image_uint16(path_str)]
+
+
+def parse_typhoon_channel_id(filename: str) -> str | None:
+    """
+    Extract a channel identifier from a Typhoon / ImageQuant TIFF filename.
+
+    Two conventions are recognised:
+    - Bracket notation: "20260507-142651-[IRlong].tif"  → "IRlong"
+    - Wavelength suffix: "scan_700nm_ch1.tif"           → "700nm"
+
+    Returns None if neither pattern is found.
+    """
+    m = re.search(r'\[([^\]]+)\]', filename)
+    if m:
+        return m.group(1)
+    m = re.search(r'(\d+nm)', filename, re.IGNORECASE)
+    if m:
+        return m.group(1)
+    return None
+
+
+def uint16_to_qpixmap(img: np.ndarray) -> QPixmap:
+    """
+    Convert uint16 grayscale NumPy array to QPixmap through Grayscale16 QImage.
+    """
+    qimg = uint16_to_qimage(img)
+    return QPixmap.fromImage(qimg, Qt.NoFormatConversion)

pysternblot/integrity.py

@@ -0,0 +1,312 @@
+# Pystern Blot
+# SPDX-License-Identifier: GPL-3.0-only
+
+from __future__ import annotations
+
+import json
+import platform
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from PIL import Image
+
+from . import __version__
+from .models import Project
+from .storage import Workspace, sha256_file
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _asset_info(workspace: Workspace, project: Project, sha256: str) -> dict[str, Any]:
+    path = workspace.asset_original_file(sha256)
+    asset = project.assets.get(sha256)
+
+    with Image.open(path) as im:
+        mode = im.mode
+        width, height = im.size
+
+    bit_depth = 16 if mode in ("I;16", "I;16L", "I;16B") else None
+
+    return {
+        "sha256": sha256,
+        "stored_original_path": str(path),
+        "stored_original_sha256_check": sha256_file(str(path)),
+        "original_source_path": getattr(asset, "original_source_path", None) if asset else None,
+        "filename": path.name,
+        "image_mode": mode,
+        "bit_depth": bit_depth,
+        "width_px": width,
+        "height_px": height,
+    }
+
+
+def _marker_set_name(project: Project, marker_set_id: str | None) -> str | None:
+    if not marker_set_id:
+        return None
+    for ms in project.marker_sets:
+        if ms.id == marker_set_id:
+            return ms.name
+    return None
+
+
+def _blot_record(workspace: Workspace, project: Project, blot) -> dict[str, Any]:
+    display = blot.display
+    crop = blot.crop
+
+    record = {
+        "blot_id": blot.id,
+        "protein_label": {
+            "text": blot.protein_label.text,
+            "font_size_pt": blot.protein_label.font_size_pt,
+        },
+        "source_image": _asset_info(workspace, project, blot.asset_sha256),
+        "operations": {
+            "crop": {
+                "x": crop.x,
+                "y": crop.y,
+                "w": crop.w,
+                "h": crop.h,
+                "mode": crop.mode,
+                "ladder_anchor": crop.ladder_anchor,
+            },
+            "rotation_deg": display.rotation_deg,
+            "levels": {
+                "black": display.levels_black,
+                "white": display.levels_white,
+                "gamma": display.levels_gamma,
+            },
+            "invert": display.invert,
+            "auto_contrast": display.auto_contrast,
+        },
+        "overlay": {
+            "present": blot.overlay_asset_sha256 is not None,
+            "asset": (
+                _asset_info(workspace, project, blot.overlay_asset_sha256)
+                if blot.overlay_asset_sha256
+                else None
+            ),
+            "visible": display.overlay_visible,
+            "alpha": display.overlay_alpha,
+        },
+        "ladder": {
+            "lane_index": blot.ladder.lane_index,
+            "marker_set_id": blot.ladder.marker_set_id,
+            "marker_set_name": _marker_set_name(project, blot.ladder.marker_set_id),
+            "show_ticks": blot.ladder.show_ticks,
+            "calibration_points": [
+                {"y_px": p.y_px, "kda": p.kda}
+                for p in blot.ladder.calibration_points
+            ],
+            "fit": blot.ladder.fit.model_dump() if blot.ladder.fit else None,
+        },
+        "overlay_ladder": (
+            blot.overlay_ladder.model_dump()
+            if getattr(blot, "overlay_ladder", None) is not None
+            else None
+        ),
+    }
+
+    return record
+
+
+def build_integrity_report(
+    project: Project,
+    workspace: Workspace,
+    project_json_path: str | Path | None = None,
+    exported_files: list[str | Path] | None = None,
+) -> dict[str, Any]:
+    exported_files = exported_files or []
+
+    report = {
+        "schema": "pysternblot.integrity_report.v1",
+        "created_utc": _utc_now(),
+        "pysternblot_version": __version__,
+        "system": {
+            "python": platform.python_version(),
+            "platform": platform.platform(),
+        },
+        "project": {
+            "id": project.project.id,
+            "name": project.project.name,
+            "created_utc": project.project.created_utc,
+            "modified_utc": project.project.modified_utc,
+            "app_version": project.project.app_version,
+            "license": project.project.license,
+            "project_json_path": str(project_json_path) if project_json_path else None,
+            "project_json_sha256": (
+                sha256_file(str(project_json_path))
+                if project_json_path and Path(project_json_path).exists()
+                else None
+            ),
+        },
+        "panel": {
+            "layout_order": list(project.panel.layout.order),
+            "style": project.panel.style.model_dump(),
+            "lane_layout": project.panel.lane_layout.model_dump(),
+            "legend": project.panel.legend.model_dump(),
+        },
+        "blots": [
+            _blot_record(workspace, project, blot)
+            for blot in project.panel.blots
+        ],
+        "exports": [
+            {
+                "path": str(path),
+                "sha256": sha256_file(str(path)) if Path(path).exists() else None,
+            }
+            for path in exported_files
+        ],
+    }
+
+    return report
+
+
+def write_integrity_json(report: dict[str, Any], path: str | Path) -> Path:
+    path = Path(path)
+    path.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    return path
+
+
+def write_integrity_html(report: dict[str, Any], path: str | Path) -> Path:
+    path = Path(path)
+
+    rows = []
+    for blot in report["blots"]:
+        src = blot["source_image"]
+        ops = blot["operations"]
+        overlay = blot["overlay"]
+
+        rows.append(f"""
+        <tr>
+          <td>{blot["blot_id"]}</td>
+          <td>{blot["protein_label"]["text"]}</td>
+          <td><code>{src["sha256"]}</code></td>
+          <td>{src["bit_depth"]}</td>
+          <td>{src["width_px"]} × {src["height_px"]}</td>
+          <td>x={ops["crop"]["x"]}, y={ops["crop"]["y"]}, w={ops["crop"]["w"]}, h={ops["crop"]["h"]}</td>
+          <td>{ops["rotation_deg"]}</td>
+          <td>{ops["levels"]["black"]}–{ops["levels"]["white"]}, γ={ops["levels"]["gamma"]}</td>
+          <td>{overlay["present"]}</td>
+        </tr>
+        """)
+
+    operation_rows = []
+    for entry in report.get("operation_log", []):
+        operation_rows.append(f"""
+        <tr>
+          <td>{entry.get("timestamp_utc", "")}</td>
+          <td>{entry.get("operation", "")}</td>
+          <td>{entry.get("target_type", "") or ""}</td>
+          <td>{entry.get("target_id", "") or ""}</td>
+          <td>{entry.get("field", "") or ""}</td>
+          <td><code>{json.dumps(entry.get("old_value", None), ensure_ascii=False)}</code></td>
+          <td><code>{json.dumps(entry.get("new_value", None), ensure_ascii=False)}</code></td>
+          <td>{entry.get("note", "") or ""}</td>
+        </tr>
+        """)
+
+    operation_section = ""
+    if operation_rows:
+        operation_section = f"""
+<h2>Chronological operation log</h2>
+<table>
+<thead>
+<tr>
+<th>Time UTC</th>
+<th>Operation</th>
+<th>Target type</th>
+<th>Target ID</th>
+<th>Field</th>
+<th>Old value</th>
+<th>New value</th>
+<th>Note</th>
+</tr>
+</thead>
+<tbody>
+{''.join(operation_rows)}
+</tbody>
+</table>
+"""
+
+    html = f"""<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Pystern Blot integrity report</title>
+<style>
+body {{ font-family: Arial, sans-serif; margin: 32px; color: #222; }}
+h1, h2 {{ margin-bottom: 0.3em; }}
+table {{ border-collapse: collapse; width: 100%; font-size: 13px; }}
+th, td {{ border: 1px solid #ccc; padding: 6px; vertical-align: top; }}
+th {{ background: #eee; }}
+code {{ font-size: 11px; word-break: break-all; }}
+.summary {{ background: #f7f7f7; padding: 12px; border: 1px solid #ddd; }}
+</style>
+</head>
+<body>
+<h1>Pystern Blot integrity report</h1>
+
+<div class="summary">
+<p><strong>Project:</strong> {report["project"]["name"]}</p>
+<p><strong>Project ID:</strong> {report["project"]["id"]}</p>
+<p><strong>Created UTC:</strong> {report["created_utc"]}</p>
+<p><strong>Pystern Blot version:</strong> {report["pysternblot_version"]}</p>
+<p><strong>Schema:</strong> {report["schema"]}</p>
+</div>
+
+<h2>Blot provenance</h2>
+<table>
+<thead>
+<tr>
+<th>Blot</th>
+<th>Protein</th>
+<th>Source SHA256</th>
+<th>Bit depth</th>
+<th>Source size</th>
+<th>Crop</th>
+<th>Rotation</th>
+<th>Levels</th>
+<th>Overlay</th>
+</tr>
+</thead>
+<tbody>
+{''.join(rows)}
+</tbody>
+</table>
+
+{operation_section}
+
+<h2>Machine-readable report</h2>
+<p>The companion JSON file contains the complete project, panel, legend, ladder, crop, overlay and export provenance{" including the chronological operation log" if operation_rows else ""}.</p>
+
+</body>
+</html>
+"""
+
+    path.write_text(html, encoding="utf-8")
+    return path
+
+
+def build_detailed_integrity_report(
+    project: Project,
+    workspace: Workspace,
+    project_json_path: str | Path | None = None,
+    exported_files: list[str | Path] | None = None,
+) -> dict[str, Any]:
+    report = build_integrity_report(
+        project=project,
+        workspace=workspace,
+        project_json_path=project_json_path,
+        exported_files=exported_files,
+    )
+
+    report["schema"] = "pysternblot.detailed_integrity_report.v1"
+    report["operation_log"] = [
+        entry.model_dump()
+        for entry in getattr(project, "operation_log", [])
+    ]
+
+    return report

pysternblot/main.py

@@ -0,0 +1,14 @@
+# Pystern Blot
+# SPDX-License-Identifier: GPL-3.0-only
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+
+from .app import run
+
+def main():
+    run()
+
+if __name__ == "__main__":
+    main()