use super::stroke_math::{StrokeMath, StrokeShape};
use super::vertex_seq::VertexSequence;
use super::{Generator, accumulate};
use crate::Point;
use crate::path::PathCode;
use crate::path::convert::Vertex;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Status {
Initial,
Ready,
Outline,
OutVertices,
EndPoly,
Stop,
}
#[derive(Clone, Debug)]
pub(crate) struct Contour {
math: StrokeMath,
src: VertexSequence,
out: Vec<Point>,
status: Status,
closed: bool,
src_vertex: usize,
out_vertex: usize,
cmd: PathCode,
}
impl Contour {
pub(crate) fn new(width: f64) -> Self {
Self {
math: StrokeMath::new(width, &StrokeShape::default()),
src: VertexSequence::default(),
out: Vec::new(),
status: Status::Initial,
closed: false,
src_vertex: 0,
out_vertex: 0,
cmd: PathCode::MoveTo,
}
}
}
impl Generator for Contour {
fn remove_all(&mut self) {
self.src.clear();
self.closed = false;
self.status = Status::Initial;
}
fn add_vertex(&mut self, vertex: Vertex) {
self.status = Status::Initial;
accumulate(&mut self.src, &mut self.closed, vertex);
}
fn rewind(&mut self) {
if self.status == Status::Initial {
self.src.close(true);
}
self.status = Status::Ready;
self.src_vertex = 0;
}
fn vertex(&mut self) -> Option<Vertex> {
loop {
match self.status {
Status::Initial => self.rewind(),
Status::Ready => {
if self.src.len() < 2 + usize::from(self.closed) {
return None;
}
self.status = Status::Outline;
self.cmd = PathCode::MoveTo;
self.src_vertex = 0;
self.out_vertex = 0;
}
Status::Outline => {
if self.src_vertex >= self.src.len() {
self.status = Status::EndPoly;
continue;
}
let i = self.src_vertex;
let (prev, curr, next) = (self.src.prev(i), self.src.get(i), self.src.next(i));
self.math
.calc_join(&mut self.out, prev, curr, next, prev.dist, curr.dist);
self.src_vertex += 1;
self.status = Status::OutVertices;
self.out_vertex = 0;
}
Status::OutVertices => {
if let Some(&p) = self.out.get(self.out_vertex) {
self.out_vertex += 1;
let cmd = std::mem::replace(&mut self.cmd, PathCode::LineTo);
return Some(Vertex::new(cmd, p));
}
self.status = Status::Outline;
}
Status::EndPoly => {
if !self.closed {
return None;
}
self.status = Status::Stop;
return Some(Vertex::new(PathCode::ClosePoly, Point::ORIGIN));
}
Status::Stop => return None,
}
}
}
}