nrl-tracker 1.6.0__py3-none-any.whl → 1.7.1__py3-none-any.whl

pytcl/mathematical_functions/transforms/stft.py

@@ -22,7 +22,7 @@ References
        Speech, and Signal Processing, 32(2), 236-243.
 """
 
-from typing import NamedTuple, Optional, Union
+from typing import Any, NamedTuple, Optional, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -77,7 +77,7 @@ class Spectrogram(NamedTuple):
 
 
 def get_window(
-    window: Union[str, tuple, ArrayLike],
+    window: Union[str, tuple[str, Any], ArrayLike],
     length: int,
     fftbins: bool = True,
 ) -> NDArray[np.floating]:
@@ -174,7 +174,7 @@ def window_bandwidth(
 def stft(
     x: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: int = 256,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
@@ -264,13 +264,13 @@ def stft(
 def istft(
     Zxx: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: Optional[int] = None,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
     input_onesided: bool = True,
     boundary: bool = True,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute the inverse Short-Time Fourier Transform.
 
@@ -351,7 +351,7 @@ def istft(
 def spectrogram(
     x: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: int = 256,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
@@ -436,11 +436,11 @@ def spectrogram(
 def reassigned_spectrogram(
     x: ArrayLike,
     fs: float = 1.0,
-    window: Union[str, tuple, ArrayLike] = "hann",
+    window: Union[str, tuple[str, Any], ArrayLike] = "hann",
     nperseg: int = 256,
     noverlap: Optional[int] = None,
     nfft: Optional[int] = None,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute reassigned spectrogram for improved time-frequency resolution.
 
@@ -538,7 +538,7 @@ def mel_spectrogram(
     window: str = "hann",
     nperseg: int = 2048,
     noverlap: Optional[int] = None,
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute mel-scaled spectrogram.
 
@@ -611,15 +611,15 @@ def mel_spectrogram(
     # Mel frequency centers
     mel_freqs = _mel_frequencies(n_mels, fmin, fmax)
 
-    return mel_freqs, spec_result.times, mel_spec
+    return (mel_freqs, spec_result.times, mel_spec)
 
 
-def _hz_to_mel(hz: Union[float, ArrayLike]) -> Union[float, NDArray]:
+def _hz_to_mel(hz: Union[float, ArrayLike]) -> Union[float, NDArray[np.floating]]:
     """Convert frequency in Hz to mel scale."""
     return 2595.0 * np.log10(1.0 + np.asarray(hz) / 700.0)
 
 
-def _mel_to_hz(mel: Union[float, ArrayLike]) -> Union[float, NDArray]:
+def _mel_to_hz(mel: Union[float, ArrayLike]) -> Union[float, NDArray[np.floating]]:
     """Convert mel scale to frequency in Hz."""
     return 700.0 * (10.0 ** (np.asarray(mel) / 2595.0) - 1.0)
 

pytcl/mathematical_functions/transforms/wavelets.py

@@ -20,7 +20,7 @@ References
 .. [2] Daubechies, I. (1992). Ten Lectures on Wavelets. SIAM.
 """
 
