Struct Match 

pub struct Match<'a, T> {
    pub object: &'a T,
    pub separation: Angle,
    pub in_frame: bool,
    pub offset: Offset,
    pub position_angle: Angle,
}

A ranked match: a borrowed catalogue object plus its computed geometry.

Returned by rank, Matcher::query, and is_framed.

Example

use skymath::{Angle, Equatorial, ParseMode};
use target_match::{rank, Constraint, Field, 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 catalog = [Target { name: "M 31", ra: 10.6847, dec: 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 = rank(pointing, &catalog, Constraint::within(&field, RadiusPolicy::Circumscribed));
let m = &hits[0];
assert_eq!(m.object.name, "M 31");
assert!(m.in_frame);
assert!(m.separation.arcseconds() < 2.0);

Fields

object: &'a T

The matched object, borrowed from the caller’s slice or the Matcher.

separation: Angle

Great-circle separation from the frame centre.

in_frame: bool

Whether the object is inside the active membership shape.

offset: Offset

The object’s offset relative to the frame centre.

position_angle: Angle

Position angle from frame centre to the object (degrees East of North).

Trait Implementations

impl<'a, T: Clone> Clone for Match<'a, T>

fn clone(&self) -> Match<'a, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T: Copy> Copy for Match<'a, T>

impl<'a, T: Debug> Debug for Match<'a, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T: PartialEq> PartialEq for Match<'a, T>

fn eq(&self, other: &Match<'a, T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a, T: PartialEq> StructuralPartialEq for Match<'a, T>