solvastro 0.1.1

A Rust blind plate solver
Documentation
extern crate log;

use std::error::Error;
use std::fs::File;
use std::io::BufWriter;
use std::path::PathBuf;
use std::time::{Duration, Instant};

use memmap::MmapOptions;
use nalgebra::Vector3;
use structopt::StructOpt;

use solvastro::dynamic_index::process_query::process_query;
use solvastro::dynamic_index::star_index_container::ReadableStarIndexContainer;
use solvastro::dynamic_index::verified_solution::VerifiedSolution;
use solvastro::settings::Settings;
use solvastro::structs_f64::quad::QuadCode;
use solvastro::structs_f64::query::Query;

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

    /// Save code-query and catalogue-star-query logs as JSON.
    #[structopt(long)]
    save_results: bool,
}

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

    let file = File::open(cli_args.star_index.as_path())?;
    let buf = unsafe { MmapOptions::new().map(&file)? };

    let index = ReadableStarIndexContainer::load(&buf)?;
    println!("index loaded: {:?}", &index);

    let duration_startup = start.elapsed();

    let queries: Vec<Query> = serde_json::from_reader(File::open("input/query-batch.json")?)?;
    let mut cat_star_query_log: Vec<Vec<(Vector3<f64>, f32, usize)>> = vec![];
    let start = Instant::now();

    let best_solutions: Vec<(String, (Option<VerifiedSolution>, Vec<QuadCode>), Duration)> =
        queries
            .into_iter()
            .map(|query| {
                let start_1 = Instant::now();
                log::info!("starting process_query");
                let result = process_query(&index, &query, &config);
                log::info!("result: {:?}", &result);
                let duration_processing_1 = start_1.elapsed();
                cat_star_query_log.push(result.2);

                (
                    query.filename.clone(),
                    (result.0, result.1),
                    duration_processing_1,
                )
            })
            .collect();

    let duration_processing = start.elapsed();

    let mut total_logodds = 0f64;
    let mut all_attempts: Vec<QuadCode> = vec![];

    for (filename, (sol, mut attempts), elapsed) in best_solutions {
        if let Some(best_solution) = sol {
            let cat_quad_idx = best_solution.solution.as_ref().map(|s| s.cat_quad_idx);
            println!(
                "{:?} logodds: {:?}, cat_quad_idx: {:?}, duration: {:?}",
                &filename, &best_solution.logodds, cat_quad_idx, &elapsed
            );
            total_logodds += best_solution.logodds;
        }

        all_attempts.append(&mut attempts);
    }

    println!("Total Logodds: {:?}", &total_logodds);
    println!("Startup time: {:?}", duration_startup);
    println!("Processing time: {:?}", duration_processing);

    if cli_args.save_results {
        let file = BufWriter::new(File::create("batch-test-k6-code-queries.json")?);
        serde_json::to_writer(file, &all_attempts).expect("could not save code query list");

        let file = BufWriter::new(File::create("batch-test-k6-cat_star_query_log.json")?);
        serde_json::to_writer(file, &cat_star_query_log)
            .expect("could not save cat_star_query_log");
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn save_results_is_opt_in() {
        let defaults = CliArgs::from_iter_safe(["batch-test", "index.rkyv"]).unwrap();
        assert!(!defaults.save_results);

        let enabled =
            CliArgs::from_iter_safe(["batch-test", "index.rkyv", "--save-results"]).unwrap();
        assert!(enabled.save_results);
    }
}