feat(script): add OutlineExpr::Bool

Author: rami3l

Cargo.lock

@@ -3,7 +3,7 @@
 
 mod exchange;
 
-use kurbo::{Affine, CubicBez, Line, ParamCurve, PathSeg};
+use kurbo::{Affine, CubicBez, Line, ParamCurve, PathEl, PathSeg};
 use serde::{Deserialize, Serialize};
 
 use crate::point::Point2D;
@@ -160,6 +160,46 @@ impl CubicBezier {
             closed: self.closed,
         }
     }
+
+    pub fn from_kurbo(path: &kurbo::BezPath) -> Self {
+        let elems = path.elements();
+        let mut res = Self {
+            segments: Vec::with_capacity(elems.len() - 1),
+            start: Point2D::default(),
+            closed: false,
+        };
+
+        for elem in elems {
+            match elem {
+                PathEl::MoveTo(p) => res.start = *p,
+                PathEl::LineTo(p) => res.segments.push(CubicSegment::Line(*p)),
+                PathEl::QuadTo(_, _) => {
+                    unimplemented!("quadratic segments are not supported in CubicBezier")
+                }
+                PathEl::CurveTo(c1, c2, p) => res.segments.push(CubicSegment::Curve(*c1, *c2, *p)),
+                PathEl::ClosePath => res.closed = true,
+            }
+        }
+
+        res
+    }
+
+    pub fn to_kurbo(&self) -> kurbo::BezPath {
+        let mut path = kurbo::BezPath::new();
+
+        path.move_to(self.start);
+        for seg in &self.segments {
+            match seg {
+                CubicSegment::Line(end) => path.line_to(*end),
+                CubicSegment::Curve(c1, c2, end) => path.curve_to(*c1, *c2, *end),
+            }
+        }
+        if self.closed {
+            path.close_path();
+        }
+
+        path
+    }
 }
 
 pub struct CubicBezierBuilder<P = Point2D> {

crates/monoxide-curves/src/cube.rs

@@ -11,6 +11,7 @@ version.workspace = true
 by_address.workspace = true
 indexmap.workspace = true
 itertools.workspace = true
+linesweeper = "0.4.0"
 monoxide-curves.workspace = true
 monoxide-spiro.workspace = true
 monoxide-ttf.workspace = true

crates/monoxide-script/Cargo.toml

@@ -1,11 +1,13 @@
 use std::sync::Arc;
 
+use linesweeper::BinaryOp;
 use monoxide_curves::{CubicBezier, SpiroCurve, point::Point2D, xform::Affine2D};
 
 #[derive(Debug, Clone)]
 pub enum OutlineExpr {
     Bezier(CubicBezier),
     Spiro(SpiroCurve),
+    Bool(BinaryOp, Arc<OutlineExpr>, Arc<OutlineExpr>),
     Stroked(Arc<OutlineExpr>, f64),
     Transformed(Arc<OutlineExpr>, Affine2D),
 }
@@ -24,4 +26,8 @@ impl OutlineExpr {
     pub fn transformed(self: Arc<Self>, xform: Affine2D) -> Arc<Self> {
         Arc::new(OutlineExpr::Transformed(self, xform))
     }
+
+    pub fn bool(self: Arc<Self>, other: Arc<Self>, op: BinaryOp) -> Arc<Self> {
+        Arc::new(OutlineExpr::Bool(op, self, other))
+    }
 }

crates/monoxide-script/src/ast/simple.rs

@@ -1,10 +1,10 @@
 mod bezier_builder;
 mod spiro_builder;
 
-use std::{iter, sync::Arc};
+use std::sync::Arc;
 
 pub use bezier_builder::{BezierBuilder, BezierInst};
-use itertools::chain;
+use linesweeper::BinaryOp;
 use monoxide_curves::xform::Affine2D;
 pub use spiro_builder::{SpiroBuilder, SpiroInst, SpiroInstOpts};
 
@@ -40,6 +40,38 @@ pub trait IntoOutlineExt: IntoOutline {
     {
         self.into_outline().transformed(xform)
     }
+
+    fn or<U: IntoOutline>(self, other: U) -> Arc<OutlineExpr>
+    where
+        Self: Sized,
+    {
+        self.into_outline()
+            .bool(other.into_outline(), BinaryOp::Union)
+    }
+
+    fn diff<U: IntoOutline>(self, other: U) -> Arc<OutlineExpr>
+    where
+        Self: Sized,
+    {
+        self.into_outline()
+            .bool(other.into_outline(), BinaryOp::Difference)
+    }
+
+    fn and<U: IntoOutline>(self, other: U) -> Arc<OutlineExpr>
+    where
+        Self: Sized,
+    {
+        self.into_outline()
+            .bool(other.into_outline(), BinaryOp::Intersection)
+    }
+
+    fn xor<U: IntoOutline>(self, other: U) -> Arc<OutlineExpr>
+    where
+        Self: Sized,
+    {
+        self.into_outline()
+            .bool(other.into_outline(), BinaryOp::Xor)
+    }
 }
 
 impl<T: IntoOutline> IntoOutlineExt for T {}
@@ -86,30 +118,10 @@ pub trait IntoOutlinesExt: IntoOutlines {
             .into_iter()
             .map(move |outline| outline.transformed(xform))
     }
-
-    fn add<U: IntoOutlines>(self, other: U) -> Add<Self, U>
-    where
-        Self: Sized,
-    {
-        Add(self, other)
-    }
 }
 
 impl<T: IntoOutlines> IntoOutlinesExt for T {}
 
