napari-microplate 0.1.0__py3-none-any.whl

napari_microplate/__init__.py

@@ -0,0 +1,3 @@
+"""napari-microplate — plugin chạy full microplate pipeline (align → detect → classify)."""
+
+__version__ = "0.1.0"

napari_microplate/_dock.py

@@ -0,0 +1,113 @@
+"""napari dock widget cho full microplate pipeline.
+
+npe2 manifest trỏ tới `MicroplateWidget` (callable trả widget). Khi click "Run
+Pipeline": lấy ảnh từ layer đang chọn → chạy 3 stage → thêm 2 layer (plate
+aligned image + wells shapes màu theo class) + thông báo counts + tuỳ chọn save PNG.
+"""
+
+from pathlib import Path
+
+import numpy as np
+from magicgui import magic_factory
+
+from ._pipeline import CLASS_COLORS, CLASS_NAMES, get_pipeline
+from ._viz import draw_result, save_png
+
+
+def _to_gray_uint8(data):
+    """Ép dữ liệu layer napari về uint8 grayscale 2D."""
+    arr = np.asarray(data)
+    if arr.ndim == 3:                       # (H,W,3) hoặc (H,W,4)
+        if arr.shape[-1] >= 3:
+            # napari dùng RGB; OpenCV muốn BGR → đảo kênh cho đúng trước gray
+            arr = arr[..., :3][..., ::-1]
+        arr = arr.mean(axis=-1) if arr.ndim == 3 else arr
+    if arr.dtype != np.uint8:
+        arr = arr.astype(np.float32)
+        if arr.max() <= 1.0:
+            arr = arr * 255.0
+        arr = np.clip(arr, 0, 255).astype(np.uint8)
+    return arr
+
+
+def _bgr_to_rgb01(bgr):
+    """BGR uint8 (0..255) → RGB float (0..1) cho face_color của napari Shapes."""
+    r, g, b = int(bgr[2]), int(bgr[1]), int(bgr[0])
+    return (r / 255.0, g / 255.0, b / 255.0, 1.0)
+
+
+@magic_factory(
+    call_button="Run Pipeline",
+    layout="vertical",
+    input_layer={"label": "Image layer"},
+    save_png={"label": "Save PNG"},
+    save_dir={"label": "Save dir", "mode": "d"},
+)
+def _pipeline_widget(
+    viewer: "napari.Viewer",
+    input_layer: "napari.layers.Image",
+    save_png: bool = False,
+    save_dir: Path = Path.home(),
+):
+    if input_layer is None:
+        from napari.utils.notifications import warning
+        warning("Chọn 1 image layer chứa ảnh microplate raw trước.")
+        return
+
+    from napari.utils.notifications import info
+
+    img_gray = _to_gray_uint8(input_layer.data)
+
+    pipe = get_pipeline()
+    out = pipe.run_array(img_gray)
+
+    # ── Layer 1: plate aligned (grayscale image) ──
+    # Gỡ layer cũ cùng tên để chạy lại không chồng
+    for nm in ("aligned_plate", "wells"):
+        if nm in viewer.layers:
+            del viewer.layers[nm]
+    viewer.add_image(out['plate'], name="aligned_plate", colormap="gray")
+
+    # ── Layer 2: well bbox (shapes), màu theo class ──
+    rects = []
+    face_colors = []
+    for (x1, y1, x2, y2, _), cls in zip(out['boxes'], out['classes']):
+        # napari toạ độ theo (row, col) = (y, x)
+        rects.append(np.array([[y1, x1], [y1, x2], [y2, x2], [y2, x1]]))
+        name = CLASS_NAMES.get(int(cls), 'NoGrowth')
+        face_colors.append(_bgr_to_rgb01(CLASS_COLORS[name]))
+
+    counts = {'Growth': 0, 'NoGrowth': 0, 'NoAgar': 0}
+    for cls in out['classes']:
+        counts[CLASS_NAMES.get(int(cls), 'NoGrowth')] += 1
+
+    if rects:
+        viewer.add_shapes(
+            rects,
+            shape_type="rectangle",
+            face_color=face_colors,
+            edge_color="white",
+            edge_width=1,
+            opacity=0.35,
+            name="wells",
+        )
+
+    msg = (f"Total wells: {len(out['boxes'])} — "
+           f"Growth={counts['Growth']} "
+           f"NoGrowth={counts['NoGrowth']} "
+           f"NoAgar={counts['NoAgar']}")
+    info(msg)
+    print(msg)
+
+    if save_png:
+        canvas, _ = draw_result(out, show_labels=True)
+        save_dir = Path(save_dir)
+        save_dir.mkdir(parents=True, exist_ok=True)
+        stem = Path(str(input_layer.name)).stem or "result"
+        out_path = save_dir / f"pipeline_{stem}.png"
+        save_png(canvas, out_path)
+        info(f"Đã lưu: {out_path}")
+
+
+# npe2 trỏ tới callable này — magic_factory trả widget mới mỗi lần gọi.
+MicroplateWidget = _pipeline_widget

