mod contour;
mod math;
mod stroke;
mod stroke_math;
mod vertex_seq;
use crate::Point;
use crate::path::PathCode;
use crate::path::convert::{Vertex, VertexSource};
pub(crate) use contour::Contour;
pub use math::{
INTERSECTION_EPSILON, calc_distance, calc_intersection, calc_intersection_fusing, cross_product,
};
pub(crate) use stroke::Stroke;
pub use stroke_math::{InnerJoin, LineCap, LineJoin, StrokeMath, StrokeShape};
pub use vertex_seq::{VERTEX_DIST_EPSILON, VertexDist, VertexSequence};
pub(crate) trait Generator {
fn remove_all(&mut self);
fn add_vertex(&mut self, vertex: Vertex);
fn rewind(&mut self);
fn vertex(&mut self) -> Option<Vertex>;
}
fn accumulate(src: &mut VertexSequence, closed: &mut bool, vertex: Vertex) {
match vertex.code {
PathCode::MoveTo => src.modify_last(VertexDist::new(vertex.point)),
PathCode::ClosePoly => *closed = true,
PathCode::LineTo | PathCode::Curve3 | PathCode::Curve4 => {
src.add(VertexDist::new(vertex.point));
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Status {
Initial,
Accumulate,
Generate,
}
#[derive(Clone, Debug)]
pub(crate) struct Outline<I, G> {
source: I,
generator: G,
status: Status,
running: bool,
start: Point,
}
impl<I: VertexSource, G: Generator> Outline<I, G> {
pub(crate) const fn new(source: I, generator: G) -> Self {
Self {
source,
generator,
status: Status::Initial,
running: false,
start: Point::ORIGIN,
}
}
fn accumulate(&mut self) {
self.generator.remove_all();
self.generator.add_vertex(Vertex::move_to(self.start));
loop {
let Some(vertex) = self.source.next() else {
self.running = false;
break;
};
match vertex.code {
PathCode::MoveTo => {
self.start = vertex.point;
break;
}
PathCode::ClosePoly => {
self.generator.add_vertex(vertex);
break;
}
PathCode::LineTo | PathCode::Curve3 | PathCode::Curve4 => {
self.generator.add_vertex(vertex);
}
}
}
self.generator.rewind();
}
}
impl<I: VertexSource, G: Generator> Iterator for Outline<I, G> {
type Item = Vertex;
fn next(&mut self) -> Option<Vertex> {
loop {
match self.status {
Status::Initial => {
let first = self.source.next();
self.running = first.is_some();
self.start = first.map_or(Point::ORIGIN, |v| v.point);
self.status = Status::Accumulate;
}
Status::Accumulate => {
if !self.running {
return None;
}
self.accumulate();
self.status = Status::Generate;
}
Status::Generate => match self.generator.vertex() {
Some(vertex) => return Some(vertex),
None => self.status = Status::Accumulate,
},
}
}
}
}
impl<I: VertexSource, G: Generator> VertexSource for Outline<I, G> {
fn rewind(&mut self) {
self.source.rewind();
self.status = Status::Initial;
}
}