nrl-tracker 0.21.4__py3-none-any.whl → 0.22.0__py3-none-any.whl

pytcl/mathematical_functions/transforms/__init__.py

@@ -7,57 +7,51 @@ This module provides signal transforms for time-frequency analysis:
 - Wavelet transforms (CWT and DWT)
 """
 
-from pytcl.mathematical_functions.transforms.fourier import (
-    CoherenceResult,
-    CrossSpectrum,
-    PowerSpectrum,
-    coherence,
-    cross_spectrum,
-    fft,
-    fft2,
-    fftshift,
-    frequency_axis,
-    ifft,
-    ifft2,
-    ifftshift,
-    irfft,
-    magnitude_spectrum,
-    periodogram,
-    phase_spectrum,
-    power_spectrum,
-    rfft,
-    rfft_frequency_axis,
-)
-from pytcl.mathematical_functions.transforms.stft import (
-    Spectrogram,
-    STFTResult,
-    get_window,
-    istft,
-    mel_spectrogram,
-    reassigned_spectrogram,
-    spectrogram,
-    stft,
-    window_bandwidth,
-)
-from pytcl.mathematical_functions.transforms.wavelets import (
-    PYWT_AVAILABLE,
-    CWTResult,
-    DWTResult,
-    available_wavelets,
-    cwt,
-    dwt,
-    dwt_single_level,
-    frequencies_to_scales,
-    gaussian_wavelet,
-    idwt,
-    idwt_single_level,
-    morlet_wavelet,
-    ricker_wavelet,
-    scales_to_frequencies,
-    threshold_coefficients,
-    wavelet_info,
-    wpt,
-)
+from pytcl.mathematical_functions.transforms.fourier import CoherenceResult
+from pytcl.mathematical_functions.transforms.fourier import CrossSpectrum
+from pytcl.mathematical_functions.transforms.fourier import PowerSpectrum
+from pytcl.mathematical_functions.transforms.fourier import coherence
+from pytcl.mathematical_functions.transforms.fourier import cross_spectrum
+from pytcl.mathematical_functions.transforms.fourier import fft
+from pytcl.mathematical_functions.transforms.fourier import fft2
+from pytcl.mathematical_functions.transforms.fourier import fftshift
+from pytcl.mathematical_functions.transforms.fourier import frequency_axis
+from pytcl.mathematical_functions.transforms.fourier import ifft
+from pytcl.mathematical_functions.transforms.fourier import ifft2
+from pytcl.mathematical_functions.transforms.fourier import ifftshift
+from pytcl.mathematical_functions.transforms.fourier import irfft
+from pytcl.mathematical_functions.transforms.fourier import magnitude_spectrum
+from pytcl.mathematical_functions.transforms.fourier import periodogram
+from pytcl.mathematical_functions.transforms.fourier import phase_spectrum
+from pytcl.mathematical_functions.transforms.fourier import power_spectrum
+from pytcl.mathematical_functions.transforms.fourier import rfft
+from pytcl.mathematical_functions.transforms.fourier import rfft_frequency_axis
+from pytcl.mathematical_functions.transforms.stft import Spectrogram
+from pytcl.mathematical_functions.transforms.stft import STFTResult
+from pytcl.mathematical_functions.transforms.stft import get_window
+from pytcl.mathematical_functions.transforms.stft import istft
+from pytcl.mathematical_functions.transforms.stft import mel_spectrogram
+from pytcl.mathematical_functions.transforms.stft import reassigned_spectrogram
+from pytcl.mathematical_functions.transforms.stft import spectrogram
+from pytcl.mathematical_functions.transforms.stft import stft
+from pytcl.mathematical_functions.transforms.stft import window_bandwidth
+from pytcl.mathematical_functions.transforms.wavelets import PYWT_AVAILABLE
+from pytcl.mathematical_functions.transforms.wavelets import CWTResult
+from pytcl.mathematical_functions.transforms.wavelets import DWTResult
+from pytcl.mathematical_functions.transforms.wavelets import available_wavelets
+from pytcl.mathematical_functions.transforms.wavelets import cwt
+from pytcl.mathematical_functions.transforms.wavelets import dwt
+from pytcl.mathematical_functions.transforms.wavelets import dwt_single_level
+from pytcl.mathematical_functions.transforms.wavelets import frequencies_to_scales
+from pytcl.mathematical_functions.transforms.wavelets import gaussian_wavelet
+from pytcl.mathematical_functions.transforms.wavelets import idwt
+from pytcl.mathematical_functions.transforms.wavelets import idwt_single_level
+from pytcl.mathematical_functions.transforms.wavelets import morlet_wavelet
+from pytcl.mathematical_functions.transforms.wavelets import ricker_wavelet
+from pytcl.mathematical_functions.transforms.wavelets import scales_to_frequencies
+from pytcl.mathematical_functions.transforms.wavelets import threshold_coefficients
+from pytcl.mathematical_functions.transforms.wavelets import wavelet_info
+from pytcl.mathematical_functions.transforms.wavelets import wpt
 
 __all__ = [
     # Fourier transform types

pytcl/mathematical_functions/transforms/fourier.py

@@ -23,10 +23,13 @@ References
        Electroacoustics, 15(2), 70-73.
 """
 
