Struct Catalog 

pub struct Catalog { /* private fields */ }

A catalog of stars

The catalog contains an indexed (and possibly named) list of stars, which can be searched by id, name, or geometrically

Design rationale for Vec<Subcube>

There are roughly 4,000 (3769 in fact) subcubes used out of 32^3 (i.e. 32,768) by a star catalog with an ELE_PER_SIDE of 32

Purely using a vec of 32^3 vecs is 1MB of storage, plus subcube contents

A hash map from subcube to vec with 4k entries used is probably 64kB plus 128kB for the vecs themselves; access is slower though.

Implementations

impl Catalog

pub fn load_catalog<P: AsRef<Path>>( catalog_filename: P, magnitude: f32, ) -> Result<Self, Error>

pub fn add_star(&mut self, star: Star)

Add a star to the catalog

This also clears any derived data and marks the catalog as usorted

pub fn add_name<I: Into<String>>(&mut self, index: CatalogIndex, name: I)

Add a name for a single star in the catalog; the star must have been found by ID

The catalog must have been sorted beforehand

pub fn add_names<I: Into<String> + Clone>( &mut self, id_names: &[(usize, I)], ignore_not_found: bool, ) -> Result<(), Error>

Add names for a set of stars in the catalog, from their IDs

The catalog must have been sorted beforehand

pub fn retain<F>(&mut self, f: F)

where F: StarFilterFn,

Retain stars that match a certain criterion; the rest are dropped

This should be invoked prior to any stars being named; it also clears the derived data (e.g. geometric searching will not be allowed until a derive_data() call is invoked)

impl Catalog

pub fn len(&self) -> usize

Get the number of stars in the catalog

pub fn is_empty(&self) -> bool

Returns true if the catalog contains no stars

pub fn is_sorted(&self) -> bool

Returns true if the catalog has been sorted (and is thus ready for names to be added)

impl Catalog

pub fn clear_filter(&mut self) -> StarFilter

pub fn filter(&self) -> &StarFilter

pub fn set_filter(&mut self, f: StarFilter)

pub fn add_filter(&mut self, f: StarFilter)

impl Catalog

pub fn derive_data(&mut self)

Derive data from the stars in the catalog - such as what stars are in which subcubes

This does not impact the sorting - indeed, usually the catalog is sorted before the data is derived.

pub fn sort(&mut self)

Sort the stars so that to create the index (and hence afterwards they can be searched by id)

To do: Must remap name identifiers too

impl Catalog

pub fn is_filtered(&self, star: &Star, n: usize) -> bool

Run all the filters

pub fn find_sorted(&self, id: usize) -> Option<CatalogIndex>

Find a star from its ID

The catalog must have been sorted beforehand

pub fn find_name(&self, name: &str) -> Option<CatalogIndex>

Find a star from its name

pub fn find_id_or_name(&self, s: &str) -> Result<CatalogIndex, Error>

Find a star from a string, which might be an id or a name

pub fn closest_to_dir<I>( &self, subcube_iter: I, vector: &[f64; 3], ) -> Option<(f64, CatalogIndex)>

where I: Iterator<Item = Subcube>,

Find the closest star in the catalog given a direction vector

This requires the catalog to have had its data derived beforehand

pub fn closest_to_ra_de<I>( &self, subcube_iter: I, ra: f64, de: f64, ) -> Option<(f64, CatalogIndex)>

where I: Iterator<Item = Subcube>,

Find the closest star in the catalog given an RA and DE in radians

This requires the catalog to have had its data derived beforehand

pub fn find_stars_around( &self, vector: &[f64; 3], max_angle: f64, ) -> Vec<CatalogIndex>

Find stars within a certain angle around a vector

Needs data to have been derived for the Catalog

pub fn find_star_triangles<I>( &self, subcube_iter: I, angles_to_find: &[f64; 3], max_angle_delta: f64, ) -> Vec<(CatalogIndex, CatalogIndex, CatalogIndex)>

where I: Iterator<Item = Subcube>,

Find a triangle of stars given the visual angles between them

Needs data to have been derived for the Catalog

impl Catalog

pub fn iter_stars(&self) -> StarIter<'_>

pub fn iter_within_subcubes<I>(&self, subcube_iter: I) -> StarSubcubeIter<'_, I>

where I: Iterator<Item = Subcube>,

Iterate over all the stars in the catalog within a set of subcubes provide by an iterator

Trait Implementations

impl Default for Catalog

fn default() -> Catalog

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Catalog

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Index<CatalogIndex> for Catalog

type Output = Star

The returned type after indexing.

fn index(&self, s: CatalogIndex) -> &Star

Performs the indexing (container[index]) operation.

impl Index<Subcube> for Catalog

type Output = Vec<CatalogIndex>

The returned type after indexing.

fn index(&self, q: Subcube) -> &Vec<CatalogIndex>

Performs the indexing (container[index]) operation.

impl Serialize for Catalog

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.