-from typing import Callable, List, NamedTuple, Optional, Union
+from typing import Any, Callable, List, NamedTuple, Optional, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -262,7 +262,7 @@ def gaussian_wavelet(
 def cwt(
     signal: ArrayLike,
     scales: ArrayLike,
-    wavelet: Union[str, Callable[[int], NDArray]] = "morlet",
+    wavelet: Union[str, Callable[[int], NDArray[np.floating]]] = "morlet",
     fs: float = 1.0,
     method: str = "fft",
 ) -> CWTResult:
@@ -312,16 +312,16 @@ def cwt(
     n = len(signal)
 
     # Determine wavelet function
-    def _morlet_default(M: int) -> NDArray:
+    def _morlet_default(M: int) -> NDArray[np.floating]:
         return morlet_wavelet(M, w=5.0)
 
-    def _ricker_default(M: int) -> NDArray:
+    def _ricker_default(M: int) -> NDArray[np.floating]:
         return ricker_wavelet(M, a=1.0)
 
-    def _gaussian1_default(M: int) -> NDArray:
+    def _gaussian1_default(M: int) -> NDArray[np.floating]:
         return gaussian_wavelet(M, order=1)
 
-    def _gaussian2_default(M: int) -> NDArray:
+    def _gaussian2_default(M: int) -> NDArray[np.floating]:
         return gaussian_wavelet(M, order=2)
 
     if callable(wavelet):
@@ -596,7 +596,7 @@ def dwt_single_level(
     signal: ArrayLike,
     wavelet: str = "db4",
     mode: str = "symmetric",
-) -> tuple:
+) -> tuple[NDArray[np.floating], NDArray[np.floating]]:
     """
     Compute single-level DWT decomposition.
 
@@ -673,7 +673,7 @@ def wpt(
     wavelet: str = "db4",
     level: Optional[int] = None,
     mode: str = "symmetric",
-) -> dict:
+) -> dict[str, NDArray[np.floating]]:
     """
     Compute the Wavelet Packet Transform.
 
@@ -748,7 +748,7 @@ def available_wavelets() -> List[str]:
     return pywt.wavelist()
 
 
-def wavelet_info(wavelet: str) -> dict:
+def wavelet_info(wavelet: str) -> dict[str, Any]:
     """
     Get information about a wavelet.
 

pytcl/navigation/geodesy.py

@@ -10,7 +10,7 @@ This module provides geodetic utilities including:
 
 import logging
 from functools import lru_cache
-from typing import NamedTuple, Tuple
+from typing import Any, NamedTuple, Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -715,12 +715,12 @@ def clear_geodesy_cache() -> None:
     _logger.debug("Geodesy caches cleared")
 
 
-def get_geodesy_cache_info() -> dict:
+def get_geodesy_cache_info() -> dict[str, Any]:
     """Get cache statistics for geodesy computations.
 
     Returns
     -------
-    dict
+    dict[str, Any]
         Dictionary with cache statistics for inverse and direct geodetic caches.
     """
     return {

pytcl/navigation/great_circle.py

@@ -12,7 +12,7 @@ computing the shortest path on a sphere, including:
 
 import logging
 from functools import lru_cache
-from typing import NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -505,7 +505,7 @@ def great_circle_intersect(
     """
 
     # Convert to Cartesian unit vectors
-    def to_cartesian(lat, lon):
+    def to_cartesian(lat: Any, lon: Any) -> NDArray[np.float64]:
         return np.array(
             [np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)]
         )
