fix ruff

Author: JosephBrunet

pyproject.toml

@@ -112,6 +112,7 @@ testpaths = [
 ]
 
 [tool.ruff]
+target-version = "py312"
 fix = true
 force-exclude = true
 lint.select = ["F", "I", "UP"]

src/cardiotensor/orientation/orientation_computation_pipeline.py

@@ -166,12 +166,8 @@ def compute_orientation(
 
     if angle_mode.lower() == "ha_ia":
         angle_names = ("HA", "IA")
-        angle_titles = ("Helix Angle", "Intrusion Angle")
-        angle_ranges = ((-90, 90), (-90, 90))
     elif angle_mode.lower() == "az_el":
         angle_names = ("AZ", "EL")
-        angle_titles = ("Azimuth", "Elevation")
-        angle_ranges = ((-180, 180), (-90, 90))
     else:
         raise ValueError("ANGLE_MODE must be 'ha_ia' or 'az_el'")
 

src/cardiotensor/scripts/analysis_streamlines.py

@@ -17,7 +17,6 @@
 
 import argparse
 from pathlib import Path
-from typing import Union
 
 import matplotlib as mpl
 import matplotlib.pyplot as plt
@@ -89,7 +88,7 @@ def load_streamlines(path: Path, key: str | None = None) -> list[np.ndarray]:
     return [sl for sl in streamlines if sl.ndim == 2 and sl.shape[1] == 3]
 
 
-VoxelSize = Union[float, tuple[float, float, float]]
+VoxelSize = float | tuple[float, float, float]
 
 
 def _scale_phys(P: np.ndarray, voxel_size: VoxelSize) -> np.ndarray:

src/cardiotensor/tractography/generate_streamlines.py

@@ -101,153 +101,6 @@ def trilinear_interpolate_scalar(
     return float(c)
 
 
-def trace_streamline(
-    start_pt: tuple[float, float, float],
-    vector_field: np.ndarray,
-    fa_volume: np.ndarray | None = None,
-    fa_threshold: float = 0.1,
-    step_length: float = 0.5,
-    max_steps: int | None = 1000,
-    angle_threshold: float = 60.0,
-    eps: float = 1e-10,
-    direction: int = 1,
-) -> list[tuple[float, float, float]]:
-    """
-    Trace one streamline from `start_pt` (z,y,x) in the continuous vector_field.
-    - Interpolate & normalize each sub‐step
-    - Move forward by `step_length` voxels each step using RK4
-    - `direction` = +1 (default) or -1 to reverse integration direction
-    """
-    Z, Y, X = vector_field.shape[1:]
-    coords: list[tuple[float, float, float]] = [
-        (float(start_pt[0]), float(start_pt[1]), float(start_pt[2]))
-    ]
-    current_pt = np.array(start_pt, dtype=np.float64)
-    prev_dir: np.ndarray | None = None  # previous unit vector
-
-    def interp_unit(pt: np.ndarray) -> np.ndarray | None:
-        """Return a normalized direction vector at fractional pt, or None if invalid."""
-        vec = trilinear_interpolate_vector(vector_field, (pt[0], pt[1], pt[2]))
-        if np.isnan(vec).any():
-            return None
-        norm = np.linalg.norm(vec)
-        if norm < eps:
-            return None
-        return np.array([vec[2], vec[1], vec[0]]) / norm * direction  # flip to (z,y,x)
-
-    step_count = 0
-    while max_steps is None or step_count < max_steps:
-        step_count += 1
-
-        if fa_volume is not None:
-            fa_value = trilinear_interpolate_scalar(fa_volume, tuple(current_pt))
-            if fa_value < fa_threshold:
-                break
-
-        k1 = interp_unit(current_pt)
-        if k1 is None:
-            break
-        if prev_dir is not None:
-            angle = np.degrees(np.arccos(np.clip(np.dot(prev_dir, k1), -1.0, 1.0)))
-            if angle > angle_threshold:
-                break
-
-        mid1 = current_pt + 0.5 * step_length * k1
-        k2 = interp_unit(mid1)
-        if k2 is None:
-            break
-
-        mid2 = current_pt + 0.5 * step_length * k2
-        k3 = interp_unit(mid2)
-        if k3 is None:
-            break
-
-        end_pt = current_pt + step_length * k3
-        k4 = interp_unit(end_pt)
-        if k4 is None:
-            break
-
-        angle4 = np.degrees(np.arccos(np.clip(np.dot(k1, k4), -1.0, 1.0)))
-        if angle4 > angle_threshold:
-            break
-
-        increment = (step_length / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4)
-        next_pt = current_pt + increment
-        next_dir = k1
-
-        zn, yn, xn = next_pt
-        if not (0 <= zn < Z and 0 <= yn < Y and 0 <= xn < X):
-            break
-
-        coords.append((float(zn), float(yn), float(xn)))
-        current_pt = next_pt
-        prev_dir = next_dir
-
-    return coords
-
-
-def generate_streamlines_from_vector_field(
-    vector_field: np.ndarray,
-    seed_points: np.ndarray,
-    fa_volume: np.ndarray | None = None,
-    fa_threshold: float = 0.1,
-    step_length: float = 0.5,
-    max_steps: int | None = None,
-    angle_threshold: float = 60.0,
-    min_length_pts: int = 10,
-    bidirectional: bool = True,
-) -> list[list[tuple[float, float, float]]]:
-    """
-    Given a 3D vector_field (shape = (3, Z, Y, X)) and a set of integer‐seed voxels,
-    returns a list of streamlines (each streamline = a list of float (z,y,x) points),
-    filtered so that only those longer than `min_length_pts` are kept.
-    Optionally trace in both directions from each seed point.
-    """
-    all_streamlines: list[list[tuple[float, float, float]]] = []
-    total_seeds = len(seed_points)
-
-    with alive_bar(total_seeds, title="Tracing Streamlines") as bar:
-        for zi, yi, xi in seed_points:
-            start = (float(zi), float(yi), float(xi))
-
-            # Forward tracing
-            forward_pts = trace_streamline(
-                start_pt=start,
-                vector_field=vector_field,
-                fa_volume=fa_volume,
-                fa_threshold=fa_threshold,
-                step_length=step_length,
-                max_steps=max_steps,
-                angle_threshold=angle_threshold,
-                direction=1,
-            )
-
-            # Backward tracing if enabled
-            if bidirectional:
-                backward_pts = trace_streamline(
-                    start_pt=start,
-                    vector_field=vector_field,
-                    fa_volume=fa_volume,
-                    fa_threshold=fa_threshold,
-                    step_length=step_length,
-                    max_steps=max_steps,
-                    angle_threshold=angle_threshold,
-                    direction=-1,
-                )
-                # Remove duplicate seed point and reverse
-                backward_pts = backward_pts[::-1][:-1] if len(backward_pts) > 1 else []
-                full_streamline = backward_pts + forward_pts
-            else:
-                full_streamline = forward_pts
-
-            if len(full_streamline) >= min_length_pts:
-                all_streamlines.append(full_streamline)
-
-            bar()
-
-    return all_streamlines
-
-
 def save_trk_dipy_from_vox_zyx(
     streamlines_zyx: list[list[tuple[float, float, float]]],
     out_path: str | Path,
@@ -295,8 +148,6 @@ def save_trk_dipy_from_vox_zyx(
 
 
 # ---------- tracing ----------
-
-
 def trace_streamline(
     start_pt: tuple[float, float, float],
     vector_field: np.ndarray,