solvastro 0.1.1

A Rust blind plate solver
Documentation
use super::generate_query_quads::QuadProducer;
use super::matcher::{calc_code, matcher};
use super::solver::solver;
use super::tuner::tune_until_best;
use super::verified_solution::VerifiedSolution;
use super::verifier::verifier;
use crate::dynamic_index::star_index_container::ReadableStarIndexContainer;
use crate::settings::Settings;
use crate::structs_f64::quad::{Quad, QuadCode};
use crate::structs_f64::query::{Query, QueryPoint};
use log::*;
use nalgebra::{Vector2, Vector3};

const THRESHOLD_STOP: f64 = 100f64;
const THRESHOLD_TUNE: f64 = 60f64;

pub fn process_query(
    index: &ReadableStarIndexContainer,
    query: &Query,
    config: &Settings,
) -> (
    Option<VerifiedSolution>,
    Vec<QuadCode>,
    Vec<(Vector3<f64>, f32, usize)>,
) {
    let mut cat_star_query_log: Vec<(Vector3<f64>, f32, usize)> = vec![];

    let query_quad_producer = QuadProducer::new(&query);
    let mut query_quads = query_quad_producer.generate_query_quads();
    let mut quad_matches = matcher(&mut query_quads, &query, &index);
    let mut candidate_solutions = solver(&mut quad_matches, &query, &index, config);
    let verified_solutions = verifier(
        &mut candidate_solutions,
        &query,
        &index,
        &mut cat_star_query_log,
    );

    let (best_solution, attempts) = first_acceptable_or_best(verified_solutions, &query);

    if let Some(vsol) = best_solution {
        debug!(
            "Initial Solution WCS: {:?}",
            &vsol.solution.as_ref().unwrap().wcs
        );
        info!("Initial Solution logodds: {:}", &vsol.logodds);

        if vsol.logodds > THRESHOLD_TUNE {
            let tuned = tune_until_best(vsol, query, index, &config.tuner, &mut cat_star_query_log);
            return (Some(tuned), attempts, cat_star_query_log);
        } else {
            info!(
                "logodds < TUNE_THRESHOLD ({:}). Not bothering to tune",
                THRESHOLD_TUNE
            );

            return (Some(vsol), attempts, cat_star_query_log);
        }
    }

    (None, attempts, cat_star_query_log)
}

fn first_acceptable_or_best(
    verified_solns_iter: impl Iterator<Item = VerifiedSolution>,
    query: &Query,
) -> (Option<VerifiedSolution>, Vec<QuadCode>) {
    let mut best_solution_logodds = f64::NEG_INFINITY;
    let mut best_solution: Option<VerifiedSolution> = None;

    let mut performed = vec![];

    for verified_solution in verified_solns_iter {
        let query_quad: Quad = verified_solution.solution.as_ref().unwrap().query_quad;
        let query_code = calc_code(&query_quad, &query.points);
        performed.push(query_code);

        if verified_solution.logodds > best_solution_logodds {
            best_solution_logodds = verified_solution.logodds;
            best_solution = Some(verified_solution);
            if best_solution_logodds > THRESHOLD_STOP {
                info!(
                    "Stopping verification early, got a strong match (logodds: {:?})",
                    best_solution_logodds
                );
                break;
            } else {
                info!("New best solution (logodds: {:?})", best_solution_logodds);
            }
        }
    }
    info!(
        "Finished verification. Strongest match has logodds {:?}",
        best_solution_logodds
    );

    (best_solution, performed)
}

pub fn undistort_query(query: &Query, distortion_params: (f64, f64)) -> Query {
    let scale = Vector2::new((query.img_w / 2) as f64, (query.img_h / 2) as f64);
    println!("scale: {:?}", &scale);

    let points = query
        .points
        .iter()
        .map(|p| {
            let orig = Vector2::new(p.x, p.y);
            println!("orig: {:?}", &orig);
            let mag = (orig - scale).magnitude();
            println!("mag: {:?}", &mag);

            let normalized = (orig - scale).normalize();
            println!("normalized: {:?}", &normalized);

            let correction_factor =
                1.0 + (mag * distortion_params.0) + (mag * mag * distortion_params.1);
            println!("correction_factor: {:?}", &correction_factor);

            let undistorted = scale + normalized.scale(correction_factor * mag);
            println!("undistorted: {:?}", &undistorted);

            QueryPoint {
                x: undistorted[0],
                y: undistorted[1],
                ..*p
            }
        })
        .collect::<Vec<_>>();

    Query {
        filename: query.filename.clone(),
        img_w: query.img_w,
        img_h: query.img_h,
        points,
    }
}

#[cfg(test)]
mod tests {
    use super::undistort_query;
    use crate::structs_f64::query::{Query, QueryPoint};

    #[test]
    fn can_correct_radial_distortion() {
        let query = Query {
            filename: "file".to_string(),
            img_w: 100,
            img_h: 100,
            points: vec![
                QueryPoint {
                    x: 50.0,
                    y: 50.0,
                    amplitude: 100.0,
                    radius: 2.0,
                },
                QueryPoint {
                    x: 25.0,
                    y: 25.0,
                    amplitude: 100.0,
                    radius: 2.0,
                },
                QueryPoint {
                    x: 55.0,
                    y: 55.0,
                    amplitude: 100.0,
                    radius: 2.0,
                },
            ],
        };

        let undistorted_query = undistort_query(&query, (0.004, 0.0));

        assert_eq!(undistorted_query.points[0].x, 50.0);
        assert_eq!(undistorted_query.points[0].y, 50.0);

        assert_eq!(undistorted_query.points[1].x, 45.58058261758408);
        assert_eq!(undistorted_query.points[1].y, 45.58058261758408);

        assert_eq!(undistorted_query.points[2].x, 54.41941738241592);
        assert_eq!(undistorted_query.points[2].y, 54.41941738241592);
    }
}