-pub struct Add<T, U>(T, U);
-
-impl<T: IntoOutlines, U: IntoOutlines> IntoOutlines for Add<T, U> {
-    type Outlines = iter::Chain<
-        <T::Outlines as IntoIterator>::IntoIter,
-        <U::Outlines as IntoIterator>::IntoIter,
-    >;
-
-    fn into_outlines(self) -> Self::Outlines {
-        chain!(self.0.into_outlines(), self.1.into_outlines())
-    }
-}
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! ctrl_pt {

crates/monoxide-script/src/dsl.rs

@@ -1,5 +1,8 @@
 use itertools::{Itertools, chain};
-use monoxide_curves::{CubicBezier, SpiroCurve, stroke::StrokedSpiroCurve, xform::AffineExt};
+use linesweeper::{FillRule, binary_op};
+use monoxide_curves::{
+    CubicBezier, SpiroCurve, convert::spiro_to_cube, stroke::StrokedSpiroCurve, xform::AffineExt,
+};
 
 use crate::{ast::OutlineExpr, trace::EvalTracer};
 
@@ -21,8 +24,7 @@ pub fn eval_outline<E: EvalTracer>(
             let output_size_before = out.len();
             let id = dbg.spiro_to_bezier(evaled.id);
             for spiro in spiros {
-                let bez = monoxide_curves::convert::spiro_to_cube(&spiro.points)
-                    .map_err(|e| EvalError::CurveError(id, e))?;
+                let bez = spiro_to_cube(&spiro.points).map_err(|e| EvalError::CurveError(id, e))?;
                 out.extend(bez);
             }
             dbg.intermediate_output(id, &out[output_size_before..]);
@@ -71,8 +73,8 @@ impl<Id: Copy> EvalValue<Id> {
                 let mut beziers = vec![];
                 let id = dbg.spiro_to_bezier(self.id);
                 for spiro in &spiros {
-                    let bez = monoxide_curves::convert::spiro_to_cube(&spiro.points)
-                        .map_err(|e| EvalError::CurveError(id, e))?;
+                    let bez =
+                        spiro_to_cube(&spiro.points).map_err(|e| EvalError::CurveError(id, e))?;
                     beziers.extend(bez);
                 }
                 dbg.intermediate_output(id, &beziers);
@@ -89,11 +91,27 @@ pub enum EvalError<Id> {
     )]
     StrokingABezier(Id),
 
+    #[error(
+        "boolean operation on multiple beziers unimplemented at {0}: try using a single bezier"
+    )]
+    BoolingMultipleBeziers(Id),
+
+    #[error("boolean operation error at {0}: {1}")]
+    Boolean(Id, #[source] linesweeper::Error),
+
     #[error("curve evaluation error at {0}: {1}")]
     CurveError(Id, #[source] monoxide_curves::error::Error),
 }
 
 fn eval_outline_internal<E: EvalTracer>(expr: &OutlineExpr, dbg: &mut E) -> EvalResult<E> {
+    let to_bez = |spiro: &SpiroCurve, id, dbg: &mut E| {
+        let bez = spiro_to_cube(&spiro.points).map_err(|e| EvalError::CurveError(id, e))?;
+        if E::needs_evaluate_intermediate() {
+            dbg.intermediate_output(id, &bez);
+        }
+        Ok(bez)
+    };
+
     match expr {
         OutlineExpr::Bezier(cubic_bezier) => {
             let id = dbg.constructed_bezier(cubic_bezier);
@@ -102,15 +120,42 @@ fn eval_outline_internal<E: EvalTracer>(expr: &OutlineExpr, dbg: &mut E) -> Eval
         OutlineExpr::Spiro(spiro) => {
             let id = dbg.constructed_spiro(&spiro.points);
 
-            if E::needs_evaluate_intermediate() {
-                // convert to beziers if needed
-                let bez = monoxide_curves::convert::spiro_to_cube(&spiro.points)
-                    .map_err(|e| EvalError::CurveError(id, e))?;
-                dbg.intermediate_output(id, &bez);
-            }
+            // convert to beziers if needed
+            to_bez(spiro, id, dbg)?;
 
             Ok(EvalValue::spiro(spiro.clone(), id))
         }
+        OutlineExpr::Bool(op, lhs, rhs) => {
+            let mut eval_half = |outline| {
+                let evaled = eval_outline_internal(outline, dbg)?;
+                let bez = match evaled.kind {
+                    EvalValueKind::Beziers(bez) => Ok(bez),
+                    EvalValueKind::Spiros(spiro) => spiro
+                        .into_iter()
+                        .map(|s| to_bez(&s, evaled.id, dbg))
+                        .flatten_ok()
+                        .try_collect(),
+                }?;
+                let [bez] = &bez[..] else {
+                    return Err(EvalError::BoolingMultipleBeziers(evaled.id));
+                };
+                Ok((evaled.id, bez.to_kurbo()))
+            };
+
+            let (lhs_id, lhs) = eval_half(lhs)?;
+            let (rhs_id, rhs) = eval_half(rhs)?;
+
+            let id = dbg.boolean_added(&[lhs_id, rhs_id]);
+            let merged = binary_op(&lhs, &rhs, FillRule::NonZero, *op)
+                .map_err(|e| EvalError::Boolean(id, e))?
+                .contours()
+                .map(|it| CubicBezier::from_kurbo(&it.path))
+                .collect();
+            Ok(EvalValue {
+                kind: EvalValueKind::Beziers(merged),
+                id,
+            })
+        }
         OutlineExpr::Stroked(outline_expr, width) => {
             let evaled = eval_outline_internal(outline_expr, dbg)?;
             match evaled.kind {
@@ -176,10 +221,7 @@ fn eval_stroked<E: EvalTracer>(
     if E::needs_evaluate_intermediate() {
         // Convert both original spiro and the stroked spiro to beziers
         let bezs: Vec<_> = chain!(eval_spiros, &out_spiros)
-            .map(|spiro| {
-                monoxide_curves::convert::spiro_to_cube(&spiro.points)
-                    .map_err(|e| EvalError::CurveError(id, e))
-            })
+            .map(|spiro| spiro_to_cube(&spiro.points).map_err(|e| EvalError::CurveError(id, e)))
             .flatten_ok()
             .try_collect()?;
         dbg.intermediate_output(id, &bezs);