use super::helpers::{
OrientedCircles, inscribed_from_spanning_ray, refine_stations, reverse_inscribed_circles,
};
use crate::AngleDir::{Ccw, Cw};
use crate::Resample::ByCount;
use crate::airfoil::inscribed_circle::InscribedCircle;
use crate::common::points::{dist, mid_point};
use crate::geom2::hull::farthest_pair_indices;
use crate::geom2::polyline2::SpanningRay;
use crate::geom2::{LineOps2, rot90};
use crate::{Curve2, UnitVec2};
use crate::{Line2, Result};
use parry2d_f64::query::Ray;
use parry2d_f64::shape::ConvexPolygon;
pub fn camber_detect_upper_dir(camber_line: &Curve2) -> Result<UnitVec2> {
let check = Line2::from_points(
&camber_line.at_front().point(),
&camber_line.at_back().point(),
);
let resampled = camber_line.resample(ByCount(50))?;
let mut best = 0.0;
let mut best_point = None;
for p in resampled.points() {
let cp = check.projected_point(p);
let d = dist(p, &cp);
if d > best {
best = d;
best_point = Some(p);
}
}
if let Some(point) = best_point {
let cp = check.projected_point(point);
let dir = point - cp;
Ok(UnitVec2::new_normalize(dir))
} else {
Err("Failed to find point on camber line for face orientation detection".into())
}
}
pub fn extract_camber_line(
section: &Curve2,
hull: &ConvexPolygon,
tol: Option<f64>,
) -> Result<Vec<InscribedCircle>> {
let (i0, i1) = farthest_pair_indices(hull);
let p0 = &hull.points()[i0];
let p1 = &hull.points()[i1];
let dir = p1 - p0;
let normal = rot90(Cw) * dir;
let mid_ray = Ray::new(mid_point(p0, p1), normal);
let spanning = section
.try_create_spanning_ray(&mid_ray)
.ok_or("Failed to create first spanning ray")?;
let mut stations0 = extract_half_camber_line(section, &spanning, tol)?;
let stations1 = extract_half_camber_line(section, &spanning.reversed(), tol)?;
reverse_inscribed_circles(&mut stations0);
stations0.extend(stations1);
Ok(stations0)
}
fn advance_search_along_ray(
section: &Curve2,
last_station: &InscribedCircle,
general_tol: f64,
) -> RayAdvance {
let camber_point = last_station.camber_point();
let (_, farthest) = section
.max_point_in_direction(&camber_point.normal)
.unwrap();
let distance = camber_point.scalar_projection(&farthest);
if distance - last_station.radius() < last_station.radius() * 0.375 {
return RayAdvance::End;
}
let mut frac = 0.25;
while frac > 0.05 {
let advance_dist = frac * last_station.radius();
if advance_dist < general_tol {
return RayAdvance::End;
}
let next_center = camber_point.at_distance(advance_dist);
let test_dir = rot90(Ccw) * camber_point.normal;
let test_ray = Ray::new(next_center, test_dir.into_inner());
if let Some(ray) = section.try_create_spanning_ray(&test_ray) {
let last_dist = dist(&last_station.contact_pos, &last_station.contact_neg);
let new_dist = ray.dir().norm();
if new_dist < 0.5 * last_dist {
frac *= 0.75;
continue;
}
return RayAdvance::Valid(ray);
} else {
frac *= 0.75;
}
}
RayAdvance::Failed
}
enum RayAdvance {
Valid(SpanningRay),
End,
Failed,
}
fn extract_half_camber_line(
curve: &Curve2,
starting_ray: &SpanningRay,
tol: Option<f64>,
) -> Result<Vec<InscribedCircle>> {
let outer_tol = tol.unwrap_or(1e-3);
let inner_tol = outer_tol * 1e-2;
let mut stations = OrientedCircles::create(false);
let mut refine_stack: Vec<InscribedCircle> = Vec::new();
let mut ray = starting_ray.clone();
loop {
let circle = inscribed_from_spanning_ray(curve, &ray, inner_tol);
refine_stack.push(circle);
refine_stations(
curve,
&mut stations,
&mut refine_stack,
outer_tol,
inner_tol,
);
let station = &stations.last().expect("Station was not transferred");
match advance_search_along_ray(curve, station, outer_tol) {
RayAdvance::Valid(r) => {
ray = r;
}
RayAdvance::End => {
break;
}
RayAdvance::Failed => {
return Err(Box::from("Failed to advance search along ray"));
}
};
}
Ok(stations.take_circles())
}