napari_microplate/_models.py

@@ -0,0 +1,39 @@
+"""Định nghĩa model Stage 1 (EfficientNet corner regression) — port từ full_pipeline.ipynb."""
+
+import timm
+import torch
+import torch.nn as nn
+
+
+class EfficientNetCorner(nn.Module):
+    """EfficientNet-B3 backbone + regression head xuất 4 corner (8 giá trị, sigmoid).
+
+    Input: ảnh grayscale 1 kênh. gray_to_rgb (conv 1x1) nhân bản thành 3 kênh
+    trước khi đưa vào backbone timm.
+    """
+
+    def __init__(self, variant='b3', dropout=0.0):
+        super().__init__()
+        self.gray_to_rgb = nn.Conv2d(1, 3, kernel_size=1, bias=False)
+        nn.init.constant_(self.gray_to_rgb.weight, 1.0 / 3.0)
+        self.backbone = timm.create_model(
+            f'efficientnet_{variant}', pretrained=False,
+            num_classes=0, global_pool='avg',
+        )
+        feat_dim = self.backbone.num_features
+        self.head = nn.Sequential(
+            nn.Linear(feat_dim, 512), nn.SiLU(inplace=True), nn.Dropout(p=dropout),
+            nn.Linear(512, 256), nn.SiLU(inplace=True), nn.Dropout(p=dropout * 0.5),
+            nn.Linear(256, 8), nn.Sigmoid(),
+        )
+
+    def forward(self, x):
+        return self.head(self.backbone(self.gray_to_rgb(x)))
+
+
+def order_corners_tl_tr_br_bl(pts):
+    """Sort 4 (x,y) points → TL, TR, BR, BL (consistent warp target)."""
+    by_y = sorted(pts, key=lambda p: p[1])
+    top = sorted(by_y[:2], key=lambda p: p[0])
+    bot = sorted(by_y[2:], key=lambda p: p[0])
+    return [top[0], top[1], bot[1], bot[0]]

napari_microplate/_pipeline.py

