e4f86d11fe8a
squircle.rs
//! Rectangles with smoothed ("squircle") corners, as design tools offer next to the corner radius
//! (#286). A plain rounded corner joins the straight edge with a sudden change of curvature; a
//! smoothed corner starts curving earlier, along a cubic Bézier, and keeps a shorter circular arc
//! in the middle, so the outline flows into the edge.
//!
//! For a corner of radius `r` and smoothing `s` (0 = circular, 1 = no arc left), the corner takes
//! `p = (1 + s) · r` of each edge. The arc keeps `90° · (1 − s)` around the corner's diagonal and
//! each side of it is a cubic whose handles lie on the edge, so the curve is tangent to the edge
//! where it starts and to the arc where it meets it. When `p` would exceed half the shorter side,
//! the smoothing is reduced first, then the radius. The construction is our own derivation from
//! these constraints.
/// The outline of a `w` x `h` rectangle with corners of radius `radius` smoothed by `smoothing`
/// (0..=1), as path data in the rectangle's own coordinates (`M`, `L`, `C`, `Z`; y down).
pub fn path_d(w: f64, h: f64, radius: f64, smoothing: f64) -> String {
let w = if w.is_finite() { w.max(0.0) } else { 0.0 };
let h = if h.is_finite() { h.max(0.0) } else { 0.0 };
let half = w.min(h) / 2.0;
let r = if radius.is_finite() { radius.clamp(0.0, half) } else { 0.0 };
let mut s = if smoothing.is_finite() { smoothing.clamp(0.0, 1.0) } else { 0.0 };
if r <= 0.0 {
return format!("M 0 0 L {w} 0 L {w} {h} L 0 {h} Z");
}
s = s.min(half / r - 1.0).max(0.0);
let c = corner(r, s);
// The top-right corner in local terms: `u` runs back along the top edge from the corner,
// `v` down the right edge. Each corner maps (u, v) to the rectangle by symmetry.
let corners: [&dyn Fn(f64, f64) -> (f64, f64); 4] = [
&|u, v| (w - u, v), // top right: from the top edge to the right edge
&|u, v| (w - v, h - u), // bottom right: from the right edge to the bottom edge
&|u, v| (u, h - v), // bottom left: from the bottom edge to the left edge
&|u, v| (v, u), // top left: from the left edge to the top edge
];
let mut d = String::new();
let pt = |f: &dyn Fn(f64, f64) -> (f64, f64), (u, v): (f64, f64)| {
let (x, y) = f(u, v);
format!("{} {}", round(x), round(y))
};
for (i, f) in corners.iter().enumerate() {
let segs = c.segments();
if i == 0 {
d.push_str(&format!("M {}", pt(*f, segs[0])));
} else {
d.push_str(&format!(" L {}", pt(*f, segs[0])));
}
for k in 0..3 {
let b = 1 + k * 3;
d.push_str(&format!(" C {} {} {}", pt(*f, segs[b]), pt(*f, segs[b + 1]), pt(*f, segs[b + 2])));
}
}
d.push_str(" Z");
d
}
fn round(v: f64) -> f64 {
(v * 1000.0).round() / 1000.0 + 0.0
}
/// One corner in (u, v) terms: distance back along the incoming edge, distance along the outgoing.
struct Corner {
p: f64,
a: f64,
b: f64,
c: f64,
d: f64,
r: f64,
arc: f64,
}
fn corner(r: f64, s: f64) -> Corner {
use std::f64::consts::{FRAC_PI_2, FRAC_PI_4};
let p = (1.0 + s) * r;
let arc = FRAC_PI_2 * (1.0 - s);
// The arc's chord, and where the edge curve meets the arc.
let arc_chord = (arc / 2.0).sin() * r * std::f64::consts::SQRT_2;
let alpha = (FRAC_PI_2 - arc) / 2.0;
let p3_p4 = r * (alpha / 2.0).tan();
let beta = FRAC_PI_4 * s;
let c = p3_p4 * beta.cos();
let d = c * beta.tan();
let b = ((p - arc_chord - c - d) / 3.0).max(0.0);
let a = 2.0 * b;
Corner { p, a, b, c, d, r, arc }
}
impl Corner {
/// Ten points: the start on the incoming edge, then three cubics (control, control, end):
/// edge → arc start, the arc, arc end → outgoing edge.
fn segments(&self) -> [(f64, f64); 10] {
let Corner { p, a, b, c, d, r, arc } = *self;
// Edge curve into the arc: handles on the edge, ending where the arc starts.
let e0 = (p, 0.0);
let e1 = (p - a, 0.0);
let e2 = (p - a - b, 0.0);
let e3 = (p - a - b - c, d);
// The arc around the centre (r, r) in (u, v), symmetric about the corner's diagonal.
// Angles from +u towards +v: the corner itself is at 5π/4 from the centre; the arc runs
// from the incoming edge's side (larger angle) to the outgoing edge's side.
let start = std::f64::consts::FRAC_PI_4 * 5.0 + arc / 2.0;
let end = start - arc;
let at = |t: f64| (r + r * t.cos(), r + r * t.sin());
let k = 4.0 / 3.0 * (arc / 4.0).tan() * r;
let a0 = at(start);
let a3 = at(end);
// Tangent of the arc travelled towards smaller angles: (sin t, −cos t).
let a1 = (a0.0 + k * start.sin(), a0.1 - k * start.cos());
let a2 = (a3.0 - k * end.sin(), a3.1 + k * end.cos());
// Mirror of the edge curve onto the outgoing edge (swap u and v), reversed.
let o1 = (e2.1, e2.0);
let o2 = (e1.1, e1.0);
let o3 = (e0.1, e0.0);
let _ = (e3, a0);
[e0, e1, e2, a0, a1, a2, a3, o1, o2, o3]
}
}
#[cfg(test)]
mod tests {
use super::*;
fn numbers(d: &str) -> Vec<f64> {
d.split_whitespace().filter_map(|t| t.parse().ok()).collect()
}
#[test]
fn no_radius_is_a_rectangle() {
assert_eq!(path_d(100.0, 50.0, 0.0, 0.6), "M 0 0 L 100 0 L 100 50 L 0 50 Z");
}
#[test]
fn edge_curve_meets_the_arc() {
for s in [0.0, 0.3, 0.6, 1.0] {
let c = corner(10.0, s);
let seg = c.segments();
let e3 = (c.p - c.a - c.b - c.c, c.d);
// The arc starts on the circle and where the edge curve ends.
assert!((seg[3].0 - e3.0).abs() < 1e-6 && (seg[3].1 - e3.1).abs() < 1e-6, "s={s}: {:?} vs {:?}", seg[3], e3);
// The arc is symmetric about the diagonal u = v.
assert!((seg[3].0 - seg[6].1).abs() < 1e-9 && (seg[3].1 - seg[6].0).abs() < 1e-9);
}
}
#[test]
fn zero_smoothing_is_a_circular_corner() {
let c = corner(10.0, 0.0);
let seg = c.segments();
assert!((c.p - 10.0).abs() < 1e-9);
assert!((seg[3].0 - 10.0).abs() < 1e-9 && seg[3].1.abs() < 1e-9);
assert!((seg[6].0).abs() < 1e-9 && (seg[6].1 - 10.0).abs() < 1e-9);
}
#[test]
fn smoothing_uses_more_of_the_edge() {
let d0 = numbers(&path_d(200.0, 100.0, 20.0, 0.0));
let d6 = numbers(&path_d(200.0, 100.0, 20.0, 0.6));
// The first point is where the top-right corner starts on the top edge.
assert_eq!((d0[0], d0[1]), (180.0, 0.0));
assert_eq!((d6[0], d6[1]), (168.0, 0.0));
}
#[test]
fn stays_inside_and_reduces_smoothing_when_the_rectangle_is_small() {
for (w, h, r, s) in [(100.0, 40.0, 20.0, 1.0), (40.0, 40.0, 50.0, 0.8), (10.0, 300.0, 4.0, 0.6), (300.0, 120.0, 30.0, 0.6)] {
let n = numbers(&path_d(w, h, r, s));
assert!(n.chunks(2).all(|p| p[0] >= -1e-6 && p[0] <= w + 1e-6 && p[1] >= -1e-6 && p[1] <= h + 1e-6), "{w}x{h} r{r} s{s}");
// Corners never cross the middle of an edge.
assert!(n[0] >= w / 2.0 - 1e-6);
}
assert!(numbers(&path_d(f64::NAN, 10.0, f64::INFINITY, f64::NAN)).iter().all(|v| v.is_finite()));
}
#[test]
fn four_symmetric_corners() {
let n = numbers(&path_d(120.0, 80.0, 16.0, 0.6));
// 4 corners x 10 points, 2 numbers each.
assert_eq!(n.len(), 80);
let pts: Vec<(f64, f64)> = n.chunks(2).map(|p| (p[0], p[1])).collect();
for &(x, y) in &pts {
let mirrored = (120.0 - x, 80.0 - y);
assert!(pts.iter().any(|q| (q.0 - mirrored.0).abs() < 0.01 && (q.1 - mirrored.1).abs() < 0.01), "{x},{y}");
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.