diff options
Diffstat (limited to 'src/vector/morph.zig')
| -rw-r--r-- | src/vector/morph.zig | 60 |
1 files changed, 55 insertions, 5 deletions
diff --git a/src/vector/morph.zig b/src/vector/morph.zig index f285c7e..a05037d 100644 --- a/src/vector/morph.zig +++ b/src/vector/morph.zig @@ -2,7 +2,9 @@ //! in order; each pair's subpaths, then each subpath's cubics, are made equal //! in number by splitting the longest curves; then every control point and //! color is interpolated. A shape without a partner collapses to (or grows -//! from) the other drawing's center. +//! from) the other drawing's center. Outer contours pair with outer ones +//! and holes with holes, so a glyph's counter stays a counter; a hole +//! without a partner shrinks to nothing (or grows) inside its shape. const std = @import("std"); const geom = @import("math"); const Drawing = @import("Drawing.zig"); @@ -22,10 +24,14 @@ pub fn between(arena: std.mem.Allocator, a: Drawing, ma: geom.Affine, b: Drawing // The missing side is the other side, shrunk to a point. const pa = try placed(arena, a, sa, ma, sb, b, mb, cb); const pb = try placed(arena, b, sb, mb, sa, a, ma, ca); - const count = @max(pa.len, pb.len); - for (0..count) |k| { - const from = try pad(arena, pa, k, if (pa.len > 0) lastPoint(pa) else ca); - const to = try pad(arena, pb, k, if (pb.len > 0) lastPoint(pb) else cb); + // Outer contours pair up, then holes; a missing shape's subpaths + // are its partner's, in order. + const ha = if (sa != null and sb != null) try holesLast(arena, pa) else 0; + const hb = if (sa != null and sb != null) try holesLast(arena, pb) else 0; + const outers = @max(pa.len - ha, pb.len - hb); + for (0..outers + @max(ha, hb)) |k| { + const from = try side(arena, pa, ha, pb, hb, k, outers, ca); + const to = try side(arena, pb, hb, pa, ha, k, outers, cb); const aligned = try align2(arena, from.cubics, to.cubics); for (aligned[0], aligned[1]) |x, y| { var c: Cubic = undefined; @@ -78,6 +84,50 @@ fn pad(arena: std.mem.Allocator, paths: []const Path, k: usize, point: Vec) !Pat return .{ .cubics = one, .closed = false }; } +/// Puts the holes of `paths` (wound against the largest, as a font's +/// counters are) after its outer contours, each in order; returns how many. +fn holesLast(arena: std.mem.Allocator, paths: []Path) !usize { + const areas = try arena.alloc(f32, paths.len); + var main: f32 = 0; + for (areas, paths) |*area, p| { + area.* = geom.cross(p.cubics[p.cubics.len - 1][3], p.cubics[0][0]); + for (p.cubics) |c| area.* += geom.cross(c[0], c[1]) + geom.cross(c[1], c[2]) + geom.cross(c[2], c[3]); + if (@abs(area.*) > @abs(main)) main = area.*; + } + const all = try arena.dupe(Path, paths); + var n: usize = 0; + var holes: usize = 0; + for ([_]bool{ false, true }) |hole| for (all, areas) |p, area| if ((area * main < 0) == hole) { + paths[n] = p; + n += 1; + holes += @intFromBool(hole); + }; + return holes; +} + +/// One side's path for pair `k`: its outer contours, then its holes. One it +/// lacks is a point: an outer contour's where its last one ends (or at its +/// drawing's `middle`); a hole's where the other side's hole has its middle, +/// relative to the outer contours' bounds on each side, so that a hole with +/// no partner shrinks to nothing (or grows) inside its shape, moving with it. +fn side(arena: std.mem.Allocator, own: []const Path, holes: usize, other: []const Path, other_holes: usize, k: usize, outers: usize, middle: Vec) !Path { + const shell = own[0 .. own.len - holes]; + if (k < outers) return pad(arena, shell, k, if (shell.len > 0) lastPoint(shell) else middle); + const j = k - outers; + if (j < holes) return own[own.len - holes + j]; + const there = extent(other[0 .. other.len - other_holes]); + const here = extent(shell); + const hole = extent(other[other.len - other_holes + j ..][0..1]); + const at = ((hole.min + hole.max) / geom.splat(2) - there.min) / (there.max - there.min); + return pad(arena, &.{}, 0, here.min + at * (here.max - here.min)); +} + +fn extent(paths: []const Path) geom.Bounds { + var b: geom.Bounds = .{}; + for (paths) |p| for (p.cubics) |c| for (c) |q| b.add(q); + return b; +} + fn lastPoint(paths: []const Path) Vec { const last = paths[paths.len - 1].cubics; return last[last.len - 1][3]; |