@@ -661,7 +661,7 @@ def great_circle_tdoa_loc(
     delta_d12 = delta_r12 / radius
     delta_d13 = delta_r13 / radius
 
-    def objective(lat, lon):
+    def objective(lat: Any, lon: Any) -> Any:
         """Objective function: difference between computed and observed TDOAs."""
         d1 = great_circle_distance(lat, lon, lat1, lon1, radius=1.0)
         d2 = great_circle_distance(lat, lon, lat2, lon2, radius=1.0)
@@ -836,12 +836,12 @@ def clear_great_circle_cache() -> None:
     _logger.debug("Great circle caches cleared")
 
 
-def get_cache_info() -> dict:
+def get_cache_info() -> dict[str, Any]:
     """Get cache statistics for great circle computations.
 
     Returns
     -------
-    dict
+    dict[str, Any]
         Dictionary with cache statistics for distance and azimuth caches.
     """
     return {

pytcl/plotting/coordinates.py

@@ -5,10 +5,10 @@ This module provides functions for visualizing coordinate systems,
 rotations, and transformations in 2D and 3D.
 """
 
-from typing import List, Optional, Tuple
+from typing import Any, List, Optional, Tuple
 
 import numpy as np
-from numpy.typing import ArrayLike
+from numpy.typing import ArrayLike, NDArray
 
 try:
     import plotly.graph_objects as go
@@ -180,17 +180,17 @@ def plot_euler_angles(
     angles = np.asarray(angles)
 
     # Create rotation matrices for each axis
-    def rotx(a):
+    def rotx(a: Any) -> NDArray[np.float64]:
         return np.array(
             [[1, 0, 0], [0, np.cos(a), -np.sin(a)], [0, np.sin(a), np.cos(a)]]
         )
 
-    def roty(a):
+    def roty(a: Any) -> NDArray[np.float64]:
         return np.array(
             [[np.cos(a), 0, np.sin(a)], [0, 1, 0], [-np.sin(a), 0, np.cos(a)]]
         )
 
-    def rotz(a):
+    def rotz(a: Any) -> NDArray[np.float64]:
         return np.array(
             [[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]]
         )
@@ -293,7 +293,7 @@ def plot_quaternion_interpolation(
     q_end = q_end / np.linalg.norm(q_end)
 
     # SLERP interpolation
-    def quat_slerp(q1, q2, t):
+    def quat_slerp(q1: Any, q2: Any, t: Any) -> NDArray[np.float64]:
         dot = np.dot(q1, q2)
         if dot < 0:
             q2 = -q2
@@ -303,7 +303,7 @@ def plot_quaternion_interpolation(
         theta = np.arccos(dot)
         return (np.sin((1 - t) * theta) * q1 + np.sin(t * theta) * q2) / np.sin(theta)
 
-    def quat_to_rotmat(q):
+    def quat_to_rotmat(q: Any) -> NDArray[np.float64]:
         w, x, y, z = q
         return np.array(
             [

pytcl/plotting/tracks.py

@@ -196,7 +196,7 @@ def plot_tracking_result(
     covariances: Optional[List[ArrayLike]] = None,
     x_idx: int = 0,
     y_idx: int = 2,
-    cov_xy_idx: tuple = (0, 2),
+    cov_xy_idx: tuple[int, int] = (0, 2),
     ellipse_interval: int = 5,
     n_std: float = 2.0,
     title: str = "Tracking Result",
@@ -596,7 +596,7 @@ def create_animated_tracking(
     covariances: Optional[List[ArrayLike]] = None,
     x_idx: int = 0,
     y_idx: int = 2,
-    cov_xy_idx: tuple = (0, 2),
+    cov_xy_idx: tuple[int, int] = (0, 2),
     n_std: float = 2.0,
     frame_duration: int = 100,
     title: str = "Animated Tracking",

pytcl/static_estimation/maximum_likelihood.py

@@ -12,7 +12,7 @@ References
        Wiley, 2001.
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Any, Callable, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -75,10 +75,10 @@ class CRBResult(NamedTuple):
 
 
 def fisher_information_numerical(
-    log_likelihood: Callable[[NDArray], float],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
     theta: ArrayLike,
     h: float = 1e-5,
-) -> NDArray[np.floating]:
+) -> np.ndarray[Any, Any]:
     """
     Compute Fisher information matrix numerically.
 
@@ -189,11 +189,13 @@ def fisher_information_gaussian(
 
 
 def fisher_information_exponential_family(
-    sufficient_stats: Callable[[NDArray, NDArray], NDArray],
+    sufficient_stats: Callable[
+        [np.ndarray[Any, Any], np.ndarray[Any, Any]], np.ndarray[Any, Any]
+    ],
     theta: ArrayLike,
     data: ArrayLike,
     h: float = 1e-5,
-) -> NDArray[np.floating]:
+) -> np.ndarray[Any, Any]:
     """
     Fisher information for exponential family distributions.
 
@@ -232,10 +234,10 @@ def fisher_information_exponential_family(
 
 
 def observed_fisher_information(
-    log_likelihood: Callable[[NDArray], float],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
     theta: ArrayLike,
     h: float = 1e-5,
-) -> NDArray[np.floating]:
+) -> np.ndarray[Any, Any]:
     """
     Compute observed Fisher information (negative Hessian).
 
@@ -409,10 +411,10 @@ def efficiency(
 
 
 def mle_newton_raphson(
-    log_likelihood: Callable[[NDArray], float],
-    score: Callable[[NDArray], NDArray],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
+    score: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
     theta_init: ArrayLike,
-    hessian: Optional[Callable[[NDArray], NDArray]] = None,
+    hessian: Optional[Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]]] = None,
     max_iter: int = 100,
     tol: float = 1e-8,
     h: float = 1e-5,
@@ -460,7 +462,7 @@ def mle_newton_raphson(
 
     converged = False
 
-    def numerical_hessian(t: NDArray) -> NDArray:
+    def numerical_hessian(t: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
         H = np.zeros((n_params, n_params))
         for i in range(n_params):
             for j in range(i, n_params):
@@ -532,9 +534,9 @@ def mle_newton_raphson(
 
 
 def mle_scoring(
-    log_likelihood: Callable[[NDArray], float],
-    score: Callable[[NDArray], NDArray],
-    fisher_info: Callable[[NDArray], NDArray],
+    log_likelihood: Callable[[np.ndarray[Any, Any]], float],
+    score: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
+    fisher_info: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]],
     theta_init: ArrayLike,
     max_iter: int = 100,
     tol: float = 1e-8,

pytcl/static_estimation/robust.py

@@ -12,7 +12,7 @@ References
        Cartography," Communications of the ACM, 1981.
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Any, Callable, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -313,8 +313,8 @@ def tau_scale(
 def irls(
     A: ArrayLike,
     b: ArrayLike,
-    weight_func: Callable[[NDArray], NDArray] = huber_weight,
-    scale_func: Callable[[NDArray], float] = mad,
+    weight_func: Callable[[np.ndarray[Any, Any]], np.ndarray[Any, Any]] = huber_weight,
+    scale_func: Callable[[np.ndarray[Any, Any]], float] = mad,
     max_iter: int = 50,
     tol: float = 1e-6,
 ) -> RobustResult:
@@ -455,7 +455,7 @@ def huber_regression(
     Gaussian errors and resistance to outliers.
     """
 
-    def weight_func(r: NDArray) -> NDArray:
+    def weight_func(r: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
         return huber_weight(r, c)
 
     return irls(A, b, weight_func=weight_func, max_iter=max_iter, tol=tol)
@@ -504,7 +504,7 @@ def tukey_regression(
     Huber for gross outliers.
     """
 
-    def weight_func(r: NDArray) -> NDArray:
+    def weight_func(r: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
         return tukey_weight(r, c)
 
     return irls(A, b, weight_func=weight_func, max_iter=max_iter, tol=tol)

pytcl/terrain/loaders.py

@@ -21,7 +21,7 @@ References
 import os
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import NDArray
@@ -31,7 +31,7 @@ from .dem import DEMGrid
 # Model parameters
 _GEBCO_BASE_URL = "https://www.gebco.net/data-products/gridded-bathymetry-data"
 
-GEBCO_PARAMETERS: Dict[str, Dict] = {
+GEBCO_PARAMETERS: dict[str, dict[str, Any]] = {
     "GEBCO2024": {
         "resolution_arcsec": 15.0,
         "n_lat": 43200,
@@ -58,7 +58,7 @@ GEBCO_PARAMETERS: Dict[str, Dict] = {
     },
 }
 
-EARTH2014_PARAMETERS: Dict[str, Dict] = {
+EARTH2014_PARAMETERS: dict[str, dict[str, Any]] = {
     "SUR": {
         "description": "Physical surface (topography, ice surface, 0 over oceans)",
         "file_pattern": "Earth2014.SUR2014.1min.geod.bin",
@@ -275,7 +275,7 @@ def parse_gebco_netcdf(
     lat_max: Optional[float] = None,
     lon_min: Optional[float] = None,
     lon_max: Optional[float] = None,
-) -> Tuple[NDArray, float, float, float, float]:
+) -> tuple[NDArray[np.floating], float, float, float, float]:
     """Parse GEBCO NetCDF file and extract region.
 
     Parameters
@@ -369,7 +369,7 @@ def parse_earth2014_binary(
     lat_max: Optional[float] = None,
     lon_min: Optional[float] = None,
     lon_max: Optional[float] = None,
-) -> Tuple[NDArray, float, float, float, float]:
+) -> tuple[NDArray[np.floating], float, float, float, float]:
     """Parse Earth2014 binary file and extract region.
 
     Earth2014 files are stored as int16 big-endian binary data,

pytcl/trackers/hypothesis.py

@@ -155,7 +155,7 @@ def generate_joint_associations(
         track_idx: int,
         current: Dict[int, int],
         used_meas: Set[int],
-    ):
+    ) -> None:
         """Recursively enumerate associations."""
         if track_idx == n_tracks:
             associations.append(current.copy())

pytcl/trackers/mht.py

@@ -15,7 +15,7 @@ References
        IEEE Trans. Automatic Control, 1979.
 """
 
-from typing import Callable, Dict, List, NamedTuple, Optional, Set
+from typing import Callable, Dict, List, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -322,8 +322,8 @@ class MHTTracker:
     def _predict_tracks(
         self,
         tracks: Dict[int, MHTTrack],
-        F: NDArray,
-        Q: NDArray,
+        F: NDArray[np.floating],
+        Q: NDArray[np.floating],
     ) -> Dict[int, MHTTrack]:
         """Predict all tracks forward in time."""
         predicted = {}
@@ -352,8 +352,8 @@ class MHTTracker:
     def _compute_gating_and_likelihoods(
         self,
         tracks: Dict[int, MHTTrack],
-        Z: NDArray,
-    ) -> tuple[Set[tuple], Dict[tuple, float]]:
+        Z: NDArray[np.floating],
+    ) -> tuple[set[tuple[int, int]], dict[tuple[int, int], float]]:
         """Compute gating matrix and likelihood values."""
         gated = set()
         likelihood_matrix = {}
@@ -387,8 +387,8 @@ class MHTTracker:
         self,
         association: Dict[int, int],
         tracks: Dict[int, MHTTrack],
-        Z: NDArray,
-        likelihood_matrix: Dict[tuple, float],
+        Z: NDArray[np.floating],
+        likelihood_matrix: dict[tuple[int, int], float],
     ) -> float:
         """Compute likelihood of a joint association."""
         likelihood = 1.0
@@ -417,7 +417,7 @@ class MHTTracker:
     def _update_track(
         self,
         track: MHTTrack,
-        measurement: NDArray,
+        measurement: NDArray[np.floating],
         meas_idx: int,
     ) -> MHTTrack:
         """Update a track with a measurement."""
@@ -502,7 +502,7 @@ class MHTTracker:
 
     def _initiate_track(
         self,
-        measurement: NDArray,
+        measurement: NDArray[np.floating],
         meas_idx: int,
     ) -> MHTTrack:
         """Initiate a new track from a measurement."""

pytcl/trackers/multi_target.py

@@ -225,7 +225,7 @@ class MultiTargetTracker:
                 track.covariance = F @ track.covariance @ F.T + Q
                 track.time = self._time
 
-    def _associate(self, Z: NDArray[np.float64]) -> dict:
+    def _associate(self, Z: NDArray[np.float64]) -> dict[int, int]:
         """
         Associate measurements to tracks using GNN.