tau-fibrils-yolo 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

tau_fibrils_yolo/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.4'
-__version_tuple__ = version_tuple = (0, 0, 4)
+__version__ = version = '0.0.6'
+__version_tuple__ = version_tuple = (0, 0, 6)

tau_fibrils_yolo/_widget.py

@@ -16,6 +16,8 @@ from qtpy.QtWidgets import (
     QDoubleSpinBox,
     QFileDialog,
 )
+from matplotlib.backends.backend_qt5agg import FigureCanvas
+
 from tau_fibrils_yolo.predict import FibrilsDetector
 from tau_fibrils_yolo.postprocess import (
     boxes_kernel_density_map,
@@ -23,7 +25,21 @@ from tau_fibrils_yolo.postprocess import (
     outside_image_border_filter,
     overlapping_obb_filter,
 )
-from tau_fibrils_yolo.crossover_distance import crossover_distance_measurement
+from tau_fibrils_yolo.measure import (
+    box_measurements,
+    line_profile_measurements,
+    crossover_distance_measurement,
+)
+
+import matplotlib as mpl
+
+mpl.rc("axes", edgecolor="white")
+mpl.rc("axes", facecolor="#262930")
+mpl.rc("axes", labelcolor="white")
+mpl.rc("savefig", facecolor="#262930")
+mpl.rc("text", color="white")
+mpl.rc("xtick", color="white")
+mpl.rc("ytick", color="white")
 
 
 class YoloDetectorWidget(QWidget):
@@ -74,6 +90,19 @@ class YoloDetectorWidget(QWidget):
         export_btn.clicked.connect(self._save_csv)
         grid_layout.addWidget(export_btn, 6, 0, 1, 2)
 
+        # Line profile plot
+        self.canvas = FigureCanvas()
+        self.canvas.figure.set_tight_layout(True)
+        self.canvas.figure.patch.set_facecolor("#262930")
+        self.axes = self.canvas.figure.subplots()
+        self.axes.cla()
+        self.axes.set_ylabel("Intensity")
+        self.axes.set_xlabel("Pixels")
+        self.canvas.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self.canvas.setMaximumSize(500, 300)
+        self.canvas.setMinimumSize(300, 150)
+        grid_layout.addWidget(self.canvas, 7, 0, 1, 2)
+
         # Setup layer callbacks
         self.viewer.layers.events.inserted.connect(
             lambda e: e.value.events.name.connect(self._on_layer_change)
@@ -98,7 +127,9 @@ class YoloDetectorWidget(QWidget):
     def _prediction_thread(self, rescale_factor):
         all_boxes = []
         all_probas = []
-        for k, boxes, probas in self.predictor.yield_predictions(self.selected_image, rescale_factor):
+        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
@@ -148,38 +179,36 @@ class YoloDetectorWidget(QWidget):
                 "opacity": 1.0,
                 "edge_width": 1,
                 "edge_color": "#ff0000",
-                "properties": {
-                    "probability": probas,
-                },
             }
 
             self.shapes_layer = self.viewer.add_shapes(boxes, **shape_kwargs)
+            self.shapes_layer.mouse_double_click_callbacks.append(
+                self._handle_double_click
+            )
+            self.shapes_layer.mode = "DIRECT"
         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]
+        if len(boxes):
+            filt = outside_image_border_filter(boxes)
+            boxes = boxes[filt]
+            probas = probas[filt]
 
-        filt = overlapping_obb_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]
+            filt = minimum_neighbor_distance_filter(boxes, rescale_factor)
+            boxes = boxes[filt]
+            probas = probas[filt]
 
         if len(boxes) == 0:
             show_info("No fibrils were detected.")
@@ -191,72 +220,75 @@ class YoloDetectorWidget(QWidget):
             density_map, colormap="inferno", opacity=0.5, blending="additive"
         )
         density_layer.visible = False
+        self.viewer.layers.selection.active = self.shapes_layer
 
         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)
+            center, length, width = box_measurements(box)
             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.shapes_layer.data = boxes
+        self.shapes_layer.properties = {
+            "probability": probas,
+            "length": lengths,
+            "width": widths,
+            "center_x": centers_x,
+            "center_y": centers_y,
         }
-        self.crossover_shapes_layer = self.viewer.add_shapes(line_data, **lines_props)
 
