Struct Matcher 

pub struct Matcher<T> { /* private fields */ }

A prebuilt, declination-sorted index for repeated queries against one catalogue.

Produces results identical to rank for the same objects, pointing, and constraint — the index is a performance optimization only. Build it once, then query many pointings.

Example

use skymath::{Angle, Equatorial, ParseMode};
use target_match::{Constraint, Field, Matcher, Membership, Optics, RadiusPolicy, SkyObject};

struct Target {
    name: &'static str,
    ra: f64,
    dec: f64,
}
impl SkyObject for Target {
    fn position(&self) -> Equatorial {
        Equatorial::j2000(Angle::from_degrees(self.ra), Angle::from_degrees(self.dec)).unwrap()
    }
}

let matcher = Matcher::from_objects(vec![
    Target { name: "M 31", ra: 10.6847, dec: 41.2688 },
    Target { name: "M 33", ra: 23.4621, dec: 30.6599 },
]);
assert_eq!(matcher.objects().len(), 2);

let pointing = Equatorial::parse_j2000("00:42:44.3", "+41:16:09", ParseMode::Strict).unwrap();
let field = Field::from_optics(Optics {
    focal_mm: 800.0,
    pixel_um: (3.76, 3.76),
    binning: (1, 1),
    pixels: (6248, 4176),
})
.unwrap();

let hits = matcher.query(pointing, Constraint::within(&field, RadiusPolicy::Circumscribed).nearest_one());
assert_eq!(hits[0].object.name, "M 31");

let m = matcher.is_framed(
    pointing,
    &matcher.objects()[0],
    Membership::Circular { radius: Angle::from_degrees(1.0) },
);
assert!(m.in_frame);

Implementations

impl<T: SkyObject> Matcher<T>

pub fn from_objects(objects: Vec<T>) -> Self

Build an index from a set of objects (original order is preserved for tie-breaking and objects).

Example

use skymath::{Angle, Equatorial};
use target_match::{Matcher, SkyObject};

struct Target { ra_deg: f64, dec_deg: f64 }
impl SkyObject for Target {
    fn position(&self) -> Equatorial {
        Equatorial::j2000(Angle::from_degrees(self.ra_deg), Angle::from_degrees(self.dec_deg)).unwrap()
    }
}

let matcher = Matcher::from_objects(vec![
    Target { ra_deg: 10.6847, dec_deg: 41.2688 },
    Target { ra_deg: 23.4621, dec_deg: 30.6599 },
]);
assert_eq!(matcher.objects().len(), 2);

pub fn objects(&self) -> &[T]

The stored objects, in their original insertion order.

Example

use skymath::{Angle, Equatorial};
use target_match::{Matcher, SkyObject};

struct Target { name: &'static str, ra_deg: f64, dec_deg: f64 }
impl SkyObject for Target {
    fn position(&self) -> Equatorial {
        Equatorial::j2000(Angle::from_degrees(self.ra_deg), Angle::from_degrees(self.dec_deg)).unwrap()
    }
}

let matcher = Matcher::from_objects(vec![Target { name: "M 31", ra_deg: 10.6847, dec_deg: 41.2688 }]);
assert_eq!(matcher.objects()[0].name, "M 31");

pub fn query(&self, pointing: Equatorial, c: Constraint) -> Vec<Match<'_, T>>

Query the index for a pointing under a constraint. Results are identical to calling rank with objects.

Example

use skymath::{Angle, Equatorial, ParseMode};
use target_match::{Constraint, Field, Matcher, Optics, RadiusPolicy, SkyObject};

struct Target { name: &'static str, ra_deg: f64, dec_deg: f64 }
impl SkyObject for Target {
    fn position(&self) -> Equatorial {
        Equatorial::j2000(Angle::from_degrees(self.ra_deg), Angle::from_degrees(self.dec_deg)).unwrap()
    }
}

let matcher = Matcher::from_objects(vec![Target { name: "M 31", ra_deg: 10.6847, dec_deg: 41.2688 }]);
let pointing = Equatorial::parse_j2000("00:42:44.3", "+41:16:09", ParseMode::Strict).unwrap();
let field = Field::from_optics(Optics {
    focal_mm: 800.0, pixel_um: (3.76, 3.76), binning: (1, 1), pixels: (6248, 4176),
})
.unwrap();

let hits = matcher.query(pointing, Constraint::within(&field, RadiusPolicy::Circumscribed).nearest_one());
assert_eq!(hits[0].object.name, "M 31");

pub fn is_framed<'a>( &self, pointing: Equatorial, object: &'a T, m: Membership, ) -> Match<'a, T>

Evaluate a single stored-or-external object against a frame (see is_framed).

Example

use skymath::{Angle, Equatorial, ParseMode};
use target_match::{Matcher, Membership, SkyObject};

struct Target { ra_deg: f64, dec_deg: f64 }
impl SkyObject for Target {
    fn position(&self) -> Equatorial {
        Equatorial::j2000(Angle::from_degrees(self.ra_deg), Angle::from_degrees(self.dec_deg)).unwrap()
    }
}

let matcher = Matcher::from_objects(vec![Target { ra_deg: 10.6847, dec_deg: 41.2688 }]);
let pointing = Equatorial::parse_j2000("00:42:44.3", "+41:16:09", ParseMode::Strict).unwrap();

let obj = &matcher.objects()[0];
let m = matcher.is_framed(pointing, obj, Membership::Circular { radius: Angle::from_degrees(1.0) });
assert!(m.in_frame);