use crate::airfoil::InscribedCircle;
use crate::common::Intersection;
use crate::common::points::{dist, ramer_douglas_peucker};
use crate::geom2::polyline2::SpanningRay;
use crate::geom2::{LineOps2, Segment2, UnitVec2, intersection_param};
use crate::{Circle2, Curve2, Point2, Result, SurfacePoint2};
pub fn reverse_inscribed_circles(stations: &mut [InscribedCircle]) {
stations.reverse();
stations.iter_mut().for_each(|i| i.reverse_in_place());
}
pub fn curve_from_inscribed_circles(stations: &[InscribedCircle], tol: f64) -> Result<Curve2> {
let camber_points = stations.iter().map(|c| c.circle.center).collect::<Vec<_>>();
Curve2::from_points(&camber_points, tol, false)
}
pub fn find_tmax_circle(stations: &[InscribedCircle]) -> Option<&InscribedCircle> {
let mut max_diameter = 0.0;
let mut max_circle = None;
for c in stations {
let diameter = c.circle.ball.radius * 2.0;
if diameter > max_diameter {
max_diameter = diameter;
max_circle = Some(c);
}
}
max_circle
}
pub fn inscribed_from_spanning_ray(curve: &Curve2, ray: &SpanningRay, tol: f64) -> InscribedCircle {
let mut positive = InscribedCircleSearchState::new(1.0, ray.at(1.0));
let mut negative = InscribedCircleSearchState::new(0.0, ray.at(0.0));
let mut working;
while (positive.fraction - negative.fraction) * ray.dir().norm() > tol {
let fraction = (positive.fraction + negative.fraction) * 0.5;
working = ray.at(fraction);
let closest = curve.at_closest_to_point(&working);
let to_closest = closest.point() - working; let distance = dist(&working, &closest.point());
if to_closest.dot(&ray.dir()) > 0.0 {
positive.update(fraction, distance, closest.point());
} else {
negative.update(fraction, distance, closest.point());
}
}
let circle = Circle2::from_point(
ray.at((positive.fraction + negative.fraction) * 0.5),
(positive.distance + negative.distance) * 0.5,
);
InscribedCircle::new(ray.clone(), positive.point, negative.point, circle)
}
struct InscribedCircleSearchState {
fraction: f64,
distance: f64,
point: Point2,
}
impl InscribedCircleSearchState {
fn new(fraction: f64, point: Point2) -> InscribedCircleSearchState {
InscribedCircleSearchState {
fraction,
distance: 0.0,
point,
}
}
fn update(&mut self, fraction: f64, distance: f64, point: Point2) {
self.distance = distance;
self.fraction = fraction;
self.point = point;
}
}
fn portion_weight(portion: &Curve2, sp: &SurfacePoint2) -> f64 {
let mut total = 0.0;
for i in 0..portion.points().len() - 1 {
let p0 = portion.points()[i];
let p1 = portion.points()[i + 1];
let w = 0.5 * (sp.scalar_projection(&p0) + sp.scalar_projection(&p1));
let l = dist(&p0, &p1);
total += w * l;
}
total / portion.length()
}
pub fn extract_curve_beyond_station(
section: &Curve2,
last_station: &InscribedCircle,
direction: &UnitVec2,
) -> Option<Curve2> {
let split0 = section.at_closest_to_point(&last_station.contact_pos);
let split1 = section.at_closest_to_point(&last_station.contact_neg);
let portion0 = section.between_lengths(split0.length_along(), split1.length_along());
let portion1 = section.between_lengths(split1.length_along(), split0.length_along());
let sp = SurfacePoint2::new(last_station.center(), *direction);
match (portion0, portion1) {
(Some(p0), Some(p1)) => {
let w0 = portion_weight(&p0, &sp);
let w1 = portion_weight(&p1, &sp);
Some(if w0 > w1 { p0 } else { p1 })
}
(Some(p0), None) => {
if portion_weight(&p0, &sp) > 0.0 {
Some(p0)
} else {
None
}
}
(None, Some(p1)) => {
if portion_weight(&p1, &sp) > 0.0 {
Some(p1)
} else {
None
}
}
(None, None) => None,
}
}
pub fn extract_edge_sub_curve(
section: &Curve2,
last_station: &InscribedCircle,
tol_fraction: Option<f64>,
) -> Option<Curve2> {
let frac = tol_fraction.unwrap_or(0.25);
let split0 = section.at_closest_to_point(&last_station.spanning_ray.origin());
let split1 = section.at_closest_to_point(
&(last_station.spanning_ray.origin() + last_station.spanning_ray.dir()),
);
let portion0 = section.between_lengths(split0.length_along(), split1.length_along());
let portion1 = section.between_lengths(split1.length_along(), split0.length_along());
let perimeter = section.length();
if let Some(p0) = portion0
&& p0.length() < perimeter * frac
{
return Some(p0);
}
if let Some(p1) = portion1
&& p1.length() < perimeter * frac
{
return Some(p1);
}
None
}
pub struct OrientedCircles {
circles: Vec<InscribedCircle>,
reversed: bool,
}
impl OrientedCircles {
pub fn create(reversed: bool) -> Self {
OrientedCircles {
circles: Vec::new(),
reversed,
}
}
pub fn new(circles: Vec<InscribedCircle>, reversed: bool) -> Self {
OrientedCircles { circles, reversed }
}
pub fn get_full_curve(&self) -> Result<Curve2> {
let curve = curve_from_inscribed_circles(&self.circles, 1e-4)?;
if self.reversed {
Ok(curve.reversed())
} else {
Ok(curve)
}
}
pub fn discard_sections_beyond_point(&mut self, p: &Point2) {
let c = self.get_full_curve().unwrap();
let l = c.at_closest_to_point(p).length_along();
self.circles.retain(|cr| {
let d = c.at_closest_to_point(&cr.center()).length_along();
d < l
});
}
pub fn get_end_curve(&self, distance: f64) -> Result<Curve2> {
let mut total = 0.0;
let mut points = Vec::new();
if self.circles.len() < 2 {
return Err(Box::from(
"Cannot create a curve from less than two circles",
));
}
let mut i = if self.reversed {
0
} else {
self.circles.len() - 1
};
while total < distance {
let c = &self.circles[i];
if let Some(last) = points.last() {
total += dist(last, &c.center());
}
points.push(c.circle.center);
if self.reversed {
if i == self.circles.len() - 1 {
break;
}
i += 1;
} else {
if i == 0 {
break;
}
i -= 1;
}
}
let points = points.into_iter().rev().collect::<Vec<_>>();
Curve2::from_points(&points, 1e-4, false)
}
pub fn last(&self) -> Option<&InscribedCircle> {
if self.reversed {
self.circles.first()
} else {
self.circles.last()
}
}
pub fn push(&mut self, circle: InscribedCircle) {
let mut c = circle;
if let Some(last) = self.last()
&& last.spanning_ray.dir().dot(&c.spanning_ray.dir()) < 0.0
{
c.reverse_in_place();
}
if self.reversed {
self.circles.insert(0, c);
} else {
self.circles.push(c);
}
}
pub fn intersect_from_end(&self, section: &Curve2) -> Result<Point2> {
let last = self.last().ok_or("No inscribed circles in container")?;
let c = self.get_end_curve(last.radius())?;
let end = c.at_back().direction_line();
let ts = section
.intersection(&end)
.iter()
.map(|(t, _)| *t)
.collect::<Vec<_>>();
if ts.is_empty() {
Err("Failed to find intersection with airfoil section".into())
} else {
let t = ts.iter().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap();
Ok(end.at(*t))
}
}
pub fn take_circles(self) -> Vec<InscribedCircle> {
self.circles
}
pub fn end_sp(&self) -> Result<SurfacePoint2> {
if self.circles.len() < 2 {
return Err(Box::from(
"Cannot create a curve from less than two circles",
));
}
let centers = self
.circles
.iter()
.map(|c| c.circle.center)
.collect::<Vec<_>>();
let simplified = ramer_douglas_peucker(¢ers, 1e-4);
if simplified.len() < 2 {
return Err(Box::from(
"Failed to simplify circle centers, not enough points remaining",
));
}
let (p0, p1) = if self.reversed {
(simplified[1], simplified[0])
} else {
(
simplified[simplified.len() - 2],
simplified[simplified.len() - 1],
)
};
let d = UnitVec2::try_new(p1 - p0, 1e-12).ok_or(format!(
"Failed to create direction vector ({} circles)",
self.circles.len()
))?;
Ok(SurfacePoint2::new(p1, d))
}
pub fn end_intersection_with_seg(&self, seg: &Segment2) -> Result<Point2> {
let sp = self.end_sp()?;
if let Some((t0, _)) =
intersection_param(&sp.point, &sp.normal.into_inner(), &seg.a, &seg.dir())
{
Ok(sp.at_distance(t0))
} else {
Err("Failed to find camber end intersection with segment".into())
}
}
}
pub fn refine_stations(
section: &Curve2,
dest: &mut OrientedCircles,
stack: &mut Vec<InscribedCircle>,
outer_tol: f64,
inner_tol: f64,
) {
while let Some(next) = stack.pop() {
if let Some(last) = dest.last() {
let n = if next.spanning_ray.dir().dot(&last.spanning_ray.dir()) < 0.0 {
next.reversed()
} else {
next
};
let test_ray = n.spanning_ray.symmetry(&last.spanning_ray);
if let Some(ray) = section.try_create_spanning_ray(&test_ray) {
let mid = inscribed_from_spanning_ray(section, &ray, inner_tol);
let error = mid.interpolation_error(&n, last);
if error > outer_tol {
stack.push(n);
stack.push(mid);
} else {
dest.push(n);
}
}
} else {
dest.push(next);
}
}
}