-        self.shapes_layer.data = boxes
-        self.shapes_layer.properties = (
+        self.shapes_layer.edge_color = "#00ff00"
+        self.shapes_layer.refresh()
+
+        self.df = pd.DataFrame(
             {
                 "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}!")
+
+    def _handle_double_click(self, *args, **kwargs):
+        if self.shapes_layer.mode in ["direct", "select"]:
+            selected_data = self.shapes_layer.selected_data
+            if len(selected_data) == 1:
+                selected_shape_idx = list(self.shapes_layer.selected_data)[0]
+                boxes = self.shapes_layer.data
+                image = self.cb_image.currentData()
+                box = boxes[selected_shape_idx]
+                line_profile_width, line_profile_centerline = line_profile_measurements(box, image)
+                crossover_distance = crossover_distance_measurement(box, image)
+                crossover_distance_centerline = crossover_distance_measurement(box, image, method="centerline")
+                self._draw(line_profile_width, line_profile_centerline, crossover_distance, crossover_distance_centerline)
+
+    def _draw(self, line_profile_width, line_profile_centerline, crossover_distance, crossover_distance_centerline):
+        self.axes.cla()
+        self.axes.plot(line_profile_width, label=f"box_width (crossover_dist: {crossover_distance:.0f} px)")
+        self.axes.plot(line_profile_centerline, color="orange", label=f"centerline (crossover_dist: {crossover_distance_centerline:.0f} px)")
+        self.axes.set_ylabel("Intensity")
+        self.axes.set_xlabel("Pixels")
+        self.axes.set_xlim(0, len(line_profile_width))
+        self.axes.legend(bbox_to_anchor=(0, 1.02, 1, 0.2), loc="lower left", mode="expand", borderaxespad=0, ncol=1)
+        self.canvas.draw()

tau_fibrils_yolo/cli.py

@@ -1,5 +1,5 @@
 from tau_fibrils_yolo.predict import FibrilsDetector
-from tau_fibrils_yolo.crossover_distance import crossover_distance_measurement
+from tau_fibrils_yolo.measure import crossover_distance_measurement
 import tifffile
 from pathlib import Path
 import argparse

tau_fibrils_yolo/measure.py

@@ -0,0 +1,91 @@
+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, method="width"):
+    if len(image.shape) == 3:
+        image = image[..., 0]
+
+    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)
+    
+    if method == "width":
+        # 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
+        )
+    elif method == "centerline":
+        pixel_values = profile_line(
+            image, src=p5, dst=p6, linewidth=1, 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))
+
+    return distance
+
+
+def box_measurements(box):
+    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)
+
+    diagonal = p6 - p5
+    center = p5 + diagonal / 2
+
+    return center, line_length, line_width
+
+
+def line_profile_measurements(box, image):
+    if len(image.shape) == 3:
+        image = image[..., 0]
+
+    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)
+
+    # Compute the intensity profile along the line, averaged over the width
+    pixel_values_width = profile_line(
+        image, src=p5, dst=p6, linewidth=int(line_width), order=1
+    )
+    # or just the centerline
+    pixel_values_centerline = profile_line(image, src=p5, dst=p6, linewidth=1, order=1)
+
+    return pixel_values_width, pixel_values_centerline

tau_fibrils_yolo/postprocess.py

@@ -53,11 +53,12 @@ def boxes_center_coordinates(boxes):
 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
+    grid_size_x = image.shape[0] // downscale_factor
+    grid_size_y = image.shape[1] // 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]),
+        np.linspace(0, grid_size_y - 1, grid_size_y),
+        np.linspace(0, grid_size_x - 1, grid_size_x),
     )
 
     grid_points = np.vstack([y_grid.ravel(), x_grid.ravel()]).T
@@ -70,7 +71,7 @@ def boxes_kernel_density_map(boxes, image, gaussian_sigma_px=50, downscale_facto
 
     kde.fit(boxes_center_coordinates(boxes) / downscale_factor)
 
-    density_map = np.exp(kde.score_samples(grid_points)).reshape(image_shape)
+    density_map = np.exp(kde.score_samples(grid_points)).reshape((grid_size_x, grid_size_y))
     density_map = zoom(density_map, zoom=downscale_factor, order=1)
     density_map = rescale_intensity(density_map, out_range=(0, 1))