DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Text wrap: an image's contour stops at its frame
aiongg254cc49d1bed
diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rsindex e9f532375..5ade72645 100644--- a/crates/compose/src/lib.rs+++ b/crates/compose/src/lib.rs@@ -301,6 +301,9 @@ pub struct Exclusion {#[derive(Clone, Debug, PartialEq)]pub struct Contour {pub rings: Vec<Vec<Point>>,+ /// The frame path of an outline taken from a placed graphic: the frame clips the graphic, so+ /// the outline counts only within it (empty: no clip).+ pub clip: Vec<Vec<Point>>,pub offset: f64,}@@ -310,65 +313,105 @@ const MAX_CONTOUR_POINTS: usize = 8192;impl Contour {/// The outline of `path` (after `to_inner`), flattened; None if it is empty or too detailed.fn of(path: &designcraft_geom::BezPath, to_inner: designcraft_geom::Affine, offset: f64) -> Option<Contour> {- let mut rings: Vec<Vec<Point>> = Vec::new();- let mut n = 0usize;- let mut too_many = false;- designcraft_geom::kurbo::flatten(to_inner * path.clone(), 0.25, |el| {- n += 1;- too_many |= n > MAX_CONTOUR_POINTS;- match el {- designcraft_geom::PathEl::MoveTo(p) => rings.push(vec![p]),- designcraft_geom::PathEl::LineTo(p) => match rings.last_mut() {- Some(r) => r.push(p),- None => rings.push(vec![p]),- },- _ => {}- }- });- rings.retain(|r| r.len() >= 2 && r.iter().all(|p| p.x.is_finite() && p.y.is_finite()));- (!too_many && !rings.is_empty() && offset.is_finite()).then_some(Contour { rings, offset: offset.max(0.0) })+ let rings = flatten_rings(path, to_inner)?;+ offset.is_finite().then_some(Contour { rings, clip: Vec::new(), offset: offset.max(0.0) })+ }++ /// This outline counted only within `frame` (after `to_inner`); unclipped if the frame is+ /// empty or too detailed.+ fn within(self, frame: &designcraft_geom::BezPath, to_inner: designcraft_geom::Affine) -> Contour {+ match flatten_rings(frame, to_inner) {+ Some(clip) => Contour { clip, ..self },+ None => self,+ }+ }++ /// The outline mapped by `a`.+ fn transformed(self, a: designcraft_geom::Affine) -> Contour {+ let map = |rings: Vec<Vec<Point>>| rings.into_iter().map(|r| r.into_iter().map(|p| a * p).collect()).collect();+ Contour { rings: map(self.rings), clip: map(self.clip), offset: self.offset }}fn bounds(&self) -> Rect {- let mut pts = self.rings.iter().flatten();- let Some(&p0) = pts.next() else { return Rect::ZERO };- let r = pts.fold(Rect::from_points(p0, p0), |r, &p| r.union_pt(p));+ let Some(r) = rings_bounds(&self.rings) else { return Rect::ZERO };+ let r = match rings_bounds(&self.clip) {+ Some(c) => r.intersect(c),+ None => r,+ };r.inflate(self.offset, self.offset)}/// Horizontal extent of the outline (offset included) within the band `y0..y1`: the band is- /// widened by the offset, and the outline's x-range there is widened by it too.+ /// widened by the offset, the outline's x-range there is limited to the clip's x-range there,+ /// then widened by the offset too.fn band_extent(&self, y0: f64, y1: f64) -> Option<(f64, f64)> {let (y0, y1) = (y0 - self.offset, y1 + self.offset);- let mut lo = f64::INFINITY;- let mut hi = f64::NEG_INFINITY;- for ring in &self.rings {- let Some(&last) = ring.last() else { continue };- let mut p = last;- for &q in ring {- let (a, b) = (p, q);- p = q;- if a.y.max(b.y) < y0 || a.y.min(b.y) > y1 {- continue;- }- let dy = b.y - a.y;- let (t0, t1) = if dy.abs() < 1e-12 {- (0.0, 1.0)- } else {- let (ta, tb) = ((y0 - a.y) / dy, (y1 - a.y) / dy);- (ta.min(tb).clamp(0.0, 1.0), ta.max(tb).clamp(0.0, 1.0))- };- for t in [t0, t1] {- let x = a.x + t * (b.x - a.x);- lo = lo.min(x);- hi = hi.max(x);- }- }+ let (mut lo, mut hi) = rings_band_extent(&self.rings, y0, y1)?;+ if !self.clip.is_empty() {+ let (a, b) = rings_band_extent(&self.clip, y0, y1)?;+ (lo, hi) = (lo.max(a), hi.min(b));}(lo <= hi).then_some((lo - self.offset, hi + self.offset))}}+/// The closed polylines of `path` (after `to_inner`), flattened; None if it is empty or too detailed.+fn flatten_rings(path: &designcraft_geom::BezPath, to_inner: designcraft_geom::Affine) -> Option<Vec<Vec<Point>>> {+ let mut rings: Vec<Vec<Point>> = Vec::new();+ let mut n = 0usize;+ let mut too_many = false;+ designcraft_geom::kurbo::flatten(to_inner * path.clone(), 0.25, |el| {+ n += 1;+ too_many |= n > MAX_CONTOUR_POINTS;+ match el {+ designcraft_geom::PathEl::MoveTo(p) => rings.push(vec![p]),+ designcraft_geom::PathEl::LineTo(p) => match rings.last_mut() {+ Some(r) => r.push(p),+ None => rings.push(vec![p]),+ },+ _ => {}+ }+ });+ rings.retain(|r| r.len() >= 2 && r.iter().all(|p| p.x.is_finite() && p.y.is_finite()));+ (!too_many && !rings.is_empty()).then_some(rings)+}++fn rings_bounds(rings: &[Vec<Point>]) -> Option<Rect> {+ let mut pts = rings.iter().flatten();+ let &p0 = pts.next()?;+ Some(pts.fold(Rect::from_points(p0, p0), |r, &p| r.union_pt(p)))+}++/// Horizontal extent of closed polylines within the band `y0..y1`.+fn rings_band_extent(rings: &[Vec<Point>], y0: f64, y1: f64) -> Option<(f64, f64)> {+ let mut lo = f64::INFINITY;+ let mut hi = f64::NEG_INFINITY;+ for ring in rings {+ let Some(&last) = ring.last() else { continue };+ let mut p = last;+ for &q in ring {+ let (a, b) = (p, q);+ p = q;+ if a.y.max(b.y) < y0 || a.y.min(b.y) > y1 {+ continue;+ }+ let dy = b.y - a.y;+ let (t0, t1) = if dy.abs() < 1e-12 {+ (0.0, 1.0)+ } else {+ let (ta, tb) = ((y0 - a.y) / dy, (y1 - a.y) / dy);+ (ta.min(tb).clamp(0.0, 1.0), ta.max(tb).clamp(0.0, 1.0))+ };+ for t in [t0, t1] {+ let x = a.x + t * (b.x - a.x);+ lo = lo.min(x);+ hi = hi.max(x);+ }+ }+ }+ (lo <= hi).then_some((lo, hi))+}+/// The wrap exclusion of `other` (an item whose inner space maps to the spread by `xf`) for a/// frame whose inner space is reached from the spread by `inv`. `left_page` places the object on/// a left page (for the spine sides).@@ -387,16 +430,24 @@ pub fn exclusion(other: &designcraft_doc::Item, xf: designcraft_geom::Affine, inWrapSide::AwayFromSpine => WrapSide::RightSide,s => s,};- let contour = (other.wrap.mode == WrapMode::Contour && other.shape != designcraft_doc::Shape::Group)- .then(|| contour_path(other))- .and_then(|path| Contour::of(&path, inv * xf, other.wrap.offsets[0]));+ let contour = (other.wrap.mode == WrapMode::Contour && other.shape != designcraft_doc::Shape::Group).then(|| contour_path(other)).and_then(+ |(path, frame)| {+ let c = Contour::of(&path, inv * xf, other.wrap.offsets[0])?;+ Some(match frame {+ Some(frame) => c.within(&frame, inv * xf),+ None => c,+ })+ },+ );let rect = contour.as_ref().map_or_else(|| inv.transform_rect_bbox(r), Contour::bounds);Exclusion { rect, mode: other.wrap.mode, side, contour }}-/// The outline a contour wrap follows, in the item's inner space. Graphic frames follow their contour type; detected edges, alpha channels and image paths need-/// the image, so they follow the frame's path (as other frames do).-fn contour_path(it: &designcraft_doc::Item) -> designcraft_geom::BezPath {+/// The outline a contour wrap follows, in the item's inner space, and for an outline taken from+/// the placed graphic, the frame path that clips it. Graphic frames follow their contour type;+/// detected edges, alpha channels and image paths need the image, so they follow the frame's path+/// (as other frames do).+fn contour_path(it: &designcraft_doc::Item) -> (designcraft_geom::BezPath, Option<designcraft_geom::BezPath>) {let frame = designcraft_geom::corners::apply(&it.path, &it.corners);if it.wrap.contour == designcraft_doc::ContourType::BoundingBox&& let Some(g) = it.graphic()@@ -405,10 +456,10 @@ fn contour_path(it: &designcraft_doc::Item) -> designcraft_geom::BezPath {let gb = g.xf.transform_rect_bbox(Rect::new(0.0, 0.0, g.size.0, g.size.1));let r = gb.intersect(fb);if r.width() > 0.0 && r.height() > 0.0 {- return designcraft_geom::kurbo::Shape::to_path(&r, 0.1);+ return (designcraft_geom::kurbo::Shape::to_path(&r, 0.1), Some(frame));}}- frame+ (frame, None)}/// One frame of the thread, ready for composition.@@ -547,11 +598,7 @@ pub fn frame_specs(doc: &Document, sid: StoryId) -> Vec<FrameSpec> {let v = designcraft_doc::vertical_text_xf(area).inverse();let ex = exclusions.into_iter()- .map(|e| Exclusion {- rect: v.transform_rect_bbox(e.rect),- contour: e.contour.map(|c| Contour { rings: c.rings.iter().map(|r| r.iter().map(|&p| v * p).collect()).collect(), ..c }),- ..e- })+ .map(|e| Exclusion { rect: v.transform_rect_bbox(e.rect), contour: e.contour.map(|c| c.transformed(v)), ..e }).collect();let pr = page_rect.map(|(a, b)| (v.transform_rect_bbox(a), v.transform_rect_bbox(b)));(Rect::new(0.0, 0.0, area.height(), area.width()), ex, None, pr)diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rsindex c5d2149ee..7cb0858f5 100644--- a/crates/compose/src/tests.rs+++ b/crates/compose/src/tests.rs@@ -304,6 +304,39 @@ fn a_line_meets_the_wrap_from_its_top_to_its_baseline() {}}+#[test]+fn an_image_contour_stops_at_its_frame() {+ let (mut d, sid, _) = doc_with(&[LOREM; 2].join(" "), Rect::new(0.0, 0.0, 300.0, 800.0), ParaAttrs::default());+ let lid = d.default_layer();+ // An L-shaped frame: its right edge is at x = 150 down to y = 150, then at 250 below.+ let pts = [(0.0, 50.0), (150.0, 50.0), (150.0, 150.0), (250.0, 150.0), (250.0, 200.0), (0.0, 200.0)].map(|(x, y)| Point::new(x, y));+ let frame = designcraft_geom::path::PathData::single(designcraft_geom::path::SubPath::polyline(&pts, true));+ let mut it = designcraft_doc::Item::new(ItemId(d.alloc()), lid, designcraft_doc::Shape::Polygon, frame);+ // The image overhangs the frame on every side.+ it.content = designcraft_doc::Content::Graphic(designcraft_doc::Graphic {+ asset: designcraft_doc::AssetId(d.alloc()),+ size: (300.0, 250.0),+ xf: designcraft_geom::Affine::IDENTITY,+ auto_fit: designcraft_doc::Fitting::None,+ fit_align: 4,+ crop: [0.0; 4],+ });+ it.wrap.mode = WrapMode::Contour;+ it.wrap.side = WrapSide::RightSide;+ it.wrap.contour = designcraft_doc::ContourType::BoundingBox;+ it.wrap.offsets = [4.0; 4];+ d.insert_item(SpreadRef::Doc(0), it, None).unwrap();+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let beside: Vec<&Line> = cs.frames[0].lines.iter().filter(|l| l.baseline - l.ascent > 54.0 && l.baseline < 146.0).collect();+ assert!(beside.len() >= 3, "{} lines beside the frame", beside.len());+ for l in beside {+ assert!((l.x0 - 154.0).abs() < 0.5, "line at {} starts at {}", l.baseline, l.x0);+ }+ // Below the step the frame is wider.+ let low = cs.frames[0].lines.iter().find(|l| l.baseline - l.ascent > 154.0 && l.baseline < 196.0).unwrap();+ assert!((low.x0 - 254.0).abs() < 0.5, "{}", low.x0);+}+#[test]fn paragraph_composer_is_no_worse_than_greedy() {// Sum of squared slack over lines (excluding last) should not exceed the greedy result.