tau-fibrils-yolo 0.0.1__py3-none-any.whl

tau_fibrils_yolo/__init__.py

@@ -0,0 +1,2 @@
+from tau_fibrils_yolo._widget import YoloDetectorWidget
+from tau_fibrils_yolo.predict import FibrilsDetector

tau_fibrils_yolo/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)

tau_fibrils_yolo/_widget.py

@@ -0,0 +1,262 @@
+import numpy as np
+import pandas as pd
+import napari
+import napari.layers
+from napari.utils.notifications import show_info
+from napari.qt.threading import thread_worker
+from PyQt5.QtCore import Qt
+from qtpy.QtWidgets import (
+    QComboBox,
+    QGridLayout,
+    QLabel,
+    QProgressBar,
+    QPushButton,
+    QWidget,
+    QSizePolicy,
+    QDoubleSpinBox,
+    QFileDialog,
+)
+from tau_fibrils_yolo.predict import FibrilsDetector
+from tau_fibrils_yolo.postprocess import (
+    boxes_kernel_density_map,
+    minimum_neighbor_distance_filter,
+    outside_image_border_filter,
+    overlapping_obb_filter,
+)
+from tau_fibrils_yolo.crossover_distance import crossover_distance_measurement
+
+
+class YoloDetectorWidget(QWidget):
+    def __init__(self, napari_viewer):
+        super().__init__()
+
+        self.viewer = napari_viewer
+        self.predictor = FibrilsDetector()
+
+        self.shapes_layer = None
+        self.crossover_shapes_layer = None
+        self.df = None
+
+        # Layout
+        grid_layout = QGridLayout()
+        grid_layout.setAlignment(Qt.AlignTop)
+        self.setLayout(grid_layout)
+
+        # Image
+        self.cb_image = QComboBox()
+        self.cb_image.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        grid_layout.addWidget(QLabel("Image", self), 0, 0)
+        grid_layout.addWidget(self.cb_image, 0, 1)
+
+        # Rescale factor
+        self.bx_rescale = QDoubleSpinBox()
+        self.bx_rescale.setMinimum(0.01)
+        self.bx_rescale.setMaximum(100.0)
+        self.bx_rescale.setSingleStep(0.05)
+        self.bx_rescale.setValue(1.0)
+        grid_layout.addWidget(QLabel("Rescale factor", self), 2, 0)
+        grid_layout.addWidget(self.bx_rescale, 2, 1)
+
+        # Compute button
+        self.btn = QPushButton("Detect fibrils", self)
+        self.btn.clicked.connect(self._start_detection)
+        grid_layout.addWidget(self.btn, 3, 0, 1, 2)
+
+        # Progress bar
+        self.pbar = QProgressBar(self, minimum=0, maximum=1)
+        self.pbar.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        grid_layout.addWidget(self.pbar, 4, 0, 1, 2)
+
+        self.cd_label = QLabel("Crossover distance: -", self)
+        grid_layout.addWidget(self.cd_label, 5, 0, 1, 2)
+
+        export_btn = QPushButton("Export results (.csv)", self)
+        export_btn.clicked.connect(self._save_csv)
+        grid_layout.addWidget(export_btn, 6, 0, 1, 2)
+
+        # Setup layer callbacks
+        self.viewer.layers.events.inserted.connect(
+            lambda e: e.value.events.name.connect(self._on_layer_change)
+        )
+        self.viewer.layers.events.inserted.connect(self._on_layer_change)
+        self.viewer.layers.events.removed.connect(self._on_layer_change)
+        self.viewer.layers.events.removed.connect(self._reset_shapes_layer)
+        self._on_layer_change(None)
+
+    def _on_layer_change(self, e):
+        self.cb_image.clear()
+        for x in self.viewer.layers:
+            if isinstance(x, napari.layers.Image):
+                if x.data.ndim in [2, 3]:
+                    self.cb_image.addItem(x.name, x.data)
+
+    def _reset_shapes_layer(self, e):
+        if (self.shapes_layer is not None) and not (self.shapes_layer in e.sources[0]):
+            self.shapes_layer = None
+
+    @thread_worker
+    def _prediction_thread(self, rescale_factor):
+        all_boxes = []
+        all_probas = []
+        for k, boxes, probas in self.predictor.yield_predictions(self.selected_image, rescale_factor):
+            all_boxes.extend(boxes)
+            all_probas.extend(probas)
+            yield k, boxes, probas
+
+        all_boxes = np.array(all_boxes)
+        all_probas = np.array(all_probas)
+
+        return all_boxes, all_probas, rescale_factor
+
+    def _start_detection(self):
+        self.selected_image = self.cb_image.currentData()
+        if self.selected_image is None:
+            return
+
+        if self.shapes_layer is not None:  # Note: How to properly delete a layer?
+            self.shapes_layer.data = []
+            self.shapes_layer = None
+
+        if self.crossover_shapes_layer is not None:
+            self.crossover_shapes_layer.data = []
+            self.crossover_shapes_layer = None
+
+        rescale_factor = self.bx_rescale.value()
+
+        worker = self._prediction_thread(rescale_factor)
+
+        worker.yielded.connect(self._update_viewer)
+        worker.yielded.connect(lambda payload: self.pbar.setValue(payload[0]))
+        worker.returned.connect(lambda _: self.pbar.setMaximum(1))
+        worker.returned.connect(self._load_in_viewer)
+        n_crops = self.predictor.n_crops(self.selected_image, rescale_factor)
+        self.pbar.setMaximum(n_crops)
+        self.pbar.setValue(0)
+        worker.start()
+
+    def _update_viewer(self, payload):
+        _, boxes, probas = payload
+
+        if len(boxes) == 0:
+            return
+
+        if self.shapes_layer is None:
+            shape_kwargs = {
+                "shape_type": "rectangle",
+                "name": "Tau fibrils (Yolo)",
+                "face_color": "transparent",
+                "opacity": 1.0,
+                "edge_width": 1,
+                "edge_color": "#ff0000",
+                "properties": {
+                    "probability": probas,
+                },
+            }
+
+            self.shapes_layer = self.viewer.add_shapes(boxes, **shape_kwargs)
+        else:
+            # Update the layer data
+            current_data = self.shapes_layer.data
+            current_data.extend(boxes)
+            current_probas = self.shapes_layer.properties.get("probability")
+            current_probas = list(current_probas)
+            current_probas.extend(probas)
+            self.shapes_layer.data = current_data
+            self.shapes_layer.properties = ({"probability": current_probas},)
+            self.shapes_layer.refresh()
+
+    def _load_in_viewer(self, payload):
+        """Callback from thread returning."""
+        boxes, probas, rescale_factor = payload
+
+        filt = outside_image_border_filter(boxes)
+        boxes = boxes[filt]
+        probas = probas[filt]
+
+        filt = overlapping_obb_filter(boxes)
+        boxes = boxes[filt]
+        probas = probas[filt]
+
+        filt = minimum_neighbor_distance_filter(boxes, rescale_factor)
+        boxes = boxes[filt]
+        probas = probas[filt]
+
+        if len(boxes) == 0:
+            show_info("No fibrils were detected.")
+            return
+
+        density_map = boxes_kernel_density_map(boxes, self.selected_image)
+
+        density_layer = self.viewer.add_image(
+            density_map, colormap="inferno", opacity=0.5, blending="additive"
+        )
+        density_layer.visible = False
+
+        probas = list(probas)
+
+        # Get the lines and crossover distances
+        image = self.cb_image.currentData()
+        distances = []
+        line_data = []
+        centers_x = []
+        centers_y = []
+        lengths = []
+        widths = []
+        for box in boxes:
+            distance, line_points, center, length, width = (
+                crossover_distance_measurement(box, image)
+            )
+            distances.append(distance)
+            line_data.append(line_points)
+            centers_x.append(center[0])
+            centers_y.append(center[1])
+            lengths.append(length)
+            widths.append(width)
+
+        self.df = pd.DataFrame(
+            {
+                "detection_probability": probas,
+                "crossover_distance": distances,
+                "length": lengths,
+                "width": widths,
+                "center_x": centers_x,
+                "center_y": centers_y,
+            }
+        )
+
+        lines_props = {
+            "shape_type": "line",
+            "name": "Crossover distance",
+            "opacity": 1.0,
+            "edge_width": 1,
+            "edge_color": "probability",
+            "properties": {"probability": probas, "distance": distances},
+        }
+        self.crossover_shapes_layer = self.viewer.add_shapes(line_data, **lines_props)
+
+        self.shapes_layer.data = boxes
+        self.shapes_layer.properties = (
+            {
+                "probability": probas,
+                "distance": distances,
+                "length": lengths,
+                "width": widths,
+                "center_x": centers_x,
+                "center_y": centers_y,
+            },
+        )
+        self.shapes_layer.edge_color = "#00ff00"
+        self.shapes_layer.refresh()
+
+    def _save_csv(self):
+        if self.df is None:
+            print("No detection data found.")
+            return
+
+        print("Saving CSV.")
+        filename, _ = QFileDialog.getSaveFileName(self, "Save as CSV", ".", "*.csv")
+        if not filename.endswith(".csv"):
+            filename += ".csv"
+
+        self.df.to_csv(filename)
+        print(f"Saved {filename}!")