@@ -0,0 +1,194 @@
+"""Full microplate pipeline: Stage 1 align → Stage 2 detect → Stage 3 classify.
+
+Port từ full_pipeline.ipynb. Đổi: nhận array grayscale trực tiếp (run_array) để
+dùng trong napari widget mà không cần ghi file tạm. Models lazy-load 1 lần.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+import cv2
+import joblib
+import numpy as np
+import torch
+import torch.nn as nn
+
+from ._models import EfficientNetCorner, order_corners_tl_tr_br_bl
+from ._weights import resolve_weight
+
+# ── Fork ultralytics ch=1 được VENDOR trong package (napari_microplate/_vendor).
+# Đưa _vendor lên đầu sys.path để `import ultralytics` (và các absolute import
+# nội bộ của nó) resolve về bản vendor này, không bị nhầm với pip package. ──
+_VENDOR_DIR = Path(__file__).resolve().parent / "_vendor"
+if str(_VENDOR_DIR) not in sys.path:
+    sys.path.insert(0, str(_VENDOR_DIR))
+
+# ─────────────────────────────────────────────
+# CONFIG — khớp 1:1 với notebook (đừng sửa lẻ tẻ)
+# ─────────────────────────────────────────────
+STAGE1_VARIANT  = 'b3'
+STAGE1_IMG_SIZE = 896
+
+STAGE2_CONF = 0.05
+STAGE2_IOU  = 0.15
+STAGE2_MAX  = 384
+
+STAGE3_SIZE = 64
+
+# Phải khớp generate_stage2_data.py (PLATE_MARGIN = 0.08).
+PLATE_MARGIN = 0.08
+
+CLASS_NAMES = {0: 'Growth', 1: 'NoGrowth', 2: 'NoAgar'}
+CLASS_COLORS = {  # BGR
+    'Growth':   (0, 180, 0),
+    'NoGrowth': (0, 0, 220),
+    'NoAgar':   (200, 0, 200),
+}
+
+
+def _get_device():
+    return torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+
+class MicroplatePipeline:
+    """Singleton-ish wrapper load 3 model lần đầu, cache lại cho các lần gọi sau."""
+
+    def __init__(self, device=None):
+        self.device = device or _get_device()
+        self._model1 = None      # EfficientNetCorner
+        self._model2 = None      # YOLO
+        self._rf_model = None    # RandomForest
+        self._w1 = None
+        self._w2 = None
+        self._w3 = None
+
+    def _ensure_loaded(self):
+        if self._model1 is not None:
+            return
+        print('[MicroplatePipeline] loading models (lần đầu)...')
+        self._w1 = resolve_weight('stage1')
+        self._w2 = resolve_weight('stage2')
+        self._w3 = resolve_weight('stage3')
+
+        # Stage 1
+        self._model1 = EfficientNetCorner(variant=STAGE1_VARIANT, dropout=0.0).to(self.device)
+        ckpt = torch.load(str(self._w1), map_location=self.device)
+        state = ckpt['model_state'] if isinstance(ckpt, dict) and 'model_state' in ckpt else ckpt
+        self._model1.load_state_dict(state)
+        self._model1.eval()
+
+        # Stage 2 — import sau khi đã thêm fork lên sys.path
+        from ultralytics import YOLO
+        self._model2 = YOLO(str(self._w2))
+
+        # Stage 3
+        bundle = joblib.load(str(self._w3))
+        self._rf_model = bundle['model'] if isinstance(bundle, dict) and 'model' in bundle else bundle
+
+        dev = 'cuda' if self.device.type == 'cuda' else 'cpu'
+        print(f'[MicroplatePipeline] ready on {dev}')
+
+    # ── Stage 1 ──────────────────────────────
+    @torch.no_grad()
+    def _stage1_align_array(self, img_gray):
+        """img_gray: 2D uint8. Trả (plate_gray, ordered_corners_px)."""
+        h_o, w_o = img_gray.shape[:2]
+        img_r = cv2.resize(img_gray, (STAGE1_IMG_SIZE, STAGE1_IMG_SIZE)).astype(np.float32) / 255.0
+        img_r = (img_r - 0.485) / 0.229
+        t = torch.from_numpy(img_r).unsqueeze(0).unsqueeze(0).to(self.device)
+        pred = self._model1(t).cpu().numpy().reshape(4, 2)
+        corners_px = pred * np.array([w_o, h_o])
+        ordered = np.array(order_corners_tl_tr_br_bl(corners_px.tolist()), dtype=np.float32)
+
+        w_top    = np.linalg.norm(ordered[1] - ordered[0])
+        w_bottom = np.linalg.norm(ordered[2] - ordered[3])
+        h_left   = np.linalg.norm(ordered[3] - ordered[0])
+        h_right  = np.linalg.norm(ordered[2] - ordered[1])
+        plate_w = int(round((w_top + w_bottom) / 2))
+        plate_h = int(round((h_left + h_right) / 2))
+
+        out_w = int(round(plate_w * (1 + 2 * PLATE_MARGIN)))
+        out_h = int(round(plate_h * (1 + 2 * PLATE_MARGIN)))
+        pad_x = int(plate_w * PLATE_MARGIN)
+        pad_y = int(plate_h * PLATE_MARGIN)
+        dst = np.array([
+            [pad_x,               pad_y],
+            [pad_x + plate_w - 1, pad_y],
+            [pad_x + plate_w - 1, pad_y + plate_h - 1],
+            [pad_x,               pad_y + plate_h - 1],
+        ], dtype=np.float32)
+        M = cv2.getPerspectiveTransform(ordered, dst)
+        plate = cv2.warpPerspective(img_gray, M, (out_w, out_h), borderValue=0)
+        return plate, ordered
+
+    # ── Stage 2 ──────────────────────────────
+    def _stage2_detect(self, plate_gray):
+        H, W = plate_gray.shape[:2]
+        res = self._model2(plate_gray, conf=STAGE2_CONF, iou=STAGE2_IOU,
+                           max_det=STAGE2_MAX, verbose=False, ch=1)[0]
+        boxes = []
+        if res.boxes is not None and len(res.boxes):
+            for b in res.boxes:
+                x1, y1, x2, y2 = b.xyxy[0].cpu().numpy().astype(int)
+                conf = float(b.conf[0])
+                boxes.append((int(x1), int(y1), int(x2), int(y2), conf))
+        return boxes
+
+    # ── Stage 3 ──────────────────────────────
+    def _stage3_classify(self, plate_gray, boxes, margin_ratio=0.05):
+        if not boxes:
+            return []
+        H, W = plate_gray.shape[:2]
+        crops = []
+        for (x1, y1, x2, y2, _) in boxes:
+            cx, cy = (x1 + x2) / 2, (y1 + y2) / 2
+            bw, bh = x2 - x1, y2 - y1
+            half_w = bw * (1 + 2 * margin_ratio) / 2
+            half_h = bh * (1 + 2 * margin_ratio) / 2
+            x1c, y1c = int(cx - half_w), int(cy - half_h)
+            x2c, y2c = int(cx + half_w), int(cy + half_h)
+            x1c, y1c = max(0, x1c), max(0, y1c)
+            x2c, y2c = min(W, x2c), min(H, y2c)
+            crop = (plate_gray[y1c:y2c, x1c:x2c]
+                    if x2c > x1c and y2c > y1c
+                    else np.zeros((STAGE3_SIZE, STAGE3_SIZE), dtype=np.uint8))
+            crop = cv2.resize(crop, (STAGE3_SIZE, STAGE3_SIZE), interpolation=cv2.INTER_AREA)
+            crops.append(crop)
+        X = np.stack(crops).reshape(-1, STAGE3_SIZE * STAGE3_SIZE).astype(np.float32) / 255.0
+        return list(self._rf_model.predict(X))
+
+    # ── Public API ───────────────────────────
+    def run_array(self, img_gray):
+        """img_gray: 2D uint8 grayscale. Trả dict {plate, corners, boxes, classes}."""
+        self._ensure_loaded()
+        if img_gray.ndim == 3:
+            img_gray = cv2.cvtColor(img_gray, cv2.COLOR_BGR2GRAY)
+        plate, corners = self._stage1_align_array(img_gray)
+        boxes = self._stage2_detect(plate)
+        classes = self._stage3_classify(plate, boxes)
+        return {
+            'orig': img_gray,
+            'corners': corners,
+            'plate': plate,
+            'boxes': boxes,
+            'classes': classes,
+        }
+
+    def run(self, img_path):
+        """Tiện ích cho CLI/script: đọc file ảnh → run_array."""
+        img = cv2.imread(str(img_path), cv2.IMREAD_GRAYSCALE)
+        if img is None:
+            raise FileNotFoundError(img_path)
+        return self.run_array(img)
+
+
+# Singleton module-level cho widget dùng chung
+_DEFAULT = None
+
+
+def get_pipeline():
+    global _DEFAULT
+    if _DEFAULT is None:
+        _DEFAULT = MicroplatePipeline()
+    return _DEFAULT

napari_microplate/_vendor/ultralytics/__init__.py

@@ -0,0 +1,30 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+__version__ = "8.3.2"
+
+import os
+
+# Set ENV Variables (place before imports)
+os.environ["OMP_NUM_THREADS"] = "1"  # reduce CPU utilization during training
+
+from ultralytics.data.explorer.explorer import Explorer
+from ultralytics.models import NAS, RTDETR, SAM, YOLO, FastSAM, YOLOWorld
+from ultralytics.utils import ASSETS, SETTINGS
+from ultralytics.utils.checks import check_yolo as checks
+from ultralytics.utils.downloads import download
+
+settings = SETTINGS
+__all__ = (
+    "__version__",
+    "ASSETS",
+    "YOLO",
+    "YOLOWorld",
+    "NAS",
+    "SAM",
+    "FastSAM",
+    "RTDETR",
+    "checks",
+    "download",
+    "settings",
+    "Explorer",
+)