Merge branch 'pr/519' into batch1
This commit is contained in:
Brandon Thomas
commit
d6d26d2b38
|
|
@ -141,6 +141,7 @@ Newest first.
|
|||
- **2026-10-12** · Native engine saves and exports replace files atomically; failed writes retain the original, private staging preserves Unix permissions, and valid long filenames work. Desktop Services and CLI raster exports remain separate follow-ups. No readiness percentage change.
|
||||
- **2026-10-12** · Hyphenation Zone applies to the Single-line Composer only, as in InDesign. With the default Paragraph Composer, ragged text hyphenates where InDesign does (aper-natem), giving the same line breaks. No readiness percentage change.
|
||||
- **2026-10-12** · The Tools panel's Fill/Stroke keys work: D (default fill and stroke), X (fill or stroke in front), Shift+X (swap per object, tints included) and / (Apply None), as `color.*` commands; swap and default are one undo step (`object.swapFillStroke`, `object.defaultFillStroke`); the Color panel follows the proxy's fill/stroke choice. No readiness percentage change.
|
||||
- **2026-10-11** · Corner Options keep curved sides curved and round every corner point, including where an arc meets a line (a Pathfinder quarter circle with rounded corners stayed a triangle). No readiness percentage change.
|
||||
- **2026-10-12** · Words in capitals hyphenate like capitalized words (FERRUM COM-MODI), as in InDesign; Hyphenate Capitalized Words off keeps them whole. No readiness percentage change.
|
||||
- **2026-10-11** · `transform.move {copy}`, Edit › Duplicate and Step and Repeat return the copies' ids, so a script can go on with them. No readiness percentage change.
|
||||
- **2026-10-11** · `object.fill` and `object.stroke` refuse a swatch name the document doesn't have (it painted nothing) and suggest the name meant (`Paper` → `[Paper]`). No readiness percentage change.
|
||||
|
|
|
|||
|
|
@ -1,9 +1,10 @@
|
|||
//! Live corner options (Object → Corner Options): rounded, inverse rounded, inset, bevel, fancy.
|
||||
//!
|
||||
//! Corners are applied at render time to the straight-segment corners of a closed path, so the
|
||||
//! frame keeps its simple editable geometry (as in InDesign).
|
||||
//! Corners are applied at render time to the corner points of a closed path (where its direction
|
||||
//! turns), so the frame keeps its simple editable geometry (as in InDesign). Curved sides stay
|
||||
//! curved: a corner where an arc meets a line trims the arc along its length.
|
||||
|
||||
use kurbo::{BezPath, Point, Vec2};
|
||||
use kurbo::{BezPath, CubicBez, ParamCurve, ParamCurveArclen, Point, Vec2};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::path::{PathData, SubPath};
|
||||
|
|
@ -63,8 +64,9 @@ impl CornerOptions {
|
|||
}
|
||||
}
|
||||
|
||||
/// Apply corner options to `path`. Corners are applied to anchors joining two straight segments of
|
||||
/// closed subpaths; other anchors are kept. Anchor `i` of every subpath uses `opts.corners[i % 4]`.
|
||||
/// Apply corner options to `path`. Corners are applied to the corner points of closed subpaths
|
||||
/// (where the incoming and outgoing directions differ, curved sides included); smooth points are
|
||||
/// kept. Anchor `i` of every subpath uses `opts.corners[i % 4]`.
|
||||
pub fn apply(path: &PathData, opts: &CornerOptions) -> BezPath {
|
||||
if opts.is_none() {
|
||||
return path.to_bezpath();
|
||||
|
|
@ -76,50 +78,84 @@ pub fn apply(path: &PathData, opts: &CornerOptions) -> BezPath {
|
|||
out
|
||||
}
|
||||
|
||||
/// Arc length accuracy (points) when trimming curved sides.
|
||||
const ARC_ACCURACY: f64 = 1e-3;
|
||||
/// Directions closer than this (cosine, about 1°) are a smooth point, not a corner.
|
||||
const SMOOTH: f64 = 0.9998;
|
||||
|
||||
/// The unit direction a segment leaves its start in (None for a point).
|
||||
fn start_dir(c: &CubicBez) -> Option<Vec2> {
|
||||
[c.p1, c.p2, c.p3].into_iter().map(|q| q - c.p0).find(|d| d.hypot() > 1e-9).map(|d| d / d.hypot())
|
||||
}
|
||||
|
||||
/// The unit direction a segment arrives at its end in (None for a point).
|
||||
fn end_dir(c: &CubicBez) -> Option<Vec2> {
|
||||
[c.p2, c.p1, c.p0].into_iter().map(|q| c.p3 - q).find(|d| d.hypot() > 1e-9).map(|d| d / d.hypot())
|
||||
}
|
||||
|
||||
/// Does the path turn where `prev` ends and `next` starts?
|
||||
fn is_corner(prev: &CubicBez, next: &CubicBez) -> bool {
|
||||
matches!((end_dir(prev), start_dir(next)), (Some(a), Some(b)) if a.dot(b) < SMOOTH)
|
||||
}
|
||||
|
||||
fn apply_subpath(sp: &SubPath, opts: &CornerOptions, out: &mut BezPath) {
|
||||
let n = sp.anchors.len();
|
||||
let straight_corner = |i: usize| {
|
||||
let a = &sp.anchors[i];
|
||||
sp.closed && !a.has_in() && !a.has_out()
|
||||
};
|
||||
if !sp.closed || n < 3 || !(0..n).any(straight_corner) {
|
||||
if !sp.closed || n < 2 {
|
||||
sp.to_bezpath_into(out);
|
||||
return;
|
||||
}
|
||||
let pts: Vec<Point> = sp.anchors.iter().map(|a| a.p).collect();
|
||||
let mut first = true;
|
||||
for i in 0..n {
|
||||
let c = opts.corners[i % 4];
|
||||
let p = pts[i];
|
||||
let prev = pts[(i + n - 1) % n];
|
||||
let next = pts[(i + 1) % n];
|
||||
if c.is_none() || !straight_corner(i) || !straight_corner((i + n - 1) % n) && sp.anchors[(i + n - 1) % n].has_out() {
|
||||
if first {
|
||||
out.move_to(p);
|
||||
first = false;
|
||||
} else {
|
||||
out.line_to(p);
|
||||
// Segment `i` runs from anchor `i` to anchor `i + 1`; the corner at anchor `i` joins segments
|
||||
// `i - 1` and `i`, and takes at most half of each.
|
||||
let segs: Vec<CubicBez> = (0..n).map(|i| sp.segment(i)).collect();
|
||||
let lines: Vec<bool> = (0..n).map(|i| sp.segment_is_line(i)).collect();
|
||||
// Straight sides are measured (and trimmed below) exactly; curves by arc length.
|
||||
let lens: Vec<f64> = segs.iter().zip(&lines).map(|(c, line)| if *line { (c.p3 - c.p0).hypot() } else { c.arclen(ARC_ACCURACY) }).collect();
|
||||
let size: Vec<f64> = (0..n)
|
||||
.map(|i| {
|
||||
let c = opts.corners[i % 4];
|
||||
let prev = (i + n - 1) % n;
|
||||
if c.is_none() || !is_corner(&segs[prev], &segs[i]) {
|
||||
return 0.0;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let din = prev - p;
|
||||
let dout = next - p;
|
||||
let (lin, lout) = (din.hypot(), dout.hypot());
|
||||
if lin < 1e-9 || lout < 1e-9 {
|
||||
continue;
|
||||
}
|
||||
let s = c.size.min(lin / 2.0).min(lout / 2.0);
|
||||
let ui = din / lin;
|
||||
let uo = dout / lout;
|
||||
let a = p + ui * s; // entry point on incoming edge
|
||||
let b = p + uo * s; // exit point on outgoing edge
|
||||
if first {
|
||||
out.move_to(a);
|
||||
first = false;
|
||||
c.size.min(lens[prev] / 2.0).min(lens[i] / 2.0).max(0.0)
|
||||
})
|
||||
.collect();
|
||||
if size.iter().all(|s| *s <= 0.0) {
|
||||
sp.to_bezpath_into(out);
|
||||
return;
|
||||
}
|
||||
// Each segment without the parts its corners take.
|
||||
let trimmed: Vec<CubicBez> = (0..n)
|
||||
.map(|i| {
|
||||
let (s0, s1) = (size[i], size[(i + 1) % n]);
|
||||
if lines[i] {
|
||||
let c = &segs[i];
|
||||
let u = if lens[i] > 1e-12 { (c.p3 - c.p0) / lens[i] } else { Vec2::ZERO };
|
||||
let (a, b) = (c.p0 + u * s0, c.p3 - u * s1);
|
||||
return CubicBez::new(a, a, b, b);
|
||||
}
|
||||
let t0 = if s0 > 0.0 { segs[i].inv_arclen(s0, ARC_ACCURACY) } else { 0.0 };
|
||||
let t1 = if s1 > 0.0 { segs[i].inv_arclen(lens[i] - s1, ARC_ACCURACY) } else { 1.0 };
|
||||
segs[i].subsegment(t0..t1.max(t0))
|
||||
})
|
||||
.collect();
|
||||
out.move_to(trimmed[0].p0);
|
||||
for i in 0..n {
|
||||
let seg = &trimmed[i];
|
||||
if lines[i] {
|
||||
out.line_to(seg.p3);
|
||||
} else {
|
||||
out.line_to(a);
|
||||
out.curve_to(seg.p1, seg.p2, seg.p3);
|
||||
}
|
||||
// The corner at the segment's end, from where this segment stops to where the next starts.
|
||||
let j = (i + 1) % n;
|
||||
let next = &trimmed[j];
|
||||
if size[j] > 0.0 {
|
||||
match (end_dir(seg).or_else(|| end_dir(&segs[i])), start_dir(next).or_else(|| start_dir(&segs[j]))) {
|
||||
(Some(ta), Some(tb)) => corner_shape(out, opts.corners[j % 4].shape, sp.anchors[j].p, seg.p3, next.p0, -ta, tb, size[j]),
|
||||
_ => out.line_to(next.p0),
|
||||
}
|
||||
}
|
||||
corner_shape(out, c.shape, p, a, b, ui, uo, s);
|
||||
}
|
||||
out.close_path();
|
||||
}
|
||||
|
|
@ -185,6 +221,67 @@ mod tests {
|
|||
assert!((a - std::f64::consts::PI * 100.0).abs() < 1.0, "{a}");
|
||||
}
|
||||
|
||||
fn nearest(bp: &BezPath, p: Point) -> f64 {
|
||||
use kurbo::ParamCurveNearest;
|
||||
bp.segments().map(|s| s.nearest(p, 1e-6).distance_sq.sqrt()).fold(f64::INFINITY, f64::min)
|
||||
}
|
||||
|
||||
/// A quarter disc of radius 100 centred on (0, 100): its arc from (0, 0) to (100, 100).
|
||||
fn quarter_disc() -> PathData {
|
||||
let k = 100.0 * crate::shapes::KAPPA;
|
||||
let mut a0 = crate::path::Anchor::corner(Point::new(0.0, 0.0));
|
||||
a0.h_out = Point::new(k, 0.0);
|
||||
let mut a1 = crate::path::Anchor::corner(Point::new(100.0, 100.0));
|
||||
a1.h_in = Point::new(100.0, 100.0 - k);
|
||||
let a2 = crate::path::Anchor::corner(Point::new(0.0, 100.0));
|
||||
PathData::new(vec![SubPath { anchors: vec![a0, a1, a2], closed: true }])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rounded_corners_keep_curved_sides_and_round_where_an_arc_meets_a_line() {
|
||||
let p = quarter_disc();
|
||||
let bp = apply(&p, &CornerOptions::uniform(CornerShape::Rounded, 20.0));
|
||||
// Still a quarter disc (area pi/4 * 100^2 = 7854), less three small rounded corners; a
|
||||
// triangle would be 5000.
|
||||
let area = bp.area().abs();
|
||||
assert!(area > 7300.0 && area < 7854.0, "area {area}");
|
||||
// The middle of the arc is kept.
|
||||
let mid = Point::new(100.0 * std::f64::consts::FRAC_1_SQRT_2, 100.0 - 100.0 * std::f64::consts::FRAC_1_SQRT_2);
|
||||
assert!(nearest(&bp, mid) < 0.05, "{}", nearest(&bp, mid));
|
||||
// All three corners are rounded off: the line-line one and both where the arc meets a line.
|
||||
for corner in [Point::new(0.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)] {
|
||||
assert!(nearest(&bp, corner) > 3.0, "{corner:?} is still sharp");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn straight_sides_are_trimmed_exactly() {
|
||||
let r = rectangle(Rect::new(0.0, 0.0, 100.0, 60.0));
|
||||
let bp = apply(&r, &CornerOptions::uniform(CornerShape::Bevel, 10.0));
|
||||
// Every point a bevelled rectangle goes through sits exactly 10 pt from a corner.
|
||||
let pts: Vec<Point> = bp
|
||||
.elements()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
kurbo::PathEl::MoveTo(p) | kurbo::PathEl::LineTo(p) => Some(*p),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(pts.len(), 9, "{pts:?}");
|
||||
for p in pts {
|
||||
assert!([0.0, 10.0, 90.0, 100.0].contains(&p.x) && [0.0, 10.0, 50.0, 60.0].contains(&p.y), "{p:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn smooth_points_are_not_corners() {
|
||||
let e = crate::shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 60.0));
|
||||
for shape in CornerShape::ALL.into_iter().skip(1) {
|
||||
let bp = apply(&e, &CornerOptions::uniform(shape, 20.0));
|
||||
assert!((bp.area().abs() - e.to_bezpath().area().abs()).abs() < 1e-6, "{shape:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn size_is_clamped_to_half_edge() {
|
||||
let r = rectangle(Rect::new(0.0, 0.0, 10.0, 10.0));
|
||||
|
|
|
|||
Loading…
Reference in New Issue