tau_fibrils_yolo/cli.py

@@ -0,0 +1,102 @@
+from tau_fibrils_yolo.predict import FibrilsDetector
+from tau_fibrils_yolo.crossover_distance import crossover_distance_measurement
+import tifffile
+from pathlib import Path
+import argparse
+import glob
+import pandas as pd
+
+
+def process_input_file_predict(input_image_file, predictor, rescale_factor):
+    image = tifffile.imread(input_image_file)
+
+    boxes, probas = predictor.predict(image, rescale_factor)
+
+    distances = []
+    line_data = []
+    centers_x = []
+    centers_y = []
+    lengths = []
+    widths = []
+    for box in boxes:
+        distance, line_points, center, length, width = (
+            crossover_distance_measurement(box, image)
+        )
+        distances.append(distance)
+        line_data.append(line_points)
+        centers_x.append(center[0])
+        centers_y.append(center[1])
+        lengths.append(length)
+        widths.append(width)
+
+    df = pd.DataFrame(
+            {
+                "detection_probability": probas,
+                "crossover_distance": distances,
+                "length": lengths,
+                "width": widths,
+                "center_x": centers_x,
+                "center_y": centers_y,
+            }
+        )
+
+    pt = Path(input_image_file)
+    out_file_name = pt.parent / f"{pt.stem}_results.csv"
+
+    df.to_csv(out_file_name)
+
+    print("Saved results to ", out_file_name)
+
+
+def cli_predict_image():
+    """Command-line entry point for model inference."""
+    parser = argparse.ArgumentParser(description="Use this command to run inference.")
+    parser.add_argument(
+        "-i",
+        type=str,
+        required=True,
+        help="Input image. Must be a TIF image file.",
+    )
+    parser.add_argument(
+        "-r",
+        type=float,
+        required=False,
+        default=1.0,
+        help="Rescale factor.",
+    )
+    args = parser.parse_args()
+
+    input_image_file = args.i
+    rescale_factor = args.r
+
+    predictor = FibrilsDetector()
+
+    process_input_file_predict(input_image_file, predictor, rescale_factor)
+
+
+def cli_predict_folder():
+    parser = argparse.ArgumentParser(
+        description="Use this command to run inference in batch on a given folder."
+    )
+    parser.add_argument(
+        "-i",
+        type=str,
+        required=True,
+        help="Input folder. Must contain suitable TIF image files.",
+    )
+    parser.add_argument(
+        "-r",
+        type=float,
+        required=False,
+        default=1.0,
+        help="Rescale factor.",
+    )
+    args = parser.parse_args()
+
+    input_folder = args.i
+    rescale_factor = args.r
+
+    predictor = FibrilsDetector()
+
+    for input_image_file in glob.glob(str(Path(input_folder) / "*.tif")):
+        process_input_file_predict(input_image_file, predictor, rescale_factor)

