349 lines
14 KiB
Rust
349 lines
14 KiB
Rust
use crate::transform::Footprint;
|
|
|
|
use bezier_rs::{ManipulatorGroup, Subpath};
|
|
use graphene_core::transform::Transform;
|
|
use graphene_core::vector::misc::BooleanOperation;
|
|
pub use graphene_core::vector::*;
|
|
use graphene_core::{Color, GraphicElement, GraphicGroup};
|
|
pub use path_bool as path_bool_lib;
|
|
use path_bool::FillRule;
|
|
use path_bool::PathBooleanOperation;
|
|
|
|
use glam::{DAffine2, DVec2};
|
|
use std::ops::Mul;
|
|
|
|
#[node_macro::node(category(""))]
|
|
async fn boolean_operation<F: 'n + Send>(
|
|
#[implementations(
|
|
(),
|
|
Footprint,
|
|
)]
|
|
footprint: F,
|
|
#[implementations(
|
|
() -> GraphicGroup,
|
|
Footprint -> GraphicGroup,
|
|
)]
|
|
group_of_paths: impl Node<F, Output = GraphicGroup>,
|
|
operation: BooleanOperation,
|
|
) -> VectorData {
|
|
let group_of_paths = group_of_paths.eval(footprint).await;
|
|
|
|
fn vector_from_image<T: Transform>(image_frame: T) -> VectorData {
|
|
let corner1 = DVec2::ZERO;
|
|
let corner2 = DVec2::new(1., 1.);
|
|
let mut subpath = Subpath::new_rect(corner1, corner2);
|
|
subpath.apply_transform(image_frame.transform());
|
|
let mut vector_data = VectorData::from_subpath(subpath);
|
|
vector_data
|
|
.style
|
|
.set_fill(graphene_core::vector::style::Fill::Solid(Color::from_rgb_str("777777").unwrap().to_gamma_srgb()));
|
|
vector_data
|
|
}
|
|
|
|
fn union_vector_data(graphic_element: &GraphicElement) -> VectorData {
|
|
match graphic_element {
|
|
GraphicElement::VectorData(vector_data) => *vector_data.clone(),
|
|
// Union all vector data in the graphic group into a single vector
|
|
GraphicElement::GraphicGroup(graphic_group) => {
|
|
let vector_data = collect_vector_data(graphic_group);
|
|
boolean_operation_on_vector_data(&vector_data, BooleanOperation::Union)
|
|
}
|
|
GraphicElement::Raster(image) => vector_from_image(image),
|
|
}
|
|
}
|
|
|
|
fn collect_vector_data(graphic_group: &GraphicGroup) -> Vec<VectorData> {
|
|
// Ensure all non vector data in the graphic group is converted to vector data
|
|
let vector_data = graphic_group.iter().map(|(element, _)| union_vector_data(element));
|
|
// Apply the transform from the parent graphic group
|
|
let transformed_vector_data = vector_data.map(|mut vector_data| {
|
|
vector_data.transform = graphic_group.transform * vector_data.transform;
|
|
vector_data
|
|
});
|
|
transformed_vector_data.collect::<Vec<_>>()
|
|
}
|
|
|
|
fn subtract<'a>(vector_data: impl Iterator<Item = &'a VectorData>) -> VectorData {
|
|
let mut vector_data = vector_data.into_iter();
|
|
let mut result = vector_data.next().cloned().unwrap_or_default();
|
|
let mut next_vector_data = vector_data.next();
|
|
|
|
while let Some(lower_vector_data) = next_vector_data {
|
|
let transform_of_lower_into_space_of_upper = result.transform.inverse() * lower_vector_data.transform;
|
|
|
|
let upper_path_string = to_path(&result, DAffine2::IDENTITY);
|
|
let lower_path_string = to_path(lower_vector_data, transform_of_lower_into_space_of_upper);
|
|
|
|
#[allow(unused_unsafe)]
|
|
let boolean_operation_string = unsafe { boolean_subtract(upper_path_string, lower_path_string) };
|
|
let boolean_operation_result = from_path(&boolean_operation_string);
|
|
|
|
result.colinear_manipulators = boolean_operation_result.colinear_manipulators;
|
|
result.point_domain = boolean_operation_result.point_domain;
|
|
result.segment_domain = boolean_operation_result.segment_domain;
|
|
result.region_domain = boolean_operation_result.region_domain;
|
|
|
|
next_vector_data = vector_data.next();
|
|
}
|
|
result
|
|
}
|
|
|
|
fn boolean_operation_on_vector_data(vector_data: &[VectorData], boolean_operation: BooleanOperation) -> VectorData {
|
|
match boolean_operation {
|
|
BooleanOperation::Union => {
|
|
// Reverse vector data so that the result style is the style of the first vector data
|
|
let mut vector_data = vector_data.iter().rev();
|
|
let mut result = vector_data.next().cloned().unwrap_or_default();
|
|
let mut second_vector_data = Some(vector_data.next().unwrap_or(const { &VectorData::empty() }));
|
|
|
|
// Loop over all vector data and union it with the result
|
|
while let Some(lower_vector_data) = second_vector_data {
|
|
let transform_of_lower_into_space_of_upper = result.transform.inverse() * lower_vector_data.transform;
|
|
|
|
let upper_path_string = to_path(&result, DAffine2::IDENTITY);
|
|
let lower_path_string = to_path(lower_vector_data, transform_of_lower_into_space_of_upper);
|
|
|
|
#[allow(unused_unsafe)]
|
|
let boolean_operation_string = unsafe { boolean_union(upper_path_string, lower_path_string) };
|
|
let boolean_operation_result = from_path(&boolean_operation_string);
|
|
|
|
result.colinear_manipulators = boolean_operation_result.colinear_manipulators;
|
|
result.point_domain = boolean_operation_result.point_domain;
|
|
result.segment_domain = boolean_operation_result.segment_domain;
|
|
result.region_domain = boolean_operation_result.region_domain;
|
|
second_vector_data = vector_data.next();
|
|
}
|
|
result
|
|
}
|
|
BooleanOperation::SubtractFront => subtract(vector_data.iter()),
|
|
BooleanOperation::SubtractBack => subtract(vector_data.iter().rev()),
|
|
BooleanOperation::Intersect => {
|
|
let mut vector_data = vector_data.iter().rev();
|
|
let mut result = vector_data.next().cloned().unwrap_or_default();
|
|
let mut second_vector_data = Some(vector_data.next().unwrap_or(const { &VectorData::empty() }));
|
|
|
|
// For each vector data, set the result to the intersection of that data and the result
|
|
while let Some(lower_vector_data) = second_vector_data {
|
|
let transform_of_lower_into_space_of_upper = result.transform.inverse() * lower_vector_data.transform;
|
|
|
|
let upper_path_string = to_path(&result, DAffine2::IDENTITY);
|
|
let lower_path_string = to_path(lower_vector_data, transform_of_lower_into_space_of_upper);
|
|
|
|
#[allow(unused_unsafe)]
|
|
let boolean_operation_string = unsafe { boolean_intersect(upper_path_string, lower_path_string) };
|
|
let boolean_operation_result = from_path(&boolean_operation_string);
|
|
|
|
result.colinear_manipulators = boolean_operation_result.colinear_manipulators;
|
|
result.point_domain = boolean_operation_result.point_domain;
|
|
result.segment_domain = boolean_operation_result.segment_domain;
|
|
result.region_domain = boolean_operation_result.region_domain;
|
|
second_vector_data = vector_data.next();
|
|
}
|
|
result
|
|
}
|
|
BooleanOperation::Difference => {
|
|
let mut vector_data_iter = vector_data.iter().rev();
|
|
let mut any_intersection = VectorData::empty();
|
|
let mut second_vector_data = Some(vector_data_iter.next().unwrap_or(const { &VectorData::empty() }));
|
|
|
|
// Find where all vector data intersect at least once
|
|
while let Some(lower_vector_data) = second_vector_data {
|
|
let all_other_vector_data = boolean_operation_on_vector_data(&vector_data.iter().filter(|v| v != &lower_vector_data).cloned().collect::<Vec<_>>(), BooleanOperation::Union);
|
|
|
|
let transform_of_lower_into_space_of_upper = all_other_vector_data.transform.inverse() * lower_vector_data.transform;
|
|
|
|
let upper_path_string = to_path(&all_other_vector_data, DAffine2::IDENTITY);
|
|
let lower_path_string = to_path(lower_vector_data, transform_of_lower_into_space_of_upper);
|
|
|
|
#[allow(unused_unsafe)]
|
|
let boolean_intersection_string = unsafe { boolean_intersect(upper_path_string, lower_path_string) };
|
|
let mut boolean_intersection_result = from_path(&boolean_intersection_string);
|
|
|
|
boolean_intersection_result.transform = all_other_vector_data.transform;
|
|
boolean_intersection_result.style = all_other_vector_data.style.clone();
|
|
boolean_intersection_result.alpha_blending = all_other_vector_data.alpha_blending;
|
|
|
|
let transform_of_lower_into_space_of_upper = boolean_intersection_result.transform.inverse() * any_intersection.transform;
|
|
|
|
let upper_path_string = to_path(&boolean_intersection_result, DAffine2::IDENTITY);
|
|
let lower_path_string = to_path(&any_intersection, transform_of_lower_into_space_of_upper);
|
|
|
|
#[allow(unused_unsafe)]
|
|
let union_result = from_path(&unsafe { boolean_union(upper_path_string, lower_path_string) });
|
|
any_intersection = union_result;
|
|
|
|
any_intersection.transform = boolean_intersection_result.transform;
|
|
any_intersection.style = boolean_intersection_result.style.clone();
|
|
any_intersection.alpha_blending = boolean_intersection_result.alpha_blending;
|
|
|
|
second_vector_data = vector_data_iter.next();
|
|
}
|
|
// Subtract the area where they intersect at least once from the union of all vector data
|
|
let union = boolean_operation_on_vector_data(vector_data, BooleanOperation::Union);
|
|
boolean_operation_on_vector_data(&[union, any_intersection], BooleanOperation::SubtractFront)
|
|
}
|
|
}
|
|
}
|
|
|
|
// The first index is the bottom of the stack
|
|
let mut boolean_operation_result = boolean_operation_on_vector_data(&collect_vector_data(&group_of_paths), operation);
|
|
|
|
let transform = boolean_operation_result.transform;
|
|
VectorData::transform(&mut boolean_operation_result, transform);
|
|
boolean_operation_result.style.set_stroke_transform(DAffine2::IDENTITY);
|
|
boolean_operation_result.transform = DAffine2::IDENTITY;
|
|
boolean_operation_result.upstream_graphic_group = Some(group_of_paths);
|
|
|
|
boolean_operation_result
|
|
}
|
|
|
|
fn to_path(vector: &VectorData, transform: DAffine2) -> Vec<path_bool::PathSegment> {
|
|
let mut path = Vec::new();
|
|
for subpath in vector.stroke_bezier_paths() {
|
|
to_path_segments(&mut path, &subpath, transform);
|
|
}
|
|
path
|
|
}
|
|
|
|
fn to_path_segments(path: &mut Vec<path_bool::PathSegment>, subpath: &bezier_rs::Subpath<PointId>, transform: DAffine2) {
|
|
use path_bool::PathSegment;
|
|
let mut global_start = None;
|
|
let mut global_end = DVec2::ZERO;
|
|
for bezier in subpath.iter() {
|
|
const EPS: f64 = 1e-8;
|
|
let transformed = bezier.apply_transformation(|pos| transform.transform_point2(pos).mul(EPS.recip()).round().mul(EPS));
|
|
let start = transformed.start;
|
|
let end = transformed.end;
|
|
if global_start.is_none() {
|
|
global_start = Some(start);
|
|
}
|
|
global_end = end;
|
|
let segment = match transformed.handles {
|
|
bezier_rs::BezierHandles::Linear => PathSegment::Line(start, end),
|
|
bezier_rs::BezierHandles::Quadratic { handle } => PathSegment::Quadratic(start, handle, end),
|
|
bezier_rs::BezierHandles::Cubic { handle_start, handle_end } => PathSegment::Cubic(start, handle_start, handle_end, end),
|
|
};
|
|
path.push(segment);
|
|
}
|
|
if let Some(start) = global_start {
|
|
path.push(PathSegment::Line(global_end, start));
|
|
}
|
|
}
|
|
|
|
fn from_path(path_data: &[Path]) -> VectorData {
|
|
const EPSILON: f64 = 1e-5;
|
|
|
|
fn is_close(a: DVec2, b: DVec2) -> bool {
|
|
(a - b).length_squared() < EPSILON * EPSILON
|
|
}
|
|
|
|
let mut all_subpaths = Vec::new();
|
|
|
|
for path in path_data.iter().filter(|path| !path.is_empty()) {
|
|
let cubics: Vec<[DVec2; 4]> = path.iter().map(|segment| segment.to_cubic()).collect();
|
|
let mut groups = Vec::new();
|
|
let mut current_start = None;
|
|
|
|
for (index, cubic) in cubics.iter().enumerate() {
|
|
let [start, handle1, handle2, end] = *cubic;
|
|
|
|
if current_start.is_none() || !is_close(start, current_start.unwrap()) {
|
|
// Start a new subpath
|
|
if !groups.is_empty() {
|
|
all_subpaths.push(Subpath::new(std::mem::take(&mut groups), true));
|
|
}
|
|
// Use the correct in-handle (None) and out-handle for the start point
|
|
groups.push(ManipulatorGroup::new(start, None, Some(handle1)));
|
|
} else {
|
|
// Update the out-handle of the previous point
|
|
if let Some(last) = groups.last_mut() {
|
|
last.out_handle = Some(handle1);
|
|
}
|
|
}
|
|
|
|
// Add the end point with the correct in-handle and out-handle (None)
|
|
groups.push(ManipulatorGroup::new(end, Some(handle2), None));
|
|
|
|
current_start = Some(end);
|
|
|
|
// Check if this is the last segment
|
|
if index == cubics.len() - 1 {
|
|
all_subpaths.push(Subpath::new(groups, true));
|
|
groups = Vec::new(); // Reset groups for the next path
|
|
}
|
|
}
|
|
}
|
|
|
|
VectorData::from_subpaths(all_subpaths, false)
|
|
}
|
|
|
|
pub fn convert_usvg_path(path: &usvg::Path) -> Vec<Subpath<PointId>> {
|
|
let mut subpaths = Vec::new();
|
|
let mut groups = Vec::new();
|
|
|
|
let mut points = path.data().points().iter();
|
|
let to_vec = |p: &usvg::tiny_skia_path::Point| DVec2::new(p.x as f64, p.y as f64);
|
|
|
|
for verb in path.data().verbs() {
|
|
match verb {
|
|
usvg::tiny_skia_path::PathVerb::Move => {
|
|
subpaths.push(Subpath::new(std::mem::take(&mut groups), false));
|
|
let Some(start) = points.next().map(to_vec) else { continue };
|
|
groups.push(ManipulatorGroup::new(start, Some(start), Some(start)));
|
|
}
|
|
usvg::tiny_skia_path::PathVerb::Line => {
|
|
let Some(end) = points.next().map(to_vec) else { continue };
|
|
groups.push(ManipulatorGroup::new(end, Some(end), Some(end)));
|
|
}
|
|
usvg::tiny_skia_path::PathVerb::Quad => {
|
|
let Some(handle) = points.next().map(to_vec) else { continue };
|
|
let Some(end) = points.next().map(to_vec) else { continue };
|
|
if let Some(last) = groups.last_mut() {
|
|
last.out_handle = Some(last.anchor + (2. / 3.) * (handle - last.anchor));
|
|
}
|
|
groups.push(ManipulatorGroup::new(end, Some(end + (2. / 3.) * (handle - end)), Some(end)));
|
|
}
|
|
usvg::tiny_skia_path::PathVerb::Cubic => {
|
|
let Some(first_handle) = points.next().map(to_vec) else { continue };
|
|
let Some(second_handle) = points.next().map(to_vec) else { continue };
|
|
let Some(end) = points.next().map(to_vec) else { continue };
|
|
if let Some(last) = groups.last_mut() {
|
|
last.out_handle = Some(first_handle);
|
|
}
|
|
groups.push(ManipulatorGroup::new(end, Some(second_handle), Some(end)));
|
|
}
|
|
usvg::tiny_skia_path::PathVerb::Close => {
|
|
subpaths.push(Subpath::new(std::mem::take(&mut groups), true));
|
|
}
|
|
}
|
|
}
|
|
subpaths.push(Subpath::new(groups, false));
|
|
subpaths
|
|
}
|
|
|
|
type Path = Vec<path_bool::PathSegment>;
|
|
|
|
fn boolean_union(a: Path, b: Path) -> Vec<Path> {
|
|
path_bool(a, b, PathBooleanOperation::Union)
|
|
}
|
|
|
|
fn path_bool(a: Path, b: Path, op: PathBooleanOperation) -> Vec<Path> {
|
|
match path_bool::path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, op) {
|
|
Ok(results) => results,
|
|
Err(e) => {
|
|
let a_path = path_bool::path_to_path_data(&a, 0.001);
|
|
let b_path = path_bool::path_to_path_data(&b, 0.001);
|
|
log::error!("Boolean error {e:?} encountered while processing {a_path}\n {op:?}\n {b_path}");
|
|
Vec::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn boolean_subtract(a: Path, b: Path) -> Vec<Path> {
|
|
path_bool(a, b, PathBooleanOperation::Difference)
|
|
}
|
|
|
|
pub fn boolean_intersect(a: Path, b: Path) -> Vec<Path> {
|
|
path_bool(a, b, PathBooleanOperation::Intersection)
|
|
}
|