zea 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

zea/tools/fit_scan_cone.py

@@ -11,20 +11,13 @@ This module provides functionality to:
 """
 
 import argparse
-import os
 from pathlib import Path
 
-if __name__ == "__main__":
-    os.environ["KERAS_BACKEND"] = (
-        "numpy"  # recommend using numpy for this since some line fitting is performed on CPU
-    )
-
-import keras
 import matplotlib.pyplot as plt
 import numpy as np
-from keras import ops
 
 from zea import log
+from zea.tensor_ops import translate
 
 
 def filter_edge_points_by_boundary(edge_points, is_left=True, min_cone_half_angle_deg=20):
@@ -33,35 +26,32 @@ def filter_edge_points_by_boundary(edge_points, is_left=True, min_cone_half_angl
     Enforces minimum cone angle constraint to ensure valid cone shapes.
 
     Args:
-        edge_points: Tensor of shape (N, 2) containing (x, y) coordinates of edge points
+        edge_points: Array of shape (N, 2) containing (x, y) coordinates of edge points
         is_left: Boolean indicating whether these are left (True) or right (False) edge points
         min_cone_half_angle_deg: Minimum expected half-angle of the cone in degrees
 
     Returns:
-        Tensor of shape (M, 2) containing filtered edge points that satisfy the boundary constraints
+        Array of shape (M, 2) containing filtered edge points that satisfy the boundary constraints
     """
-    if ops.shape(edge_points)[0] == 0:
+    if len(edge_points) == 0:
         return edge_points
 
     # Convert minimum angle to slope
-    min_slope = ops.tan(np.radians(min_cone_half_angle_deg))
+    min_slope = np.tan(np.radians(min_cone_half_angle_deg))
 
     # Sort by y coordinate (top to bottom)
-    sorted_indices = ops.argsort(edge_points[:, 1])
-    sorted_points = ops.take(edge_points, sorted_indices, axis=0)
+    sorted_indices = np.argsort(edge_points[:, 1])
+    sorted_points = edge_points[sorted_indices]
 
     filtered_points = []
 
-    # Convert to numpy for the iterative logic (this part is hard to vectorize)
-    sorted_points_np = ops.convert_to_numpy(sorted_points)
-
-    for i, point in enumerate(sorted_points_np):
+    for i, point in enumerate(sorted_points):
         x, y = point
         is_boundary_point = True
 
         # Check all points above this one
         for j in range(i):
-            above_x, above_y = sorted_points_np[j]
+            above_x, above_y = sorted_points[j]
             dy = y - above_y
             min_dx_required = min_slope * dy
 