tau_fibrils_yolo/crossover_distance.py

@@ -0,0 +1,49 @@
+import numpy as np
+from numpy.linalg import norm
+from scipy.fft import fft
+from scipy.fft import fftfreq
+from skimage.measure import profile_line
+from skimage.exposure import rescale_intensity
+
+
+def crossover_distance_measurement(box, image):
+    p0, p1, p2, p3 = box
+
+    if norm(p2 - p0) < norm(p1 - p0):
+        p0, p3, p2, p1 = box
+
+    p5 = p0 + (p1 - p0) / 2
+    p6 = p3 + (p2 - p3) / 2
+
+    line_width = norm(p1 - p0)
+    line_length = norm(p2 - p0)
+
+    # Compute the intensity profile along the line, averaged over the width
+    pixel_values = profile_line(
+        image, src=p5, dst=p6, linewidth=int(line_width), order=1
+    )
+
+    # Normalize the pixel values
+    pixel_values = rescale_intensity(pixel_values, out_range=(-1, 1))
+
+    # Perform the Fourier transform
+    fft_values = fft(pixel_values)
+
+    # Calculate the frequencies
+    freqs = fftfreq(len(pixel_values))[1:]  # Remove frequency = zero (?)
+
+    # Identify the main frequency
+    main_freq = freqs[np.argmax(np.abs(fft_values))]
+
+    # Calculate the distance
+    distance = (1 / main_freq) * (line_length / len(pixel_values))
+
+    # Line for visualization
+    diagonal = p6 - p5
+    center = p5 + diagonal / 2
+    diagonal_norm = diagonal / norm(diagonal)
+    line_points = np.array(
+        [center - distance / 2 * diagonal_norm, center + distance / 2 * diagonal_norm]
+    )
+
+    return distance, line_points, center, line_length, line_width

