nrl-tracker 0.22.2__py3-none-any.whl → 0.22.4__py3-none-any.whl

pytcl/plotting/metrics.py

@@ -148,7 +148,9 @@ def plot_nees_sequence(
     fig.add_trace(
         go.Scatter(
             x=np.concatenate([time, time[::-1]]),
-            y=np.concatenate([np.full(n_steps, upper_bound), np.full(n_steps, lower_bound)]),
+            y=np.concatenate(
+                [np.full(n_steps, upper_bound), np.full(n_steps, lower_bound)]
+            ),
             fill="toself",
             fillcolor="rgba(0, 255, 0, 0.1)",
             line=dict(color="rgba(0,0,0,0)"),
@@ -532,7 +534,9 @@ def plot_consistency_summary(
     fig.add_trace(
         go.Scatter(
             x=np.concatenate([time, time[::-1]]),
-            y=np.concatenate([np.full(n_steps, nees_upper), np.full(n_steps, nees_lower)]),
+            y=np.concatenate(
+                [np.full(n_steps, nees_upper), np.full(n_steps, nees_lower)]
+            ),
             fill="toself",
             fillcolor="rgba(0, 255, 0, 0.1)",
             line=dict(color="rgba(0,0,0,0)"),
@@ -576,7 +580,9 @@ def plot_consistency_summary(
         fig.add_trace(
             go.Scatter(
                 x=np.concatenate([time, time[::-1]]),
-                y=np.concatenate([np.full(n_steps, nis_upper), np.full(n_steps, nis_lower)]),
+                y=np.concatenate(
+                    [np.full(n_steps, nis_upper), np.full(n_steps, nis_lower)]
+                ),
                 fill="toself",
                 fillcolor="rgba(0, 255, 0, 0.1)",
                 line=dict(color="rgba(0,0,0,0)"),

pytcl/plotting/tracks.py

@@ -369,7 +369,11 @@ def plot_multi_target_tracks(
 
     for idx, (track_id, states) in enumerate(tracks.items()):
         states = np.asarray(states)
-        color = colors.get(track_id) if colors else default_colors[idx % len(default_colors)]
+        color = (
+            colors.get(track_id)
+            if colors
+            else default_colors[idx % len(default_colors)]
+        )
 
         fig.add_trace(
             go.Scatter(
@@ -532,7 +536,9 @@ def plot_estimation_comparison(
 
         # Error bounds
         if covariances is not None:
-            sigma = n_std * np.array([np.sqrt(P[state_idx, state_idx]) for P in covariances])
+            sigma = n_std * np.array(
+                [np.sqrt(P[state_idx, state_idx]) for P in covariances]
+            )
             upper = estimates[:, state_idx] + sigma
             lower = estimates[:, state_idx] - sigma
 
@@ -734,7 +740,9 @@ def create_animated_tracking(
                         method="animate",
                         args=[
                             [None],
-                            dict(frame=dict(duration=0, redraw=False), mode="immediate"),
+                            dict(
+                                frame=dict(duration=0, redraw=False), mode="immediate"
+                            ),
                         ],
                     ),
                 ],

pytcl/static_estimation/least_squares.py

@@ -303,7 +303,8 @@ def total_least_squares(
     # The solution exists if V[n, n] != 0
     if abs(V[n, n]) < 1e-14:
         raise ValueError(
-            "TLS solution does not exist. The smallest singular value " "has multiplicity > 1."
+            "TLS solution does not exist. The smallest singular value "
+            "has multiplicity > 1."
         )
 
     # TLS solution: x = -V[0:n, n] / V[n, n]

pytcl/static_estimation/maximum_likelihood.py

@@ -654,9 +654,9 @@ def mle_gaussian(
         theta = np.array(theta)
 
         # Log-likelihood
-        log_lik = -n / 2 * np.log(2 * np.pi * var_mle) - np.sum((data - mean_mle) ** 2) / (
-            2 * var_mle
-        )
+        log_lik = -n / 2 * np.log(2 * np.pi * var_mle) - np.sum(
+            (data - mean_mle) ** 2
+        ) / (2 * var_mle)
 
         # Fisher information
         n_params = len(theta)

pytcl/terrain/dem.py

@@ -193,7 +193,9 @@ class DEMGrid:
 
     def _in_bounds(self, lat: float, lon: float) -> bool:
         """Check if coordinates are within DEM bounds."""
-        return self.lat_min <= lat <= self.lat_max and self.lon_min <= lon <= self.lon_max
+        return (
+            self.lat_min <= lat <= self.lat_max and self.lon_min <= lon <= self.lon_max
+        )
 
     def _get_indices(self, lat: float, lon: float) -> Tuple[int, int, float, float]:
         """Get grid indices and fractional parts for interpolation.
@@ -273,7 +275,11 @@ class DEMGrid:
             z00 = self.data[i, j]
             z01 = self.data[i, j + 1] if j + 1 < self.n_lon else z00
             z10 = self.data[i + 1, j] if i + 1 < self.n_lat else z00
-            z11 = self.data[i + 1, j + 1] if (i + 1 < self.n_lat and j + 1 < self.n_lon) else z00
+            z11 = (
+                self.data[i + 1, j + 1]
+                if (i + 1 < self.n_lat and j + 1 < self.n_lon)
+                else z00
+            )
 
             # Check for nodata
             values = [z00, z01, z10, z11]

pytcl/terrain/loaders.py

@@ -308,7 +308,8 @@ def parse_gebco_netcdf(
         import netCDF4 as nc
     except ImportError:
         raise ImportError(
-            "netCDF4 is required for loading GEBCO files.\n" "Install with: pip install netCDF4"
+            "netCDF4 is required for loading GEBCO files.\n"
+            "Install with: pip install netCDF4"
         )
 
     # Set defaults for global extent
@@ -431,9 +432,13 @@ def parse_earth2014_binary(
 
     # Compute row/column indices
     i_start = max(0, int(np.floor((np.radians(lat_min_deg) - lat_start) / d_lat)))
-    i_end = min(EARTH2014_N_LAT, int(np.ceil((np.radians(lat_max_deg) - lat_start) / d_lat)) + 1)
+    i_end = min(
+        EARTH2014_N_LAT, int(np.ceil((np.radians(lat_max_deg) - lat_start) / d_lat)) + 1
+    )
     j_start = max(0, int(np.floor((np.radians(lon_min_deg) - lon_start) / d_lon)))
-    j_end = min(EARTH2014_N_LON, int(np.ceil((np.radians(lon_max_deg) - lon_start) / d_lon)) + 1)
+    j_end = min(
+        EARTH2014_N_LON, int(np.ceil((np.radians(lon_max_deg) - lon_start) / d_lon)) + 1
+    )
 
     # Read binary data
     # File is stored as int16 big-endian, rows from south to north
@@ -450,7 +455,9 @@ def parse_earth2014_binary(
             f.seek(row_offset + col_offset)
 
             # Read row segment
-            row_data = np.frombuffer(f.read(n_cols * 2), dtype=">i2")  # big-endian int16
+            row_data = np.frombuffer(
+                f.read(n_cols * 2), dtype=">i2"
+            )  # big-endian int16
             data[i, :] = row_data.astype(np.float64)
 
     # Compute actual bounds
@@ -571,7 +578,8 @@ def load_gebco(
     """
     if version not in GEBCO_PARAMETERS:
         raise ValueError(
-            f"Unknown GEBCO version: {version}. " f"Valid versions: {list(GEBCO_PARAMETERS.keys())}"
+            f"Unknown GEBCO version: {version}. "
+            f"Valid versions: {list(GEBCO_PARAMETERS.keys())}"
         )
 
     return _load_gebco_cached(version, lat_min, lat_max, lon_min, lon_max)

pytcl/terrain/visibility.py

@@ -184,7 +184,10 @@ def line_of_sight(
     # Compute distances from observer
     dlat = sample_lats - obs_lat
     dlon = sample_lons - obs_lon
-    a = np.sin(dlat / 2) ** 2 + np.cos(obs_lat) * np.cos(sample_lats) * np.sin(dlon / 2) ** 2
+    a = (
+        np.sin(dlat / 2) ** 2
+        + np.cos(obs_lat) * np.cos(sample_lats) * np.sin(dlon / 2) ** 2
+    )
     c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
     distances = earth_radius * c
 
@@ -247,7 +250,9 @@ def line_of_sight(
         else:
             grazing_angle = -np.pi / 2
 
-    return LOSResult(visible, grazing_angle, obstacle_distance, obstacle_elevation, min_clearance)
+    return LOSResult(
+        visible, grazing_angle, obstacle_distance, obstacle_elevation, min_clearance
+    )
 
 
 def viewshed(

pytcl/trackers/hypothesis.py

@@ -294,7 +294,10 @@ def n_scan_prune(
                     hyp_tracks_at_cutoff.add(track_id)
 
         # Keep if tracks match (or if no tracks at cutoff)
-        if hyp_tracks_at_cutoff == best_tracks_at_cutoff or len(best_tracks_at_cutoff) == 0:
+        if (
+            hyp_tracks_at_cutoff == best_tracks_at_cutoff
+            or len(best_tracks_at_cutoff) == 0
+        ):
             pruned.append(hyp)
 
     # Renormalize probabilities
@@ -512,7 +515,9 @@ class HypothesisTree:
         new_hypotheses = []
 
         for hyp in self.hypotheses:
-            for assoc_idx, (assoc, likelihood) in enumerate(zip(associations, likelihoods)):
+            for assoc_idx, (assoc, likelihood) in enumerate(
+                zip(associations, likelihoods)
+            ):
                 # Compute new hypothesis probability
                 new_prob = hyp.probability * likelihood
 

pytcl/trackers/mht.py

@@ -223,7 +223,9 @@ class MHTTracker:
         predicted_tracks = self._predict_tracks(current_tracks, F, Q)
 
         # Compute gating and likelihoods
-        gated, likelihood_matrix = self._compute_gating_and_likelihoods(predicted_tracks, Z)
+        gated, likelihood_matrix = self._compute_gating_and_likelihoods(
+            predicted_tracks, Z
+        )
 
         # Generate associations for each hypothesis
         track_id_list = list(predicted_tracks.keys())
@@ -268,7 +270,9 @@ class MHTTracker:
 
         # Update tracks based on associations
         new_tracks_per_assoc: Dict[int, List[MHTTrack]] = {}
-        updated_tracks: Dict[int, Dict[int, MHTTrack]] = {}  # assoc_idx -> track_id -> track
+        updated_tracks: Dict[int, Dict[int, MHTTrack]] = (
+            {}
+        )  # assoc_idx -> track_id -> track
 
         for assoc_idx, assoc in enumerate(associations):
             updated_tracks[assoc_idx] = {}
@@ -291,7 +295,9 @@ class MHTTracker:
                 updated_tracks[assoc_idx][track_id] = upd_track
 
             # Handle unassigned measurements -> new tracks
-            assigned_meas = set(meas_idx for meas_idx in assoc.values() if meas_idx >= 0)
+            assigned_meas = set(
+                meas_idx for meas_idx in assoc.values() if meas_idx >= 0
+            )
             for j in range(n_meas):
                 if j not in assigned_meas:
                     new_track = self._initiate_track(Z[j], j)
@@ -402,7 +408,9 @@ class MHTTracker:
 
         # Clutter and new track terms for unassigned measurements
         n_unassigned = len(Z) - len(used_meas)
-        likelihood *= (self.config.clutter_density + self.config.new_track_weight) ** n_unassigned
+        likelihood *= (
+            self.config.clutter_density + self.config.new_track_weight
+        ) ** n_unassigned
 
         return likelihood
 
@@ -526,7 +534,9 @@ class MHTTracker:
         new_hypotheses = []
 
         for hyp in self.hypothesis_tree.hypotheses:
-            for assoc_idx, (assoc, likelihood) in enumerate(zip(associations, likelihoods)):
+            for assoc_idx, (assoc, likelihood) in enumerate(
+                zip(associations, likelihoods)
+            ):
                 # Compute new hypothesis probability
                 new_prob = hyp.probability * likelihood