solvastro 0.1.1

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

use glob::glob_with;
use glob::MatchOptions;
use image::io::Reader as ImageReader;
use image::{DynamicImage, GenericImageView};
use structopt::StructOpt;

use solvastro::create_query::create_query;
use solvastro::process_image;
use solvastro::process_image::create_point_extraction_handlers;
use solvastro::settings::Settings;
use solvastro::structs_f64::query::Query;
use std::fs::File;
use std::path::PathBuf;

#[derive(Debug, StructOpt)]
struct CliArgs {
    image_path_pattern: String,

    /// JSON file to write for batch-test.
    #[structopt(long, parse(from_os_str), default_value = "input/query-batch.json")]
    output: PathBuf,
}

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

    let options = MatchOptions {
        case_sensitive: true,
        require_literal_separator: true,
        require_literal_leading_dot: true,
    };

    let mut queries: Vec<Query> = vec![];

    for path in glob_with(&cli_args.image_path_pattern, options)
        .unwrap()
        .flatten()
    {
        println!("processing {:?}...", path.display());

        let img: DynamicImage = ImageReader::open(&path)?.decode()?;
        println!("Dimensions: {:?}", img.dimensions());

        let processed_image = process_image::process_image(&img)?;

        let (point_detector, point_fitter) =
            create_point_extraction_handlers(&config.query_generator);

        let query = create_query(
            path.to_str().unwrap(),
            &processed_image,
            point_detector,
            point_fitter,
        );
        println!("Query points: {:?}", query.points.len());

        queries.push(query);
    }

    println!("saving batch of {:?} queries", queries.len());
    serde_json::to_writer(File::create(&cli_args.output)?, &queries)?;
    Ok(())
}