use crate::{Error, Path64, PathD, PathKind, Paths64, PathsD, validate_path64, validate_pathd};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum ClipType {
Intersection = 1,
Union = 2,
Difference = 3,
Xor = 4,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum FillRule {
EvenOdd = 0,
NonZero = 1,
Positive = 2,
Negative = 3,
}
#[derive(Clone, Copy, Debug)]
pub struct BooleanRequest<'a> {
pub subjects: &'a [Path64],
pub clips: &'a [Path64],
pub clip_type: ClipType,
pub fill_rule: FillRule,
}
impl<'a> BooleanRequest<'a> {
#[must_use]
pub const fn new(
subjects: &'a [Path64],
clips: &'a [Path64],
clip_type: ClipType,
fill_rule: FillRule,
) -> Self {
Self { subjects, clips, clip_type, fill_rule }
}
}
#[derive(Clone, Copy, Debug)]
pub struct BooleanRequestD<'a> {
pub subjects: &'a [PathD],
pub clips: &'a [PathD],
pub clip_type: ClipType,
pub fill_rule: FillRule,
}
impl<'a> BooleanRequestD<'a> {
#[must_use]
pub const fn new(
subjects: &'a [PathD],
clips: &'a [PathD],
clip_type: ClipType,
fill_rule: FillRule,
) -> Self {
Self { subjects, clips, clip_type, fill_rule }
}
}
pub fn validate_request(request: &BooleanRequest<'_>) -> Result<(), Error> {
for path in request.subjects.iter().chain(request.clips) {
validate_path64(path, PathKind::Closed)?;
}
Ok(())
}
pub fn validate_requestd(request: &BooleanRequestD<'_>) -> Result<(), Error> {
for path in request.subjects.iter().chain(request.clips) {
validate_pathd(path, PathKind::Closed)?;
}
Ok(())
}
pub fn boolean_op(request: BooleanRequest<'_>) -> Result<Paths64, Error> {
validate_request(&request)?;
crate::boolean::boolean_op64(request)
}
pub fn boolean_opd(request: BooleanRequestD<'_>) -> Result<PathsD, Error> {
validate_requestd(&request)?;
crate::boolean::boolean_opd(request)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exposes_stable_operation_values() {
assert_eq!(ClipType::Intersection as u8, 1);
assert_eq!(ClipType::Union as u8, 2);
assert_eq!(ClipType::Difference as u8, 3);
assert_eq!(ClipType::Xor as u8, 4);
assert_eq!(FillRule::EvenOdd as u8, 0);
assert_eq!(FillRule::NonZero as u8, 1);
assert_eq!(FillRule::Positive as u8, 2);
assert_eq!(FillRule::Negative as u8, 3);
}
#[test]
fn validates_then_executes_union_with_empty_clip() {
let square =
vec![crate::Point64::new(0, 0), crate::Point64::new(1, 0), crate::Point64::new(1, 1)];
let request = BooleanRequest {
subjects: &[square],
clips: &[],
clip_type: ClipType::Union,
fill_rule: FillRule::NonZero,
};
assert_eq!(validate_request(&request), Ok(()));
assert_eq!(boolean_op(request).expect("valid request").len(), 1);
}
#[test]
fn rejects_invalid_boolean_input_before_kernel() {
let request = BooleanRequest {
subjects: &[vec![crate::Point64::new(0, 0)]],
clips: &[],
clip_type: ClipType::Intersection,
fill_rule: FillRule::EvenOdd,
};
assert!(matches!(boolean_op(request), Err(Error::InvalidPath { .. })));
}
#[test]
fn validates_double_requests() {
let square = vec![
crate::PointD::new(0.0, 0.0),
crate::PointD::new(1.0, 0.0),
crate::PointD::new(1.0, 1.0),
];
let request = BooleanRequestD {
subjects: &[square],
clips: &[],
clip_type: ClipType::Union,
fill_rule: FillRule::NonZero,
};
assert!(validate_requestd(&request).is_ok());
assert_eq!(crate::boolean_opd(request).expect("valid request").len(), 1);
let bad = BooleanRequestD {
subjects: &[vec![crate::PointD::new(0.0, 0.0), crate::PointD::new(f64::NAN, 0.0)]],
clips: &[],
clip_type: ClipType::Union,
fill_rule: FillRule::EvenOdd,
};
assert!(matches!(validate_requestd(&bad), Err(Error::InvalidPath { .. })));
}
}