pub mod camber;
pub mod edges;
mod geometry;
pub mod inscribed;
mod measurements;
pub mod orient;
mod position;
use crate::airfoil2::geometry::geometry_only_analysis;
use crate::airfoil2::inscribed::Inscribed;
use crate::airfoil2::position::{pos_camber, pos_offset, pos_radius};
use crate::metrology::Distance2;
use crate::{Curve2, CurveStation2, Point2, Result};
pub use orient::{OrientFwdAft, OrientUpperLower};
use serde::{Deserialize, Serialize};
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum AfSide {
Upper,
Lower,
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
pub enum AfPos {
OnCamber,
Radius,
EdgeOffset,
}
pub struct SectionInput<'a> {
pub section: &'a Curve2,
pub general_tol: f64,
pub resolve_tol: f64,
}
impl<'a> SectionInput<'a> {
pub fn new(section: &'a Curve2, general_tol: f64) -> Self {
Self {
section,
general_tol,
resolve_tol: general_tol * 0.1,
}
}
}
#[derive(Debug, Clone, Copy)]
pub enum AfEdgeSearch {
Auto,
Open,
Sharp,
Square,
RoundedSquare,
FullRound,
BlendedRound,
SplineMaxK,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum AfEdgeGeometry {
Open,
Sharp(Point2),
Square(Point2, Point2),
RoundedSquare(Point2, Point2, f32),
FullRound(Point2, f32),
BlendedRound(Point2, f32),
SplineMaxK(Point2, f32),
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct AfEdge {
pub point: Point2,
pub geometry: AfEdgeGeometry,
}
impl AfEdge {
pub fn new(point: Point2, geometry: AfEdgeGeometry) -> Self {
Self { point, geometry }
}
}
#[derive(Clone)]
pub struct AfGeometry {
pub leading: AfEdge,
pub trailing: AfEdge,
pub camber: Curve2,
pub upper: Curve2,
pub lower: Curve2,
pub circles: Vec<Inscribed>,
}
impl AfGeometry {
pub fn af_point(&self, side: AfSide, method: AfPos, value: f64) -> Option<CurveStation2<'_>> {
let target = match side {
AfSide::Upper => &self.upper,
AfSide::Lower => &self.lower,
};
match method {
AfPos::OnCamber => pos_camber(value, &self.camber, target),
AfPos::Radius => pos_radius(value, &self.camber, target),
AfPos::EdgeOffset => pos_offset(value, &self.camber, target),
}
}
pub fn thickness_at(&self, method: AfPos, value: f64) -> Option<Distance2> {
measurements::thickness(self, method, value)
}
pub fn max_thickness(&self) -> Distance2 {
measurements::max_thickness(self)
}
pub fn try_from_geometric_analysis(
section: &Curve2,
general_tol: f64,
fwd_aft: OrientFwdAft,
upper_lower: OrientUpperLower,
le_search: AfEdgeSearch,
te_search: AfEdgeSearch,
) -> Result<Self> {
geometry_only_analysis(
section,
general_tol,
fwd_aft,
upper_lower,
le_search,
te_search,
)
}
pub fn max_thickness_circle(&self) -> &Inscribed {
self.circles
.iter()
.max_by(|a, b| {
a.c.r()
.partial_cmp(&b.c.r())
.unwrap_or(std::cmp::Ordering::Equal)
})
.expect("AfGeometry is guaranteed to contain at least one inscribed circle")
}
}