dymokomi/luce-image
Source of release 0.45.1
0.45.1 / src / canvas / graph_tests.lucb
#==============================================================================================
#
# canvas/graph_tests - Node graphs on a vector layer: files, steps and the cells an edit draws
#
#==============================================================================================
## Layer `id`'s pixels read back into `pixels`.
func graph_pixels(canvas: Canvas*, id: i64, pixels: f32[]) -> !:
let document = canvas.document else trap("bound")
try ((document.find((u64)id) else trap("layer")).tiles() else trap("tiles")).read(pixels)
func graph_alpha(pixels: const f32[], width: usize, x: usize, y: usize) -> f32:
return pixels[(y * width + x) * 4 + 3]
## The node of `kind` in the layer at `index`'s graph, by id.
func node_of(canvas: Canvas*, index: i64, kind: i64) -> i64!:
for node in 0..<(try canvas.graph_node_count(index)):
if (try canvas.graph_node_value(index, node, 1)) == (f64)kind:
return (i64)(try canvas.graph_node_value(index, node, 0))
trap("no such node")
test "a new vector layer draws its default graph; edits are steps, undone and saved":
var canvas = try Canvas(800, 600)
defer canvas.close()
_ = try canvas.add_layer("Background")
canvas.bind_headless() catch failure:
assert(failure.code == gpu.unavailable)
return
let layer = try canvas.add_vector_layer("Vector 1")
assert((try canvas.layer_shaped(1)) and canvas.undo_name() == "New Vector Layer")
assert((try canvas.graph_node_count(1)) == 4 and (try canvas.graph_link_count(1)) == 3 and (try canvas.generated_count(1)) == 12)
let pixels = try new f32[800 * 600 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try graph_pixels(&canvas, layer, pixels)
# The top star of the ring sits above the middle; the middle itself is clear.
let radius = 600.0 * 0.32
assert(graph_alpha(pixels, 800, 400, (usize)(300.0 - radius)) > 0.99 and graph_alpha(pixels, 800, 400, 300) < 0.01)
# More stars round the ring: a step of its own, undone.
let circle = try node_of(&canvas, 1, node_circle)
try canvas.set_graph_value(layer, circle, 0, 20.0)
assert(canvas.undo_name() == "Node Setting" and (try canvas.generated_count(1)) == 20)
try canvas.set_graph_value(layer, circle, 0, 24.0)
assert((try canvas.generated_count(1)) == 24)
try canvas.undo()
assert((try canvas.generated_count(1)) == 12 and (try canvas.graph_node_value(1, 1, 4)) == 12.0)
try canvas.redo()
assert((try canvas.generated_count(1)) == 24)
# A square wired in instead of the star; the old wire's gone, both nodes kept.
let square = try canvas.add_graph_node(layer, node_rectangle, 0.0, 0.0)
let clone = try node_of(&canvas, 1, node_clone)
try canvas.link_graph(layer, square, clone, 0)
assert((try canvas.graph_link_count(1)) == 3 and canvas.undo_name() == "Connect")
try canvas.unlink_graph(layer, clone, 0)
assert((try canvas.generated_count(1)) == 0 and (try canvas.graph_link_count(1)) == 2)
try graph_pixels(&canvas, layer, pixels)
assert(graph_alpha(pixels, 800, 400, (usize)(300.0 - radius)) < 0.01)
try canvas.undo()
assert((try canvas.generated_count(1)) == 24)
try canvas.delete_graph_node(layer, square)
assert((try canvas.graph_node_count(1)) == 4 and (try canvas.graph_link_count(1)) == 2 and (try canvas.generated_count(1)) == 0)
try canvas.undo()
# A node moved in the editor draws nothing new, but is a step.
try canvas.move_graph_node(layer, square, 300.0, 500.0)
assert(canvas.undo_name() == "Move Node" and (try canvas.graph_node_value(1, 4, 2)) == 300.0)
# Saved and opened: the same graph, which puts out the same shapes.
let path = "build/canvas-graph.l2d"
try canvas.save_package(path)
let reopened = try Canvas.open(path)
defer reopened.release()
let opened = reopened.value()
assert((try opened.graph_node_count(1)) == 5 and (try opened.graph_link_count(1)) == 3)
for node in 0..<(i64)5:
for field in 0..<(i64)28:
assert((try opened.graph_node_value(1, node, field)) == (try canvas.graph_node_value(1, node, field)))
for link in 0..<(i64)3:
for field in 0..<(i64)3:
assert((try opened.graph_link_value(1, link, field)) == (try canvas.graph_link_value(1, link, field)))
assert((try opened.generated_count(1)) == 24)
# Undone back to before the layer, it is gone.
while canvas.can_undo():
try canvas.undo()
assert(canvas.layer_count() == 1)
test "a Path node takes a hand-made element and follows it when it changes":
var canvas = try Canvas(400, 300)
defer canvas.close()
let layer = try canvas.add_layer("Vector")
canvas.bind_headless() catch failure:
assert(failure.code == gpu.unavailable)
return
try canvas.set_shape(layer, 0, 10.0, 10.0, 20.0, 20.0, 5, 0.0, true, 1.0, 0.0, 0.0, false, 0.0, 0.0, 0.0, 1.0)
let output = try canvas.add_graph_node(layer, node_output, 0.0, 0.0)
let path = try canvas.add_graph_node(layer, node_path, 0.0, 0.0)
try canvas.set_graph_value(layer, path, (i64)slot_x, 200.0)
try canvas.link_graph(layer, path, output, 0)
assert((try canvas.generated_count(0)) == 1)
let pixels = try new f32[400 * 300 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try graph_pixels(&canvas, layer, pixels)
assert(graph_alpha(pixels, 400, 20, 20) > 0.99 and graph_alpha(pixels, 400, 220, 20) > 0.99)
# The element moved alone: its copy follows it.
try canvas.set_active_element(layer, 0)
try canvas.move_layer(layer, 0, 100)
try graph_pixels(&canvas, layer, pixels)
assert(graph_alpha(pixels, 400, 220, 20) < 0.01 and graph_alpha(pixels, 400, 220, 120) > 0.99)
test "a graph edit draws again only the cells its changed shapes cover, at 15000 by 24000":
# Thousands of shapes' drawing is more than the test's fixed buffer holds.
with memory.heap:
try many_stars()
func many_stars() -> !:
var canvas = try Canvas(15000, 24000)
defer canvas.close()
_ = try canvas.add_layer("Background")
canvas.bind_headless() catch failure:
assert(failure.code == gpu.unavailable)
return
let started = time.now()
let layer = try canvas.add_vector_layer("Stars")
# Thousands of stars: a 60 by 80 grid over the canvas, and the default ring.
let star = try node_of(&canvas, 1, node_star)
try canvas.set_graph_value(layer, star, (i64)slot_width, 90.0)
try canvas.set_graph_value(layer, star, (i64)slot_height, 90.0)
let grid = try canvas.add_graph_node(layer, node_grid, 0.0, 0.0)
try canvas.set_graph_value(layer, grid, 0, 60.0)
try canvas.set_graph_value(layer, grid, 1, 80.0)
try canvas.set_graph_value(layer, grid, 2, 240.0)
try canvas.set_graph_value(layer, grid, 3, 290.0)
try canvas.set_graph_value(layer, grid, 4, 7500.0)
try canvas.set_graph_value(layer, grid, 5, 12000.0)
let field = try canvas.add_graph_node(layer, node_clone, 0.0, 0.0)
try canvas.link_graph(layer, star, field, 0)
try canvas.link_graph(layer, grid, field, 1)
let both = try canvas.add_graph_node(layer, node_merge, 0.0, 0.0)
let ring = try node_of(&canvas, 1, node_clone)
let output = try node_of(&canvas, 1, node_output)
try canvas.link_graph(layer, field, both, 0)
try canvas.link_graph(layer, ring, both, 1)
let built = time.now()
try canvas.link_graph(layer, both, output, 0)
let drawn_at = time.now()
assert((try canvas.generated_count(1)) == 4812)
let document = canvas.document else trap("bound")
let tiles = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
let columns = tiles.columns()
let rows = tiles.rows()
let before = try new u64[(usize)columns * (usize)rows] --- in memory.heap
defer free(before) in memory.heap
for row in 0..<rows:
for column in 0..<columns:
before[(usize)row * (usize)columns + (usize)column] = tiles.stamp(column, row)
# The ring's radius changed: its twelve stars move, the grid's 4800 stay.
var expected = try CellMask.create(15000, 24000)
defer expected.close()
for at in 4800..<(usize)4812:
try expected.mark_spec(canvas.records[1].generated.specs[at])
let circle = try node_of(&canvas, 1, node_circle)
let edit = time.now()
try canvas.set_graph_value(layer, circle, 1, 5000.0)
let edited = time.now()
assert(canvas.records[1].graph_evaluated == 3)
for at in 4800..<(usize)4812:
try expected.mark_spec(canvas.records[1].generated.specs[at])
let after = (document.find((u64)layer) else trap("layer")).tiles() else trap("tiles")
var changed: usize = 0
for row in 0..<rows:
for column in 0..<columns:
if after.stamp(column, row) != before[(usize)row * (usize)columns + (usize)column]:
changed += 1
assert(expected.marked(column, row))
assert(changed > 0 and changed <= expected.count())
print(f"graph timing: layer {(built - started) // 1000000} ms, 4812 stars drawn {(drawn_at - built) // 1000000} ms, ring edit {(edited - edit) // 1000000} ms over {changed} cells")