TwoPy 0.3.8__tar.gz → 0.3.9__tar.gz

{twopy-0.3.8 → twopy-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twopy
-Version: 0.3.8
+Version: 0.3.9
 Summary: Two-photon imaging analysis tool with a napari interface.
 Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
 License-Expression: MIT

{twopy-0.3.8 → twopy-0.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "twopy"
-version = "0.3.8"
+version = "0.3.9"
 description = "Two-photon imaging analysis tool with a napari interface."
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/conversion/alignment_crop.py

@@ -67,6 +67,12 @@ def load_alignment_valid_crop(
             f"[{frame_start}, {frame_stop}) for {alignment.shape[0]} rows"
         )
         raise ValueError(msg)
+    if alignment.shape[0] < aligned_movie.shape[0]:
+        msg = (
+            "Alignment text must have at least one row per aligned movie frame: "
+            f"{alignment.shape[0]} rows for {aligned_movie.shape[0]} frames"
+        )
+        raise ValueError(msg)
 
     alignment_window = alignment[frame_start:frame_stop, :]
     line_scan = _is_line_scan(acquisition)
@@ -79,10 +85,14 @@ def load_alignment_valid_crop(
         source_x_pixel_count=source_spatial_shape[0],
         line_scan=line_scan,
     )
-    alignment_shift_pixels = _alignment_shift_pixels(
-        alignment[: aligned_movie.shape[0], :],
+    full_alignment = alignment[: aligned_movie.shape[0], :]
+    alignment_offset_pixels = _alignment_offset_pixels(
+        full_alignment,
         line_scan=line_scan,
     )
+    alignment_shift_pixels = _alignment_shift_pixels(
+        full_alignment, line_scan=line_scan
+    )
     motion_artifact_mask = alignment_shift_pixels > motion_threshold_pixels
     kept_alignment, over_moved_count = _remove_over_moved_alignment_rows(
         alignment_window,
@@ -103,6 +113,7 @@ def load_alignment_valid_crop(
         y_cutoff_pixels=y_cutoff,
         over_moved_frame_count=over_moved_count,
         motion_threshold_pixels=motion_threshold_pixels,
+        alignment_offset_pixels=alignment_offset_pixels,
         alignment_shift_pixels=alignment_shift_pixels,
         motion_artifact_mask=motion_artifact_mask,
     )
@@ -212,6 +223,27 @@ def _alignment_shift_pixels(
     return np.sqrt(alignment[:, 0] ** 2 + alignment[:, 1] ** 2)
 
 
+def _alignment_offset_pixels(
+    alignment: npt.NDArray[np.float64],
+    *,
+    line_scan: bool,
+) -> npt.NDArray[np.float64]:
+    """Return signed x/y alignment offsets in pixels.
+
+    Args:
+        alignment: Alignment table with x/y offset columns.
+        line_scan: Whether this recording is a line scan.
+
+    Returns:
+        Array shaped ``(frames, 2)`` with x then y offsets.
+    """
+    offsets = np.zeros((alignment.shape[0], 2), dtype=np.float64)
+    offsets[:, 0] = alignment[:, 0]
+    if not line_scan:
+        offsets[:, 1] = alignment[:, 1]
+    return offsets
+
+
 def _alignment_crop_from_offsets(
     alignment: npt.NDArray[np.float64],
     *,

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/conversion/hdf5_writing.py

@@ -198,6 +198,11 @@ def _write_alignment_crop_group(
     crop_group.attrs["y_cutoff_pixels"] = alignment_crop.y_cutoff_pixels
     crop_group.attrs["over_moved_frame_count"] = alignment_crop.over_moved_frame_count
     crop_group.attrs["motion_threshold_pixels"] = alignment_crop.motion_threshold_pixels
+    crop_group.create_dataset(
+        "alignment_offset_pixels",
+        data=alignment_crop.alignment_offset_pixels,
+        compression="gzip",
+    )
     crop_group.create_dataset(
         "alignment_shift_pixels",
         data=alignment_crop.alignment_shift_pixels,

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/conversion/types.py

@@ -255,6 +255,7 @@ class AlignmentCropAudit:
     y_cutoff_pixels: int
     over_moved_frame_count: int
     motion_threshold_pixels: float
+    alignment_offset_pixels: npt.NDArray[np.float64]
     alignment_shift_pixels: npt.NDArray[np.float64]
     motion_artifact_mask: npt.NDArray[np.bool_]
 

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/converted.py

@@ -159,8 +159,8 @@ class RecordingData:
 
     Inputs: twopy-converted HDF5 files.
     Outputs: metadata dictionaries, stimulus arrays with column names,
-    photodiode vectors, mean image, frame-count audit values, and a lazy movie
-    reader.
+    photodiode vectors, mean image, alignment crop and motion arrays,
+    frame-count audit values, and a lazy movie reader.
 
     This object is the analysis-facing representation of one converted
     recording. It deliberately excludes source MATLAB/TIFF ownership.
@@ -181,6 +181,7 @@ class RecordingData:
     high_res_pd: npt.NDArray[np.float64]
     mean_image: npt.NDArray[np.float64]
     alignment_valid_crop: SpatialCrop
+    alignment_offset_pixels: npt.NDArray[np.float64] | None
     alignment_shift_pixels: npt.NDArray[np.float64]
     motion_artifact_mask: npt.NDArray[np.bool_]
     frame_counts: FrameCountAudit
@@ -278,6 +279,7 @@ def load_converted_recording(
                 ndim=2,
             ),
             alignment_valid_crop=_read_alignment_valid_crop(h5_file),
+            alignment_offset_pixels=_read_alignment_offset_pixels(h5_file),
             alignment_shift_pixels=require_float64_array(
                 h5_file["movie/alignment_valid_crop/alignment_shift_pixels"][()],
                 name="movie/alignment_valid_crop/alignment_shift_pixels",
@@ -440,6 +442,15 @@ def _validate_loaded_recording(recording: RecordingData) -> None:
             f"{recording.movie.shape[1:]}"
         )
         raise ValueError(msg)
+    if (
+        recording.alignment_offset_pixels is not None
+        and recording.alignment_offset_pixels.shape != (frame_count, 2)
+    ):
+        msg = (
+            "alignment_offset_pixels must have x/y values for each movie frame; "
+            f"got {recording.alignment_offset_pixels.shape} for {frame_count} frames"
+        )
+        raise ValueError(msg)
     if recording.alignment_shift_pixels.shape != (frame_count,):
         msg = (
             "alignment_shift_pixels must have one value per movie frame; "
@@ -712,6 +723,27 @@ def _read_alignment_valid_crop(h5_file: h5py.File) -> SpatialCrop:
     )
 
 
+def _read_alignment_offset_pixels(
+    h5_file: h5py.File,
+) -> npt.NDArray[np.float64] | None:
+    """Read optional signed x/y alignment offsets from converted HDF5.
+
+    Args:
+        h5_file: Open ``recording_data.h5`` file.
+
+    Returns:
+        Per-frame x/y offsets, or ``None`` for older converted files.
+    """
+    dataset_name = "movie/alignment_valid_crop/alignment_offset_pixels"
+    if dataset_name not in h5_file:
+        return None
+    return require_float64_array(
+        h5_file[dataset_name][()],
+        name=dataset_name,
+        ndim=2,
+    )
+
+
 def _normalize_spatial_crop(
     spatial_shape: tuple[int, int],
     spatial_crop: SpatialCrop | None,

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/napari/empty_state.py

@@ -135,13 +135,13 @@ def empty_viewer_message(*, update_command: str | None = None) -> str:
     """Return the empty-viewer text for the current update state."""
     if not update_command:
         return _BASE_EMPTY_VIEWER_MESSAGE
-    return f"{_BASE_EMPTY_VIEWER_MESSAGE}\n\nUpdate\n{update_command}"
+    return f"{_BASE_EMPTY_VIEWER_MESSAGE}\n\n{update_command}"
 
 
 def _is_empty_viewer_message(text: str) -> bool:
     """Return whether text is owned by twopy's empty-recording overlay."""
     return text == EMPTY_VIEWER_MESSAGE or text.startswith(
-        f"{EMPTY_VIEWER_MESSAGE}\n\nUpdate\n"
+        f"{EMPTY_VIEWER_MESSAGE}\n\n"
     )
 
 

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/napari/plotting/docks/options_panel.py

@@ -27,6 +27,7 @@ from twopy.napari.plotting.export_controls import (
     ResponseExportState,
     create_response_export_tab,
 )
+from twopy.napari.plotting.motion_summary import MotionSummaryWidget
 from twopy.napari.plotting.normalization_options import NormalizationOptionsWidget
 from twopy.napari.plotting.panels import (
     SidebarTextLabel,
@@ -56,6 +57,7 @@ class ResponseOptionsPanel:
         roi_save_path_label: Metadata-tab label showing the ROI output path.
         update_status_label: Metadata-tab label showing save or processing status.
         update_notice_label: Metadata-tab label showing the update command.
+        motion_summary_widget: Metadata-tab widget showing alignment movement.
         export_status_label: Export-tab label showing save/export action status.
         reload_saved_button: Load-tab button that reloads persisted response
             outputs.
@@ -83,6 +85,7 @@ class ResponseOptionsPanel:
     roi_save_path_label: SidebarTextLabel
     update_status_label: SidebarTextLabel
     update_notice_label: SidebarTextLabel
+    motion_summary_widget: MotionSummaryWidget
     export_status_label: SidebarTextLabel
     reload_saved_button: QPushButton
     plot_options_layout: QVBoxLayout
@@ -153,6 +156,7 @@ def create_response_options_panel(
     roi_save_path_label = SidebarTextLabel(f"ROI output: {DEFAULT_PATH_TEXT}")
     update_status_label = SidebarTextLabel("")
     update_notice_label = SidebarTextLabel("")
+    motion_summary_widget = MotionSummaryWidget()
     export_status_label = SidebarTextLabel("Exports save beside the recording.")
 
     plot_options_layout = QVBoxLayout()
@@ -209,6 +213,7 @@ def create_response_options_panel(
             roi_output_label=roi_save_path_label,
             status_label=update_status_label,
             update_notice_label=update_notice_label,
+            motion_summary_widget=motion_summary_widget,
         ),
         "Metadata",
     )
@@ -232,6 +237,7 @@ def create_response_options_panel(
         roi_save_path_label=roi_save_path_label,
         update_status_label=update_status_label,
         update_notice_label=update_notice_label,
+        motion_summary_widget=motion_summary_widget,
         export_status_label=export_status_label,
         reload_saved_button=reload_saved_button,
         plot_options_layout=plot_options_layout,

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/napari/plotting/docks/response_plot_widget.py

@@ -275,6 +275,7 @@ class _ResponsePlotWidget(QWidget):
         self._roi_save_path_label = options_panel.roi_save_path_label
         self._update_status_label = options_panel.update_status_label
         self._update_notice_label = options_panel.update_notice_label
+        self._motion_summary_widget = options_panel.motion_summary_widget
         self._export_status_label = options_panel.export_status_label
         self._reload_saved_button = options_panel.reload_saved_button
         self._plot_options_layout = options_panel.plot_options_layout
@@ -496,6 +497,7 @@ class _ResponsePlotWidget(QWidget):
         self._analysis_path_label.setText(f"Analysis output: {DEFAULT_PATH_TEXT}")
         self._roi_save_path_label.setText(f"ROI output: {DEFAULT_PATH_TEXT}")
         self._update_status_label.setText("")
+        self._motion_summary_widget.set_recording(None)
         self._export_status_label.setText("Exports save beside the recording.")
         self._reset_empty_option_tabs()
         self._set_status("No recording loaded.")
@@ -528,6 +530,7 @@ class _ResponsePlotWidget(QWidget):
         self._recording = recording
         self._output_route = output_route or recording_output_route(recording)
         self._roi_generation_widget.set_recording(recording)
+        self._motion_summary_widget.set_recording(recording)
         self._analysis_path = resolved_analysis_path(None, recording)
         epoch_names = stimulus_epoch_names_by_number(recording)
         self._delta_f_over_f_options_widget.set_epoch_choices(

twopy-0.3.9/src/twopy/napari/plotting/motion_summary.py

@@ -0,0 +1,324 @@
+"""Inline Motion metadata widget for the twopy napari sidebar.
+
+Inputs: converted recording alignment crop, per-frame signed movement offsets,
+movement magnitudes, and motion-artifact masks.
+Outputs: a compact Metadata-tab section with crop metrics and a movement plot.
+"""
+
+import numpy as np
+import numpy.typing as npt
+from qtpy.QtCore import QRect, Qt
+from qtpy.QtGui import QColor, QPainter, QPainterPath, QPaintEvent, QPen
+from qtpy.QtWidgets import QGroupBox, QSizePolicy, QVBoxLayout, QWidget
+
+from twopy.converted import RecordingData
+from twopy.napari.plotting.panels import SidebarTextLabel
+
+__all__ = ["MotionSummaryWidget"]
+
+
+class MotionSummaryWidget(QGroupBox):
+    """Metadata-tab section that shows alignment movement over recording frames.
+
+    Inputs: a loaded converted recording.
+    Outputs: a compact crop/motion text summary plus a movement plot.
+    """
+
+    def __init__(self) -> None:
+        """Create an empty motion summary section."""
+        super().__init__("Motion")
+        self._summary_label = SidebarTextLabel("No recording loaded.")
+        self._plot = _MotionPlotWidget()
+        layout = QVBoxLayout()
+        layout.setSpacing(4)
+        layout.addWidget(self._summary_label)
+        layout.addWidget(self._plot)
+        self.setLayout(layout)
+
+    def set_recording(self, recording: RecordingData | None) -> None:
+        """Show movement metadata for one recording.
+
+        Args:
+            recording: Loaded converted recording, or ``None`` for empty state.
+
+        Returns:
+            None.
+        """
+        if recording is None:
+            self._summary_label.setText("No recording loaded.")
+            self._plot.set_motion(None, None, None)
+            return
+        self._summary_label.setText(_motion_summary_text(recording))
+        self._plot.set_motion(
+            recording.alignment_offset_pixels,
+            recording.alignment_shift_pixels,
+            recording.motion_artifact_mask,
+        )
+
+
+class _MotionPlotWidget(QWidget):
+    """Small inline plot for per-frame left-right and up-down movement."""
+
+    def __init__(self) -> None:
+        """Create an empty plot widget sized for the metadata sidebar."""
+        super().__init__()
+        self._values = np.empty((0, 0), dtype=np.float64)
+        self._has_xy_offsets = False
+        self._motion_mask = np.array([], dtype=np.bool_)
+        self.setFixedHeight(120)
+        self.setMinimumWidth(1)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Fixed)
+
+    def set_motion(
+        self,
+        offset_pixels: npt.NDArray[np.float64] | None,
+        shift_pixels: npt.NDArray[np.float64] | None,
+        motion_mask: npt.NDArray[np.bool_] | None,
+    ) -> None:
+        """Replace the plotted movement arrays.
+
+        Args:
+            offset_pixels: Optional signed x/y movement offsets per movie frame.
+            shift_pixels: Total movement magnitude in pixels per movie frame.
+            motion_mask: Boolean mask marking high-motion frames.
+
+        Returns:
+            None.
+        """
+        values: npt.NDArray[np.float64]
+        self._has_xy_offsets = offset_pixels is not None
+        if offset_pixels is not None:
+            values = np.asarray(offset_pixels, dtype=np.float64)
+            if values.ndim != 2 or values.shape[1] != 2:
+                values = np.empty((0, 0), dtype=np.float64)
+        elif shift_pixels is not None:
+            values = np.ravel(np.asarray(shift_pixels, dtype=np.float64))[:, None]
+        else:
+            self._values = np.empty((0, 0), dtype=np.float64)
+            self._motion_mask = np.array([], dtype=np.bool_)
+            self.update()
+            return
+        self._values = (
+            values
+            if bool(np.all(np.isfinite(values)))
+            else np.nan_to_num(values, nan=0.0, posinf=0.0, neginf=0.0)
+        )
+        if motion_mask is None:
+            self._motion_mask = np.zeros(self._values.shape[0], dtype=np.bool_)
+        else:
+            mask = np.ravel(np.asarray(motion_mask, dtype=np.bool_))
+            self._motion_mask = (
+                mask
+                if mask.shape == (self._values.shape[0],)
+                else np.zeros(self._values.shape[0], dtype=np.bool_)
+            )
+        self.update()
+
+    def paintEvent(self, a0: QPaintEvent | None) -> None:
+        """Draw the movement plot.
+
+        Args:
+            a0: Qt paint event.
+
+        Returns:
+            None.
+        """
+        del a0
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.fillRect(self.rect(), QColor("#20252d"))
+        if self._values.size == 0:
+            painter.setPen(QColor("#a9b4c0"))
+            painter.drawText(
+                self.rect(),
+                Qt.AlignmentFlag.AlignCenter,
+                "No motion data",
+            )
+            painter.end()
+            return
+        _draw_motion_plot(
+            painter,
+            self.rect(),
+            self._values,
+            self._motion_mask,
+            has_xy_offsets=self._has_xy_offsets,
+        )
+        painter.end()
+
+
+def _motion_summary_text(recording: RecordingData) -> str:
+    """Return compact crop and motion metrics for the Metadata tab."""
+    crop = recording.alignment_valid_crop
+    top = crop.axis0_start
+    bottom = crop.original_shape[0] - crop.axis0_stop
+    left = crop.axis1_start
+    right = crop.original_shape[1] - crop.axis1_stop
+    shifts = np.ravel(recording.alignment_shift_pixels)
+    finite_shifts = shifts[np.isfinite(shifts)]
+    bad_count = int(np.count_nonzero(recording.motion_artifact_mask))
+    frame_count = int(shifts.shape[0])
+    p95 = float(np.percentile(finite_shifts, 95)) if finite_shifts.size else 0.0
+    max_shift = float(np.max(finite_shifts)) if finite_shifts.size else 0.0
+    return (
+        f"Visible crop: {crop.shape[1]} x {crop.shape[0]} px "
+        f"from a {crop.original_shape[1]} x {crop.original_shape[0]} px frame\n"
+        "Removed border: "
+        f"left {left} px, right {right} px, top {top} px, bottom {bottom} px\n"
+        f"Total movement: 95% of frames moved <= {p95:.2f} px; "
+        f"max {max_shift:.2f} px; high-motion {bad_count}/{frame_count} frames\n"
+        + _plot_description(recording)
+    )
+
+
+def _plot_description(recording: RecordingData) -> str:
+    """Return the plot legend text for available movement data."""
+    if recording.alignment_offset_pixels is None:
+        return (
+            "Plot: total movement only. Reconvert this recording to see "
+            "independent x/y pixel movement."
+        )
+    return "Plot: left-right movement in blue, up-down movement in yellow"
+
+
+def _draw_motion_plot(
+    painter: QPainter,
+    widget_rect: QRect,
+    values: npt.NDArray[np.float64],
+    motion_mask: npt.NDArray[np.bool_],
+    *,
+    has_xy_offsets: bool,
+) -> None:
+    """Draw axes, movement trace, and high-motion markers."""
+    if not has_xy_offsets:
+        _draw_magnitude_plot(painter, widget_rect, values[:, 0], motion_mask)
+        return
+    rect = widget_rect
+    plot_left = float(rect.left()) + 42.0
+    plot_top = float(rect.top()) + 10.0
+    plot_width = max(1.0, float(rect.width()) - 54.0)
+    plot_height = max(1.0, float(rect.height()) - 32.0)
+    plot_bottom = plot_top + plot_height
+    y_mid = plot_top + plot_height / 2.0
+    y_abs_max = max(1.0, float(np.max(np.abs(values))))
+
+    painter.setPen(QPen(QColor("#697584"), 1))
+    painter.drawLine(
+        int(plot_left),
+        int(plot_bottom),
+        int(plot_left + plot_width),
+        int(plot_bottom),
+    )
+    painter.drawLine(int(plot_left), int(plot_top), int(plot_left), int(plot_bottom))
+    painter.setPen(QColor("#a9b4c0"))
+    painter.drawText(2, int(plot_top + 8), f"+{y_abs_max:.1f}")
+    painter.drawText(2, int(y_mid + 4), "0")
+    painter.drawText(2, int(plot_bottom), f"-{y_abs_max:.1f}")
+
+    frame_count = int(values.shape[0])
+    if frame_count == 1:
+        x_values = np.array([plot_left], dtype=np.float64)
+    else:
+        x_values = np.linspace(plot_left, plot_left + plot_width, frame_count)
+
+    _draw_offset_line(
+        painter,
+        x_values=x_values,
+        offsets=values[:, 0],
+        y_mid=y_mid,
+        y_scale=plot_height / (2.0 * y_abs_max),
+        color=QColor("#6ec6ff"),
+    )
+    _draw_offset_line(
+        painter,
+        x_values=x_values,
+        offsets=values[:, 1],
+        y_mid=y_mid,
+        y_scale=plot_height / (2.0 * y_abs_max),
+        color=QColor("#f2c14e"),
+    )
+    painter.setPen(QColor("#6ec6ff"))
+    painter.drawText(int(plot_left + plot_width - 34.0), int(plot_top + 12.0), "x")
+    painter.setPen(QColor("#f2c14e"))
+    painter.drawText(int(plot_left + plot_width - 18.0), int(plot_top + 12.0), "y")
+
+    if motion_mask.shape == (frame_count,) and bool(np.any(motion_mask)):
+        painter.setPen(QPen(QColor("#ff6b6b"), 1))
+        for x_value in x_values[motion_mask]:
+            painter.drawLine(
+                int(x_value),
+                int(plot_top),
+                int(x_value),
+                int(plot_bottom),
+            )
+
+
+def _draw_magnitude_plot(
+    painter: QPainter,
+    widget_rect: QRect,
+    shift_pixels: npt.NDArray[np.float64],
+    motion_mask: npt.NDArray[np.bool_],
+) -> None:
+    """Draw one total movement magnitude trace."""
+    rect = widget_rect
+    plot_left = float(rect.left()) + 42.0
+    plot_top = float(rect.top()) + 10.0
+    plot_width = max(1.0, float(rect.width()) - 54.0)
+    plot_height = max(1.0, float(rect.height()) - 32.0)
+    plot_bottom = plot_top + plot_height
+    y_max = max(1.0, float(np.max(shift_pixels)))
+
+    painter.setPen(QPen(QColor("#697584"), 1))
+    painter.drawLine(
+        int(plot_left),
+        int(plot_bottom),
+        int(plot_left + plot_width),
+        int(plot_bottom),
+    )
+    painter.drawLine(int(plot_left), int(plot_top), int(plot_left), int(plot_bottom))
+    painter.setPen(QColor("#a9b4c0"))
+    painter.drawText(2, int(plot_top + 8), f"{y_max:.1f}")
+    painter.drawText(2, int(plot_bottom), "0")
+
+    frame_count = int(shift_pixels.shape[0])
+    if frame_count == 1:
+        x_values = np.array([plot_left], dtype=np.float64)
+    else:
+        x_values = np.linspace(plot_left, plot_left + plot_width, frame_count)
+
+    y_values = plot_bottom - shift_pixels * (plot_height / y_max)
+    path = QPainterPath()
+    path.moveTo(float(x_values[0]), float(y_values[0]))
+    for x_value, y_value in zip(x_values[1:], y_values[1:], strict=False):
+        path.lineTo(float(x_value), float(y_value))
+    painter.setPen(QPen(QColor("#6ec6ff"), 1.5))
+    painter.drawPath(path)
+    painter.drawText(int(plot_left + plot_width - 48.0), int(plot_top + 12.0), "total")
+
+    if motion_mask.shape == (frame_count,) and bool(np.any(motion_mask)):
+        painter.setPen(QPen(QColor("#ff6b6b"), 1))
+        for x_value in x_values[motion_mask]:
+            painter.drawLine(
+                int(x_value),
+                int(plot_top),
+                int(x_value),
+                int(plot_bottom),
+            )
+
+
+def _draw_offset_line(
+    painter: QPainter,
+    *,
+    x_values: npt.NDArray[np.float64],
+    offsets: npt.NDArray[np.float64],
+    y_mid: float,
+    y_scale: float,
+    color: QColor,
+) -> None:
+    """Draw one signed alignment-offset line."""
+    y_values = y_mid - offsets * y_scale
+    path = QPainterPath()
+    path.moveTo(float(x_values[0]), float(y_values[0]))
+    for x_value, y_value in zip(x_values[1:], y_values[1:], strict=False):
+        path.lineTo(float(x_value), float(y_value))
+    painter.setPen(QPen(color, 1.5))
+    painter.drawPath(path)

{twopy-0.3.8 → twopy-0.3.9}/src/twopy/napari/plotting/panels.py

@@ -135,6 +135,7 @@ def response_metadata_tab(
     roi_output_label: SidebarTextLabel,
     status_label: SidebarTextLabel,
     update_notice_label: SidebarTextLabel,
+    motion_summary_widget: QWidget | None = None,
 ) -> QWidget:
     """Create the tab that shows selected-recording metadata.
 
@@ -146,6 +147,7 @@ def response_metadata_tab(
         roi_output_label: Label showing the ROI output path.
         status_label: Label showing the latest app action or update command.
         update_notice_label: Label showing the copyable update command.
+        motion_summary_widget: Optional section showing alignment movement.
 
     Returns:
         Scrollable Qt widget for the Metadata tab.
@@ -158,6 +160,8 @@ def response_metadata_tab(
         _metadata_group("Outputs", analysis_output_label, roi_output_label),
     )
     layout.addWidget(_metadata_group("Status", status_label, update_notice_label))
+    if motion_summary_widget is not None:
+        layout.addWidget(motion_summary_widget)
     layout.addStretch(1)
     return scrolling_tab(layout)
 

{twopy-0.3.8 → twopy-0.3.9}/src/twopy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twopy
-Version: 0.3.8
+Version: 0.3.9
 Summary: Two-photon imaging analysis tool with a napari interface.
 Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
 License-Expression: MIT

{twopy-0.3.8 → twopy-0.3.9}/src/twopy.egg-info/SOURCES.txt

@@ -158,6 +158,7 @@ src/twopy/napari/plotting/export.py
 src/twopy/napari/plotting/export_controls.py
 src/twopy/napari/plotting/form_controls.py
 src/twopy/napari/plotting/label_visibility.py
+src/twopy/napari/plotting/motion_summary.py
 src/twopy/napari/plotting/normalization_options.py
 src/twopy/napari/plotting/options.py
 src/twopy/napari/plotting/panels.py

{twopy-0.3.8 → twopy-0.3.9}/tests/test_background_subtraction.py

@@ -580,6 +580,10 @@ class BackgroundSubtractionTest(unittest.TestCase):
             high_res_pd=np.zeros(0, dtype=np.float64),
             mean_image=movie_values.mean(axis=0),
             alignment_valid_crop=alignment_crop,
+            alignment_offset_pixels=np.zeros(
+                (movie_values.shape[0], 2),
+                dtype=np.float64,
+            ),
             alignment_shift_pixels=np.zeros(movie_values.shape[0], dtype=np.float64),
             motion_artifact_mask=np.zeros(movie_values.shape[0], dtype=np.bool_),
             frame_counts=FrameCountAudit(