simple-napari-cci-annotator 0.0.2__py3-none-any.whl

simple_napari_cci_annotator/__init__.py

@@ -0,0 +1,7 @@
+from ._widget import SimpleCciAnnotatorQWidget
+
+__version__ = "0.0.2"
+
+__all__ = [
+    "SimpleCciAnnotatorQWidget",
+]

simple_napari_cci_annotator/_widget.py

@@ -0,0 +1,478 @@
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+from qtpy.QtCore import QThread, QTimer, Signal
+from qtpy.QtWidgets import (
+    QFileDialog,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ._yolo_utils import (
+    CCIYoloWrapper,
+    create_training_set,
+    save_vectors_to_txt,
+)
+
+
+class _RetrainWorker(QThread):
+    """Runs YOLO retraining in a background thread."""
+
+    finished = Signal(str)
+    failed = Signal(str)
+
+    def __init__(self, yolo, model_root, destination_path, parent=None):
+        super().__init__(parent)
+        self._yolo = yolo
+        self._model_root = model_root
+        self._destination_path = destination_path
+
+    def run(self):
+        model_root = self._model_root
+        corrections_root = model_root / "corrections"
+
+        if self._destination_path is not None:
+            retrain_root = self._destination_path
+        else:
+            stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            retrain_root = model_root / f"retrained_{stamp}"
+
+        dataset_dir = retrain_root / "dataset"
+        traces_dir = retrain_root / "training_traces"
+
+        try:
+            retrain_root.mkdir(parents=True, exist_ok=True)
+            create_training_set(
+                path_to_images=corrections_root,
+                path_to_vectors=corrections_root,
+                destination_path=dataset_dir,
+                label_names=[(0, "LABEL")],
+            )
+
+            config = self._load_training_config(corrections_root)
+
+            self._yolo.train(
+                data_set_file=dataset_dir / "dataset.yaml",
+                image_size=config["image_size"],
+                batch=config["batch"],
+                epochs=config["epochs"],
+                patience=config["patience"],
+                project=traces_dir,
+                name="run",
+                exist_ok=True,
+            )
+
+            best_model = traces_dir / "run" / "weights" / "best.pt"
+            if not best_model.exists():
+                raise FileNotFoundError(f"best.pt not found at: {best_model}")
+
+            shutil.copy2(best_model, retrain_root / "best.pt")
+            shutil.rmtree(traces_dir, ignore_errors=True)
+        except Exception as exc:  # pragma: no cover - GUI runtime guard
+            self.failed.emit(f"Retrain failed: {exc}")
+            return
+
+        self.finished.emit(f"Retrain done. New model saved in: {retrain_root}")
+
+    def _load_training_config(self, corrections_root: Path) -> dict:
+        config_file = corrections_root / "training_config.json"
+        if config_file.exists():
+            try:
+                with open(config_file) as f:
+                    return json.load(f)
+            except Exception:
+                pass
+        return {"image_size": 640, "batch": 8, "epochs": 100, "patience": 30}
+
+
+class SimpleCciAnnotatorQWidget(QWidget):
+    """Minimal YOLO bbox annotator flow for napari.
+
+    Workflow:
+    1) Select model path (.pt) and load model
+    2) Predict bboxes on the active image
+    3) User edits shapes
+    4) Add correction (image + edited labels)
+    5) Retrain to produce a new model folder
+    """
+
+    PRED_LAYER_NAME = "yolo_bboxes"
+
+    def __init__(self, napari_viewer):
+        super().__init__()
+        self.napari_viewer = napari_viewer
+        self.setWindowTitle("Simple CCI Annotator")
+
+        self._yolo: CCIYoloWrapper | None = None
+        self._model_path: Path | None = None
+        self._destination_path: Path | None = None
+        self._retrain_worker: _RetrainWorker | None = None
+
+        self._spinner_timer = QTimer(self)
+        self._spinner_timer.setInterval(400)
+        self._spinner_timer.timeout.connect(self._tick_spinner)
+        self._spinner_frames = ["Retraining .", "Retraining ..", "Retraining ...", "Retraining"]
+        self._spinner_index = 0
+
+        self._model_path_input = QLineEdit()
+        self._model_path_input.setPlaceholderText("Path to YOLO model (.pt) or model folder")
+
+        browse_button = QPushButton("Browse")
+        browse_button.clicked.connect(self._on_browse_model)
+
+        load_button = QPushButton("Load model")
+        load_button.clicked.connect(self._on_load_model)
+
+        predict_button = QPushButton("Predict")
+        predict_button.clicked.connect(self._on_predict)
+
+        self.destination_path_input = QLineEdit()
+        self.destination_path_input.setPlaceholderText("Path to save retrained model")
+
+        browse_destination_button = QPushButton("Browse")
+        browse_destination_button.clicked.connect(self._on_browse_destination)
+
+        add_correction_button = QPushButton("Add correction")
+        add_correction_button.clicked.connect(self._on_add_correction)
+
+        self._retrain_button = QPushButton("Retrain")
+        self._retrain_button.clicked.connect(self._on_retrain)
+
+        row_model = QHBoxLayout()
+        row_model.addWidget(QLabel("Model"))
+        row_model.addWidget(self._model_path_input)
+        row_model.addWidget(browse_button)
+
+        row_actions = QHBoxLayout()
+        row_actions.addWidget(load_button)
+        row_actions.addWidget(predict_button)
+
+        row_destination = QHBoxLayout()
+        row_destination.addWidget(QLabel("Destination"))
+        row_destination.addWidget(self.destination_path_input)
+        row_destination.addWidget(browse_destination_button)
+
+        row_train = QHBoxLayout()
+        row_train.addWidget(add_correction_button)
+        row_train.addWidget(self._retrain_button)
+        #row_train.addStretch(1)
+
+        layout = QVBoxLayout()
+        layout.addLayout(row_model)
+        layout.addLayout(row_actions)
+        layout.addLayout(row_destination)
+        layout.addLayout(row_train)
+        layout.addStretch(1)
+        self.setLayout(layout)
+
+    def _show_info(self, text: str) -> None:
+        QMessageBox.information(self, "Simple CCI Annotator", text)
+
+    def _show_error(self, text: str) -> None:
+        QMessageBox.critical(self, "Simple CCI Annotator", text)
+
+    def _on_browse_model(self) -> None:
+        model_dir = QFileDialog.getExistingDirectory(
+            self,
+            "Select model folder (.pt will be loaded or yolov8n.pt will be copied)"
+        )
+        if model_dir:
+            self._model_path_input.setText(model_dir)
+
+    def _on_browse_destination(self) -> None:
+        destination_dir = QFileDialog.getExistingDirectory(self, "Select destination for retrained model")
+        if destination_dir:
+            self.destination_path_input.setText(destination_dir)
+
+    def _on_load_model(self) -> None:
+        model_input = self._model_path_input.text().strip()
+        if not model_input:
+            self._show_error("Model path cannot be empty. Select a .pt file or a folder.")
+            return
+
+        model_path_input = Path(model_input)
+        if not model_path_input.exists():
+            self._show_error("Model path does not exist.")
+            return
+
+        model_path: Path
+        copied_default_model = False
+
+        if model_path_input.is_file():
+            if model_path_input.suffix.lower() != ".pt":
+                self._show_error("Select a valid .pt model file or a folder.")
+                return
+            model_path = model_path_input
+        elif model_path_input.is_dir():
+            pt_files = sorted(model_path_input.glob("*.pt"))
+            if pt_files:
+                model_path = pt_files[0]
+            else:
+                default_model_source = Path(__file__).parent / "models" / "yolov8n.pt"
+                if not default_model_source.exists():
+                    self._show_error("No .pt found in selected folder, and bundled yolov8n.pt is missing.")
+                    return
+
+                model_path = model_path_input / "yolov8n.pt"
+                shutil.copy2(default_model_source, model_path)
+                copied_default_model = True
+        else:
+            self._show_error("Select a valid .pt model file or a folder.")
+            return
+
+        try:
+            self._yolo = CCIYoloWrapper(str(model_path))
+            self._model_path = model_path
+        except Exception as exc:  # pragma: no cover - GUI runtime guard
+            self._show_error(f"Could not load model: {exc}")
+            return
+
+        if copied_default_model:
+            self._show_info(f"No .pt model was found in the folder. Copied bundled model to: {model_path}")
+
+        self._show_info(f"Model loaded: {model_path.name}")
+
+    def _get_active_image_layer(self):
+        layer = self.napari_viewer.layers.selection.active
+        if layer is None:
+            self._show_error("Select an image layer first.")
+            return None
+
+        if getattr(layer, "data", None) is None:
+            self._show_error("Active layer has no image data.")
+            return None
+        return layer
+
+    def _is_image_layer(self, layer) -> bool:
+        return layer is not None and layer.__class__.__name__.lower().endswith("image")
+
+    def _get_single_image_layer(self):
+        image_layers = [layer for layer in self.napari_viewer.layers if self._is_image_layer(layer)]
+        if len(image_layers) == 0:
+            self._show_error("No image layer found.")
+            return None
+        if len(image_layers) > 1:
+            self._show_error("Multiple image layers found. Keep only one image layer before adding a correction.")
+            return None
+        return image_layers[0]
+
+    def _get_layer_by_name(self, name: str):
+        for layer in self.napari_viewer.layers:
+            if getattr(layer, "name", None) == name:
+                return layer
+        return None
+
+    def _is_shapes_layer(self, layer) -> bool:
+        return layer is not None and layer.__class__.__name__.lower().endswith("shapes")
+
+    def _on_predict(self) -> None:
+        if self._yolo is None:
+            self._show_error("Load a model first.")
+            return
+
+        image_layer = self._get_active_image_layer()
+        if image_layer is None:
+            return
+
+        image_data = np.asarray(image_layer.data)
+        if image_data.ndim < 2:
+            self._show_error("Unsupported image shape.")
+            return
+
+        try:
+            prediction = self._yolo.predict(image_data)
+            boxes = prediction[0].boxes.xyxy.cpu().numpy() if len(prediction) else np.empty((0, 4))
+        except Exception as exc:  # pragma: no cover - GUI runtime guard
+            self._show_error(f"Prediction failed: {exc}")
+            return
+
+        rects = []
+        for x1, y1, x2, y2 in boxes:
+            rects.append(np.array([[y1, x1], [y1, x2], [y2, x2], [y2, x1]], dtype=float))
+
+        existing = self._get_layer_by_name(self.PRED_LAYER_NAME)
+        if existing is not None:
+            self.napari_viewer.layers.remove(existing)
+
+        self.napari_viewer.add_shapes(
+            rects,
+            name=self.PRED_LAYER_NAME,
+            shape_type="rectangle",
+            edge_width=2,
+            edge_color="yellow",
+            face_color="transparent",
+        )
+        self._show_info(f"Prediction done: {len(rects)} bbox(es). Edit them, then click Add correction.")
+
+    def _find_shapes_layer(self):
+        layer = self._get_layer_by_name(self.PRED_LAYER_NAME)
+        if self._is_shapes_layer(layer):
+            return layer
+
+        selected = self.napari_viewer.layers.selection.active
+        if self._is_shapes_layer(selected):
+            return selected
+        return None
+
+    def _to_safe_stem(self, name: str) -> str:
+        stem = re.sub(r"[^a-zA-Z0-9._-]+", "_", name.strip())
+        return stem or "image"
+
+    def _get_model_root(self) -> Path | None:
+        if self._model_path is None:
+            return None
+        return self._model_path.parent
+
+    def _as_rgb_uint8(self, image: np.ndarray) -> np.ndarray:
+        if image.ndim == 2:
+            image = np.stack([image] * 3, axis=-1)
+        elif image.ndim == 3 and image.shape[-1] > 3:
+            image = image[..., :3]
+
+        if image.dtype != np.uint8:
+            image = np.clip(image, 0, 255).astype(np.uint8)
+        return image
+
+    def _create_training_config(self, corrections_root: Path, image_size: int | None = None) -> None:
+        """Create a training configuration JSON file in the corrections directory.
+        Args:
+            corrections_root: Path to the corrections directory
+            image_size: Optional image size to use. If not provided, defaults to 640.
+        """
+        if image_size is None:
+            image_size = 640
+
+        config = {
+            "image_size": image_size,
+            "batch": 8,
+            "epochs": 100,
+            "patience": 30,
+        }
+        config_file = corrections_root / "training_config.json"
+        with open(config_file, 'w') as f:
+            json.dump(config, f, indent=2)
+
+    def _load_training_config(self, corrections_root: Path) -> dict:
+        """Load training configuration from JSON file, return defaults if not found."""
+        config_file = corrections_root / "training_config.json"
+        if config_file.exists():
+            try:
+                with open(config_file) as f:
+                    return json.load(f)
+            except Exception:
+                pass
+
+        # Return defaults if file doesn't exist or can't be read
+        return {
+            "image_size": 640,
+            "batch": 8,
+            "epochs": 100,
+            "patience": 30,
+        }
+
+    def _on_add_correction(self) -> None:
+        destination_text = self.destination_path_input.text().strip()
+        self._destination_path = Path(destination_text) if destination_text else None
+        model_root = self._get_model_root()
+        if model_root is None:
+            self._show_error("Load a model first.")
+            return
+
+        image_layer = self._get_single_image_layer()
+        if image_layer is None:
+            return
+
+        shapes_layer = self._find_shapes_layer()
+        if shapes_layer is None:
+            self._show_error(f"No shapes layer found. Use '{self.PRED_LAYER_NAME}' or select a shapes layer.")
+            return
+
+        image_data = self._as_rgb_uint8(np.asarray(image_layer.data))
+        h, w = image_data.shape[:2]
+        if h <= 0 or w <= 0:
+            self._show_error("Image has invalid size.")
+            return
+
+        corrections_root = model_root / "corrections"
+        corrections_root.mkdir(parents=True, exist_ok=True)
+
+        stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        stem = f"{self._to_safe_stem(getattr(image_layer, 'name', 'image'))}_{stamp}"
+        image_out = corrections_root / f"{stem}.png"
+        label_out = corrections_root / f"{stem}.txt"
+
+        vectors: list[tuple[int, list[tuple[float, float]]]] = []
+        for shape in np.asarray(shapes_layer.data, dtype=float):
+            pts: list[tuple[float, float]] = []
+            for y, x in shape:
+                xn = float(np.clip(x / w, 0.0, 1.0))
+                yn = float(np.clip(y / h, 0.0, 1.0))
+                pts.append((xn, yn))
+            if pts:
+                vectors.append((0, pts))
+
+        try:
+            Image.fromarray(image_data).save(image_out)
+            save_vectors_to_txt(vectors, label_out)
+            # Use the larger image dimension as the training image size
+            img_size = max(h, w)
+            self._create_training_config(corrections_root, image_size=img_size)
+        except Exception as exc:  # pragma: no cover - GUI runtime guard
+            self._show_error(f"Could not save correction: {exc}")
+            return
+
+        self._show_info(f"Saved correction to: {corrections_root}")
+
+    def _on_retrain(self) -> None:
+        if self._yolo is None or self._model_path is None:
+            self._show_error("Load a model first.")
+            return
+
+        model_root = self._model_path.parent
+        corrections_root = model_root / "corrections"
+
+        if not corrections_root.exists():
+            self._show_error("No corrections found. Add at least one correction first.")
+            return
+
+        self._retrain_button.setEnabled(False)
+        self._spinner_index = 0
+        self._spinner_timer.start()
+
+        self._retrain_worker = _RetrainWorker(
+            yolo=self._yolo,
+            model_root=model_root,
+            destination_path=self._destination_path,
+            parent=self,
+        )
+        self._retrain_worker.finished.connect(self._on_retrain_done)
+        self._retrain_worker.failed.connect(self._on_retrain_error)
+        self._retrain_worker.start()
+
+    def _tick_spinner(self) -> None:
+        self._retrain_button.setText(self._spinner_frames[self._spinner_index % len(self._spinner_frames)])
+        self._spinner_index += 1
+
+    def _on_retrain_done(self, message: str) -> None:
+        self._spinner_timer.stop()
+        self._retrain_button.setText("Retrain")
+        self._retrain_button.setEnabled(True)
+        self._show_info(message)
+
+    def _on_retrain_error(self, message: str) -> None:
+        self._spinner_timer.stop()
+        self._retrain_button.setText("Retrain")
+        self._retrain_button.setEnabled(True)
+        self._show_error(message)

simple_napari_cci_annotator/_yolo_utils.py

@@ -0,0 +1,207 @@
+import shutil
+from pathlib import Path
+
+
+def _points_to_yolo_xywh(points: list[tuple[float, float]]) -> tuple[float, float, float, float] | None:
+    """Convert normalized polygon points to normalized YOLO xywh box."""
+    if not points:
+        return None
+
+    xs = [x for x, _ in points]
+    ys = [y for _, y in points]
+
+    x_min = min(xs)
+    x_max = max(xs)
+    y_min = min(ys)
+    y_max = max(ys)
+
+    x_center = (x_min + x_max) / 2.0
+    y_center = (y_min + y_max) / 2.0
+    width = x_max - x_min
+    height = y_max - y_min
+
+    if width <= 0 or height <= 0:
+        return None
+
+    x_center = min(max(x_center, 0.0), 1.0)
+    y_center = min(max(y_center, 0.0), 1.0)
+    width = min(max(width, 0.0), 1.0)
+    height = min(max(height, 0.0), 1.0)
+    return x_center, y_center, width, height
+
+
+def save_vectors_to_txt(vectors: list[tuple[int, list[tuple[float, float]]]], file_path: Path) -> None:
+    """Save vectors to a text file in YOLO detection format: class x_center y_center width height."""
+    with open(file_path, 'w') as f:
+        for class_type, points in vectors:
+            bbox = _points_to_yolo_xywh(points)
+            if bbox is None:
+                continue
+            x_center, y_center, width, height = bbox
+            f.write(f"{class_type} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")
+
+
+def convert_txt_labels_to_yolo_xywh(path: Path) -> int:
+    """Convert label txt files from polygon format to YOLO xywh format in-place.
+
+    Returns:
+        int: Number of files rewritten.
+    """
+    path = Path(path)
+    txt_files = [path] if path.is_file() else sorted(path.rglob("*.txt"))
+    converted = 0
+
+    for txt_file in txt_files:
+        if txt_file.name == "dataset.yaml":
+            continue
+
+        new_lines: list[str] = []
+        has_polygon_line = False
+
+        for raw_line in txt_file.read_text(encoding="utf-8").splitlines():
+            line = raw_line.strip()
+            if not line:
+                continue
+
+            parts = line.split()
+            if len(parts) == 5:
+                new_lines.append(line)
+                continue
+
+            if len(parts) < 7 or len(parts[1:]) % 2 != 0:
+                continue
+
+            class_id = parts[0]
+            coords = [float(v) for v in parts[1:]]
+            points = list(zip(coords[0::2], coords[1::2]))
+            bbox = _points_to_yolo_xywh(points)
+            if bbox is None:
+                continue
+
+            has_polygon_line = True
+            x_center, y_center, width, height = bbox
+            new_lines.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
+
+        if has_polygon_line:
+            txt_file.write_text("\n".join(new_lines) + ("\n" if new_lines else ""), encoding="utf-8")
+            converted += 1
+
+    return converted
+
+
+def create_training_set(path_to_images: Path, path_to_vectors: Path, destination_path: Path, label_names: list[tuple[int, str]]) -> None:
+    """Create a YOLO training set by copying images and annotations to the destination path.
+    Args:
+        path_to_images (Path): Path to the directory containing images.
+        path_to_annotations (Path): Path to the directory containing annotation files.
+        destination_path (Path): Path to the destination directory for the training set.
+        label_names (list[tuple[int, str]]): List of tuples defining class indices and their names.
+    """
+    # Create destination directories
+    images_dest_path = destination_path / Path("images")
+    labels_dest_path = destination_path / Path("labels")
+
+    if images_dest_path.exists():
+        shutil.rmtree(images_dest_path)
+    if labels_dest_path.exists():
+        shutil.rmtree(labels_dest_path)
+
+    images_dest_val = images_dest_path / Path("val")
+    images_dest_train = images_dest_path / Path("train")
+
+    labels_dest_val = labels_dest_path / Path("val")
+    labels_dest_train = labels_dest_path / Path("train")
+
+    images_dest_val.mkdir(parents=True, exist_ok=True)
+    images_dest_train.mkdir(parents=True, exist_ok=True)
+    labels_dest_val.mkdir(parents=True, exist_ok=True)
+    labels_dest_train.mkdir(parents=True, exist_ok=True)
+
+    img_exts = {".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff", ".webp"}
+    vec_exts = {".txt"}
+
+    images = sorted([p for p in path_to_images.iterdir() if p.suffix.lower() in img_exts])
+    label_vectors = sorted([p for p in path_to_vectors.iterdir() if p.suffix.lower() in vec_exts])
+
+    labels_by_stem = {}
+    for label_path in label_vectors:
+        label_stem = label_path.stem
+        if label_stem.endswith("training"):
+            label_stem = label_stem[:-len("training")]
+        labels_by_stem[label_stem] = label_path
+
+    for idx, img_path in enumerate(images):
+        if idx % 2 == 0:
+            image_destination = images_dest_train / img_path.name
+            label_destination_dir = labels_dest_train
+        else:
+            image_destination = images_dest_val / img_path.name
+            label_destination_dir = labels_dest_val
+
+        shutil.copy2(img_path, image_destination)
+
+        label_path = labels_by_stem.get(img_path.stem)
+        if label_path is not None:
+            shutil.copy2(label_path, label_destination_dir / f"{img_path.stem}.txt")
+
+    dataset_file = destination_path / Path("dataset.yaml")
+    with open(dataset_file, 'w') as dataset_file:
+        dataset_file.write("train: ./images/train/\n")
+        dataset_file.write("val: ./images/val/\n")
+        dataset_file.write("names:\n")
+        for class_index, class_name in label_names:
+            dataset_file.write(f"  {class_index}: {class_name}\n")
+
+        dataset_file.close()
+
+class CCIYoloWrapper:
+
+    def __init__(self, model_name_or_path: str = "yolov8n.pt"):
+        self.model_name = ""
+        self.res = None
+        self.model = self._create_model(model_name_or_path)
+
+    @staticmethod
+    def _create_model(model_name_or_path):
+        # Defer ultralytics/torch import so package import and pure helper tests
+        # do not fail on systems without a working torch runtime.
+        try:
+            from ultralytics import YOLO
+        except Exception as exc:  # pragma: no cover - runtime environment guard
+            raise RuntimeError(
+                "Failed to import ultralytics/torch. Install a compatible CPU build "
+                "for this platform to run model inference or training."
+            ) from exc
+        return YOLO(model_name_or_path)
+
+    # @classmethod
+    # def load_model_by_name(cls, model_name: str, basedir: str = 'models'):
+    #     return cls(yolomodel(None, name=model_name, basedir=basedir), model_name=model_name, basedir=basedir)
+
+    # @classmethod
+    # def new_model(cls, config=yolo.models.Config2D, model_name: str = "latest", basedir: str = 'models'):
+    #     return cls(yolomodel(config, name=model_name, basedir=basedir), model_name=model_name, basedir=basedir)
+
+    def load_model(self, weights_path: Path):
+        self.model = self._create_model(weights_path)
+
+    def predict(self, img):
+        return self.model(img)
+
+    def train(self, data_set_file: Path, image_size, batch=8, epochs=300, patience=100, ** kwargs):
+        data_set_file = Path(data_set_file)
+        if data_set_file.is_dir():
+            data_set_file = data_set_file / "dataset.yaml"
+
+        if "batch_size" in kwargs:
+            batch_size = kwargs.pop("batch_size")
+            if batch != 8 and batch != batch_size:
+                raise ValueError("Pass either 'batch' or 'batch_size', not both with different values.")
+            batch = batch_size
+
+        self.res = self.model.train(data=data_set_file, batch=batch, imgsz=image_size, epochs=epochs, patience=patience, **kwargs)
+        return self.res
+
+    def get_number_of_run_epochs(self):
+        trainer = getattr(self.model, "trainer", None)
+        return getattr(trainer, "epoch", None)

simple_napari_cci_annotator/napari.yaml

@@ -0,0 +1,14 @@
+name: simple-napari-cci-annotator
+display_name: CCI Annotator
+# use 'hidden' to remove plugin from napari hub search results
+visibility: public
+# see https://napari.org/stable/plugins/technical_references/manifest.html#fields for valid categories
+categories: ["Annotation", "Segmentation"]
+contributions:
+  commands:
+    - id: simple-napari-cci-annotator.open_widget
+      python_name: simple_napari_cci_annotator:SimpleCciAnnotatorQWidget
+      title: Simple CCI annotator plugin
+  widgets:
+    - command: simple-napari-cci-annotator.open_widget
+      display_name: Simple CCI Annotator Plugin

simple_napari_cci_annotator-0.0.2.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: simple-napari-cci-annotator
+Version: 0.0.2
+Summary: Plugin to easly test a yolo model and retrain it
+Author: Simon Leclerc
+Author-email: simon.leclerc@gu.se
+License: MIT License
+        
+        Copyright (c) 2026 LECLERC Simon
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: napari
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: qtpy
+Requires-Dist: ultralytics
+Requires-Dist: pillow
+Provides-Extra: all
+Requires-Dist: napari[all]; extra == "all"
+Provides-Extra: testing
+Requires-Dist: tox; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-qt; extra == "testing"
+Requires-Dist: napari; extra == "testing"
+Requires-Dist: pyqt5; extra == "testing"
+Dynamic: license-file
+
+
+[![License MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/CCI-GU-Sweden/simple-napari-cci-annotator/blob/main/LICENSE)
+[![Python 3.10–3.12](https://img.shields.io/badge/python-3.10%20|%203.11%20|%203.12-blue)](https://python.org)
+[![tests](https://github.com/CCI-GU-Sweden/simple-napari-cci-annotator/workflows/tests/badge.svg)](https://github.com/CCI-GU-Sweden/simple-napari-cci-annotator/actions)
+
+# Simple napari annotator
+
+Minimal napari plugin for YOLO bbox detection + quick correction + retraining.
+
+No dataset browser, no extra workflow logic. User provides the image in napari.
+
+## UI flow
+
+1. Path to model (`.pt`) or model folder
+2. `Load model`
+3. `Predict`
+4. Optional destination folder for retrained model (browse or type)
+5. Edit boxes in napari shapes layer (`yolo_bboxes`)
+6. `Add correction`
+7. `Retrain`
+
+![UI](assets/Plugin_UI.png)
+
+## Starting from scratch
+
+The model input supports either:
+
+- A `.pt` model file, or
+- A folder path.
+
+Folder behavior on `Load model`:
+
+- If the folder already contains one or more `.pt` files, the first one is loaded.
+- If the folder contains no `.pt` file, the plugin copies the bundled `yolov8n.pt` into that folder and loads it.
+- Empty model input is invalid and will show an error.
+
+If you do not have a model yet, start from a pretrained YOLOv8 nano checkpoint and use it as your initial file:
+
+- Direct download: <https://github.com/ultralytics/assets/releases/latest/download/yolov8n.pt>
+- Model overview: <https://docs.ultralytics.com/models/yolov8/>
+
+After downloading, select that `yolov8n.pt` file in the Model field and continue with the correction/retrain loop.
+
+![Loading a model](assets/Loading_model.png)
+
+## Assumptions
+
+- Input image is already RGB 8-bit (or compatible with clipping/conversion).
+- Single class (`0: LABEL`) for now.
+- Exactly one image layer should be present when using `Add correction`.
+
+![Predicting label](assets/Predicting_label.png)
+
+## Folder behavior
+
+Given a model path like:
+
+`.../my_model/best.pt`
+
+The plugin uses `.../my_model` as root.
+
+### Add correction
+
+Each click saves:
+
+- Image to `my_model/corrections/<image_name>_<timestamp>.png`
+- Labels to `my_model/corrections/<image_name>_<timestamp>.txt`
+- Training config to `my_model/corrections/training_config.json` (created/updated)
+
+Image layer behavior:
+
+- If no image layer exists, `Add correction` shows an error.
+- If more than one image layer exists, `Add correction` shows an error.
+- If exactly one image layer exists, that image layer is used for saving correction image data.
+
+`training_config.json` defaults:
+
+- `image_size`: prefilled from the current image size using `max(height, width)`
+- `batch`: `8`
+- `epochs`: `100`
+- `patience`: `30`
+
+You can edit this file before clicking `Retrain`.
+
+Label format is YOLO detection:
+
+`class x_center y_center width height`
+
+normalized to `[0, 1]`.
+
+### Retrain
+
+Each click creates:
+
+- `<retrain_root>/dataset/`
+  - `images/train`, `images/val`
+  - `labels/train`, `labels/val`
+  - `dataset.yaml`
+- Trains YOLO from those corrections
+- Copies best model to:
+  - `<retrain_root>/best.pt`
+- Deletes training traces folder after extracting `best.pt`
+
+`<retrain_root>` resolution:
+
+- If destination field is set, retraining outputs there.
+- Otherwise it defaults to `my_model/retrained_<timestamp>`.
+
+So the retrained folder keeps a clean dataset + final model, without run artifacts.
+
+Warning: Data labeled will be equally divided between traning and validation (50%).

simple_napari_cci_annotator-0.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+simple_napari_cci_annotator/__init__.py,sha256=cu8fkwHo_DMPVZqFYOb-uhVYQduQ5lTnELJg8Q1JNgs,118
+simple_napari_cci_annotator/_widget.py,sha256=dm4pH8Bd5vTOo3Lrp8bvM2tG6I54mgNUiq02l6poNmw,17232
+simple_napari_cci_annotator/_yolo_utils.py,sha256=nBwF7XIc5qRyw2zfBnVPrBdOQHWBBgzVneKL8PNENdk,7861
+simple_napari_cci_annotator/napari.yaml,sha256=RLbL8HjBYwGeXjgGPzIW1G7emMwvEcKtJKjb8HNhLD8,594
+simple_napari_cci_annotator/models/yolov8n.pt,sha256=9Zs9gz4v8y4ZS1u44I0hHcfFvfFEuQ0shBLEfM_IOzY,6549796
+simple_napari_cci_annotator-0.0.2.dist-info/licenses/LICENSE,sha256=ylVLGgTtW9zploUO9-daMtXT3TfO9FQO5AveMUbiNWY,1070
+simple_napari_cci_annotator-0.0.2.dist-info/METADATA,sha256=Y_NxfcFC1-R2cCOEikNpogVaaktKKgk1x2ShasqYr70,6017
+simple_napari_cci_annotator-0.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simple_napari_cci_annotator-0.0.2.dist-info/entry_points.txt,sha256=1dZ2XtQ1WqVc4SUQxPWsrtdmmjNWHFYoUAjXYmzEgyI,88
+simple_napari_cci_annotator-0.0.2.dist-info/top_level.txt,sha256=R7vG9R7q36NzsIlXNIxjnuKpdVurRh6Rfq-CK2Knqog,28
+simple_napari_cci_annotator-0.0.2.dist-info/RECORD,,

simple_napari_cci_annotator-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simple_napari_cci_annotator-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+simple-napari-cci-annotator = simple_napari_cci_annotator:napari.yaml

simple_napari_cci_annotator-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LECLERC Simon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple_napari_cci_annotator-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+simple_napari_cci_annotator