use std::fmt;
use super::Path;
use super::extents::DataLimits;
use crate::{Affine2D, Point};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CollectionError {
NoPaths,
NoOffsets,
}
impl fmt::Display for CollectionError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::NoPaths => "no paths provided",
Self::NoOffsets => "no offsets provided",
})
}
}
impl std::error::Error for CollectionError {}
#[derive(Clone, Copy, Debug)]
pub struct CollectionGeometry<'a> {
pub master_transform: Affine2D,
pub paths: &'a [Path],
pub transforms: &'a [Affine2D],
pub offsets: &'a [Point],
pub offset_transform: Affine2D,
}
impl CollectionGeometry<'_> {
fn item_count(&self) -> usize {
self.paths.len().max(self.offsets.len())
}
fn item(&self, i: usize, base: Affine2D) -> (&Path, Affine2D) {
let path = &self.paths[i % self.paths.len()];
let transform = if self.offsets.is_empty() {
base
} else {
let offset = self
.offset_transform
.agg_transform_point(self.offsets[i % self.offsets.len()]);
base.agg_then(Affine2D::translation(offset.x, offset.y))
};
(path, transform)
}
fn item_transform(&self, i: usize) -> Option<Affine2D> {
let count = self.transforms.len().min(self.item_count());
(count > 0).then(|| self.transforms[i % count])
}
pub fn extents(&self) -> Result<DataLimits, CollectionError> {
if self.paths.is_empty() {
return Err(CollectionError::NoPaths);
}
if self.offsets.is_empty() {
return Err(CollectionError::NoOffsets);
}
let mut limits = DataLimits::NULL;
for i in 0..self.item_count() {
let base = self.item_transform(i).unwrap_or(self.master_transform);
let (path, transform) = self.item(i, base);
limits.update_from_transformed_path(path, &transform);
}
Ok(limits)
}
pub fn pick(&self, point: Point, radius: f64, filled: bool) -> Vec<usize> {
if self.paths.is_empty() {
return Vec::new();
}
(0..self.item_count())
.filter(|&i| {
let base = self
.item_transform(i)
.map_or(self.master_transform, |t| t.agg_then(self.master_transform));
let (path, transform) = self.item(i, base);
if filled {
path.contains_point(point, Some(&transform), radius)
} else {
path.stroke_contains_point(point, &transform, radius)
}
})
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Bbox;
#[test]
fn per_item_transforms_replace_or_precede_the_master() {
let paths = [Path::unit_rectangle()];
let scale = [Affine2D::scaling(2.0, 2.0)];
let geometry = CollectionGeometry {
master_transform: Affine2D::translation(10.0, 0.0),
paths: &paths,
transforms: &scale,
offsets: &[Point::ORIGIN],
offset_transform: Affine2D::IDENTITY,
};
let limits = geometry.extents().expect("non-empty");
assert_eq!(limits.bbox, Bbox::from_extents(0.0, 0.0, 2.0, 2.0));
assert_eq!(geometry.pick(Point::new(11.5, 0.5), 0.0, true), vec![0]);
assert_eq!(
geometry.pick(Point::new(1.5, 0.5), 0.0, true),
Vec::<usize>::new()
);
}
#[test]
fn offsets_repeat_paths() {
let paths = [Path::unit_rectangle()];
let offsets = [Point::new(0.0, 0.0), Point::new(5.0, 0.0)];
let geometry = CollectionGeometry {
master_transform: Affine2D::IDENTITY,
paths: &paths,
transforms: &[],
offsets: &offsets,
offset_transform: Affine2D::IDENTITY,
};
assert_eq!(geometry.pick(Point::new(5.5, 1.2), 0.3, false), vec![1]);
assert_eq!(
geometry.extents().map(|l| l.bbox),
Ok(Bbox::from_extents(0.0, 0.0, 6.0, 1.0))
);
let empty = CollectionGeometry {
paths: &[],
..geometry
};
assert_eq!(empty.extents(), Err(CollectionError::NoPaths));
}
}