@@ -79,7 +69,7 @@ def filter_edge_points_by_boundary(edge_points, is_left=True, min_cone_half_angl
         if is_boundary_point:
             filtered_points.append(point)
 
-    return ops.convert_to_tensor(filtered_points) if filtered_points else ops.zeros((0, 2))
+    return np.array(filtered_points) if filtered_points else np.zeros((0, 2))
 
 
 def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
@@ -93,7 +83,7 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
     5. Calculates cone parameters including apex position, opening angle, and crop boundaries
 
     Args:
-        image: 2D Keras tensor (grayscale image)
+        image: 2D numpy array (grayscale image)
         min_cone_half_angle_deg: Minimum expected half-angle of the cone in degrees
         threshold: Threshold for binary image (pixels above this are considered data)
 
@@ -110,48 +100,29 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
     Raises:
         ValueError: If input image is not 2D or cone detection fails
     """
-    try:
-        import cv2
-    except ImportError as exc:
-        raise ImportError(
-            "OpenCV is required for cone detection and visualization. "
-            "Please install it with 'pip install opencv-python' or "
-            "'pip install opencv-python-headless'."
-        ) from exc
 
-    if len(ops.shape(image)) != 2:
+    if len(image.shape) != 2:
         raise ValueError("Input image must be 2D (grayscale)")
 
-    # Ensure image is in proper range for cv2.threshold
-    if image.dtype != "uint8":
-        image = ops.cast(image * 255, "uint8")
+    h, w = image.shape
 
-    h, w = ops.shape(image)
-
-    # OpenCV threshold requires numpy array
-    image_np = ops.convert_to_numpy(image)
-    _, thresh_np = cv2.threshold(image_np, threshold, 255, cv2.THRESH_BINARY)
-    thresh = ops.convert_to_tensor(thresh_np)
+    # Apply threshold
+    thresh = np.where(image > threshold, 255, 0)
 
     # Find non-zero pixel bounds
-    non_zero_indices = ops.convert_to_tensor(ops.where(thresh > 0))
-    if ops.shape(non_zero_indices)[0] == 0:
+    non_zero_indices = np.argwhere(thresh > 0)
+    if len(non_zero_indices) == 0:
         return None
 
-    min_y = ops.min(non_zero_indices[:, 0])
-    max_y = ops.max(non_zero_indices[:, 0])
+    min_y = np.min(non_zero_indices[:, 0])
+    max_y = np.max(non_zero_indices[:, 0])
 
     # Collect left and right edge points
     left_edge_points = []
     right_edge_points = []
 
-    # Convert back to numpy for row-wise processing (this is hard to vectorize efficiently)
-    thresh_np = ops.convert_to_numpy(thresh)
-    min_y_np = int(ops.convert_to_numpy(min_y))
-    max_y_np = int(ops.convert_to_numpy(max_y))
-
-    for y in range(min_y_np, max_y_np + 1):
-        row = thresh_np[y, :]
+    for y in range(min_y, max_y + 1):
+        row = thresh[y, :]
         non_zero_x = np.where(row > 0)[0]
 
         if len(non_zero_x) > 0:
@@ -163,8 +134,8 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
     if len(left_edge_points) < 10:
         return None
 
-    left_edge_points = ops.convert_to_tensor(left_edge_points, dtype="float32")
-    right_edge_points = ops.convert_to_tensor(right_edge_points, dtype="float32")
+    left_edge_points = np.array(left_edge_points, dtype=np.float32)
+    right_edge_points = np.array(right_edge_points, dtype=np.float32)
 
     # Filter edge points to keep only boundary points
     filtered_left_points = filter_edge_points_by_boundary(
@@ -176,50 +147,38 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
         min_cone_half_angle_deg=min_cone_half_angle_deg,
     )
 
-    if ops.shape(filtered_left_points)[0] < 3 or ops.shape(filtered_right_points)[0] < 3:
+    if len(filtered_left_points) < 3 or len(filtered_right_points) < 3:
         return None
 
     # Fit lines using least squares: x = a + b*y
-    # Convert to numpy for lstsq
-    filtered_left_np = ops.convert_to_numpy(filtered_left_points)
-    filtered_right_np = ops.convert_to_numpy(filtered_right_points)
-
     # Left line
-    A_left = np.vstack([np.ones(len(filtered_left_np)), filtered_left_np[:, 1]]).T
-    left_coeffs, _, _, _ = np.linalg.lstsq(A_left, filtered_left_np[:, 0], rcond=None)
+    A_left = np.vstack([np.ones(len(filtered_left_points)), filtered_left_points[:, 1]]).T
+    left_coeffs, _, _, _ = np.linalg.lstsq(A_left, filtered_left_points[:, 0], rcond=None)
     left_a, left_b = left_coeffs
 
     # Right line
-    A_right = np.vstack([np.ones(len(filtered_right_np)), filtered_right_np[:, 1]]).T
-    right_coeffs, _, _, _ = np.linalg.lstsq(A_right, filtered_right_np[:, 0], rcond=None)
+    A_right = np.vstack([np.ones(len(filtered_right_points)), filtered_right_points[:, 1]]).T
+    right_coeffs, _, _, _ = np.linalg.lstsq(A_right, filtered_right_points[:, 0], rcond=None)
     right_a, right_b = right_coeffs
 
-    # Convert back to tensors
-    left_a = ops.convert_to_tensor(left_a)
-    left_b = ops.convert_to_tensor(left_b)
-    right_a = ops.convert_to_tensor(right_a)
-    right_b = ops.convert_to_tensor(right_b)
-
     # Calculate apex as intersection of fitted lines
-    if ops.abs(left_b - right_b) < 1e-6:  # Lines are parallel
+    if np.abs(left_b - right_b) < 1e-6:  # Lines are parallel
         return None
 
     apex_y = (right_a - left_a) / (left_b - right_b)
     apex_x = left_a + left_b * apex_y
 
     # Calculate cone height
-    max_y = ops.cast(max_y, apex_y.dtype)
     cone_height = max_y - apex_y
 
     # Calculate opening angle from the line slopes
-    # Convert slopes to angles and calculate opening angle
-    left_angle = ops.arctan(left_b)  # angle of left line from horizontal
-    right_angle = ops.arctan(right_b)  # angle of right line from horizontal
-    opening_angle = ops.abs(left_angle - right_angle)
+    left_angle = np.arctan(left_b)  # angle of left line from horizontal
+    right_angle = np.arctan(right_b)  # angle of right line from horizontal
+    opening_angle = np.abs(left_angle - right_angle)
 
     min_non_zero_pixel_idx = (0, 0)
-    for i in reversed(range(0, thresh_np.shape[0])):
-        row = thresh_np[i]
+    for i in reversed(range(0, thresh.shape[0])):
+        row = thresh[i]
         non_zero_pixel_col = np.where(row > 0)[0]
         if np.any(non_zero_pixel_col):
             min_non_zero_pixel_idx = (i, non_zero_pixel_col[0])
@@ -227,15 +186,13 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
 
     circle_radius = float(
         np.sqrt(
-            (min_non_zero_pixel_idx[1] - ops.convert_to_numpy(apex_x)) ** 2
-            + (min_non_zero_pixel_idx[0] - ops.convert_to_numpy(apex_y)) ** 2
+            (min_non_zero_pixel_idx[1] - apex_x) ** 2 + (min_non_zero_pixel_idx[0] - apex_y) ** 2
         )
     )
-    circle_center_x = float(ops.convert_to_numpy(apex_x))
-    circle_center_y = float(ops.convert_to_numpy(apex_y))
+    circle_center_x = float(apex_x)
+    circle_center_y = float(apex_y)
 
     # Calculate where the circle intersects with the cone lines
-    # For line: x = a + b*y and circle: (x - cx)^2 + (y - cy)^2 = r^2
     def line_circle_intersection(a, b, cx, cy, r):
         """Find intersection of line x = a + b*y with circle centered at (cx, cy) with radius r"""
         # Substitute line equation into circle equation
@@ -261,30 +218,16 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
 
     # Find intersection points
     left_intersect = line_circle_intersection(
-        ops.convert_to_numpy(left_a),
-        ops.convert_to_numpy(left_b),
-        circle_center_x,
-        circle_center_y,
-        circle_radius,
+        left_a, left_b, circle_center_x, circle_center_y, circle_radius
     )
     right_intersect = line_circle_intersection(
-        ops.convert_to_numpy(right_a),
-        ops.convert_to_numpy(right_b),
-        circle_center_x,
-        circle_center_y,
-        circle_radius,
+        right_a, right_b, circle_center_x, circle_center_y, circle_radius
     )
 
     if left_intersect is None or right_intersect is None:
         # Fallback to line endpoints at max_y
-        left_y_bottom, left_x_bottom = (
-            ops.convert_to_numpy(max_y),
-            ops.convert_to_numpy(left_a + left_b * max_y),
-        )
-        right_y_bottom, right_x_bottom = (
-            ops.convert_to_numpy(max_y),
-            ops.convert_to_numpy(right_a + right_b * max_y),
-        )
+        left_y_bottom, left_x_bottom = max_y, left_a + left_b * max_y
+        right_y_bottom, right_x_bottom = max_y, right_a + right_b * max_y
     else:
         left_y_bottom, left_x_bottom = left_intersect
         right_y_bottom, right_x_bottom = right_intersect
@@ -297,7 +240,7 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
 
     crop_left = int(left_x_bottom) - padding_x
     crop_right = int(right_x_bottom) + padding_x
-    crop_top = int(ops.convert_to_numpy(apex_y)) - padding_y
+    crop_top = int(apex_y) - padding_y
     crop_bottom = int(sector_bottom)
 
     # Calculate final dimensions
@@ -311,50 +254,42 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
     sector_right_y = right_y_bottom
 
     # Calculate symmetry ratio (how symmetric the cone is)
-    symmetry_ratio = float(
-        ops.convert_to_numpy(
-            ops.abs(left_b + right_b) / (ops.abs(left_b) + ops.abs(right_b) + 1e-8)
-        )
-    )
+    symmetry_ratio = float(np.abs(left_b + right_b) / (np.abs(left_b) + np.abs(right_b) + 1e-8))
 
     # Calculate data coverage in the crop region
-    h_np = int(ops.convert_to_numpy(h))
-    w_np = int(ops.convert_to_numpy(w))
     crop_left_clipped = max(0, crop_left)
-    crop_right_clipped = min(w_np, crop_right)
+    crop_right_clipped = min(w, crop_right)
     crop_top_clipped = max(0, crop_top)
-    crop_bottom_clipped = min(h_np, crop_bottom)
+    crop_bottom_clipped = min(h, crop_bottom)
 
     data_coverage = 0.0
     assert crop_left_clipped < crop_right_clipped and crop_top_clipped < crop_bottom_clipped
-    crop_region = thresh_np[
-        crop_top_clipped:crop_bottom_clipped, crop_left_clipped:crop_right_clipped
-    ]
+    crop_region = thresh[crop_top_clipped:crop_bottom_clipped, crop_left_clipped:crop_right_clipped]
     data_coverage = float(np.sum(crop_region > 0) / crop_region.size)
 
     return {
-        "apex_x": float(ops.convert_to_numpy(apex_x)),
-        "apex_y": float(ops.convert_to_numpy(apex_y)),
+        "apex_x": float(apex_x),
+        "apex_y": float(apex_y),
         "crop_left": crop_left,
         "crop_right": crop_right,
         "crop_top": crop_top,
         "crop_bottom": crop_bottom,
-        "original_width": int(ops.convert_to_numpy(w)),
-        "original_height": int(ops.convert_to_numpy(h)),
+        "original_width": int(w),
+        "original_height": int(h),
         # Additional parameters for debug and analysis
-        "cone_height": float(ops.convert_to_numpy(cone_height)),
-        "opening_angle": float(ops.convert_to_numpy(opening_angle)),
+        "cone_height": float(cone_height),
+        "opening_angle": float(opening_angle),
         "new_width": new_width,
         "new_height": new_height,
         "symmetry_ratio": symmetry_ratio,
-        "first_data_row": int(ops.convert_to_numpy(min_y)),
+        "first_data_row": int(min_y),
         "data_coverage": data_coverage,
-        "apex_above_image": bool(ops.convert_to_numpy(apex_y) < 0),
+        "apex_above_image": bool(apex_y < 0),
         # Line parameters for reconstruction if needed
-        "left_slope": float(ops.convert_to_numpy(left_b)),
-        "right_slope": float(ops.convert_to_numpy(right_b)),
-        "left_intercept": float(ops.convert_to_numpy(left_a)),
-        "right_intercept": float(ops.convert_to_numpy(right_a)),
+        "left_slope": float(left_b),
+        "right_slope": float(right_b),
+        "left_intercept": float(left_a),
+        "right_intercept": float(right_a),
         # Circle parameters for the bottom boundary
         "circle_center_x": circle_center_x,
         "circle_center_y": circle_center_y,
@@ -378,11 +313,11 @@ def crop_and_center_cone(image, cone_params):
     3. Centers the apex horizontally in the final image
 
     Args:
-        image: 2D Keras tensor (grayscale image)
+        image: 2D numpy array (grayscale image)
         cone_params: Dictionary of cone parameters from detect_cone_parameters()
 
     Returns:
-        Keras tensor of the cropped and centered image with the cone apex at the top center
+        numpy array of the cropped and centered image with the cone apex at the top center
     """
     # Get crop boundaries
     crop_left = cone_params["crop_left"]
@@ -395,76 +330,70 @@ def crop_and_center_cone(image, cone_params):
         cropped = image[0:crop_bottom, crop_left:crop_right]
         # Add top padding
         top_padding = -crop_top
-        cropped_width = ops.shape(cropped)[1]
-        top_pad = ops.zeros((top_padding, cropped_width), dtype=cropped.dtype)
-        cropped = ops.concatenate([top_pad, cropped], axis=0)
+        cropped_width = cropped.shape[1]
+        top_pad = np.zeros((top_padding, cropped_width), dtype=cropped.dtype)
+        cropped = np.concatenate([top_pad, cropped], axis=0)
     else:
         cropped = image[crop_top:crop_bottom, crop_left:crop_right]
 
     # Now handle horizontal centering
     # Calculate where the apex is in the cropped image
     apex_x_in_crop = cone_params["apex_x"] - crop_left
-    cropped_height = ops.shape(cropped)[0]
-    cropped_width = ops.shape(cropped)[1]
+    cropped_height = cropped.shape[0]
+    cropped_width = cropped.shape[1]
 
     # Calculate the target center position
-    target_center_x = ops.cast(cropped_width / 2, "float32")
+    target_center_x = cropped_width / 2
 
     # Calculate how much padding we need on each side
-    # We want: left_padding + apex_x_in_crop = final_width / 2
-    # And: final_width = cropped_width + left_padding + right_padding
-    # For symmetric padding: left_padding = right_padding
-    # So: left_padding + apex_x_in_crop = (cropped_width + 2*left_padding) / 2
-    # Solving: left_padding = cropped_width/2 - apex_x_in_crop
-
     left_padding_needed = target_center_x - apex_x_in_crop
 
     # Ensure we have non-negative padding
-    left_padding = ops.maximum(0, ops.cast(left_padding_needed, "int32"))
-    right_padding = ops.maximum(0, ops.cast(-left_padding_needed, "int32"))
+    left_padding = max(0, int(left_padding_needed))
+    right_padding = max(0, int(-left_padding_needed))
 
     # Apply horizontal padding if needed
     if left_padding > 0 or right_padding > 0:
         if left_padding > 0:
-            left_pad = ops.zeros((cropped_height, left_padding), dtype=cropped.dtype)
-            cropped = ops.concatenate([left_pad, cropped], axis=1)
+            left_pad = np.zeros((cropped_height, left_padding), dtype=cropped.dtype)
+            cropped = np.concatenate([left_pad, cropped], axis=1)
 
         if right_padding > 0:
-            right_pad = ops.zeros((cropped_height, right_padding), dtype=cropped.dtype)
-            cropped = ops.concatenate([cropped, right_pad], axis=1)
+            right_pad = np.zeros((cropped_height, right_padding), dtype=cropped.dtype)
+            cropped = np.concatenate([cropped, right_pad], axis=1)
 
     return cropped
 
 
 def fit_and_crop_around_scan_cone(
-    image_tensor, min_cone_half_angle_deg=20, threshold=15, return_params=False
+    image, image_range, min_cone_half_angle_deg=20, threshold=15, return_params=False
 ):
     """
     Detect scan cone in ultrasound image and return cropped/padded image with centered apex.
 
     Args:
-        image_tensor: Keras tensor (2D grayscale image)
+        image: numpy array (2D grayscale image)
+        image_range: tuple (vmin, vmax) for display scaling
         min_cone_half_angle_deg: Minimum expected half-angle of the cone in degrees (default: 20)
-        threshold: Threshold for binary image - pixels above this are considered data (default: 15)
+        threshold: Threshold for binary image - pixels above this are considered data.
+            This is always on a scale of 0-255 (default: 15).
         return_params: If True, also return cone parameters (default: False)
 
     Returns:
-        - If return_params is False: Keras tensor (cropped and padded image with apex at center)
-        - If return_params is True: Tuple of (cropped_tensor, cone_parameters_dict)
+        - If return_params is False: numpy array (cropped and padded image with apex at center)
+        - If return_params is True: Tuple of (cropped_array, cone_parameters_dict)
 
     Raises:
         ValueError: If cone detection fails or image is not 2D
     """
-    if keras.backend.backend() != "numpy":
-        log.info(f"❗️ It is recommended to use {log.blue('numpy')} backend for `fit_scan_cone()`.")
-
     # Ensure image is 2D
-    if len(ops.shape(image_tensor)) != 2:
-        raise ValueError(f"Input must be 2D grayscale image, got shape {ops.shape(image_tensor)}")
+    if len(image.shape) != 2:
+        raise ValueError(f"Input must be 2D grayscale image, got shape {image.shape}")
 
     # Detect cone parameters
+    threshold = translate(threshold, range_from=(0, 255), range_to=image_range)
     cone_params = detect_cone_parameters(
-        image_tensor,
+        image,
         min_cone_half_angle_deg=min_cone_half_angle_deg,
         threshold=threshold,
     )
@@ -473,7 +402,7 @@ def fit_and_crop_around_scan_cone(
         raise ValueError("Failed to detect ultrasound cone in image")
 
     # Crop and center the image
-    cropped_image = crop_and_center_cone(image_tensor, cone_params)
+    cropped_image = crop_and_center_cone(image, cone_params)
 
     if return_params:
         return cropped_image, cone_params
@@ -567,7 +496,6 @@ def visualize_scan_cone(image, cone_params, output_dir="output"):
         marker="*",  # Star marker
         markersize=15,
         color="#FFD700",  # Gold
-        # markeredgecolor="white",
         markeredgewidth=2,
         label="Cone apex",
     )
@@ -673,13 +601,14 @@ def main(avi_path):
     # Convert to grayscale
     frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
-    # Convert to tensor
-    frame_tensor = ops.convert_to_tensor(frame)
-
     try:
         # Fit scan cone
         _, cone_params = fit_and_crop_around_scan_cone(
-            frame_tensor, min_cone_half_angle_deg=20, threshold=15, return_params=True
+            frame,
+            image_range=(0, 255),
+            min_cone_half_angle_deg=20,
+            threshold=15,
+            return_params=True,
         )
 
         # Create visualization
@@ -698,6 +627,7 @@ def get_args():
     parser.add_argument(
         "--input_file",
         type=str,
+        help="Path to input AVI file for visualization",
         required=True,
     )
     return parser.parse_args()

zea/tracking/__init__.py

@@ -0,0 +1,16 @@
+"""Tracking module.
+
+This module provides point tracking algorithms for 2D and 3D data.
+
+Classes:
+    - BaseTracker: Abstract base class for trackers.
+    - LucasKanadeTracker: Pyramidal Lucas-Kanade tracker (2D/3D).
+    - SegmentationTracker: Segmentation-based tracker using contour matching.
+
+"""
+
+from .base import BaseTracker
+from .lucas_kanade import LucasKanadeTracker
+from .segmentation import SegmentationTracker
+
+__all__ = ["BaseTracker", "LucasKanadeTracker", "SegmentationTracker"]

zea/tracking/base.py

@@ -0,0 +1,94 @@
+"""Base tracker class for point tracking algorithms."""
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from keras import ops
+
+
+class BaseTracker(ABC):
+    """Abstract base class for point tracking algorithms.
+
+    This class defines the interface for tracking algorithms in the zea package.
+    Implementations should handle both 2D and 3D tracking where applicable.
+
+    Args:
+        ndim: Number of dimensions (2 for 2D, 3 for 3D).
+        **kwargs: Tracker-specific parameters.
+    """
+
+    def __init__(self, ndim: int = 2, **kwargs):
+        """Initialize the tracker with parameters."""
+        self.ndim = ndim
+
+        if self.ndim not in [2, 3]:
+            raise ValueError(f"Only 2D and 3D tracking supported, got {ndim}D")
+
+    @abstractmethod
+    def track(
+        self,
+        prev_frame,
+        next_frame,
+        points,
+    ):
+        """
+        Track points from prev_frame to next_frame.
+
+        Args:
+            prev_frame: Previous frame/volume of shape (H, W) or (D, H, W).
+            next_frame: Next frame/volume of shape (H, W) or (D, H, W).
+            points: Points to track, shape (N, ndim) in (y, x) or (z, y, x) format.
+
+        Returns:
+            new_points: Tracked point locations, shape (N, ndim).
+        """
+        pass
+
+    def track_sequence(
+        self,
+        frames: List,
+        initial_points,
+    ) -> List:
+        """
+        Track points through a sequence of frames.
+
+        Args:
+            frames: List of frames/volumes to track through.
+            initial_points: Starting points in first frame, shape (N, ndim).
+
+        Returns:
+            List of N arrays, where each array has shape (T, ndim) containing
+            the trajectory of one point through all T frames.
+
+        """
+
+        n_frames = len(frames)
+        n_points = int(ops.shape(initial_points)[0])
+
+        frames_t = [ops.convert_to_tensor(f, dtype="float32") for f in frames]
+        current_points = ops.convert_to_tensor(initial_points, dtype="float32")
+
+        trajectories = [ops.zeros((n_frames, self.ndim), dtype="float32") for _ in range(n_points)]
+
+        # Set initial positions
+        for i in range(n_points):
+            trajectories[i] = ops.scatter_update(
+                trajectories[i], [[0]], ops.expand_dims(current_points[i], 0)
+            )
+
+        # Track frame by frame
+        for t in range(n_frames - 1):
+            new_points = self.track(frames_t[t], frames_t[t + 1], current_points)
+
+            for i in range(n_points):
+                trajectories[i] = ops.scatter_update(
+                    trajectories[i], [[t + 1]], ops.expand_dims(new_points[i], 0)
+                )
+
+            current_points = new_points
+
+        return trajectories
+
+    def __repr__(self):
+        """String representation of the tracker."""
+        return f"{self.__class__.__name__}(ndim={self.ndim})"