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)> {
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,
));
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)
.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()))
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.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
}