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);
}
}