solvastro 0.1.1

A Rust blind plate solver
Documentation
use std::error::Error;

use solvastro::star_index::StarIndex;
use solvastro::wcs::WcsTan;
use std::path::PathBuf;

use image::{Rgba, RgbaImage};
use imageproc::drawing::{draw_hollow_circle_mut, draw_line_segment_mut, draw_text_mut};
use kiddo::distance::squared_euclidean;
use nalgebra::{Matrix2, Rotation2, Vector2, Vector3};
use solvastro::coords::CoordCelestial;
use solvastro::quad::Quad;
use rusttype::{Font, Scale};
use std::collections::{HashMap, HashSet};
use structopt::StructOpt;

const ANNOTATED_IMG_MARKER_SRC_RADIUS: i32 = 10;
const LIMITING_MAGNITUDE: f64 = 7.0f64;

#[derive(Debug, StructOpt)]
struct CliArgs {
    #[structopt(parse(from_os_str))]
    wcs: PathBuf,

    #[structopt(parse(from_os_str))]
    star_index: PathBuf,

    ra: f64,
    dec: f64,

    #[structopt(default_value = "0.0")]
    rot_angle: f64,

    radius: f64,

    img_w: u32,
    img_h: u32,
}

#[cfg(not(tarpaulin_include))]
fn main() -> Result<(), Box<dyn Error>> {
    let cli_args = CliArgs::from_args();
    println!("cli_args: {:?}", &cli_args);

    let index: StarIndex = StarIndex::read_from_file(&cli_args.star_index)?;
    let _wcs: WcsTan = WcsTan::read_from_file(&cli_args.wcs)?;

    let scale = cli_args.radius.to_radians() / (cli_args.img_w.max(cli_args.img_h) as f64) * 180f64;
    println!("scale: {:}", &scale);

    let cd =
        Rotation2::new(cli_args.rot_angle.to_radians()) * Matrix2::new(scale, 0f64, 0f64, scale);

    println!("CD: {:#}", &cd);

    let wcs: WcsTan = WcsTan::new(
        Vector2::new(cli_args.img_w as f64 / 2f64, cli_args.img_h as f64 / 2f64),
        CoordCelestial {
            ra: cli_args.ra.to_radians(),
            dec: cli_args.dec.to_radians(),
        },
        cd,
    );

    println!("input wcs: {:?}", &wcs);

    let stars_in_img: Vec<(usize, Vector2<f64>, &String)> =
        get_stars_in_img(&cli_args, &index, wcs);

    let quads_in_img = get_quads_in_img(&stars_in_img, &index);
    println!("num quads in radius: {:?}", quads_in_img.len());

    let img = create_annotated_image(
        stars_in_img,
        quads_in_img,
        cli_args.img_w,
        cli_args.img_h,
        &index,
    );

    img.save("visualized.png")?;

    Ok(())
}

fn get_stars_in_img<'a>(
    cli_args: &CliArgs,
    index: &'a StarIndex,
    wcs: WcsTan,
) -> Vec<(usize, Vector2<f64>, &'a String)> {
    // get centre of query image in xyz space
    let img_centre_xyz: Vector3<f64> = wcs.pix_2_world(&Vector2::new(
        (cli_args.img_w / 2) as f64,
        (cli_args.img_h / 2) as f64,
    ));

    // find all stars in the catalog that are within the bounding circle of the field.
    let cat_stars = index
        .kd_stars
        .within(
            &[
                (&img_centre_xyz).x,
                (&img_centre_xyz).y,
                (&img_centre_xyz).z,
            ],
            cli_args.radius.to_radians() * cli_args.radius.to_radians(),
            &squared_euclidean,
        );

    let cat_stars: Vec<(usize, Vector2<f64>, &String)> = cat_stars
        .into_iter()
        .filter(|&(_, &idx)| index.stars.get(idx).unwrap().mag_v < LIMITING_MAGNITUDE)
        .map(|(_, &idx)| idx)
        // project them all into pixel space. Vec<(cat_stars_idx, (x, y, opt<name>))>
        .map(|star_idx| {
            let star = &index.stars[star_idx];
            wcs.world_2_pix(index.stars[star_idx].spherical())
                .map(|v| (star_idx, v, star.name_or_identifier()))
        })
        // remove the ones that fail to be projected
        .filter(|x| x.is_some())
        // unwrap those that remain
        .map(|x| x.unwrap())
        // filter out those that are outside the image
        .filter(|(_, p, _)| {
            p.x >= 0f64
                && p.y >= 0f64
                && p.x <= cli_args.img_w as f64
                && p.y <= cli_args.img_h as f64
        })
        .collect();

    println!("num cat stars in radius: {:?}", cat_stars.len());
    println!("cat stars {:?}", &cat_stars);

    cat_stars
}