tau_fibrils_yolo/napari.yaml

@@ -0,0 +1,10 @@
+name: tau-fibrils-yolo
+display_name: Tau Fibrils Yolo Detector
+contributions:
+  commands:
+    - id: tau-fibrils-yolo.start
+      title: Tau fibrils detection
+      python_name: tau_fibrils_yolo:YoloDetectorWidget
+  widgets:
+    - command: tau-fibrils-yolo.start
+      display_name: Tau fibrils detection

tau_fibrils_yolo/postprocess.py

@@ -0,0 +1,77 @@
+import numpy as np
+from skimage.exposure import rescale_intensity
+import cv2
+from scipy.ndimage import zoom
+from scipy.spatial import distance_matrix
+from sklearn.neighbors import KernelDensity
+
+
+def minimum_neighbor_distance_filter(boxes, rescale_factor, min_dist_px=150):
+    """Returns a filter matching objects isolated by less than min_dist_px pixels."""
+    min_dist_px = min_dist_px / rescale_factor
+    box_centers = boxes_center_coordinates(boxes)
+    dist_matrix = distance_matrix(box_centers, box_centers)
+    np.fill_diagonal(dist_matrix, np.inf)
+    min_distances = np.min(dist_matrix, axis=1)
+    filt = min_distances <= min_dist_px
+    return filt
+
+
+def overlapping_obb_filter(bounding_boxes):
+    """Returns the indeces of bounding boxes to keep after IOU filtering."""
+    keep = []
+    for i in range(len(bounding_boxes)):
+        should_keep_i = True
+        box_i = bounding_boxes[i]
+        for j in keep:
+            box_j = bounding_boxes[j]
+            intersection_area, _ = cv2.intersectConvexConvex(box_i, box_j)
+            if intersection_area > 0:
+                should_keep_i = False
+                break
+        if should_keep_i:
+            keep.append(i)
+    return keep
+
+
+def outside_image_border_filter(boxes):
+    """Returns a filter matching boxes falling outside the image border."""
+    return ~(boxes < 0).any(axis=2).any(axis=1)
+
+
+def boxes_center_coordinates(boxes):
+    """Returns the center coordinates of the boxes."""
+    x_coords = boxes[..., 0]
+    y_coords = boxes[..., 1]
+    box_cy = (np.max(y_coords, axis=1) + np.min(y_coords, axis=1)) / 2
+    box_cx = (np.max(x_coords, axis=1) + np.min(x_coords, axis=1)) / 2
+    box_centers = np.vstack((box_cx, box_cy)).T
+
+    return box_centers
+
+
+def boxes_kernel_density_map(boxes, image, gaussian_sigma_px=50, downscale_factor=8):
+    """Kernel density estimate from bounding box coordinates"""
+
+    image_shape = np.array(image.shape) // downscale_factor
+
+    x_grid, y_grid = np.meshgrid(
+        np.linspace(0, image_shape[1] - 1, image_shape[1]),
+        np.linspace(0, image_shape[0] - 1, image_shape[0]),
+    )
+
+    grid_points = np.vstack([y_grid.ravel(), x_grid.ravel()]).T
+
+    kde = KernelDensity(
+        bandwidth=gaussian_sigma_px, 
+        kernel="gaussian", 
+        algorithm="ball_tree"
+    )
+
+    kde.fit(boxes_center_coordinates(boxes) / downscale_factor)
+
+    density_map = np.exp(kde.score_samples(grid_points)).reshape(image_shape)
+    density_map = zoom(density_map, zoom=downscale_factor, order=1)
+    density_map = rescale_intensity(density_map, out_range=(0, 1))
+
+    return density_map

