use crate::airfoil2::{AfGeometry, AfPos, AfSide};
use crate::common::dist;
use crate::geom2::Segment2;
use crate::geom2::hull::convex_hull_2d;
use crate::metrology::Distance2;
use crate::{Curve2, Point2, Result, SurfacePoint2};
pub fn thickness(geom: &AfGeometry, method: AfPos, value: f64) -> Option<Distance2> {
let lower = geom.af_point(AfSide::Lower, method, value)?;
let upper = geom.af_point(AfSide::Upper, method, value)?;
Some(Distance2::new(lower.point(), upper.point(), None))
}
pub fn max_thickness(geom: &AfGeometry) -> Distance2 {
let c = geom.max_thickness_circle();
Distance2::new(c.p0, c.p1, None)
}
#[allow(dead_code)] pub fn caliper_chord_line(section: &Curve2, camber: &Curve2) -> Result<(Segment2, Segment2)> {
let hull_indices = convex_hull_2d(section.points());
let mut max_dist = 0.0;
let mut max_p1 = Point2::origin();
let mut max_p2 = Point2::origin();
for i in 0..hull_indices.len() {
let i1 = hull_indices[i];
let i2 = hull_indices[(i + 1) % hull_indices.len()];
let p1 = section.points()[i1];
let p2 = section.points()[i2];
let d = dist(&p1, &p2);
if d > max_dist {
max_dist = d;
max_p1 = p1;
max_p2 = p2;
}
}
let camber_le = camber.at_front().point();
let chord = if dist(&max_p1, &camber_le) < dist(&max_p2, &camber_le) {
SurfacePoint2::new_normalize(max_p1, max_p2 - max_p1)
} else {
SurfacePoint2::new_normalize(max_p2, max_p1 - max_p2)
};
let te = section
.max_point_in_direction(&chord.normal)
.ok_or("Failed to find trailing edge")?;
let le = section
.max_point_in_direction(&-chord.normal)
.ok_or("Failed to find leading edge")?;
let _chord_line = Segment2::new(&le.1, &te.1)?;
let _tangent_line = Segment2::new(&chord.projection(&le.1), &chord.projection(&te.1))?;
todo!()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::airfoil2::{AfEdgeSearch, OrientFwdAft, OrientUpperLower};
use crate::common::mid_point;
use crate::metrology::Measurement;
use crate::tests::airfoil_curve;
use approx::assert_relative_eq;
const TOL: f64 = 1e-3;
fn analyzed() -> Result<AfGeometry> {
AfGeometry::try_from_geometric_analysis(
&airfoil_curve(),
TOL,
OrientFwdAft::TmaxFwd,
OrientUpperLower::Curvature,
AfEdgeSearch::Auto,
AfEdgeSearch::Auto,
)
}
#[test]
fn thickness_endpoints_are_on_the_correct_surfaces() -> Result<()> {
let geom = analyzed()?;
let mid = geom.camber.length() * 0.5;
let d = thickness(&geom, AfPos::OnCamber, mid).ok_or("Failed to measure thickness")?;
assert!(d.value() > 0.0, "Thickness should be positive");
assert_relative_eq!(geom.lower.dist_to_point(&d.a), 0.0, epsilon = 1e-9);
assert_relative_eq!(geom.upper.dist_to_point(&d.b), 0.0, epsilon = 1e-9);
assert_relative_eq!(d.value(), dist(&d.a, &d.b), epsilon = 1e-12);
Ok(())
}
#[test]
fn thickness_works_for_every_position_method() -> Result<()> {
let geom = analyzed()?;
let tmax = geom.max_thickness_circle().radius() * 2.0;
let cases = [
(AfPos::OnCamber, geom.camber.length() * 0.5),
(AfPos::Radius, geom.camber.length() * 0.25),
(AfPos::EdgeOffset, geom.camber.length() * 0.02),
];
for (method, value) in cases {
let d = thickness(&geom, method, value)
.ok_or_else(|| format!("Failed to measure thickness with {method:?}"))?;
assert!(
d.value() > 0.0 && d.value() <= tmax,
"Thickness of {} with {:?} is not in (0, {}]",
d.value(),
method,
tmax
);
}
Ok(())
}
#[test]
fn thickness_beyond_the_camber_is_none() -> Result<()> {
let geom = analyzed()?;
let past_end = geom.camber.length() * 1.5;
assert!(thickness(&geom, AfPos::OnCamber, past_end).is_none());
Ok(())
}
#[test]
fn max_thickness_matches_the_largest_inscribed_circle() -> Result<()> {
let geom = analyzed()?;
let d = max_thickness(&geom);
let diameter = geom.max_thickness_circle().radius() * 2.0;
assert_relative_eq!(d.value(), diameter, epsilon = TOL * 0.1);
assert_relative_eq!(geom.lower.dist_to_point(&d.a), 0.0, epsilon = 1e-9);
assert_relative_eq!(geom.upper.dist_to_point(&d.b), 0.0, epsilon = 1e-9);
Ok(())
}
#[test]
fn max_thickness_is_the_inscribed_circle_not_the_orthogonal_maximum() -> Result<()> {
let geom = analyzed()?;
let inscribed = max_thickness(&geom).value();
let steps = 2000;
let length = geom.camber.length();
let mut best: Option<Distance2> = None;
for i in 1..steps {
let l = length * (i as f64) / (steps as f64);
if let Some(d) = thickness(&geom, AfPos::OnCamber, l)
&& best.as_ref().is_none_or(|b| d.value() > b.value())
{
best = Some(d);
}
}
let best = best.ok_or("The camber sweep found no valid positions")?;
assert!(
best.value() > inscribed,
"Expected the orthogonal sweep ({}) to exceed the inscribed diameter ({})",
best.value(),
inscribed
);
let section = airfoil_curve();
let clearance = section.dist_to_point(&mid_point(&best.a, &best.b));
assert!(
clearance < best.value() / 2.0,
"The sweep peak chord of {} has clearance {} at its midpoint, so it would fit as an \
inscribed circle and the two definitions should not have disagreed",
best.value(),
clearance
);
let c = geom.max_thickness_circle();
assert_relative_eq!(
section.dist_to_point(&mid_point(&c.p0, &c.p1)),
c.radius(),
epsilon = TOL * 0.1
);
Ok(())
}
}