-from typing import NamedTuple, Optional, Union
+from typing import NamedTuple
+from typing import Optional
+from typing import Union
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 from scipy import fft as scipy_fft
 from scipy import signal as scipy_signal
 

pytcl/mathematical_functions/transforms/stft.py

@@ -22,10 +22,13 @@ References
        Speech, and Signal Processing, 32(2), 236-243.
 """
 
-from typing import NamedTuple, Optional, Union
+from typing import NamedTuple
+from typing import Optional
+from typing import Union
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 from scipy import signal as scipy_signal
 
 # =============================================================================
@@ -503,12 +506,8 @@ def reassigned_spectrogram(
     win_d = np.gradient(win)
 
     # STFT with modified windows
-    result_t = stft(
-        x, fs=fs, window=win_t, nperseg=nperseg, noverlap=noverlap, nfft=nfft
-    )
-    result_d = stft(
-        x, fs=fs, window=win_d, nperseg=nperseg, noverlap=noverlap, nfft=nfft
-    )
+    result_t = stft(x, fs=fs, window=win_t, nperseg=nperseg, noverlap=noverlap, nfft=nfft)
+    result_d = stft(x, fs=fs, window=win_d, nperseg=nperseg, noverlap=noverlap, nfft=nfft)
 
     # Compute reassigned coordinates
     Zxx = result1.Zxx
@@ -592,9 +591,7 @@ def mel_spectrogram(
         noverlap = nperseg // 4
 
     # Compute linear spectrogram
-    spec_result = spectrogram(
-        x, fs=fs, window=window, nperseg=nperseg, noverlap=noverlap
-    )
+    spec_result = spectrogram(x, fs=fs, window=window, nperseg=nperseg, noverlap=noverlap)
 
     # Create mel filterbank
     mel_fb = _mel_filterbank(

pytcl/mathematical_functions/transforms/wavelets.py

@@ -20,10 +20,15 @@ References
 .. [2] Daubechies, I. (1992). Ten Lectures on Wavelets. SIAM.
 """
 
-from typing import Callable, List, NamedTuple, Optional, Union
+from typing import Callable
+from typing import List
+from typing import NamedTuple
+from typing import Optional
+from typing import Union
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 # Try to import pywavelets for DWT support
 try:
