use crate::common::points::three_point_angle;
use crate::{Point2, Result};
pub type StripFace = [u32; 3];
pub fn build_parallel_row_strip(
a: &[StripRowPoint],
y_a: f64,
b: &[StripRowPoint],
y_b: f64,
max_edge_ratio: f64,
) -> Result<Vec<StripFace>> {
let mut state = StripRowState::try_new(a, y_a, b, y_b, max_edge_ratio)?;
let mut faces = Vec::new();
while !state.is_done() {
let next_0 = state.next_0();
let next_1 = state.next_1();
match (next_0, next_1) {
(Some((e0, f0)), Some((e1, f1))) => {
if e0 < e1 {
faces.push(f0);
state.advance_0();
} else {
faces.push(f1);
state.advance_1();
}
}
(Some((_, f0)), None) => {
faces.push(f0);
state.advance_0();
}
(None, Some((_, f1))) => {
faces.push(f1);
state.advance_1();
}
(None, None) => {
if !state.has_next_1() || !state.has_next_0() {
break;
}
if state.point0().x < state.point1().x {
state.advance_0();
} else {
state.advance_1();
}
}
}
}
Ok(faces)
}
struct StripRowState<'a> {
i0: usize,
i1: usize,
row0: &'a [StripRowPoint],
row1: &'a [StripRowPoint],
y0: f64,
y1: f64,
points0: Vec<Point2>,
points1: Vec<Point2>,
max_edge_ratio: f64,
}
impl<'a> StripRowState<'a> {
pub fn point0(&self) -> Point2 {
self.points0[self.i0]
}
pub fn point1(&self) -> Point2 {
self.points1[self.i1]
}
fn validate_points(&self, pa: &Point2, pb: &Point2, pc: &Point2) -> Option<f64> {
let ea = (pb - pa).norm();
let eb = (pc - pb).norm();
let ec = (pa - pc).norm();
let strip_width = (self.y1 - self.y0).abs();
let max_edge = ea.max(eb).max(ec);
if max_edge < self.max_edge_ratio * strip_width {
let a0 = three_point_angle(pa, pb, pc);
let a1 = three_point_angle(pb, pc, pa);
let a2 = three_point_angle(pc, pa, pb);
Some(a0.max(a1).max(a2))
} else {
None
}
}
pub fn next_0(&self) -> Option<(f64, StripFace)> {
if !self.has_next_0() {
return None;
}
let pa = &self.points0[self.i0];
let pb = &self.points1[self.i1];
let pc = &self.points0[self.i0 + 1];
let Some(max_edge) = self.validate_points(pa, pb, pc) else {
return None;
};
let a = &self.row0[self.i0];
let b = &self.row1[self.i1];
let c = &self.row0[self.i0 + 1];
Some((max_edge, [a.index, b.index, c.index]))
}
pub fn next_1(&self) -> Option<(f64, StripFace)> {
if !self.has_next_1() {
return None;
}
let pa = &self.points0[self.i0];
let pb = &self.points1[self.i1];
let pc = &self.points1[self.i1 + 1];
let Some(max_edge) = self.validate_points(pa, pb, pc) else {
return None;
};
let a = &self.row0[self.i0];
let b = &self.row1[self.i1];
let c = &self.row1[self.i1 + 1];
Some((max_edge, [a.index, b.index, c.index]))
}
pub fn is_done(&self) -> bool {
self.i0 == self.row0.len() - 1 && self.i1 == self.row1.len() - 1
}
pub fn has_next_0(&self) -> bool {
self.i0 < self.row0.len() - 1
}
pub fn has_next_1(&self) -> bool {
self.i1 < self.row1.len() - 1
}
pub fn advance_0(&mut self) {
if self.has_next_0() {
self.i0 += 1;
}
}
pub fn advance_1(&mut self) {
if self.has_next_1() {
self.i1 += 1;
}
}
pub fn try_new(
row0: &'a [StripRowPoint],
y0: f64,
row1: &'a [StripRowPoint],
y1: f64,
max_edge_ratio: f64,
) -> Result<Self> {
if row0.is_empty() || row1.is_empty() {
return Err("Rows must not be empty".into());
}
if !row0.windows(2).all(|w| w[0].x <= w[1].x) {
return Err("Row 0 must be sorted by X coordinate".into());
}
if !row1.windows(2).all(|w| w[0].x <= w[1].x) {
return Err("Row 1 must be sorted by X coordinate".into());
}
let points0 = row0
.iter()
.map(|p| Point2::new(p.x, y0))
.collect::<Vec<_>>();
let points1 = row1
.iter()
.map(|p| Point2::new(p.x, y1))
.collect::<Vec<_>>();
Ok(Self {
i0: 0,
i1: 0,
row0,
row1,
y0,
y1,
points0,
points1,
max_edge_ratio,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct StripRowPoint {
pub x: f64,
pub index: u32,
}
impl StripRowPoint {
pub fn new(x: f64, index: u32) -> Self {
Self { x, index }
}
}