ruststartracker 0.2.1__tar.gz → 0.2.3__tar.gz

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ruststartracker
-Version: 0.2.1
+Version: 0.2.3
 Summary: Lightweight Python Star Tracker With Rust Backend
 License: MIT
 Author: Nicolas Tobler
@@ -14,6 +14,9 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: opencv-python-headless (>=4.9.0,<5.0.0)
+Project-URL: GaiaAttribution, https://www.cosmos.esa.int/gaia
+Project-URL: Homepage, https://github.com/ntobler/ruststartracker
+Project-URL: License, https://opensource.org/licenses/MIT
 Description-Content-Type: text/markdown
 
 # Lightweight Python Star Tracker With Rust Backend
@@ -31,12 +34,41 @@ Features:
 
 ## Example
 
+### Rust
+
+See [examples/basic.rs](examples/basic.rs)
+
+```rust
+// Get catalog positions
+let catalog: StarCatalog = StarCatalog::from_gaia(max_magnitude: ...).unwrap();
+let stars_xyz: Vec<[f32; 3]> = catalog.normalized_positions(epoch: ..., observer_position: ...);
+let stars_mag: Vec<f32> = catalog.magnitudes();
+
+// Create StarTracker instance (reuse this)
+let star_matcher = StarMatcher::new(
+    stars_xyz,
+    stars_mag,
+    max_lookup_magnitude: ...
+    max_inter_star_angle: ...,
+    inter_star_angle_tolerance: ...,
+    min_matches: ...,
+    timeout: ...
+);
+
+// Normalized observation in the camera frame
+let obs_xyz_camera: Vec<[f32; 3]> = ...
+
+let result = star_matcher.find(&obs_xyz_camera);
+println!("Result: {:?}", result);
+```
+
+### Python
 ```python
 import ruststartracker
 
 # Get catalog positions
-catalog = ruststartracker.StarCatalog()
-star_catalog_vecs = catalog.normalized_positions()
+catalog = ruststartracker.StarCatalog(max_magnitude=...)
+star_catalog_vecs = catalog.normalized_positions(epoch=...)
 
 # Define opencv camera parameters, see https://docs.opencv.org/4.x/dc/dbb/tutorial_py_calibration.html
 camera_params = ruststartracker.CameraParameters(
@@ -52,6 +84,7 @@ st = ruststartracker.StarTracker(
     max_inter_star_angle=...,
     inter_star_angle_tolerance=...,
     n_minimum_matches=...,
+    timeout_secs=...,
 )
 
 # Obtain numpy array image
@@ -66,11 +99,17 @@ print(result)
 
 ## Installation
 
-- Make sure rust tool chain (`cargo`) is installed and in the `PATH` environment variable.
-- Install with `pip install git+https://github.com/ntobler/ruststartracker.git`.
+- Install with `pip install ruststartracker` (Currently only ARM/x86 Linux wheels available).
+
+## Attributions
+
+### Gaia Data
+
+This project includes data from the European Space Agency (ESA) mission [**Gaia**](https://www.cosmos.esa.int/gaia), processed by the **Gaia Data Processing and Analysis Consortium (DPAC)**.
+Funding for the DPAC has been provided by national institutions, in particular the institutions participating in the Gaia Multilateral Agreement.
 
-## TODOs
+Gaia DR3 data is © European Space Agency and is released under the [**Creative Commons Attribution 4.0 International License (CC BY 4.0)**](https://creativecommons.org/licenses/by/4.0/).
 
-- Improve error messages.
-- Return more diagnostic data.
+> Gaia Collaboration, Vallenari et al. (2022), *A\&A* **674**, A1.
+> [DOI: 10.1051/0004-6361/202243940](https://doi.org/10.1051/0004-6361/202243940)
 

ruststartracker-0.2.3/README.md

@@ -0,0 +1,93 @@
+# Lightweight Python Star Tracker With Rust Backend
+
+Based on the methodology used in https://github.com/nasa/COTS-Star-Tracker, with following improvements:
+- Reduced dependencies to opencv and numpy for lightweight usage in a Raspberry Pi.
+- Reimplemented computationally expensive parts in rust. This includes most parts that are not image processing related.
+- Added quadratic inter star angle index look up polynomial for faster triangle search.
+- Added spatial index to look up neighboring stars.
+
+Features:
+- Attitude estimation from image and camera calibration parameters.
+- Attitude estimation from list of star observation coordinates.
+- Star catalog creation with temporal corrections.
+
+## Example
+
+### Rust
+
+See [examples/basic.rs](examples/basic.rs)
+
+```rust
+// Get catalog positions
+let catalog: StarCatalog = StarCatalog::from_gaia(max_magnitude: ...).unwrap();
+let stars_xyz: Vec<[f32; 3]> = catalog.normalized_positions(epoch: ..., observer_position: ...);
+let stars_mag: Vec<f32> = catalog.magnitudes();
+
+// Create StarTracker instance (reuse this)
+let star_matcher = StarMatcher::new(
+    stars_xyz,
+    stars_mag,
+    max_lookup_magnitude: ...
+    max_inter_star_angle: ...,
+    inter_star_angle_tolerance: ...,
+    min_matches: ...,
+    timeout: ...
+);
+
+// Normalized observation in the camera frame
+let obs_xyz_camera: Vec<[f32; 3]> = ...
+
+let result = star_matcher.find(&obs_xyz_camera);
+println!("Result: {:?}", result);
+```
+
+### Python
+```python
+import ruststartracker
+
+# Get catalog positions
+catalog = ruststartracker.StarCatalog(max_magnitude=...)
+star_catalog_vecs = catalog.normalized_positions(epoch=...)
+
+# Define opencv camera parameters, see https://docs.opencv.org/4.x/dc/dbb/tutorial_py_calibration.html
+camera_params = ruststartracker.CameraParameters(
+    camera_matrix=...,
+    cam_resolution=...,
+    dist_coefs=...,
+)
+
+# Create StarTracker instance (reuse this)
+st = ruststartracker.StarTracker(
+    star_catalog_vecs,
+    camera_params,
+    max_inter_star_angle=...,
+    inter_star_angle_tolerance=...,
+    n_minimum_matches=...,
+    timeout_secs=...,
+)
+
+# Obtain numpy array image
+img = ...
+
+# Find attitude from given image
+result = st.process_image(img)
+
+print(result)
+# StarTrackerResult(quat=[-0.43977802991867065, -0.439766526222229, -0.4398997128009796, 0.6478340029716492], match_ids=[1435, 1272, 1140, 2035, 1070, 1438, 1338, 903, 260, 2141, 1771, 1727, 385, 1717, 2204, 2062, 1989, 1634, 708, 1357], n_matches=20, duration_s=0.0003700880042742938)
+```
+
+## Installation
+
+- Install with `pip install ruststartracker` (Currently only ARM/x86 Linux wheels available).
+
+## Attributions
+
+### Gaia Data
+
+This project includes data from the European Space Agency (ESA) mission [**Gaia**](https://www.cosmos.esa.int/gaia), processed by the **Gaia Data Processing and Analysis Consortium (DPAC)**.
+Funding for the DPAC has been provided by national institutions, in particular the institutions participating in the Gaia Multilateral Agreement.
+
+Gaia DR3 data is © European Space Agency and is released under the [**Creative Commons Attribution 4.0 International License (CC BY 4.0)**](https://creativecommons.org/licenses/by/4.0/).
+
+> Gaia Collaboration, Vallenari et al. (2022), *A\&A* **674**, A1.
+> [DOI: 10.1051/0004-6361/202243940](https://doi.org/10.1051/0004-6361/202243940)

ruststartracker-0.2.3/build_script.py

@@ -0,0 +1,65 @@
+"""Build rust backend.
+
+This script is automatically run when the pyproject is installed.
+"""
+
+import pathlib
+import shutil
+import subprocess
+
+
+def download_gaia_data(output_file: pathlib.Path) -> None:
+    """Download Gaia data and save it to the specified output file.
+
+    Args:
+        output_file: Path to save the downloaded Gaia data (csv).
+    """
+    from astroquery.gaia import Gaia
+
+    Gaia.ROW_LIMIT = 10000
+
+    query = """
+    SELECT source_id, ra, dec, parallax, pmra, pmdec, phot_g_mean_mag
+    FROM gaiadr3.gaia_source
+    WHERE phot_g_mean_mag < 7
+        AND parallax > 0
+        AND astrometric_params_solved = 31
+        AND visibility_periods_used >= 8
+    """
+
+    print("Executing query on Gaia database...")
+    job = Gaia.launch_job_async(
+        query,
+        dump_to_file=True,
+        output_format="csv",
+        output_file=str(output_file.absolute()),
+        verbose=True,
+    )
+    if not job.is_finished():
+        print("Job did not finish successfully.")
+        return
+
+    print(f"Saved to: {output_file}")
+
+
+def build_script() -> None:
+    """Build rust backend and move shared library to correct folder."""
+    cwd = pathlib.Path(__file__).parent.expanduser().absolute()
+
+    gaia_file = cwd / "ruststartracker/gaia_data_j2016.csv"
+    if not gaia_file.exists():
+        download_gaia_data(gaia_file)
+
+    subprocess.check_call(  # noqa: S603
+        ["cargo", "build", "--release", "--features", "improc,gaia"],  # noqa: S607
+        cwd=cwd,
+        stdout=None,
+        stderr=None,
+    )
+    shutil.copy(
+        cwd / "target/release/libruststartracker.so", cwd / "ruststartracker/libruststartracker.so"
+    )
+
+
+if __name__ == "__main__":
+    build_script()

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/pyproject.toml

@@ -1,15 +1,20 @@
 [tool.poetry]
 name = "ruststartracker"
-version = "0.2.1"
+version = "0.2.3"
 description = "Lightweight Python Star Tracker With Rust Backend"
 authors = ["Nicolas Tobler <nitobler@gmail.com>"]
 readme = "README.md"
 license = "MIT"
 include = [
-    { path = "ruststartracker/star_catalog.tsv", format = ["sdist", "wheel"] },
+    { path = "ruststartracker/gaia_data_j2016.csv", format = ["sdist", "wheel"] },
     { path = "ruststartracker/libruststartracker.so", format = ["wheel"] },
 ]
 
+[tool.poetry.urls]
+Homepage = "https://github.com/ntobler/ruststartracker"
+License = "https://opensource.org/licenses/MIT"
+GaiaAttribution = "https://www.cosmos.esa.int/gaia"
+
 [tool.poetry.dependencies]
 python = "^3.10"
 numpy = "^1.26.0"
@@ -27,16 +32,17 @@ mypy = "^1.13.0"
 scipy-stubs = "^1.14.1.5"
 ruff = "^0.9.3"
 bump-my-version = "^1.2.0"
+astroquery = "^0.4.10"
 
 [tool.poetry.build]
-script = "rust_build.py"
+script = "build_script.py"
 
 [build-system]
-requires = ["poetry-core"]
+requires = ["poetry-core", "astroquery>=0.4.10"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.bumpversion]
-current_version = "0.2.1"
+current_version = "0.2.3"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/ruststartracker/catalog.py

@@ -11,7 +11,9 @@ import numpy.typing as npt
 AU: float = 149597870.693
 """Astronomical unit."""
 
-INTERNAL_CATALOG_FILE = pathlib.Path(__file__).parent.expanduser().absolute() / "star_catalog.tsv"
+INTERNAL_CATALOG_FILE = (
+    pathlib.Path(__file__).parent.expanduser().absolute() / "gaia_data_j2016.csv"
+)
 """Location of the internal star catalog file."""
 
 
@@ -26,7 +28,7 @@ def time_to_epoch(t: datetime.datetime) -> float:
 
 
 class StarCatalog:
-    """Star catalog from Hipparcos data."""
+    """Star catalog from Gaia data."""
 
     _data: npt.NDArray[np.float32]
     """Underlying data array."""
@@ -42,7 +44,7 @@ class StarCatalog:
     """Proper motion of the declination in mad."""
     magnitude: npt.NDArray[np.float32]
     """Magnitude values."""
-    epoch: float = 1992.25
+    epoch: float = 2016.0
     """Epoch of the catalog in years."""
 
     def __init__(
@@ -57,13 +59,10 @@ class StarCatalog:
         # Use locally included star catalog is no file is given
         filename = INTERNAL_CATALOG_FILE if filename is None else pathlib.Path(filename)
 
-        keep_columns = ("RArad", "DErad", "Plx", "pmRA", "pmDE", "Hpmag")
+        keep_columns = ("ra", "dec", "parallax", "pmra", "pmdec", "phot_g_mean_mag")
 
         with filename.open("r") as f:
-            it = csv.reader(f, delimiter="\t", strict=True)
-
-            # skip head
-            [next(it) for _ in range(52)]
+            it = csv.reader(f, delimiter=",", strict=True)
 
             # Get columns
             columns = next(it)
@@ -71,10 +70,7 @@ class StarCatalog:
             keep_columns_indices = tuple(columns.index(x) for x in keep_columns)
             min_length = len(keep_columns_indices)
 
-            mag_column_index = columns.index("Hpmag")
-
-            # Skip unit and horizontal bar
-            [next(it) for _ in range(2)]
+            mag_column_index = columns.index("phot_g_mean_mag")
 
             rows = [
                 [float(line[j]) for j in keep_columns_indices]
@@ -83,12 +79,12 @@ class StarCatalog:
             ]
         self._data = np.array(rows, dtype=np.float32)
 
-        self.ra = self._data[:, keep_columns.index("RArad")]
-        self.de = self._data[:, keep_columns.index("DErad")]
-        self.parallax = self._data[:, keep_columns.index("Plx")]
-        self.proper_motion_ra = self._data[:, keep_columns.index("pmRA")]
-        self.proper_motion_de = self._data[:, keep_columns.index("pmDE")]
-        self.magnitude = self._data[:, keep_columns.index("Hpmag")]
+        self.ra = self._data[:, keep_columns.index("ra")]
+        self.de = self._data[:, keep_columns.index("dec")]
+        self.parallax = self._data[:, keep_columns.index("parallax")]
+        self.proper_motion_ra = self._data[:, keep_columns.index("pmra")]
+        self.proper_motion_de = self._data[:, keep_columns.index("pmdec")]
+        self.magnitude = self._data[:, keep_columns.index("phot_g_mean_mag")]
 
         deg2rad = math.pi / 180
         arcsec2deg = 1 / 3600

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/ruststartracker/libruststartracker.pyi

@@ -2,12 +2,15 @@ from collections.abc import Iterator
 
 import numpy as np
 import numpy.typing as npt
+from typing_extensions import Self
 
 class StarMatcher:
     def __init__(
         self,
         stars_xyz: npt.NDArray[np.float32],
+        stars_mag: npt.NDArray[np.float32],
         max_inter_star_angle: float,
+        max_lookup_magnitude: float,
         inter_star_angle_tolerance: float,
         n_minimum_matches: int,
         timeout_secs: float,
@@ -19,7 +22,7 @@ class StarMatcher:
         npt.NDArray[np.uint32],
         npt.NDArray[np.uint32],
         int,
-        list[list[float]],
+        npt.NDArray[np.float32],
         float,
     ]: ...
 
@@ -44,15 +47,43 @@ class IterTriangleFinder:
 class UnitVectorLookup:
     def __init__(self, vec: npt.NDArray[np.float32]) -> None: ...
     def lookup_nearest(self, key: npt.NDArray[np.float32]) -> int: ...
-    def get_inter_star_index_numpy(
-        self, vec: npt.NDArray[np.float32], angle_threshold: float
-    ) -> tuple[list[list[int]], list[float], list[float]]: ...
     def get_inter_star_index(
-        self, vec: npt.NDArray[np.float32], angle_threshold: float
+        self,
+        stars: npt.NDArray[np.float32],
+        magnitudes: npt.NDArray[np.float32],
+        max_angle_rad: float,
+        max_magnitude: float,
     ) -> tuple[list[list[int]], list[float], list[float]]: ...
     def look_up_close_angles(
-        self, vectors: npt.NDArray[np.float32], max_angle_rad: float
+        self,
+        vectors: npt.NDArray[np.float32],
+        magnitudes: npt.NDArray[np.float32],
+        max_angle_rad: float,
+        max_magnitude: float,
     ) -> list[tuple[list[float], float]]: ...
     def look_up_close_angles_naive(
-        self, vectors: npt.NDArray[np.float32], max_angle_rad: float
+        self,
+        vectors: npt.NDArray[np.float32],
+        magnitudes: npt.NDArray[np.float32],
+        max_angle_rad: float,
+        max_magnitude: float,
     ) -> list[tuple[list[float], float]]: ...
+
+def get_threshold_from_histogram(
+    img: npt.NDArray[np.uint8],
+    *,
+    fraction: float,
+) -> int: ...
+def extract_observations(
+    img: npt.NDArray[np.uint8],
+    threshold: int,
+    min_star_area: int,
+    max_star_area: int,
+) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]: ...
+
+class StarCatalog:
+    @classmethod
+    def from_gaia(cls, *, max_magnitude: float | None) -> Self: ...
+    def normalized_positions(
+        self, *, epoch: float | None, observer_position: np.ndarray | None
+    ) -> npt.NDArray[np.float32]: ...

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/ruststartracker/star.py

@@ -87,8 +87,10 @@ class StarTracker:
     def __init__(
         self,
         stars_xyz: npt.NDArray[np.float32],
+        stars_mag: npt.NDArray[np.float32],
         camera_params: CameraParameters,
         *,
+        max_lookup_magnitude: float | None = None,
         max_inter_star_angle: float | None = None,
         inter_star_angle_tolerance: float = 0.0008,
         n_minimum_matches: int = 10,
@@ -98,11 +100,15 @@ class StarTracker:
 
         Args:
             stars_xyz: Positions of catalog stars
+            stars_mag: Magnitudes of catalog stars
             camera_params: Calibrated camera parameters
+            max_lookup_magnitude: Maximum magnitude of stars used in the triangulation. Reducing
+                this number means only bright stars are used for triangulation. This results in
+                faster lookup performance.
             max_inter_star_angle: Maximum angle between stars that should be indexed.
                 Calculating large inter star angles is expensive. If None, the angle is
                 calculated from the camera field of view.
-            inter_star_angle_tolerance: Tolerance for inter star angle matching.
+            inter_star_angle_tolerance: Tolerance for inter star angle matching in rad.
             n_minimum_matches: Minimum amount of required matches for a successful
                 attitude estimation
             timeout_secs: Maximum allowed search time in seconds. A StarTrackerError is raised
@@ -127,8 +133,13 @@ class StarTracker:
             dot_products = (corner_coords_xyz * np.array([0, 0, 1], dtype=np.float32)).sum(axis=-1)
             max_inter_star_angle = float(np.arccos(dot_products.max())) * 2
 
+        if max_lookup_magnitude is None:
+            max_lookup_magnitude = 100.0  # A very faint star. Almost infinity
+
         self._star_matcher = ruststartracker.libruststartracker.StarMatcher(
             np.ascontiguousarray(stars_xyz, dtype=np.float32),
+            np.ascontiguousarray(stars_mag, dtype=np.float32),
+            float(max_lookup_magnitude),
             float(max_inter_star_angle),
             float(inter_star_angle_tolerance),
             int(n_minimum_matches),
@@ -178,6 +189,20 @@ class StarTracker:
             max_star_area=max_star_area,
         )
 
+        if threshold is None:
+            threshold = ruststartracker.libruststartracker.get_threshold_from_histogram(
+                img, fraction=0.99
+            )
+
+        centroids, intensities = ruststartracker.libruststartracker.extract_observations(
+            img,
+            threshold,
+            min_star_area,
+            max_star_area,
+        )
+        centroids = np.array(centroids, dtype=np.float32)
+        intensities = np.array(intensities, dtype=np.float32)
+
         # At least 3 observations are required (one triangle)
         if len(centroids) < 3:
             raise StarTrackerError("Found too few star candidates (< 3) to continue.")
@@ -238,12 +263,12 @@ class StarTracker:
         quat, match_ids, obs_indices, n_matches, matched_obs, duration_s = result
 
         return StarTrackerResult(
-            quat=np.asarray(quat, dtype=np.float32),
-            match_ids=np.asarray(match_ids, dtype=np.uint32),
+            quat=quat,
+            match_ids=match_ids,
             n_matches=n_matches,
             duration_s=duration_s,
-            mached_obs_x=np.asarray(matched_obs, dtype=np.float32),
-            obs_indices=np.asarray(obs_indices, dtype=np.uint32),
+            mached_obs_x=matched_obs,
+            obs_indices=obs_indices,
         )
 
 

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/ruststartracker/test_backend.py

@@ -54,9 +54,12 @@ def test_unit_vector_lookup():
     close_indices_gt = np.concatenate(results, axis=-1).T[args]
     angles_gt = angles[args]
 
-    close_indices, angles, poly = uvl.get_inter_star_index_numpy(vec, angle_threshold)
-
-    close_indices, angles, poly = uvl.get_inter_star_index(vec[:, :3], angle_threshold)
+    close_indices, angles, poly = uvl.get_inter_star_index(
+        np.array(vec[:, :3], dtype=np.float32),
+        np.ones(len(vec), dtype=np.float32),
+        angle_threshold,
+        10,
+    )
     close_indices = np.array(close_indices)
     angles = np.array(angles)
     poly = np.array(poly)
@@ -101,6 +104,8 @@ def test_star_matcher():
     vec = rng.normal(size=[n_cat_stars, 3]).astype(np.float32)
     vec /= np.linalg.norm(vec, axis=-1, keepdims=True)
 
+    magnitudes = rng.uniform(0, 10, size=vec.shape[:1]).astype(np.float32)
+
     key = rng.normal(size=[3]).astype(np.float32)
     key /= np.linalg.norm(key, axis=-1, keepdims=True)
 
@@ -113,10 +118,16 @@ def test_star_matcher():
 
     rot = scipy.spatial.transform.Rotation.from_rotvec([1, 1, 1])
 
-    obs_rotated = rot.apply(obs)
+    obs_rotated = rot.apply(obs).astype(np.float32)
 
     index = libruststartracker.StarMatcher(
-        vec, np.radians(10).item(), np.radians(0.1).item(), 4, 999.0
+        vec,
+        magnitudes,
+        10,
+        np.radians(10).item(),
+        np.radians(0.1).item(),
+        4,
+        999.0,
     )
 
     res = index.find(obs_rotated)
@@ -124,7 +135,7 @@ def test_star_matcher():
     assert res is not None
 
     quat, match_ids, obs_indices, n_matches, matched_obs, time_s = res
-    np.testing.assert_allclose(quat, rot.inv().as_quat())
+    np.testing.assert_allclose(quat, rot.inv().as_quat(), rtol=1e-6)
     assert n_matches >= 4
     assert len(obs_index) == len(match_ids)
 

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/ruststartracker/test_catalog.py

@@ -1,10 +1,12 @@
 import datetime
+import time
 
 import astropy.time  # type: ignore[import]
 import numpy as np
 import pytest
 
 import ruststartracker.catalog
+import ruststartracker.libruststartracker
 
 
 def test_time_to_epoch():
@@ -43,5 +45,17 @@ def test_extract_observations():
     np.testing.assert_allclose(np.linalg.norm(positions, axis=-1), 1.0, rtol=1e-5)
 
 
+def test_python_rust():
+    t0 = time.monotonic()
+    positions = ruststartracker.catalog.StarCatalog().normalized_positions(epoch=2025.0)
+    print(f"Python catalog took {time.monotonic() - t0:.3f} seconds")
+    t0 = time.monotonic()
+    positions2 = ruststartracker.libruststartracker.StarCatalog.from_gaia(
+        max_magnitude=6.0
+    ).normalized_positions(epoch=2025.0, observer_position=None)
+    print(f"Rust catalog took {time.monotonic() - t0:.3f} seconds")
+    np.testing.assert_allclose(positions, positions2, rtol=1e-5, atol=1e-5)
+
+
 if __name__ == "__main__":
     pytest.main([__file__])

{ruststartracker-0.2.1 → ruststartracker-0.2.3}/ruststartracker/test_integration.py

@@ -25,7 +25,8 @@ def prepare() -> tuple[ruststartracker.StarTracker, np.ndarray]:
     dist_coefs = np.array([-0.44120807, -0.15954202, 0.00767012, -0.00213292, -1.64788247])
 
     catalog = ruststartracker.StarCatalog()
-    star_catalog_vecs = catalog.normalized_positions()
+    star_catalog_vecs = catalog.normalized_positions(epoch=2024)
+    star_catalog_magnitudes = catalog.magnitude
 
     camera_params = ruststartracker.CameraParameters(
         camera_matrix=camera_matrix,
@@ -35,40 +36,15 @@ def prepare() -> tuple[ruststartracker.StarTracker, np.ndarray]:
 
     st = ruststartracker.StarTracker(
         star_catalog_vecs,
+        star_catalog_magnitudes,
         camera_params,
-        inter_star_angle_tolerance=np.radians(0.1).item(),
+        inter_star_angle_tolerance=np.radians(0.05).item(),
         n_minimum_matches=5,
     )
 
     return st, star_catalog_vecs
 
 
-def test_example(prepare: tuple[ruststartracker.StarTracker, np.ndarray]):
-    os.environ["RUST_BACKTRACE"] = "1"
-
-    st, _ = prepare
-
-    obs = np.array(
-        [
-            [0.11975033, -0.02227603, 0.9925541],
-            [0.03917335, 0.04533212, 0.99820361],
-            [0.05137746, -0.01717139, 0.99853167],
-            [-0.14742009, 0.00734109, 0.98904673],
-            [0.03396359, 0.05851033, 0.99770888],
-            [-0.10286126, 0.04479652, 0.99368649],
-            [-0.050927, -0.06002669, 0.9968968],
-            [0.02815389, 0.02852981, 0.99919638],
-            [-0.1390861, 0.05684676, 0.98864731],
-            [-0.14276463, -0.13402131, 0.98064089],
-        ]
-    )
-
-    result = st.process_observation_vectors(obs)
-    np.testing.assert_allclose(
-        result.quat, [0.1722, -0.4309, 0.8818, 0.08396], rtol=1e-3, atol=1e-3
-    )
-
-
 def test_star_matcher(prepare: tuple[ruststartracker.StarTracker, np.ndarray]):
     os.environ["RUST_BACKTRACE"] = "1"