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
pattern_test.odin
+800
View File
@@ -0,0 +1,800 @@
package pdf
import "core:math"
import "core:mem"
import "core:testing"
// Pattern tests.
//
// The fixtures -- `cf_open`, `cf_parse`, `cf_stream`, `cf_close` -- live in
// function_test.odin. That document is opened by scanning (it has no xref), so
// it already carries repairs; every assertion about a repair here counts the
// growth of `doc.repairs` rather than its length.
//
// Almost everything below is about one question: where does a cell land? So
// the assertions are about device-space positions of returned matrices, not
// about pixels. `pt_origin` is the whole vocabulary -- a tile matrix maps the
// cell's own space to device space, so the image of (0,0) is where that cell's
// bbox origin sits on the page.
@(private = "file")
PT_EPS :: 1e-9
// A 10x10 cell that abuts its neighbours, offset in pattern space so that a
// composition done in the wrong order lands somewhere else.
@(private = "file")
TILE_SRC :: "<< /PatternType 1 /PaintType 1 /TilingType 1 " +
"/BBox [0 0 10 10] /XStep 10 /YStep 10 /Matrix [1 0 0 1 5 7] >>"
// The same cell anchored at the origin, for counting.
@(private = "file")
PLAIN_SRC :: "<< /PatternType 1 /PaintType 1 /TilingType 1 " +
"/BBox [0 0 10 10] /XStep 10 /YStep 10 >>"
@(private = "file")
AXIAL :: "<< /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 10 0] " +
"/Function << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> " +
"/Extend [true true] >>"
@(private = "file")
pt_tiling :: proc(t: ^testing.T, doc: ^Document, src: string, res: ^Dict = nil,
loc := #caller_location) -> ^Pattern {
p, err := pattern_load(doc, cf_stream(doc, src, nil), res)
testing.expect_value(t, err, Error.None, loc = loc)
testing.expect(t, p != nil, "pattern did not load", loc = loc)
return p
}
@(private = "file")
pt_dict_pattern :: proc(t: ^testing.T, doc: ^Document, src: string, res: ^Dict = nil,
loc := #caller_location) -> ^Pattern {
p, err := pattern_load(doc, cf_parse(doc, src), res)
testing.expect_value(t, err, Error.None, loc = loc)
testing.expect(t, p != nil, "pattern did not load", loc = loc)
return p
}
// pt_origin is where cell-space (0,0) -- the corner of /BBox -- lands.
@(private = "file")
pt_origin :: proc(m: Matrix) -> Point {
return transform_point(m, Point{0, 0})
}
@(private = "file")
pt_near :: proc(a, b: Point) -> bool {
return abs(a.x - b.x) < 1e-6 && abs(a.y - b.y) < 1e-6
}
@(private = "file")
pt_has_origin :: proc(tiles: []Matrix, want: Point) -> int {
n := 0
for m in tiles {
if pt_near(pt_origin(m), want) {
n += 1
}
}
return n
}
// pt_covers reports whether some returned cell contains the device point `q`.
// The cell is the pattern's /BBox in that tile's own space, which is exactly
// what the interpreter clips the replayed content to.
@(private = "file")
pt_covers :: proc(p: ^Pattern, tiles: []Matrix, q: Point) -> bool {
for m in tiles {
inv, ok := matrix_invert(m)
if !ok {
continue
}
if rect_contains(p.bbox, transform_point(inv, q)) {
return true
}
}
return false
}
// pt_covers_area checks a grid of sample points across `area`. Under-counting
// the lattice -- an off-by-one in the index range, a step read as the cell
// size when it is not -- leaves a stripe of the fill bare, and that is what
// this catches.
@(private = "file")
expect_covers_area :: proc(t: ^testing.T, p: ^Pattern, tiles: []Matrix, area: Rect,
steps: int, what: string, loc := #caller_location) {
for iy in 0 ..= steps {
for ix in 0 ..= steps {
q := Point{
area.x0 + (area.x1 - area.x0) * f64(ix) / f64(steps),
area.y0 + (area.y1 - area.y0) * f64(iy) / f64(steps),
}
if !pt_covers(p, tiles, q) {
testing.expectf(t, false, "%s: device point (%f,%f) is covered by no cell",
what, q.x, q.y, loc = loc)
return
}
}
}
}
// ---------------------------------------------------------------------------
// The headline: /Matrix is anchored to the page, not to the fill
// ---------------------------------------------------------------------------
// A pattern's /Matrix maps pattern space to the page's DEFAULT space
// (8.7.3.1). The transform in force when the fill runs must not move the
// lattice: the same pattern used inside `q 2 0 0 2 30 40 cm ... Q` puts its
// cells exactly where it puts them outside.
//
// The test pins two things a wrong implementation gets wrong in different
// ways: the device position of the cell that holds pattern-space (0,0), which
// catches composing in the wrong order, and the equality of the whole lattice
// across two different fill CTMs, which catches composing with the live CTM at
// all. The third assertion is the control -- feeding the fill's CTM in as if
// it were the base does move the lattice -- so the second is known to be
// testing something.
@(test)
test_pattern_matrix_is_anchored_to_default_space :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc, TILE_SRC)
// A page flip: user (0,0) is at device (0,200). The area is chosen to
// contain the cell that holds pattern-space (0,0), which the /Matrix puts
// at device (5,193).
base := Matrix{1, 0, 0, -1, 0, 200}
area := Rect{0, 150, 40, 195}
tiles := pattern_tiles(p, area, base)
defer delete(tiles)
testing.expect(t, len(tiles) > 0, "no tiles for a covered area")
// /Matrix first, then the page CTM: (0,0) -> (5,7) -> (5,193).
want := Point{5, 193}
testing.expect_value(t, pt_has_origin(tiles, want), 1)
// The same pattern, filled under `q 2 0 0 2 30 40 cm`. The interpreter
// still passes the base CTM, and the lattice must be bit-identical.
fill_ctm := matrix_mul(Matrix{2, 0, 0, 2, 30, 40}, base)
again := pattern_tiles(p, area, base)
defer delete(again)
testing.expect_value(t, len(again), len(tiles))
for m, i in again {
testing.expect(t, m == tiles[i], "the lattice moved between two fills")
}
// Control: had the fill's CTM been composed in, the cells would have gone
// somewhere else entirely. Without this the assertion above is vacuous.
wrong := pattern_tiles(p, area, fill_ctm)
defer delete(wrong)
testing.expect_value(t, pt_has_origin(wrong, want), 0)
}
// pattern_matrix is the single place the two matrices meet, so the order is
// pinned here directly: /Matrix applies first, the page CTM second. The
// reversed product is a different point for any /Matrix with a translation.
@(test)
test_pattern_matrix_composition_order :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc, TILE_SRC)
base := Matrix{1, 0, 0, -1, 0, 200}
m := pattern_matrix(p, base)
testing.expect(t, pt_near(transform_point(m, Point{0, 0}), Point{5, 193}),
"pattern matrix is not /Matrix then CTM")
testing.expect(t, !pt_near(transform_point(matrix_mul(base, p.mtx), Point{0, 0}),
Point{5, 193}), "the reversed product would have passed too")
// A nil pattern leaves the CTM alone rather than inventing one.
testing.expect(t, pattern_matrix(nil, base) == base, "nil pattern changed the CTM")
}
// The cell-to-cell offset in device space is the step carried through the same
// composition, so a rotated pattern's lattice is rotated with it and no cell
// drifts from the grid.
@(test)
test_pattern_tiles_are_one_lattice :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
// The step is deliberately not the cell size: a lattice whose pitch was
// read off /BBox instead of /XStep would still tile, and would still
// cover, and only the spacing would be wrong.
p := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 10 10] /XStep 8 /YStep 6 >>")
base := matrix_mul(rotate_matrix(30), Matrix{2, 0, 0, 2, 11, 13})
area := Rect{0, 0, 60, 60}
tiles := pattern_tiles(p, area, base)
defer delete(tiles)
testing.expect(t, len(tiles) > 4, "too few tiles to be a lattice")
m := pattern_matrix(p, base)
step_x := transform_vector(m, Point{p.xstep, 0})
step_y := transform_vector(m, Point{0, p.ystep})
// Every origin sits at base + i*step_x + j*step_y for whole i and j.
o0 := pt_origin(m)
for tm in tiles {
o := pt_origin(tm)
// Solve the 2x2 system rather than trusting a division: the steps are
// not axis-aligned here.
det := step_x.x * step_y.y - step_x.y * step_y.x
testing.expect(t, abs(det) > PT_EPS, "degenerate lattice steps")
dx := o.x - o0.x
dy := o.y - o0.y
i := (dx * step_y.y - dy * step_y.x) / det
j := (step_x.x * dy - step_x.y * dx) / det
testing.expectf(t, abs(i - math.round(i)) < 1e-6 && abs(j - math.round(j)) < 1e-6,
"cell origin (%f,%f) is off the lattice: i=%f j=%f", o.x, o.y, i, j)
}
expect_covers_area(t, p, tiles, area, 12, "rotated lattice")
}
// ---------------------------------------------------------------------------
// Counting
// ---------------------------------------------------------------------------
// A 10x10 cell over a 90x90 area, with the area deliberately not aligned to
// the lattice so the count does not depend on how a cell that merely touches
// the edge is treated.
@(test)
test_pattern_tile_count_small_cell_large_area :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc, PLAIN_SRC)
area := Rect{5, 5, 95, 95}
tiles := pattern_tiles(p, area, MATRIX_IDENTITY)
defer delete(tiles)
// i runs 0..9 and j runs 0..9: cell 0 spans [0,10] and cell 9 spans
// [90,100], and both meet the area.
testing.expect_value(t, len(tiles), 100)
testing.expect_value(t, pt_has_origin(tiles, Point{0, 0}), 1)
testing.expect_value(t, pt_has_origin(tiles, Point{90, 90}), 1)
testing.expect_value(t, pt_has_origin(tiles, Point{100, 0}), 0)
expect_covers_area(t, p, tiles, area, 20, "aligned lattice")
}
// A cell larger than its step overlaps its neighbours, which is a real design
// and not a malformation: the lattice just gets denser than the cell size.
@(test)
test_pattern_overlapping_cells :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
before := len(doc.repairs)
p := pt_tiling(t, doc,
"<< /PatternType 1 /BBox [0 0 10 10] /XStep 5 /YStep 10 >>")
testing.expect_value(t, p.xstep, 5.0)
testing.expect_value(t, len(doc.repairs), before)
area := Rect{5, 5, 95, 95}
tiles := pattern_tiles(p, area, MATRIX_IDENTITY)
defer delete(tiles)
// Twice as many columns as the abutting case, same number of rows: i runs
// -1..19, because the cell is two steps wide and so reaches back one.
testing.expect_value(t, len(tiles), 21 * 10)
// The pitch is the step, not the cell: cells sit every 5 units, so the one
// at 5 exists and is distinct from the ones at 0 and 10.
testing.expect_value(t, pt_has_origin(tiles, Point{-5, 0}), 1)
testing.expect_value(t, pt_has_origin(tiles, Point{5, 0}), 1)
testing.expect_value(t, pt_has_origin(tiles, Point{95, 90}), 1)
expect_covers_area(t, p, tiles, area, 20, "overlapping cells")
}
// A /BBox that is not at the origin is the case where the lattice index and
// the cell extent stop being the same number, and it is common: a cell drawn
// around a motif is written wherever the motif already was.
@(test)
test_pattern_offset_bbox :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
// Cells 20x40 at a 20x40 pitch, so they abut, starting at (10,20).
p := pt_tiling(t, doc,
"<< /PatternType 1 /BBox [10 20 30 60] /XStep 20 /YStep 40 >>")
area := Rect{15, 25, 75, 135}
tiles := pattern_tiles(p, area, MATRIX_IDENTITY)
defer delete(tiles)
// Across: cell i spans [10+20i, 30+20i], so i runs 0..3 for x in 15..75.
// Up: cell j spans [20+40j, 60+40j], so j runs 0..2 for y in 25..135.
testing.expect_value(t, len(tiles), 4 * 3)
// The matrix maps the cell's own space, in which the bbox corner is at
// (10,20), not at the origin.
testing.expect_value(t, pt_has_origin(tiles, Point{0, 0}), 1)
testing.expect_value(t, pt_has_origin(tiles, Point{60, 80}), 1)
expect_covers_area(t, p, tiles, area, 16, "offset bbox")
}
// An area that falls in the gap between two cells gets no cells at all: a
// /XStep larger than the cell leaves bare stripes, and painting them would
// mean stretching the pattern to fill space the file left empty.
@(test)
test_pattern_area_between_cells :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 1 1] /XStep 100 /YStep 100 >>")
gap := pattern_tiles(p, Rect{10, 10, 20, 20}, MATRIX_IDENTITY)
defer delete(gap)
testing.expect_value(t, len(gap), 0)
// The same pattern over an area that does reach a cell finds it.
hit := pattern_tiles(p, Rect{-5, -5, 5, 5}, MATRIX_IDENTITY)
defer delete(hit)
testing.expect_value(t, len(hit), 1)
testing.expect_value(t, pt_has_origin(hit, Point{0, 0}), 1)
}
// The returned slice belongs to the caller and comes from the allocator it was
// given, not from the context: a page is rendered through a scratch arena that
// is reset between pages, and a lattice that quietly allocated from the
// Document's arena instead would never be reclaimed.
//
// The assertion is the arena's own cursor, not a leak report: a slice taken
// from somewhere else leaves the arena untouched.
@(test)
test_pattern_tiles_use_the_given_allocator :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
backing: [16 * 1024]byte
arena: mem.Arena
mem.arena_init(&arena, backing[:])
p := pt_tiling(t, doc, PLAIN_SRC)
tiles := pattern_tiles(p, Rect{5, 5, 95, 95}, MATRIX_IDENTITY, mem.arena_allocator(&arena))
testing.expect_value(t, len(tiles), 100)
testing.expect(t, arena.offset >= 100 * size_of(Matrix),
"the tiles did not come from the allocator that was passed in")
lo := uintptr(raw_data(backing[:]))
at := uintptr(raw_data(tiles))
testing.expect(t, at >= lo && at < lo + uintptr(len(backing)),
"the tiles do not live in the arena")
}
// The pattern's own space is where the lattice is regular, so a rotated
// pattern needs the area pulled back through the inverse before the indices
// mean anything. If that pull-back were skipped the corners of the area would
// come out bare.
@(test)
test_pattern_tiles_under_rotation_cover_the_area :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc,
"<< /PatternType 1 /BBox [0 0 8 8] /XStep 8 /YStep 8 /Matrix [0.866 0.5 -0.5 0.866 3 4] >>")
area := Rect{-30, -30, 30, 30}
tiles := pattern_tiles(p, area, MATRIX_IDENTITY)
defer delete(tiles)
testing.expect(t, len(tiles) > 0, "rotated pattern produced no tiles")
expect_covers_area(t, p, tiles, area, 24, "rotated pattern")
}
// ---------------------------------------------------------------------------
// Guards
// ---------------------------------------------------------------------------
// /XStep 0 would stack an infinite row of cells at one place. It falls back to
// the cell width, which is what the step means when cells abut, and the
// substitution is recorded.
@(test)
test_pattern_zero_step_clamped_to_bbox :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
before := len(doc.repairs)
p := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 10 20] /XStep 0 /YStep 0 >>")
testing.expect_value(t, p.xstep, 10.0)
testing.expect_value(t, p.ystep, 20.0)
testing.expect(t, len(doc.repairs) >= before + 2, "a clamped step was not recorded")
area := Rect{5, 5, 95, 95}
tiles := pattern_tiles(p, area, MATRIX_IDENTITY)
defer delete(tiles)
testing.expect_value(t, len(tiles), 10 * 5)
expect_covers_area(t, p, tiles, area, 20, "zero step")
}
// A step a ten-thousandth of the cell is the same denial of service as zero,
// written so that it looks like a number: every device pixel would be covered
// by ten thousand cells.
@(test)
test_pattern_absurd_step_clamped :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
before := len(doc.repairs)
p := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 10 10] /XStep 0.001 /YStep 10 >>")
testing.expect_value(t, p.xstep, 10.0)
testing.expect_value(t, p.ystep, 10.0)
testing.expect(t, len(doc.repairs) > before, "a clamped step was not recorded")
// An overlap the guard is meant to allow through untouched.
before2 := len(doc.repairs)
q := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 10 10] /XStep 2.5 /YStep 10 >>")
testing.expect_value(t, q.xstep, 2.5)
testing.expect_value(t, len(doc.repairs), before2)
}
// Only the magnitude of a step spaces the lattice, so a negative one is read
// rather than repaired.
@(test)
test_pattern_negative_step_uses_magnitude :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
before := len(doc.repairs)
p := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 10 10] /XStep -10 /YStep -10 >>")
testing.expect_value(t, p.xstep, 10.0)
testing.expect_value(t, p.ystep, 10.0)
testing.expect_value(t, len(doc.repairs), before)
tiles := pattern_tiles(p, Rect{5, 5, 95, 95}, MATRIX_IDENTITY)
defer delete(tiles)
testing.expect_value(t, len(tiles), 100)
}
// A one-unit cell over a million-unit area is 10^12 replays of a content
// stream. The count is capped, the shortfall is recorded once, and what comes
// back is still a usable prefix of the lattice rather than nothing.
@(test)
test_pattern_tile_count_capped :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 1 1] /XStep 1 /YStep 1 >>")
before := len(doc.repairs)
tiles := pattern_tiles(p, Rect{0, 0, 1e6, 1e6}, MATRIX_IDENTITY)
defer delete(tiles)
testing.expect_value(t, len(tiles), MAX_PATTERN_TILES)
testing.expect(t, len(doc.repairs) > before, "the tile cap was not recorded")
// Every returned matrix is still a real lattice position, not filler.
for m, i in tiles {
o := pt_origin(m)
testing.expectf(t, is_finite(o.x) && is_finite(o.y),
"tile %d has a non-finite origin (%f,%f)", i, o.x, o.y)
}
// A page that fills with the same hostile pattern many times must cost one
// repair, not one per fill.
mid := len(doc.repairs)
more := pattern_tiles(p, Rect{0, 0, 1e6, 1e6}, MATRIX_IDENTITY)
defer delete(more)
testing.expect_value(t, len(more), MAX_PATTERN_TILES)
testing.expect_value(t, len(doc.repairs), mid)
}
// An index range computed from file numbers can be 1e300, and narrowing that
// to an int is undefined. The clamp lives in tile_range, so it is pinned
// there: what comes back is bounded, and no arithmetic on it can trap.
@(test)
test_pattern_tile_range_clamps :: proc(t: ^testing.T) {
from, to, ok := tile_range(-1e300, 1e300, 0, 10, 1e-6)
testing.expect(t, ok, "a huge but finite range was rejected")
testing.expect_value(t, from, -MAX_TILE_INDEX)
testing.expect_value(t, to, MAX_TILE_INDEX)
_, _, ok_step := tile_range(0, 10, 0, 1, 0)
testing.expect(t, !ok_step, "a zero step produced a range")
_, _, ok_nan := tile_range(math.QNAN_F64, 10, 0, 1, 1)
testing.expect(t, !ok_nan, "a NaN bound produced a range")
// An area that ends before the first cell begins has no cells at all.
_, _, ok_empty := tile_range(100, 101, 0, 1, 1000)
testing.expect(t, !ok_empty, "a gap between cells produced a range")
}
// Areas that cannot be enumerated, and patterns that have no cells.
@(test)
test_pattern_tiles_rejects_unusable_input :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_tiling(t, doc, PLAIN_SRC)
testing.expect_value(t, len(pattern_tiles(nil, Rect{0, 0, 10, 10}, MATRIX_IDENTITY)), 0)
testing.expect_value(t, len(pattern_tiles(p, RECT_EMPTY, MATRIX_IDENTITY)), 0)
// "Cover an unbounded area with a repeating cell" has no answer, and
// RECT_INFINITE's corners are finite numbers, so it has to be caught by
// identity or it would silently produce a capped field of cells.
testing.expect_value(t, len(pattern_tiles(p, RECT_INFINITE, MATRIX_IDENTITY)), 0)
nan_area := Rect{0, 0, math.QNAN_F64, 10}
testing.expect_value(t, len(pattern_tiles(p, nan_area, MATRIX_IDENTITY)), 0)
inf_ctm := Matrix{math.INF_F64, 0, 0, 1, 0, 0}
testing.expect_value(t, len(pattern_tiles(p, Rect{0, 0, 10, 10}, inf_ctm)), 0)
// A CTM that collapses the plane gives every cell zero area.
singular := Matrix{1, 1, 1, 1, 0, 0}
testing.expect_value(t, len(pattern_tiles(p, Rect{0, 0, 10, 10}, singular)), 0)
// A shading pattern paints in one pass; it has no cells to replay.
sp := pt_dict_pattern(t, doc, "<< /PatternType 2 /Shading " + AXIAL + " >>")
testing.expect_value(t, len(pattern_tiles(sp, Rect{0, 0, 10, 10}, MATRIX_IDENTITY)), 0)
}
// ---------------------------------------------------------------------------
// Uncoloured patterns
// ---------------------------------------------------------------------------
// /PaintType 2 is a stencil: the cell's own colour operators are ignored and
// the whole cell paints in the colour given alongside the pattern name, so the
// interpreter has to be told before it replays anything.
@(test)
test_pattern_uncoloured_needs_the_callers_colour :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
unc := pt_tiling(t, doc,
"<< /PatternType 1 /PaintType 2 /BBox [0 0 4 4] /XStep 4 /YStep 4 >>")
testing.expect_value(t, unc.paint_type, Paint_Type.Uncoloured)
testing.expect(t, pattern_needs_color(unc), "an uncoloured pattern must ask for a colour")
col := pt_tiling(t, doc, PLAIN_SRC)
testing.expect_value(t, col.paint_type, Paint_Type.Coloured)
testing.expect(t, !pattern_needs_color(col), "a coloured pattern supplies its own colour")
sh := pt_dict_pattern(t, doc, "<< /PatternType 2 /Shading " + AXIAL + " >>")
testing.expect(t, !pattern_needs_color(sh), "a shading pattern supplies its own colour")
testing.expect(t, !pattern_needs_color(nil), "nil asked for a colour")
// An out-of-range /PaintType is a broken file, not a third kind of paint.
odd := pt_tiling(t, doc,
"<< /PatternType 1 /PaintType 7 /BBox [0 0 4 4] /XStep 4 /YStep 4 >>")
testing.expect_value(t, odd.paint_type, Paint_Type.Coloured)
}
// ---------------------------------------------------------------------------
// Loading
// ---------------------------------------------------------------------------
@(test)
test_pattern_tiling_fields :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
res := new_dict(doc.allocator)
p, err := pattern_load(doc, cf_stream(doc,
"<< /PatternType 1 /PaintType 1 /TilingType 3 /BBox [10 20 30 60] " +
"/XStep 25 /YStep 45 /Matrix [2 0 0 2 1 1] >>", nil), res)
testing.expect_value(t, err, Error.None)
testing.expect_value(t, p.kind, Pattern_Kind.Tiling)
testing.expect_value(t, p.tiling_type, Tiling_Type.Faster_Constant_Spacing)
testing.expect_value(t, p.bbox, Rect{10, 20, 30, 60})
testing.expect_value(t, p.xstep, 25.0)
testing.expect_value(t, p.ystep, 45.0)
testing.expect_value(t, p.mtx, Matrix{2, 0, 0, 2, 1, 1})
testing.expect(t, p.content != nil, "the cell's content stream was dropped")
testing.expect(t, p.doc == doc, "the pattern lost its document")
// /Resources is required but harmless to omit for a cell that draws only
// rectangles; the resources of the stream that named the pattern stand in.
testing.expect(t, p.resources == res, "missing /Resources did not fall back")
// A pattern with resources of its own keeps them.
q, q_err := pattern_load(doc, cf_stream(doc,
"<< /PatternType 1 /BBox [0 0 4 4] /Resources << /Marker 7 >> >>", nil), res)
testing.expect_value(t, q_err, Error.None)
testing.expect(t, q.resources != res, "own /Resources were replaced by the fallback")
testing.expect_value(t, dict_int(doc, q.resources, "Marker"), i64(7))
// Absent /XStep and /YStep default to the cell size, the same as zero.
testing.expect_value(t, q.xstep, 4.0)
testing.expect_value(t, q.ystep, 4.0)
}
@(test)
test_pattern_shading_loads_its_shading :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
p := pt_dict_pattern(t, doc,
"<< /PatternType 2 /Matrix [1 0 0 1 20 30] /Shading " + AXIAL +
" /ExtGState << /ca 0.5 >> >>")
testing.expect_value(t, p.kind, Pattern_Kind.Shading)
testing.expect(t, p.shading != nil, "the shading was not loaded")
testing.expect_value(t, p.shading.kind, Shading_Kind.Axial)
testing.expect_value(t, p.shading.coords[2], 10.0)
testing.expect(t, p.ext_gstate != nil, "/ExtGState was dropped")
testing.expect_value(t, dict_num(doc, p.ext_gstate, "ca"), 0.5)
testing.expect(t, p.content == nil, "a shading pattern has no cell content")
}
// A colour space named by a bare name inside the shading has to be resolved
// through the resource dictionary the pattern was named from.
@(test)
test_pattern_shading_uses_the_resources :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
cs_dict := new_dict(doc.allocator)
dict_set(cs_dict, "Spot", Ref{5, 0})
res := new_dict(doc.allocator)
dict_set(res, "ColorSpace", cs_dict)
p := pt_dict_pattern(t, doc,
"<< /PatternType 2 /Shading << /ShadingType 2 /ColorSpace /Spot " +
"/Coords [0 0 10 0] /Function << /FunctionType 2 /Domain [0 1] " +
"/C0 [0] /C1 [1] /N 1 >> >> >>", res)
testing.expect(t, p.shading != nil && p.shading.cs != nil, "the shading has no colour space")
testing.expect_value(t, p.shading.cs.kind, Colorspace_Kind.Separation)
}
// A missing /PatternType is a broken file that still says which kind it meant.
@(test)
test_pattern_type_inferred :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
before := len(doc.repairs)
tile := pt_tiling(t, doc, "<< /BBox [0 0 4 4] /XStep 4 /YStep 4 >>")
testing.expect_value(t, tile.kind, Pattern_Kind.Tiling)
testing.expect(t, len(doc.repairs) > before, "the missing /PatternType was not recorded")
sh := pt_dict_pattern(t, doc, "<< /Shading " + AXIAL + " >>")
testing.expect_value(t, sh.kind, Pattern_Kind.Shading)
// A stream that also carries a /Shading is a shading pattern: the entry
// that only one kind has decides it.
both := pt_tiling(t, doc, "<< /BBox [0 0 4 4] /Shading " + AXIAL + " >>")
testing.expect_value(t, both.kind, Pattern_Kind.Shading)
}
@(test)
test_pattern_load_rejects_malformed :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
expect_bad :: proc(t: ^testing.T, doc: ^Document, obj: Object, what: string,
loc := #caller_location) {
p, err := pattern_load(doc, obj, nil)
testing.expect_value(t, err, Error.Bad_Pattern, loc = loc)
testing.expectf(t, p == nil, "%s produced a pattern", what, loc = loc)
}
expect_bad(t, doc, cf_parse(doc, "42"), "a number")
expect_bad(t, doc, nil, "a null")
expect_bad(t, doc, cf_parse(doc, "<< /PatternType 9 >>"), "an unknown /PatternType")
expect_bad(t, doc, cf_parse(doc, "<< /PatternType 1 /BBox [0 0 4 4] >>"),
"a tiling pattern that is not a stream")
expect_bad(t, doc, cf_stream(doc, "<< /PatternType 1 >>", nil), "no /BBox")
expect_bad(t, doc, cf_stream(doc, "<< /PatternType 1 /BBox [0 0 0 8] >>", nil),
"a /BBox with no width")
expect_bad(t, doc, cf_stream(doc, "<< /PatternType 1 /BBox [1 2 3] >>", nil),
"a short /BBox")
// Both corners are finite; the width between them is not, and an infinite
// step times a zero lattice index is a NaN cell matrix.
expect_bad(t, doc, cf_stream(doc,
"<< /PatternType 1 /BBox [-1e308 -1e308 1e308 1e308] >>", nil),
"a /BBox as wide as the number line")
expect_bad(t, doc, cf_parse(doc, "<< /PatternType 2 >>"), "no /Shading")
expect_bad(t, doc, cf_parse(doc, "<< /PatternType 2 /Shading << /ShadingType 99 >> >>"),
"an unknown shading type")
// A nil Document is a caller error, not a malformed file.
p, err := pattern_load(nil, cf_parse(doc, "<< /PatternType 1 >>"), nil)
testing.expect_value(t, err, Error.Invalid_Argument)
testing.expect(t, p == nil, "a nil document produced a pattern")
}
// A /Matrix that is not six finite numbers has to arrive as the identity --
// the format's own default -- rather than as a NaN that would poison every
// transform derived from it. The filter itself is `object_to_matrix`'s, in
// geom.odin; what is pinned here is that pattern loading goes through it and
// does not substitute a default of its own.
@(test)
test_pattern_bad_matrix_falls_back :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
short := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 4 4] /Matrix [1 0 0] >>")
testing.expect_value(t, short.mtx, MATRIX_IDENTITY)
absent := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 4 4] >>")
testing.expect_value(t, absent.mtx, MATRIX_IDENTITY)
// 1e400 parses to an infinity, which is exactly the value that must not
// reach a lattice: a single infinite entry makes every cell origin a NaN.
inf := pt_tiling(t, doc, "<< /PatternType 1 /BBox [0 0 4 4] /Matrix [1 0 0 1 0 1e400] >>")
testing.expect_value(t, inf.mtx, MATRIX_IDENTITY)
testing.expect(t, matrix_is_finite(inf.mtx), "a non-finite /Matrix was kept")
tiles := pattern_tiles(inf, Rect{0, 0, 8, 8}, MATRIX_IDENTITY)
defer delete(tiles)
testing.expect(t, len(tiles) > 0, "a repaired /Matrix still produced no cells")
for m in tiles {
o := pt_origin(m)
testing.expect(t, is_finite(o.x) && is_finite(o.y), "a cell origin is not finite")
}
}
// ---------------------------------------------------------------------------
// Bounds
// ---------------------------------------------------------------------------
@(test)
test_pattern_bounds :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
// A tiling pattern repeats over the whole plane. RECT_INFINITE is the
// identity for rect_intersect, so a caller gets back its own clip.
tile := pt_tiling(t, doc, PLAIN_SRC)
testing.expect_value(t, pattern_bounds(tile, MATRIX_IDENTITY), RECT_INFINITE)
testing.expect_value(t, rect_intersect(pattern_bounds(tile, MATRIX_IDENTITY),
Rect{3, 4, 5, 6}), Rect{3, 4, 5, 6})
// A transform that collapses the plane paints nothing, and nothing is the
// opposite identity: a caller intersecting with RECT_INFINITE here would
// flood the clip with a pattern that has no area.
testing.expect_value(t, pattern_bounds(tile, Matrix{1, 1, 1, 1, 0, 0}), RECT_EMPTY)
testing.expect_value(t, pattern_bounds(tile, Matrix{math.QNAN_F64, 0, 0, 1, 0, 0}), RECT_EMPTY)
testing.expect_value(t, pattern_bounds(nil, MATRIX_IDENTITY), RECT_EMPTY)
// An un-extended radial shading is bounded by its two circles, and the
// pattern matrix moves that bound with it.
rad := pt_dict_pattern(t, doc,
"<< /PatternType 2 /Matrix [1 0 0 1 20 30] /Shading << /ShadingType 3 " +
"/ColorSpace /DeviceGray /Coords [0 0 0 0 0 5] " +
"/Function << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> >> >>")
testing.expect_value(t, pattern_bounds(rad, MATRIX_IDENTITY), Rect{15, 25, 25, 35})
// Under a page CTM the two compose, and only in that order.
testing.expect_value(t, pattern_bounds(rad, Matrix{2, 0, 0, 2, 0, 0}),
Rect{30, 50, 50, 70})
// An axial shading is unbounded across its axis whatever its extends say.
ax := pt_dict_pattern(t, doc, "<< /PatternType 2 /Shading " + AXIAL + " >>")
testing.expect_value(t, pattern_bounds(ax, MATRIX_IDENTITY), RECT_INFINITE)
}
// ---------------------------------------------------------------------------
// Painting a shading pattern
// ---------------------------------------------------------------------------
// The shading has to be painted through the pattern matrix composed with the
// page's default CTM, so a pattern that translates its shading by 20 puts the
// ramp 20 device units further along. Three components and no alpha means the
// destination reads as opaque, so a pixel is what the shading computed.
@(test)
test_pattern_paint_shading_through_the_matrix :: proc(t: ^testing.T) {
doc := cf_open(t)
defer cf_close(t, doc)
// A ramp from black at x=0 to white at x=10 in pattern space, extended
// both ways, shifted 20 to the right by the pattern matrix.
p := pt_dict_pattern(t, doc,
"<< /PatternType 2 /Matrix [1 0 0 1 20 0] /Shading " + AXIAL + " >>")
bmp, err := bitmap_make(40, 3, 3)
testing.expect_value(t, err, Error.None)
defer bitmap_destroy(&bmp)
bitmap_fill(&bmp, [4]u8{9, 200, 30, 255})
perr := pattern_paint_shading(doc, p, &bmp, MATRIX_IDENTITY,
Raster_Clip{0, 0, bmp.width, bmp.height}, 1, .Normal, nil)
testing.expect_value(t, perr, Error.None)
px :: proc(bmp: ^Bitmap, x, y: int) -> u8 {
off, ok := bitmap_pixel_offset(bmp, x, y)
return ok ? bmp.pixels[off] : 0
}
// Pixel centres are at x+0.5, so the axis start (pattern x=0, device
// x=20) is half a pixel left of pixel 20's centre: t = 0.05.
testing.expect(t, px(&bmp, 10, 1) == 0, "the extended dark end is not black")
testing.expect(t, px(&bmp, 35, 1) == 255, "the extended bright end is not white")
mid := px(&bmp, 25, 1)
testing.expectf(t, mid > 120 && mid < 160, "midpoint of the ramp is %d, want about 140", mid)
// Without the pattern matrix the ramp would have finished by x = 10.
testing.expect(t, px(&bmp, 12, 1) == 0, "the ramp started 20 units too early")
// A tiling pattern has no shading to paint, and neither does nil.
tile := pt_tiling(t, doc, PLAIN_SRC)
testing.expect_value(t, pattern_paint_shading(doc, tile, &bmp, MATRIX_IDENTITY,
Raster_Clip{0, 0, bmp.width, bmp.height}, 1, .Normal, nil), Error.Invalid_Argument)
testing.expect_value(t, pattern_paint_shading(doc, nil, &bmp, MATRIX_IDENTITY,
Raster_Clip{0, 0, bmp.width, bmp.height}, 1, .Normal, nil), Error.Invalid_Argument)
}