@@ -526,9 +531,7 @@ def dwt(
     - 'biorN.M': Biorthogonal wavelets
     """
     if not PYWT_AVAILABLE:
-        raise ImportError(
-            "pywavelets is required for DWT. Install with: pip install pywavelets"
-        )
+        raise ImportError("pywavelets is required for DWT. Install with: pip install pywavelets")
 
     signal = np.asarray(signal, dtype=np.float64)
 
@@ -579,9 +582,7 @@ def idwt(
     True
     """
     if not PYWT_AVAILABLE:
-        raise ImportError(
-            "pywavelets is required for IDWT. Install with: pip install pywavelets"
-        )
+        raise ImportError("pywavelets is required for IDWT. Install with: pip install pywavelets")
 
     # Reconstruct coeffs list in pywt format
     # [cA_n, cD_n, cD_n-1, ..., cD_1]
@@ -617,9 +618,7 @@ def dwt_single_level(
         Detail coefficients.
     """
     if not PYWT_AVAILABLE:
-        raise ImportError(
-            "pywavelets is required for DWT. Install with: pip install pywavelets"
-        )
+        raise ImportError("pywavelets is required for DWT. Install with: pip install pywavelets")
 
     signal = np.asarray(signal, dtype=np.float64)
     cA, cD = pywt.dwt(signal, wavelet, mode=mode)
@@ -653,9 +652,7 @@ def idwt_single_level(
         Reconstructed signal.
     """
     if not PYWT_AVAILABLE:
-        raise ImportError(
-            "pywavelets is required for IDWT. Install with: pip install pywavelets"
-        )
+        raise ImportError("pywavelets is required for IDWT. Install with: pip install pywavelets")
 
     cA = np.asarray(cA, dtype=np.float64)
     cD = np.asarray(cD, dtype=np.float64)
@@ -709,9 +706,7 @@ def wpt(
     True
     """
     if not PYWT_AVAILABLE:
-        raise ImportError(
-            "pywavelets is required for WPT. Install with: pip install pywavelets"
-        )
+        raise ImportError("pywavelets is required for WPT. Install with: pip install pywavelets")
 
     signal = np.asarray(signal, dtype=np.float64)
 
@@ -817,9 +812,7 @@ def threshold_coefficients(
         Thresholded coefficients.
     """
     if not PYWT_AVAILABLE:
-        raise ImportError(
-            "pywavelets is required. Install with: pip install pywavelets"
-        )
+        raise ImportError("pywavelets is required. Install with: pip install pywavelets")
 
     # Estimate noise from finest detail coefficients
     if value is None:

pytcl/navigation/__init__.py

@@ -11,110 +11,104 @@ needed in tracking applications, including:
 - Rhumb line navigation
 """
 
-from pytcl.navigation.geodesy import (  # Ellipsoids; Coordinate conversions; Geodetic problems
-    GRS80,
-    SPHERE,
-    WGS84,
-    Ellipsoid,
-    direct_geodetic,
-    ecef_to_enu,
-    ecef_to_geodetic,
-    ecef_to_ned,
-    enu_to_ecef,
-    geodetic_to_ecef,
-    haversine_distance,
-    inverse_geodetic,
-    ned_to_ecef,
+from pytcl.navigation.geodesy import (
+    GRS80,  # Ellipsoids; Coordinate conversions; Geodetic problems
 )
-from pytcl.navigation.great_circle import (  # Great circle navigation
-    EARTH_RADIUS,
-    CrossTrackResult,
-    GreatCircleResult,
-    IntersectionResult,
-    WaypointResult,
-    angular_distance,
-    cross_track_distance,
-    destination_point,
-    great_circle_azimuth,
-    great_circle_direct,
-    great_circle_distance,
-    great_circle_intersect,
-    great_circle_inverse,
-    great_circle_path_intersect,
-    great_circle_tdoa_loc,
-    great_circle_waypoint,
-    great_circle_waypoints,
-)
-from pytcl.navigation.ins import (  # Constants; State representation; Gravity and Earth rate
-    A_EARTH,
-    B_EARTH,
-    E2_EARTH,
-    F_EARTH,
-    GM_EARTH,
-    OMEGA_EARTH,
-    IMUData,
-    INSErrorState,
-    INSState,
-    coarse_alignment,
-    compensate_imu_data,
-    coning_correction,
-    earth_rate_ned,
-    gravity_ned,
-    gyrocompass_alignment,
-    initialize_ins_state,
-    ins_error_state_matrix,
-    ins_process_noise_matrix,
-    mechanize_ins_ned,
-    normal_gravity,
-    radii_of_curvature,
-    sculling_correction,
-    skew_symmetric,
-    transport_rate_ned,
-    update_attitude_ned,
-    update_quaternion,
-)
-from pytcl.navigation.ins_gnss import (  # INS/GNSS integration
-    GPS_L1_FREQ,
-    GPS_L1_WAVELENGTH,
-    SPEED_OF_LIGHT,
-    GNSSMeasurement,
-    INSGNSSState,
-    LooseCoupledResult,
-    SatelliteInfo,
-    TightCoupledResult,
-    compute_dop,
-    compute_line_of_sight,
-    gnss_outage_detection,
-    initialize_ins_gnss,
-    loose_coupled_predict,
-    loose_coupled_update,
-    loose_coupled_update_position,
-    loose_coupled_update_velocity,
-    position_measurement_matrix,
-    position_velocity_measurement_matrix,
-    pseudorange_measurement_matrix,
-    satellite_elevation_azimuth,
-    tight_coupled_measurement_matrix,
-    tight_coupled_pseudorange_innovation,
-    tight_coupled_update,
-    velocity_measurement_matrix,
-)
-from pytcl.navigation.rhumb import (  # Rhumb line navigation
-    RhumbDirectResult,
-    RhumbIntersectionResult,
-    RhumbResult,
-    compare_great_circle_rhumb,
-    direct_rhumb,
-    direct_rhumb_spherical,
-    indirect_rhumb,
-    indirect_rhumb_spherical,
-    rhumb_bearing,
-    rhumb_distance_ellipsoidal,
-    rhumb_distance_spherical,
-    rhumb_intersect,
-    rhumb_midpoint,
-    rhumb_waypoints,
+from pytcl.navigation.geodesy import SPHERE
+from pytcl.navigation.geodesy import WGS84
+from pytcl.navigation.geodesy import Ellipsoid
+from pytcl.navigation.geodesy import direct_geodetic
+from pytcl.navigation.geodesy import ecef_to_enu
+from pytcl.navigation.geodesy import ecef_to_geodetic
+from pytcl.navigation.geodesy import ecef_to_ned
+from pytcl.navigation.geodesy import enu_to_ecef
+from pytcl.navigation.geodesy import geodetic_to_ecef
+from pytcl.navigation.geodesy import haversine_distance
+from pytcl.navigation.geodesy import inverse_geodetic
+from pytcl.navigation.geodesy import ned_to_ecef
+from pytcl.navigation.great_circle import EARTH_RADIUS  # Great circle navigation
+from pytcl.navigation.great_circle import CrossTrackResult
+from pytcl.navigation.great_circle import GreatCircleResult
+from pytcl.navigation.great_circle import IntersectionResult
+from pytcl.navigation.great_circle import WaypointResult
+from pytcl.navigation.great_circle import angular_distance
+from pytcl.navigation.great_circle import cross_track_distance
+from pytcl.navigation.great_circle import destination_point
+from pytcl.navigation.great_circle import great_circle_azimuth
+from pytcl.navigation.great_circle import great_circle_direct
+from pytcl.navigation.great_circle import great_circle_distance
+from pytcl.navigation.great_circle import great_circle_intersect
+from pytcl.navigation.great_circle import great_circle_inverse
+from pytcl.navigation.great_circle import great_circle_path_intersect
+from pytcl.navigation.great_circle import great_circle_tdoa_loc
+from pytcl.navigation.great_circle import great_circle_waypoint
+from pytcl.navigation.great_circle import great_circle_waypoints
+from pytcl.navigation.ins import (
+    A_EARTH,  # Constants; State representation; Gravity and Earth rate
 )
+from pytcl.navigation.ins import B_EARTH
+from pytcl.navigation.ins import E2_EARTH
+from pytcl.navigation.ins import F_EARTH
+from pytcl.navigation.ins import GM_EARTH
+from pytcl.navigation.ins import OMEGA_EARTH
+from pytcl.navigation.ins import IMUData
+from pytcl.navigation.ins import INSErrorState
+from pytcl.navigation.ins import INSState
+from pytcl.navigation.ins import coarse_alignment
+from pytcl.navigation.ins import compensate_imu_data
+from pytcl.navigation.ins import coning_correction
+from pytcl.navigation.ins import earth_rate_ned
+from pytcl.navigation.ins import gravity_ned
+from pytcl.navigation.ins import gyrocompass_alignment
+from pytcl.navigation.ins import initialize_ins_state
+from pytcl.navigation.ins import ins_error_state_matrix
+from pytcl.navigation.ins import ins_process_noise_matrix
+from pytcl.navigation.ins import mechanize_ins_ned
+from pytcl.navigation.ins import normal_gravity
+from pytcl.navigation.ins import radii_of_curvature
+from pytcl.navigation.ins import sculling_correction
+from pytcl.navigation.ins import skew_symmetric
+from pytcl.navigation.ins import transport_rate_ned
+from pytcl.navigation.ins import update_attitude_ned
+from pytcl.navigation.ins import update_quaternion
+from pytcl.navigation.ins_gnss import GPS_L1_FREQ  # INS/GNSS integration
+from pytcl.navigation.ins_gnss import GPS_L1_WAVELENGTH
+from pytcl.navigation.ins_gnss import SPEED_OF_LIGHT
+from pytcl.navigation.ins_gnss import GNSSMeasurement
+from pytcl.navigation.ins_gnss import INSGNSSState
+from pytcl.navigation.ins_gnss import LooseCoupledResult
+from pytcl.navigation.ins_gnss import SatelliteInfo
+from pytcl.navigation.ins_gnss import TightCoupledResult
+from pytcl.navigation.ins_gnss import compute_dop
+from pytcl.navigation.ins_gnss import compute_line_of_sight
+from pytcl.navigation.ins_gnss import gnss_outage_detection
+from pytcl.navigation.ins_gnss import initialize_ins_gnss
+from pytcl.navigation.ins_gnss import loose_coupled_predict
+from pytcl.navigation.ins_gnss import loose_coupled_update
+from pytcl.navigation.ins_gnss import loose_coupled_update_position
+from pytcl.navigation.ins_gnss import loose_coupled_update_velocity
+from pytcl.navigation.ins_gnss import position_measurement_matrix
+from pytcl.navigation.ins_gnss import position_velocity_measurement_matrix
+from pytcl.navigation.ins_gnss import pseudorange_measurement_matrix
+from pytcl.navigation.ins_gnss import satellite_elevation_azimuth
+from pytcl.navigation.ins_gnss import tight_coupled_measurement_matrix
+from pytcl.navigation.ins_gnss import tight_coupled_pseudorange_innovation
+from pytcl.navigation.ins_gnss import tight_coupled_update
+from pytcl.navigation.ins_gnss import velocity_measurement_matrix
+from pytcl.navigation.rhumb import RhumbDirectResult  # Rhumb line navigation
+from pytcl.navigation.rhumb import RhumbIntersectionResult
+from pytcl.navigation.rhumb import RhumbResult
+from pytcl.navigation.rhumb import compare_great_circle_rhumb
+from pytcl.navigation.rhumb import direct_rhumb
+from pytcl.navigation.rhumb import direct_rhumb_spherical
+from pytcl.navigation.rhumb import indirect_rhumb
+from pytcl.navigation.rhumb import indirect_rhumb_spherical
+from pytcl.navigation.rhumb import rhumb_bearing
+from pytcl.navigation.rhumb import rhumb_distance_ellipsoidal
+from pytcl.navigation.rhumb import rhumb_distance_spherical
+from pytcl.navigation.rhumb import rhumb_intersect
+from pytcl.navigation.rhumb import rhumb_midpoint
+from pytcl.navigation.rhumb import rhumb_waypoints
 
 __all__ = [
     # Ellipsoids

pytcl/navigation/geodesy.py

@@ -8,10 +8,12 @@ This module provides geodetic utilities including:
 - Earth ellipsoid parameters
 """
 
-from typing import NamedTuple, Tuple
+from typing import NamedTuple
+from typing import Tuple
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 class Ellipsoid(NamedTuple):
@@ -356,9 +358,7 @@ def ned_to_ecef(
     x, y, z : ndarray
         ECEF coordinates in meters.
     """
-    return enu_to_ecef(
-        east, north, -np.asarray(down), lat_ref, lon_ref, alt_ref, ellipsoid
-    )
+    return enu_to_ecef(east, north, -np.asarray(down), lat_ref, lon_ref, alt_ref, ellipsoid)
 
 
 def direct_geodetic(
@@ -436,11 +436,7 @@ def direct_geodetic(
                 / 4
                 * (
                     cos_sigma * (-1 + 2 * cos_2sigma_m**2)
-                    - B
-                    / 6
-                    * cos_2sigma_m
-                    * (-3 + 4 * sin_sigma**2)
-                    * (-3 + 4 * cos_2sigma_m**2)
+                    - B / 6 * cos_2sigma_m * (-3 + 4 * sin_sigma**2) * (-3 + 4 * cos_2sigma_m**2)
                 )
             )
         )
@@ -458,27 +454,20 @@ def direct_geodetic(
     lat2 = np.arctan2(
         sin_U2,
         (1 - f)
-        * np.sqrt(
-            sin_alpha**2 + (sin_U1 * sin_sigma - cos_U1 * cos_sigma * cos_alpha1) ** 2
-        ),
+        * np.sqrt(sin_alpha**2 + (sin_U1 * sin_sigma - cos_U1 * cos_sigma * cos_alpha1) ** 2),
     )
 
-    lam = np.arctan2(
-        sin_sigma * sin_alpha1, cos_U1 * cos_sigma - sin_U1 * sin_sigma * cos_alpha1
-    )
+    lam = np.arctan2(sin_sigma * sin_alpha1, cos_U1 * cos_sigma - sin_U1 * sin_sigma * cos_alpha1)
 
     C = f / 16 * cos2_alpha * (4 + f * (4 - 3 * cos2_alpha))
     L = lam - (1 - C) * f * sin_alpha * (
-        sigma
-        + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
+        sigma + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
     )
 
     lon2 = lon1 + L
 
     # Back azimuth
-    azimuth2 = np.arctan2(
-        sin_alpha, -sin_U1 * sin_sigma + cos_U1 * cos_sigma * cos_alpha1
-    )
+    azimuth2 = np.arctan2(sin_alpha, -sin_U1 * sin_sigma + cos_U1 * cos_sigma * cos_alpha1)
 
     return float(lat2), float(lon2), float(azimuth2)
 
@@ -565,10 +554,7 @@ def inverse_geodetic(
         C = f / 16 * cos2_alpha * (4 + f * (4 - 3 * cos2_alpha))
 
         lam_new = L + (1 - C) * f * sin_alpha * (
-            sigma
-            + C
-            * sin_sigma
-            * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
+            sigma + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-1 + 2 * cos_2sigma_m**2))
         )
 
         if abs(lam_new - lam) < 1e-12:
@@ -588,11 +574,7 @@ def inverse_geodetic(
             / 4
             * (
                 cos_sigma * (-1 + 2 * cos_2sigma_m**2)
-                - B
-                / 6
-                * cos_2sigma_m
-                * (-3 + 4 * sin_sigma**2)
-                * (-3 + 4 * cos_2sigma_m**2)
+                - B / 6 * cos_2sigma_m * (-3 + 4 * sin_sigma**2) * (-3 + 4 * cos_2sigma_m**2)
             )
         )
     )
@@ -601,9 +583,7 @@ def inverse_geodetic(
 
     # Azimuths
     azimuth1 = np.arctan2(cos_U2 * sin_lam, cos_U1 * sin_U2 - sin_U1 * cos_U2 * cos_lam)
-    azimuth2 = np.arctan2(
-        cos_U1 * sin_lam, -sin_U1 * cos_U2 + cos_U1 * sin_U2 * cos_lam
-    )
+    azimuth2 = np.arctan2(cos_U1 * sin_lam, -sin_U1 * cos_U2 + cos_U1 * sin_U2 * cos_lam)
 
     return float(distance), float(azimuth1), float(azimuth2)
 

pytcl/navigation/great_circle.py

@@ -10,7 +10,9 @@ computing the shortest path on a sphere, including:
 - TDOA localization on a sphere
 """
 
-from typing import NamedTuple, Optional, Tuple
+from typing import NamedTuple
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -344,9 +346,7 @@ def great_circle_direct(
     """
     d = distance / radius  # Angular distance
 
-    lat2 = np.arcsin(
-        np.sin(lat1) * np.cos(d) + np.cos(lat1) * np.sin(d) * np.cos(azimuth)
-    )
+    lat2 = np.arcsin(np.sin(lat1) * np.cos(d) + np.cos(lat1) * np.sin(d) * np.cos(azimuth))
 
     lon2 = lon1 + np.arctan2(
         np.sin(azimuth) * np.sin(d) * np.cos(lat1),
@@ -408,9 +408,7 @@ def cross_track_distance(
     # Along-track distance
     dat = np.arccos(np.cos(d13) / np.cos(dxt))
 
-    return CrossTrackResult(
-        cross_track=float(dxt * radius), along_track=float(dat * radius)
-    )
+    return CrossTrackResult(cross_track=float(dxt * radius), along_track=float(dat * radius))
 
 
 def great_circle_intersect(
@@ -452,9 +450,7 @@ def great_circle_intersect(
 
     # Convert to Cartesian unit vectors
     def to_cartesian(lat, lon):
-        return np.array(
-            [np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)]
-        )
+        return np.array([np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)])
 
     # Normal vectors to the great circles
     p1 = to_cartesian(lat1, lon1)
@@ -508,9 +504,7 @@ def great_circle_intersect(
     lat_i2 = -lat_i1
     lon_i2 = ((lon_i1 + np.pi) % (2 * np.pi)) - np.pi
 
-    return IntersectionResult(
-        float(lat_i1), float(lon_i1), float(lat_i2), float(lon_i2), True
-    )
+    return IntersectionResult(float(lat_i1), float(lon_i1), float(lat_i2), float(lon_i2), True)
 
 
 def great_circle_path_intersect(

pytcl/navigation/ins.py

@@ -18,17 +18,19 @@ References
 .. [3] J. Farrell, "Aided Navigation: GPS with High Rate Sensors", McGraw-Hill, 2008.
 """
 
-from typing import NamedTuple, Optional, Tuple
+from typing import NamedTuple
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
-from pytcl.coordinate_systems.rotations import (
-    quat2rotmat,
-    quat_multiply,
-    rotmat2quat,
-)
-from pytcl.navigation.geodesy import WGS84, Ellipsoid
+from pytcl.coordinate_systems.rotations import quat2rotmat
+from pytcl.coordinate_systems.rotations import quat_multiply
+from pytcl.coordinate_systems.rotations import rotmat2quat
+from pytcl.navigation.geodesy import WGS84
+from pytcl.navigation.geodesy import Ellipsoid
 
 # =============================================================================
 # Physical Constants
@@ -248,11 +250,7 @@ def normal_gravity(lat: float, alt: float = 0.0) -> float:
 
     # Free-air correction (first-order)
     g = g0 * (
-        1
-        - 2
-        * alt
-        / A_EARTH
-        * (1 + F_EARTH + (OMEGA_EARTH**2 * A_EARTH**2 * B_EARTH) / GM_EARTH)
+        1 - 2 * alt / A_EARTH * (1 + F_EARTH + (OMEGA_EARTH**2 * A_EARTH**2 * B_EARTH) / GM_EARTH)
     )
 
     return g
@@ -576,9 +574,7 @@ def update_quaternion(
 
     if angle < 1e-10:
         # Small angle approximation
-        delta_q = np.array(
-            [1.0, 0.5 * delta_theta[0], 0.5 * delta_theta[1], 0.5 * delta_theta[2]]
-        )
+        delta_q = np.array([1.0, 0.5 * delta_theta[0], 0.5 * delta_theta[1], 0.5 * delta_theta[2]])
     else:
         # Exact quaternion for rotation
         axis = delta_theta / angle