tau_fibrils_yolo/predict.py

@@ -0,0 +1,168 @@
+import os
+import numpy as np
+from skimage.exposure import rescale_intensity
+from skimage.transform import rescale
+from ultralytics import YOLO
+import pooch
+
+from tau_fibrils_yolo.postprocess import (
+    outside_image_border_filter,
+    minimum_neighbor_distance_filter,
+    overlapping_obb_filter,
+)
+
+
+MODEL_PATH = os.path.expanduser(os.path.join(os.getenv("XDG_DATA_HOME", "~"), ".yolo"))
+
+
+def retreive_model():
+    """Downloads the model weights from Zenodo."""
+    print(
+        " /!\ This model is on the Zenodo Sandbox (use it only for testing purposes) /!\ "
+    )
+    pooch.retrieve(
+        url="https://sandbox.zenodo.org/records/99113/files/100ep.pt",
+        known_hash="md5:2fc4be1e4feae93f75e335856be3083d",
+        path=MODEL_PATH,
+        progressbar=True,
+        fname="yolo_fibrils_100ep.pt",
+    )
+
+
+def pad_image(image, tile_size_px, overlap_px):
+    """Pads the image so that its length and width are divisible by the model's image size (which is assumed to be square)."""
+    rx, ry = image.shape
+
+    pad_x = rx % (tile_size_px - overlap_px) + overlap_px
+    half_pad_x = pad_x // 2
+    nx_ceil = np.ceil((rx + pad_x - overlap_px) / (tile_size_px - overlap_px)).astype(
+        int
+    )
+    padded_image_size_x = nx_ceil * (tile_size_px - overlap_px) + overlap_px
+
+    pad_y = ry % (tile_size_px - overlap_px) + overlap_px
+    half_pad_y = pad_y // 2
+    ny_ceil = np.ceil((ry + pad_y - overlap_px) / (tile_size_px - overlap_px)).astype(
+        int
+    )
+    padded_image_size_y = ny_ceil * (tile_size_px - overlap_px) + overlap_px
+
+    image_padded = np.zeros((padded_image_size_x, padded_image_size_y))
+
+    image_padded[half_pad_x : (half_pad_x + rx), half_pad_y : (half_pad_y + ry)] = image
+
+    return image_padded, (half_pad_x, half_pad_y), (nx_ceil, ny_ceil)
+
+
+def image_tile_generator(image, imgsz, overlap_px):
+    """Generates image tiles and their coordinates in the image domain."""
+    image_p, (pad_x, pad_y), (nx, ny) = pad_image(image, imgsz, overlap_px)
+    shift_x = imgsz - overlap_px
+    shift_y = imgsz - overlap_px
+    for ix in range(nx):
+        for iy in range(ny):
+            image_tile = image_p[
+                (ix * shift_x) : (ix * shift_x + imgsz),
+                (iy * shift_y) : (iy * shift_y + imgsz),
+            ]
+            coord_x = ix * shift_x - pad_x
+            coord_y = iy * shift_y - pad_y
+
+            yield image_tile, (coord_x, coord_y)
+
+
+def to_rgb(arr):
+    return np.repeat(arr[..., None], repeats=3, axis=-1)
+
+
+def preprocess_image(image, rescale_factor):
+    # Make sure the image is single-channel
+    if len(image.shape) == 2:
+        image = rescale_intensity(image, out_range=(0, 255)).astype(np.uint8)
+    elif len(image.shape) == 3:
+        image = image[..., 0]
+
+    # Rescale the image to make it match the target resolution.
+    image = rescale(image, rescale_factor, order=3, preserve_range=True)
+
+    return image
+
+
+def predict_generator(image, model, imgsz, rescale_factor=1.0, overlap_px=None):
+    if overlap_px is None:
+        # 10% overlap by default
+        overlap_px = imgsz // 10
+
+    image = preprocess_image(image, rescale_factor)
+
+    for k, (image_tile, (coord_x, coord_y)) in enumerate(
+        image_tile_generator(image, imgsz, overlap_px)
+    ):
+        image_input = to_rgb(image_tile)
+
+        result = model.predict(
+            source=image_input,
+            conf=0.05,  # Confidence threshold for detections.
+            iou=0.1,  # Intersection over union threshold.
+            max_det=500,  # Max detections per 640 x 640 crop
+            augment=False,
+            imgsz=imgsz,  # Square resizing
+        )[0]
+
+        probabilities = result.obb.conf.cpu().numpy()
+        boxes_coordinates = result.obb.xyxyxyxy.cpu().numpy()
+        boxes_coordinates[..., 1] = (
+            boxes_coordinates[..., 1] + coord_x
+        ) / rescale_factor
+        boxes_coordinates[..., 0] = (
+            boxes_coordinates[..., 0] + coord_y
+        ) / rescale_factor
+
+        # Invert X-Y
+        boxes_coordinates = boxes_coordinates[..., ::-1]
+
+        yield k, boxes_coordinates, probabilities
+
+
+class FibrilsDetector:
+    def __init__(self):
+        retreive_model()
+        self.model = YOLO(os.path.join(MODEL_PATH, "yolo_fibrils_100ep.pt"))
+        self.imgsz = 640
+        self.overlap_px = self.imgsz // 10
+
+    def n_crops(self, image: np.ndarray, rescale_factor: float):
+        return np.prod(
+            pad_image(
+                preprocess_image(image, rescale_factor), self.imgsz, self.overlap_px
+            )[-1]
+        )
+
+    def predict(self, image: np.ndarray, rescale_factor: float):
+        boxes = []
+        probas = []
+        for _, b, p in predict_generator(image, self.model, self.imgsz, rescale_factor):
+            boxes.extend(b)
+            probas.extend(p)
+        boxes = np.array(boxes)
+        probas = np.array(probas)
+
+        filt = outside_image_border_filter(boxes)
+        boxes = boxes[filt]
+        probas = probas[filt]
+
+        filt = overlapping_obb_filter(boxes)
+        boxes = boxes[filt]
+        probas = probas[filt]
+
+        filt = minimum_neighbor_distance_filter(boxes, rescale_factor)
+        boxes = boxes[filt]
+        probas = probas[filt]
+
+        return boxes, probas
+
+    def yield_predictions(self, image: np.ndarray, rescale_factor: float):
+        for k, boxes, probas in predict_generator(
+            image, self.model, self.imgsz, rescale_factor
+        ):
+            yield k, boxes, probas