fn get_quads_in_img<'a>(
    cat_stars: &[(usize, Vector2<f64>, &String)],
    index: &'a StarIndex,
) -> Vec<&'a Quad> {
    let mut cat_star_indices = HashSet::new();
    for &(idx, _, _) in cat_stars {
        cat_star_indices.insert(idx);
    }

    index
        .quads
        .iter()
        .filter(|&q| {
            cat_star_indices.contains(&q.a)
                && cat_star_indices.contains(&q.b)
                && cat_star_indices.contains(&q.c)
                && cat_star_indices.contains(&q.d)
        })
        .collect()
}

pub fn create_annotated_image(
    cat_stars: Vec<(usize, Vector2<f64>, &String)>,
    quads_in_img: Vec<&Quad>,
    img_w: u32,
    img_h: u32,
    index: &StarIndex,
) -> RgbaImage {
    let red = Rgba([255u8, 0u8, 0u8, 255u8]);
    let green = Rgba([0u8, 255u8, 0u8, 64u8]);

    let font = Vec::from(include_bytes!("DejaVuSans.ttf") as &[u8]);
    let font = Font::try_from_vec(font).unwrap();

    let height = 18f32;
    let scale = Scale {
        x: height,
        y: height,
    };

    let mut new_img = RgbaImage::new(img_w, img_h);
    let mut cat_map: HashMap<usize, Vector2<f64>> = HashMap::new();

    for &(idx, point, name) in cat_stars.iter() {
        let centre = (point.x as i32, point.y as i32);
        draw_hollow_circle_mut(&mut new_img, centre, ANNOTATED_IMG_MARKER_SRC_RADIUS, red);

        draw_text_mut(
            &mut new_img,
            red,
            (point.x as u32).saturating_sub(5u32),
            (point.y as u32).saturating_sub(30u32),
            scale,
            &font,
            name,
        );

        cat_map.insert(idx, point.clone_owned());
    }

    let wanted: [usize; 4] = [73, 1664, 131, 3837];
    for &quad in quads_in_img.iter() {
        let mut count = 0;
        if wanted.contains(&quad.a) {
            count += 1;
        }
        if wanted.contains(&quad.b) {
            count += 1;
        }
        if wanted.contains(&quad.c) {
            count += 1;
        }
        if wanted.contains(&quad.d) {
            count += 1;
        }

        if count >= 3 {
            println!(
                "count {:?}: {:?} ({:}, {:}, {:}, {:})",
                count,
                quad,
                index.stars[quad.a].name_or_identifier(),
                index.stars[quad.b].name_or_identifier(),
                index.stars[quad.c].name_or_identifier(),
                index.stars[quad.d].name_or_identifier()
            );
        }

        let quad_points = &[
            (
                cat_map.get(&quad.a).unwrap().x as f32,
                cat_map.get(&quad.a).unwrap().y as f32,
            ),
            (
                cat_map.get(&quad.b).unwrap().x as f32,
                cat_map.get(&quad.b).unwrap().y as f32,
            ),
            (
                cat_map.get(&quad.c).unwrap().x as f32,
                cat_map.get(&quad.c).unwrap().y as f32,
            ),
            (
                cat_map.get(&quad.d).unwrap().x as f32,
                cat_map.get(&quad.d).unwrap().y as f32,
            ),
        ];

        draw_line_segment_mut(&mut new_img, quad_points[0], quad_points[2], green);

        draw_line_segment_mut(&mut new_img, quad_points[2], quad_points[1], green);

        draw_line_segment_mut(&mut new_img, quad_points[1], quad_points[3], green);

        draw_line_segment_mut(&mut new_img, quad_points[3], quad_points[0], green);
    }

    new_img
}