Illusion/pdf-odin-llm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Illusion
2026-09-25 23:32:29 +02:00
commit fff8b677f8
114 changed files with 84233 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
path.odin
+554
View File
@@ -0,0 +1,554 @@
package pdf
import "core:math"
// Path_Verb tags one element of a path. The point count each verb consumes is
// fixed: Move and Line take one, Curve takes three (two controls and an end
// point), Close takes none.
Path_Verb :: enum u8 {
Move,
Line,
Curve,
Close,
}
// Path is a sequence of subpaths in one coordinate space.
//
// Verbs and points are kept in parallel arrays rather than as a tagged union
// per element: a page of text is tens of thousands of elements, and the
// rasteriser walks them once per fill, so the layout that keeps points
// contiguous is worth the small awkwardness of the cursor arithmetic.
Path :: struct {
verbs: [dynamic]Path_Verb,
points: [dynamic]Point,
// Start of the current subpath, for Close.
start: Point,
// Current point. Meaningless before the first Move.
cur: Point,
open: bool,
}
path_make :: proc(allocator := context.allocator, cap := 32) -> Path {
return Path{
verbs = make([dynamic]Path_Verb, 0, cap, allocator),
points = make([dynamic]Point, 0, cap, allocator),
}
}
path_destroy :: proc(p: ^Path) {
if p == nil { return }
delete(p.verbs)
delete(p.points)
p^ = {}
}
path_clear :: proc(p: ^Path) {
clear(&p.verbs)
clear(&p.points)
p.open = false
}
path_is_empty :: proc(p: ^Path) -> bool {
return p == nil || len(p.verbs) == 0
}
// ---------------------------------------------------------------------------
// Construction
//
// Every entry point drops a non-finite coordinate rather than storing it. A
// single NaN reaching the rasteriser turns a fill into an unbounded scanline
// walk, and content streams contain NaNs -- usually from a division by a zero
// text size -- often enough that filtering here is cheaper than checking in
// the inner loop.
// ---------------------------------------------------------------------------
path_move_to :: proc(p: ^Path, x, y: f64) {
if !is_finite(x) || !is_finite(y) { return }
append(&p.verbs, Path_Verb.Move)
append(&p.points, Point{x, y})
p.start = Point{x, y}
p.cur = Point{x, y}
p.open = true
}
path_line_to :: proc(p: ^Path, x, y: f64) {
if !is_finite(x) || !is_finite(y) { return }
// A line with no current point starts a subpath instead of being dropped:
// content streams do emit "l" before "m", and viewers treat it as a move.
if !p.open {
path_move_to(p, x, y)
return
}
append(&p.verbs, Path_Verb.Line)
append(&p.points, Point{x, y})
p.cur = Point{x, y}
}
path_curve_to :: proc(p: ^Path, x1, y1, x2, y2, x3, y3: f64) {
if !is_finite(x1) || !is_finite(y1) || !is_finite(x2) ||
!is_finite(y2) || !is_finite(x3) || !is_finite(y3) {
return
}
if !p.open {
path_move_to(p, x1, y1)
}
append(&p.verbs, Path_Verb.Curve)
append(&p.points, Point{x1, y1}, Point{x2, y2}, Point{x3, y3})
p.cur = Point{x3, y3}
}
// path_curve_to_v is the "v" operator: the first control point is the current
// point.
path_curve_to_v :: proc(p: ^Path, x2, y2, x3, y3: f64) {
path_curve_to(p, p.cur.x, p.cur.y, x2, y2, x3, y3)
}
// path_curve_to_y is the "y" operator: the second control point is the end
// point.
path_curve_to_y :: proc(p: ^Path, x1, y1, x3, y3: f64) {
path_curve_to(p, x1, y1, x3, y3, x3, y3)
}
path_close :: proc(p: ^Path) {
if !p.open || len(p.verbs) == 0 { return }
if p.verbs[len(p.verbs) - 1] == .Close { return }
append(&p.verbs, Path_Verb.Close)
p.cur = p.start
}
// path_rect appends a closed rectangle, in the winding direction the "re"
// operator specifies (counter-clockwise in user space).
path_rect :: proc(p: ^Path, x, y, w, h: f64) {
if !is_finite(x) || !is_finite(y) || !is_finite(w) || !is_finite(h) { return }
path_move_to(p, x, y)
path_line_to(p, x + w, y)
path_line_to(p, x + w, y + h)
path_line_to(p, x, y + h)
path_close(p)
}
// path_ellipse appends a closed ellipse inscribed in the rectangle, built from
// four cubics. The magic constant is the standard circle-to-cubic ratio.
path_ellipse :: proc(p: ^Path, r: Rect) {
K :: 0.5522847498307933
cx := (r.x0 + r.x1) * 0.5
cy := (r.y0 + r.y1) * 0.5
rx := (r.x1 - r.x0) * 0.5
ry := (r.y1 - r.y0) * 0.5
ox := rx * K
oy := ry * K
path_move_to(p, cx + rx, cy)
path_curve_to(p, cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry)
path_curve_to(p, cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy)
path_curve_to(p, cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry)
path_curve_to(p, cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy)
path_close(p)
}
// path_append copies every element of `src` onto `dst`.
path_append :: proc(dst: ^Path, src: ^Path) {
if src == nil { return }
append(&dst.verbs, ..src.verbs[:])
append(&dst.points, ..src.points[:])
dst.cur = src.cur
dst.start = src.start
dst.open = src.open || dst.open
}
// path_append_transformed copies `src` onto `dst` with `m` applied.
path_append_transformed :: proc(dst: ^Path, src: ^Path, m: Matrix) {
if src == nil { return }
for pt in src.points {
append(&dst.points, transform_point(m, pt))
}
append(&dst.verbs, ..src.verbs[:])
dst.cur = transform_point(m, src.cur)
dst.start = transform_point(m, src.start)
dst.open = src.open || dst.open
}
path_transform :: proc(p: ^Path, m: Matrix) {
for &pt in p.points {
pt = transform_point(m, pt)
}
p.cur = transform_point(m, p.cur)
p.start = transform_point(m, p.start)
}
path_clone :: proc(p: ^Path, allocator := context.allocator) -> Path {
out := path_make(allocator, max(len(p.verbs), 8))
append(&out.verbs, ..p.verbs[:])
append(&out.points, ..p.points[:])
out.cur = p.cur
out.start = p.start
out.open = p.open
return out
}
// ---------------------------------------------------------------------------
// Bounds
// ---------------------------------------------------------------------------
// path_bounds is the control-point hull, which is a conservative
// over-estimate for curves: a cubic never leaves the convex hull of its four
// points. Good enough for culling; `path_tight_bounds` is the exact one.
path_bounds :: proc(p: ^Path, m := MATRIX_IDENTITY) -> Rect {
if p == nil || len(p.points) == 0 { return RECT_EMPTY }
identity := matrix_is_identity(m)
first := identity ? p.points[0] : transform_point(m, p.points[0])
r := Rect{first.x, first.y, first.x, first.y}
for i in 1 ..< len(p.points) {
pt := identity ? p.points[i] : transform_point(m, p.points[i])
r.x0 = min(r.x0, pt.x)
r.y0 = min(r.y0, pt.y)
r.x1 = max(r.x1, pt.x)
r.y1 = max(r.y1, pt.y)
}
return r
}
// path_tight_bounds solves for the cubic's extrema instead of using the hull.
// Worth it for the clip stack, where a loose box costs whole scanlines.
path_tight_bounds :: proc(p: ^Path, m := MATRIX_IDENTITY) -> Rect {
if p == nil || len(p.verbs) == 0 { return RECT_EMPTY }
r := RECT_EMPTY
have := false
include :: proc(r: ^Rect, have: ^bool, pt: Point) {
if !have^ {
r^ = Rect{pt.x, pt.y, pt.x, pt.y}
have^ = true
return
}
r.x0 = min(r.x0, pt.x)
r.y0 = min(r.y0, pt.y)
r.x1 = max(r.x1, pt.x)
r.y1 = max(r.y1, pt.y)
}
cur := Point{}
i := 0
for verb in p.verbs {
switch verb {
case .Move, .Line:
if i >= len(p.points) { break }
pt := transform_point(m, p.points[i])
include(&r, &have, pt)
cur = pt
i += 1
case .Curve:
if i + 2 >= len(p.points) { break }
c1 := transform_point(m, p.points[i])
c2 := transform_point(m, p.points[i + 1])
e := transform_point(m, p.points[i + 2])
include(&r, &have, e)
cubic_extrema_include(&r, &have, cur, c1, c2, e)
cur = e
i += 3
case .Close:
// no points
}
}
return have ? r : RECT_EMPTY
}
// cubic_extrema_include folds the interior extrema of one cubic into the box.
// The derivative of a cubic Bezier is a quadratic; its roots in (0,1) are the
// only places the curve can turn.
@(private)
cubic_extrema_include :: proc(r: ^Rect, have: ^bool, p0, p1, p2, p3: Point) {
for axis in 0 ..< 2 {
v0 := p0[axis]
v1 := p1[axis]
v2 := p2[axis]
v3 := p3[axis]
a := -v0 + 3 * v1 - 3 * v2 + v3
b := 2 * (v0 - 2 * v1 + v2)
c := v1 - v0
fold :: proc(r: ^Rect, have: ^bool, axis: int, value: f64) {
if !is_finite(value) { return }
if !have^ {
r^ = Rect{value, value, value, value}
have^ = true
return
}
if axis == 0 {
r.x0 = min(r.x0, value)
r.x1 = max(r.x1, value)
} else {
r.y0 = min(r.y0, value)
r.y1 = max(r.y1, value)
}
}
eval :: proc(v0, v1, v2, v3, t: f64) -> f64 {
mt := 1 - t
return mt * mt * mt * v0 + 3 * mt * mt * t * v1 + 3 * mt * t * t * v2 + t * t * t * v3
}
// Degenerate to a linear derivative: solve b*t + c == 0.
if abs(a) < 1e-12 {
if abs(b) > 1e-12 {
t := -c / b
if t > 0 && t < 1 {
fold(r, have, axis, eval(v0, v1, v2, v3, t))
}
}
continue
}
// 3*a*t^2 + 2*b'*t + 3*c == 0, with the constant factors cancelled.
disc := b * b - 4 * a * c
if disc < 0 { continue }
sq := math.sqrt(disc)
for t in ([2]f64{(-b + sq) / (2 * a), (-b - sq) / (2 * a)}) {
if t > 0 && t < 1 {
fold(r, have, axis, eval(v0, v1, v2, v3, t))
}
}
}
}
// ---------------------------------------------------------------------------
// Flattening
// ---------------------------------------------------------------------------
// Flat_Subpath describes one polyline inside a Flat_Path.
Flat_Subpath :: struct {
start: int, // index into Flat_Path.points
count: int,
closed: bool,
}
// Flat_Path is a path reduced to polylines, in device space. The rasteriser
// and the stroker both consume this rather than curves.
//
// Subpaths are described explicitly rather than by a start-index array with a
// sentinel, so that several paths can be flattened into one Flat_Path -- which
// is exactly what a clip stack and a tiling pattern need to do.
Flat_Path :: struct {
points: [dynamic]Point,
subpaths: [dynamic]Flat_Subpath,
}
flat_path_make :: proc(allocator := context.allocator) -> Flat_Path {
return Flat_Path{
points = make([dynamic]Point, 0, 64, allocator),
subpaths = make([dynamic]Flat_Subpath, 0, 8, allocator),
}
}
flat_path_destroy :: proc(fp: ^Flat_Path) {
if fp == nil { return }
delete(fp.points)
delete(fp.subpaths)
fp^ = {}
}
flat_path_clear :: proc(fp: ^Flat_Path) {
clear(&fp.points)
clear(&fp.subpaths)
}
flat_path_count :: proc(fp: ^Flat_Path) -> int {
return len(fp.subpaths)
}
flat_path_slice :: proc(fp: ^Flat_Path, i: int) -> []Point {
if i < 0 || i >= len(fp.subpaths) { return nil }
sp := fp.subpaths[i]
if sp.start < 0 || sp.start + sp.count > len(fp.points) { return nil }
return fp.points[sp.start:sp.start + sp.count]
}
flat_path_bounds :: proc(fp: ^Flat_Path) -> Rect {
if fp == nil || len(fp.points) == 0 { return RECT_EMPTY }
r := Rect{fp.points[0].x, fp.points[0].y, fp.points[0].x, fp.points[0].y}
for pt in fp.points {
r.x0 = min(r.x0, pt.x)
r.y0 = min(r.y0, pt.y)
r.x1 = max(r.x1, pt.x)
r.y1 = max(r.y1, pt.y)
}
return r
}
// FLATNESS is the maximum distance, in device pixels, between the true curve
// and the polyline that replaces it. A quarter of a pixel is below what
// anti-aliased output can show and keeps segment counts sane on text.
FLATNESS :: 0.25
// path_flatten transforms `p` by `m` and subdivides every curve into line
// segments, appending the result to `out`. Existing contents of `out` are kept.
//
// Subdivision is adaptive and depth-limited: a curve with a cusp or a very
// large control polygon would otherwise subdivide until the stack ran out.
//
// `cull`, when given, is the region -- in the same space `m` maps into -- that
// the result will actually be drawn or clipped through. A curve that cannot
// reach it is replaced by its chord instead of being subdivided, which is what
// keeps a path whose control points are a billion units off the page from
// costing a million points per painting operator. See `flatten_reaches`: the
// substitution is exact, not an approximation.
path_flatten :: proc(out: ^Flat_Path, p: ^Path, m: Matrix, flatness := FLATNESS,
cull: Maybe(Rect) = nil) {
if out == nil || p == nil || len(p.verbs) == 0 { return }
tol := max(flatness, 0.01)
cull_box, culling := cull.?
cur := Point{}
i := 0
// Index into out.subpaths of the subpath being built, or -1.
active := -1
for verb in p.verbs {
if len(out.points) >= MAX_FLATTEN_POINTS { break }
switch verb {
case .Move:
if i >= len(p.points) { break }
cur = transform_point(m, p.points[i])
i += 1
append(&out.subpaths, Flat_Subpath{start = len(out.points), count = 1})
append(&out.points, cur)
active = len(out.subpaths) - 1
case .Line:
if i >= len(p.points) { break }
pt := transform_point(m, p.points[i])
i += 1
if active < 0 {
// A segment after a close begins a new subpath AT the current
// point, which `h` left at the start of the subpath it closed
// (ISO 32000-2, 8.5.2.1). Seeding it is what keeps the
// connecting segment: without `cur` the new subpath is a
// single stray point, which a fill drops and a stroke turns
// into a dot in the wrong place. The .Curve arm below has
// always done this; the two must agree.
append(&out.subpaths, Flat_Subpath{start = len(out.points), count = 1})
append(&out.points, cur)
active = len(out.subpaths) - 1
}
append(&out.points, pt)
out.subpaths[active].count += 1
cur = pt
case .Curve:
if i + 2 >= len(p.points) { break }
c1 := transform_point(m, p.points[i])
c2 := transform_point(m, p.points[i + 1])
e := transform_point(m, p.points[i + 2])
i += 3
if active < 0 {
append(&out.subpaths, Flat_Subpath{start = len(out.points), count = 1})
append(&out.points, cur)
active = len(out.subpaths) - 1
}
before := len(out.points)
flatten_cubic(&out.points, cur, c1, c2, e, tol, 0, cull_box, culling)
append(&out.points, e)
out.subpaths[active].count += len(out.points) - before
cur = e
case .Close:
if active >= 0 {
out.subpaths[active].closed = true
sp := out.subpaths[active]
if sp.count > 0 {
cur = out.points[sp.start]
}
}
// A subpath after a close starts fresh, but at the same point:
// "m 0 0 l 10 0 h l 20 0" continues from the start point.
active = -1
}
}
}
// MAX_FLATTEN_DEPTH bounds recursion at 2^16 segments per curve, which no
// legitimate curve approaches and a degenerate one would exceed forever.
MAX_FLATTEN_DEPTH :: 16
// MAX_FLATTEN_POINTS bounds the whole of one flattening. MAX_FLATTEN_DEPTH caps
// a SINGLE curve, and nothing capped the number of curves: a content stream may
// append hundreds of thousands of `c` segments to one path before the painting
// operator that clears it, and a cubic whose control points are a billion units
// off the chord subdivides to the depth limit every time. One `f` could
// therefore ask for gigabytes of polyline -- `rd_fill_path` materialises the
// whole flattened path before `raster_fill` ever sees the clip that would have
// discarded it. A million points is two orders of magnitude past the densest
// real path and costs 16 MB; past it the geometry is truncated, which draws
// part of a shape no viewer could have drawn all of.
MAX_FLATTEN_POINTS :: 1 << 20
// flatten_reaches reports whether any part of the cubic can lie inside `box`.
//
// Every point of a Bezier lies inside the convex hull of its control points,
// so a hull that misses the box means the whole curve does. It is used to stop
// subdividing there, which leaves the chord between the curve's ends in its
// place -- and that chord is inside the same hull. Deforming one to the other
// therefore never crosses a point of `box`, so the winding number, and with it
// both fill rules, is unchanged everywhere the box covers. The picture inside
// the clip is exactly the picture the full subdivision would have drawn.
//
// A non-finite coordinate makes every comparison false and the curve is kept,
// which is the same thing the un-culled path does with it.
@(private)
flatten_reaches :: proc(p0, p1, p2, p3: Point, box: Rect) -> bool {
if max(p0.x, p1.x, p2.x, p3.x) < box.x0 { return false }
if min(p0.x, p1.x, p2.x, p3.x) > box.x1 { return false }
if max(p0.y, p1.y, p2.y, p3.y) < box.y0 { return false }
if min(p0.y, p1.y, p2.y, p3.y) > box.y1 { return false }
return true
}
@(private)
flatten_cubic :: proc(out: ^[dynamic]Point, p0, p1, p2, p3: Point, tol: f64, depth: int,
cull: Rect, culling: bool) {
if depth >= MAX_FLATTEN_DEPTH || len(out) >= MAX_FLATTEN_POINTS {
return
}
// Tested at every level, not only the first: the halves of a curve that
// sweeps across the page and back are each smaller than the whole, so a
// curve nothing culls at the top collapses to a handful of segments a few
// levels down.
if culling && !flatten_reaches(p0, p1, p2, p3, cull) {
return
}
// Flatness test: how far the control points sit off the chord. d1 and d2
// are perpendicular distances scaled by the chord length, so comparing
// (d1+d2)^2 against tol^2 * chord^2 is the same as requiring the two
// perpendicular distances to sum to less than `tol` -- and the curve's own
// deviation from the chord is at most three quarters of that.
dx := p3.x - p0.x
dy := p3.y - p0.y
chord2 := dx * dx + dy * dy
if chord2 < 1e-12 {
// A curve that comes back to its own start point has no chord to
// measure against, and the cross-product test would call it flat --
// collapsing an entire loop into a zero-length segment. Measure the
// control points against the start point instead.
c1 := (p1.x - p0.x) * (p1.x - p0.x) + (p1.y - p0.y) * (p1.y - p0.y)
c2 := (p2.x - p0.x) * (p2.x - p0.x) + (p2.y - p0.y) * (p2.y - p0.y)
if max(c1, c2) <= tol * tol {
return
}
} else {
d1 := abs((p1.x - p3.x) * dy - (p1.y - p3.y) * dx)
d2 := abs((p2.x - p3.x) * dy - (p2.y - p3.y) * dx)
dd := d1 + d2
if dd * dd <= tol * tol * chord2 {
return
}
}
// de Casteljau split at t = 0.5.
p01 := Point{(p0.x + p1.x) * 0.5, (p0.y + p1.y) * 0.5}
p12 := Point{(p1.x + p2.x) * 0.5, (p1.y + p2.y) * 0.5}
p23 := Point{(p2.x + p3.x) * 0.5, (p2.y + p3.y) * 0.5}
p012 := Point{(p01.x + p12.x) * 0.5, (p01.y + p12.y) * 0.5}
p123 := Point{(p12.x + p23.x) * 0.5, (p12.y + p23.y) * 0.5}
mid := Point{(p012.x + p123.x) * 0.5, (p012.y + p123.y) * 0.5}
flatten_cubic(out, p0, p01, p012, mid, tol, depth + 1, cull, culling)
append(out, mid)
flatten_cubic(out, mid, p123, p23, p3, tol, depth + 1, cull, culling)
}