tau_fibrils_yolo-0.0.1.dist-info/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, EPFL.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tau_fibrils_yolo-0.0.1.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.1
+Name: tau-fibrils-yolo
+Version: 0.0.1
+Summary: YoloV8 model for the detection of Tau fibrils in Cryo-EM images.
+Author-email: Mallory Wittwer <mallory.wittwer@epfl.ch>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2024, EPFL.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of the copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Project-URL: homepage, https://github.com/EPFL-Center-for-Imaging/tau_fibrils_yolo
+Project-URL: repository, https://github.com/EPFL-Center-for-Imaging/tau_fibrils_yolo
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: napari[all]>=0.4.16
+Requires-Dist: qtpy
+Requires-Dist: magicgui
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: tifffile
+Requires-Dist: pooch==1.8.0
+Requires-Dist: scikit-image
+Requires-Dist: scikit-learn
+Requires-Dist: ultralytics
+Requires-Dist: opencv-contrib-python-headless
+
+![EPFL Center for Imaging logo](https://imaging.epfl.ch/resources/logo-for-gitlab.svg)
+# 🧬 Tau Fibrils Yolo - Object detection in Cryo-EM images
+
+![screenshot](assets/screenshot.png)
+
+We provide a [YoloV8](https://docs.ultralytics.com/) model for the detection of oriented bounding boxes (OBBs) of Tau fibrils in Cryo-EM images.
+
+[[`Installation`](#installation)] [[`Model`](#model)] [[`Usage`](#usage)]
+
+This project is part of a collaboration between the [EPFL Center for Imaging](https://imaging.epfl.ch/) and the [Laboratory of Biological Electron Microscopy](https://www.lbem.ch/).
+
+## Installation
+
+### As a standalone app
+
+Soon.
+
+### As a Python package
+
+We recommend performing the installation in a clean Python environment. Install our package from PyPi:
+
+```sh
+pip install tau-fibrils-yolo
+```
+
+or from the repository:
+
+```sh
+pip install git+https://gitlab.com/center-for-imaging/tau-fibrils-object-detection.git
+```
+
+or clone the repository and install with:
+
+```sh
+git clone git+https://gitlab.com/center-for-imaging/tau-fibrils-object-detection.git
+cd tau-fibrils-yolo
+pip install -e .
+```
+
+## Model
+
+The model weights (6.5 Mb) are automatically downloaded from [this repository on Zenodo](https://sandbox.zenodo.org/records/99113) the first time you run inference. The model files are saved in the user home folder in the `.yolo` directory.
+
+## Usage
+
+**In Napari**
+
+To use our model in Napari, start the viewer with
+
+```sh
+napari -w tau-fibrils-yolo
+```
+
+or open the Napari menu bar and select `Plugins > Tau fibrils detection`.
+
+Open an image using `File > Open files` or drag-and-drop an image into the viewer window.
+
+**Sample data**: To test the model, you can run it on our provided sample image. In Napari, open the image from `File > Open Sample > [TODO - add a sample image]`.
+
+
+**As a library**
+
+You can run the model to detect fibrils in an image (represented as a numpy array).
+
+```py
+from tau_fibrils_yolo import FibrilsDetector
+
+detector = FibrilsDetector()
+
+boxes, probabilities = detector.predict(your_image)
+```
+
+**As a CLI**
+
+Run inference on an image from the command-line. For example:
+
+```sh
+tau_fibrils_predict_image -i /path/to/folder/image_001.tif
+```
+
+The command will save the segmentation next to the image:
+
+```
+folder/
+    ├── image_001.tif
+    ├── image_001_results.csv
+```
+
+Optionally, you can use the `-r` flag to also rescale the image by a given factor.
+
+To run inference in batch on all images in a folder, use:
+
+```sh
+tau_fibrils_predict_folder -i /path/to/folder/
+```
+
+This will produce:
+
+```
+folder/
+    ├── image_001.tif
+    ├── image_001_results.csv
+    ├── image_002.tif
+    ├── image_002_results.csv
+```
+
+## Issues
+
+If you encounter any problems, please file an issue along with a detailed description.
+
+## License
+
+This model is licensed under the [BSD-3](LICENSE) license.
+
+## Acknowledgements
+
+We would particularly like to thank **Valentin Vuillon** for annotating the images on which this model was trained, and for developing the preliminary code that laid the foundation for this image analysis project. The repository containing his original version of the project can be found [here](https://gitlab.com/epfl-center-for-imaging/automated-analysis-tau-fibrils-project).

tau_fibrils_yolo-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+tau_fibrils_yolo/__init__.py,sha256=IKx6Hj3WAfsNmxnW5nJS7ibx59PyLKBsAzvvWqXQyeA,108
+tau_fibrils_yolo/_version.py,sha256=pMnmqZnpVmaqR5nqHztNWzbbtb1oy5bPN_v7uhOH8K8,411
+tau_fibrils_yolo/_widget.py,sha256=Eqwm0_A86OX0sJ4TZ_mtXcHfdvxIuOYfFu32y-GKVgM,8746
+tau_fibrils_yolo/cli.py,sha256=DtrKlSja2Gedziv_kSgiHztn-A-kK0DWiX0wiQJJ1y0,2724
+tau_fibrils_yolo/crossover_distance.py,sha256=_FfsSoLL-eCjWXleqKXFk6y6u9nx7qyW58r4RGdElkk,1425
+tau_fibrils_yolo/napari.yaml,sha256=CLac43pJqbklLzjkaEhVEf6aHoGeRjS-CoHPhkcaPE0,303
+tau_fibrils_yolo/postprocess.py,sha256=2e1b_JlAFtCiuWB3yGn_9cVI33GPqtDrPeiDtoyatYE,2609
+tau_fibrils_yolo/predict.py,sha256=hMViSnyX9HSTDpbB-nYrQ77F_IrChWiPdXrwqC2E8KA,5473
+tau_fibrils_yolo-0.0.1.dist-info/LICENSE,sha256=4OTqIt2xVP2wCy4QAOyXVURea7L4FKWFW6drH-hAUKU,1483
+tau_fibrils_yolo-0.0.1.dist-info/METADATA,sha256=d7S6ShQACIQ6MUGTlrOjCXzVLYM9PS8j1Wg1OyTfRcA,6041
+tau_fibrils_yolo-0.0.1.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+tau_fibrils_yolo-0.0.1.dist-info/entry_points.txt,sha256=rf5DNzu6OGSQ2sZa1YqAvR6I-wnQ_zexP0EyUB4ZxtA,221
+tau_fibrils_yolo-0.0.1.dist-info/top_level.txt,sha256=9s_o7Fja2NxRfdxnPwkMXQljx6D233h3z0JpV4a4bTE,17
+tau_fibrils_yolo-0.0.1.dist-info/RECORD,,

tau_fibrils_yolo-0.0.1.dist-info/WHEEL

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

tau_fibrils_yolo-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+tau_fibrils_predict_folder = tau_fibrils_yolo.cli:cli_predict_folder
+tau_fibrils_predict_image = tau_fibrils_yolo.cli:cli_predict_image
+
+[napari.manifest]
+tau_fibrils_yolo = tau_fibrils_yolo:napari.yaml

tau_fibrils_yolo-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tau_fibrils_yolo