dymokomi/luce-image
Source of release 0.45.1
0.45.1 / src / canvas / moat_tests.lucb
#==============================================================================================
#
# canvas/moat_tests - Large-canvas paths that work a cell at a time
#
#==============================================================================================
## The mask's value at (`x`, `y`) as read back: empty cells are white.
func mask_value_at(mask: const Tiles*, samples: f32[], x: i64, y: i64) -> f32!:
let column = (u32)(x // (i64)tile_size)
let row = (u32)(y // (i64)tile_size)
if not mask.painted(column, row):
return 1.0
try mask.read_cell(column, row, samples)
return samples[(usize)((y % (i64)tile_size) * (i64)tile_size + x % (i64)tile_size) * 4]
test "a mask filled from the selection matches it pixel for pixel; a black mask shares one tile":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(900, 700)
defer canvas.close()
let layer = try canvas.add_layer("Paint")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
# Wholly selected cells, cells the selection misses, and edges across cells.
try canvas.select_rectangle(10, 20, 600, 500)
try canvas.select_ellipse(500, 300, 380, 360, 1)
try canvas.set_mask(layer, true, 2)
let document = canvas.document else trap("bound")
let mask = (document.find((u64)layer) else trap("layer")).mask_tiles() else trap("masked")
let samples = try new f32[(usize)tile_size * (usize)tile_size * 4] --- in memory.heap
defer free(samples) in memory.heap
let selection = canvas.current()
var y: i64 = 0
while y < 700:
var x: i64 = 0
while x < 900:
let expected = (f32)selection.at(x, y) / 255.0
let found = try mask_value_at(mask, samples, x, y)
assert(math.abs((f64)(found - expected)) < 0.002)
x += 7
y += 5
# A wholly selected cell holds no tile at all.
assert(not mask.painted(1, 1))
try canvas.set_mask(layer, false)
try canvas.deselect()
try canvas.set_mask(layer, true, 1)
let black = (document.find((u64)layer) else trap("layer")).mask_tiles() else trap("masked")
assert(black.stamp(0, 0) == black.stamp(3, 2) and black.painted(3, 2))
assert((try mask_value_at(black, samples, 850, 650)) == 0.0)
test "copy reads only the selection's box, from the layer or merged, across cell edges":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(700, 500)
defer canvas.close()
let background = try canvas.add_layer("Background")
let paint = try canvas.add_layer("Paint")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, false)
try canvas.fill(background, false)
try canvas.select_rectangle(200, 150, 300, 250)
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
try canvas.fill(paint, false)
try canvas.deselect()
_ = try shown_at(&canvas, &target, 0, 0)
# A box across the square's corner and three cell edges.
let width: usize = 180
let height: usize = 140
let rgba = try new u8[width * height * 4] --- in memory.heap
defer free(rgba) in memory.heap
let document = canvas.document else trap("bound")
let tiles = (document.find((u64)paint) else trap("layer")).tiles() else trap("pixels")
try copy_layer_window(tiles, rgba, 150, 100, width, height)
# (150,100) is outside the square: clear. (260,200) inside: opaque red.
assert(rgba[3] == 0)
let inside = ((200 - 100) * width + (260 - 150)) * 4
assert(rgba[inside] == 255 and rgba[inside + 1] == 0 and rgba[inside + 3] == 255)
try copy_merged_window(&canvas, rgba, 150, 100, width, height)
# Merged: white where the square is not, red where it is.
assert(rgba[0] == 255 and rgba[1] == 255 and rgba[2] == 255 and rgba[3] == 255)
assert(rgba[inside] == 255 and rgba[inside + 1] == 0 and rgba[inside + 3] == 255)
test "trim finds the box across cells from composited bands, on transparency and on a corner color":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(900, 700)
defer canvas.close()
let paint = try canvas.add_layer("Paint")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 0.2, 0.4, 0.6, false)
try canvas.select_rectangle(123, 240, 555, 301)
try canvas.fill(paint, false)
try canvas.select_rectangle(700, 600, 9, 7)
try canvas.fill(paint, false)
try canvas.deselect()
_ = try shown_at(&canvas, &target, 0, 0)
assert(try canvas.measure_trim(0))
assert(canvas.content_left() == 123 and canvas.content_top() == 240 and canvas.content_width() == 709 - 123 and canvas.content_height() == 607 - 240)
# The top-left corner is clear too: the same box.
assert(try canvas.measure_trim(1))
assert(canvas.content_left() == 123 and canvas.content_width() == 709 - 123)
test "the histogram counts a layer's cells and the picture's bands, transparency left out":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(700, 500)
defer canvas.close()
let paint = try canvas.add_layer("Paint")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 0.2, 0.4, 0.6, false)
try canvas.select_rectangle(200, 150, 300, 250)
try canvas.fill(paint, false)
try canvas.deselect()
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.measure_histogram(paint)
let red = (i64)transfer.srgb_byte(0.2)
let blue = (i64)transfer.srgb_byte(0.6)
assert((try canvas.histogram(1, red)) == 300 * 250 and (try canvas.histogram(3, blue)) == 300 * 250)
var total: i64 = 0
for slot in 0..<(i64)256:
total += try canvas.histogram(0, slot)
assert(total == 300 * 250)
# Below a new top layer: the same picture, counted from composited bands.
let top = try canvas.add_layer("Top")
try canvas.measure_histogram_below(top)
assert((try canvas.histogram(1, red)) == 300 * 250)
test "a large document refuses TIFF clearly instead of flattening; a small one still saves it":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var small = try Canvas(300, 200)
defer small.close()
_ = try small.add_layer("Paint")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&small, &target, 0, 0)
try small.save("build/moat-small.tif")
var large = try Canvas(9000, 8000)
defer large.close()
_ = try large.add_layer("Paint")
_ = try shown_at(&large, &target, 0, 0)
var refused = false
large.save("build/moat-large.tif") catch failure:
refused = failure.code == limit
assert(refused)
test "a placed picture goes in a band at a time and lands exactly where it was put":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(900, 700)
defer canvas.close()
let layer = try canvas.add_layer("Placed")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
let width: usize = 700
let height: usize = 530
let pixels = try new f32[width * height * 4] --- in memory.heap
defer free(pixels) in memory.heap
for at in 0..<width * height:
pixels[at * 4] = (f32)(at % width) / (f32)width
pixels[at * 4 + 1] = (f32)(at // width) / (f32)height
pixels[at * 4 + 2] = 0.5
pixels[at * 4 + 3] = 1.0
let picture = try Image.from_linear_rgba(width, height, pixels)
defer picture.release()
# Centred at (400, 300): its top-left at (50, 35).
try place_image_at(&canvas, layer, picture, 400, 300)
let document = canvas.document else trap("bound")
let tiles = (document.find((u64)layer) else trap("layer")).tiles() else trap("pixels")
let samples = try new f32[(usize)tile_size * (usize)tile_size * 4] --- in memory.heap
defer free(samples) in memory.heap
# The picture went through 8-bit sRGB: compare what it holds now.
let expected = try new f32[width * height * 4] --- in memory.heap
defer free(expected) in memory.heap
try picture.value().linear_rgba(expected)
for (x, y) in [(50, 35), (299, 290), (749, 564), (400, 300), (260, 260)]:
let column = (u32)(x // 256)
let row = (u32)(y // 256)
try tiles.read_cell(column, row, samples)
let at = (usize)(((y % 256) * 256 + x % 256) * 4)
let source = (usize)(((y - 35) * (i64)width + (x - 50)) * 4)
for channel in 0..<(usize)4:
assert(math.abs((f64)(samples[at + channel] - expected[source + channel])) < 0.002)
# Outside the picture: clear.
try tiles.read_cell(0, 0, samples)
assert(samples[(10 * 256 + 10) * 4 + 3] == 0.0)
test "a gradient previewed at the view's level matches the kept one, zoomed out and at 100%":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(2048, 1536)
defer canvas.close()
let layer = try canvas.add_layer("Gradient")
var target = try gpu.Texture.create(device, 512, 384, gpu.Format.rgba8_linear)
defer target.destroy()
let size = (usize)512 * 384 * 4
let shown = try new u8[size] --- in memory.heap
defer free(shown) in memory.heap
let kept = try new u8[size] --- in memory.heap
defer free(kept) in memory.heap
for pass in 0..<(usize)2:
# The second time within a selection, as a fill keeps to it.
if pass == 1:
try canvas.select_ellipse(300, 200, 1400, 1100)
try drawn(&canvas, &target, 0.25, 0.0, 0.0, shown)
try canvas.begin_preview(layer)
try canvas.preview_gradient(100.0, 200.0, 1900.0, 1300.0, 1.0, 0.2, 0.0, 1.0, 0.0, 0.3, 1.0, 1.0, pass == 1)
try drawn(&canvas, &target, 0.25, 0.0, 0.0, shown)
try canvas.end_preview(true)
try drawn(&canvas, &target, 0.25, 0.0, 0.0, kept)
let coarse = apart(shown, kept, 3)
assert(coarse.percent < 3.0 and coarse.mean < 4.0)
# At 100% the preview is the full-size gradient itself.
try canvas.undo()
try canvas.begin_preview(layer)
try canvas.preview_gradient(100.0, 200.0, 1900.0, 1300.0, 1.0, 0.2, 0.0, 1.0, 0.0, 0.3, 1.0, 1.0, pass == 1)
try drawn(&canvas, &target, 1.0, -700.0, -500.0, shown)
try canvas.end_preview(true)
try drawn(&canvas, &target, 1.0, -700.0, -500.0, kept)
let fine = apart(shown, kept, 1)
assert(fine.percent < 0.5)
try canvas.undo()
test "a gradient's one-color cells share a tile at each end; the ramp between is drawn":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var canvas = try Canvas(1500, 1000)
defer canvas.close()
let layer = try canvas.add_layer("Gradient")
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
_ = try shown_at(&canvas, &target, 0, 0)
# A short ramp from x 600 to 800: red before, blue after.
try canvas.fill_gradient(layer, 600.0, 0.0, 800.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0)
let document = canvas.document else trap("bound")
let tiles = (document.find((u64)layer) else trap("layer")).tiles() else trap("pixels")
assert(tiles.stamp(0, 0) == tiles.stamp(1, 3) and tiles.stamp(0, 0) != tiles.stamp(2, 0))
assert(tiles.stamp(4, 0) == tiles.stamp(5, 2) and tiles.stamp(4, 0) != tiles.stamp(0, 0))
let samples = try new f32[(usize)tile_size * (usize)tile_size * 4] --- in memory.heap
defer free(samples) in memory.heap
try tiles.read_cell(1, 3, samples)
assert(samples[0] == 1.0 and samples[2] == 0.0 and samples[3] == 1.0)
try tiles.read_cell(5, 2, samples)
assert(samples[0] == 0.0 and samples[2] == 1.0)
# Within the ramp (cell 2 starts at x 512, the ramp at 600): still red at its left.
try tiles.read_cell(2, 0, samples)
assert(samples[0] == 1.0)
# Its middle is half of each as encoded values, 0.214 in linear light.
let middle = ((0 * 256) + (700 - 512)) * 4
assert(math.abs((f64)samples[middle] - 0.214) < 0.02 and math.abs((f64)samples[middle + 2] - 0.214) < 0.02)
## Rows gathered from `linear_rgba_bands` into one buffer, checking the order.
struct StreamedRows:
var pixels: f32[]
var next: usize
var width: usize
var calls: usize
func keep_streamed(context: void*?, first: usize, count: usize, pixels: f32[]) -> !:
let into = (StreamedRows*)(context else return)
if first != into.next or count > 256 or pixels.length != into.width * count * 4:
error(invalid, "bands out of order")
for index in 0..<pixels.length:
into.pixels[first * into.width * 4 + index] = pixels[index]
into.next = first + count
into.calls += 1
## `path` streamed a band at a time equals it decoded whole, and streaming
## never decoded it whole.
func streams_as_whole(path: str, width: usize, height: usize) -> !:
let streamed = try Image.open(path)
defer streamed.release()
var rows = StreamedRows(pixels = try new f32[width * height * 4] --- in memory.heap, next = 0, width = width, calls = 0)
defer free(rows.pixels) in memory.heap
try streamed.value().linear_rgba_bands(256, keep_streamed, (void*)&rows)
assert(rows.next == height and rows.calls == (height + 255) // 256)
assert(not streamed.value().is_loaded())
let whole = try Image.open(path)
defer whole.release()
let expected = try new f32[width * height * 4] --- in memory.heap
defer free(expected) in memory.heap
try whole.value().linear_rgba(expected)
for index in 0..<expected.length:
assert(expected[index] == rows.pixels[index])
test "PNG, JPEG and TIFF pictures stream a band at a time exactly as they decode whole":
let width: usize = 700
let height: usize = 600
let bytes = try new u8[width * height * 4] --- in memory.heap
defer free(bytes) in memory.heap
for y in 0..<height:
for x in 0..<width:
let at = (y * width + x) * 4
bytes[at] = (u8)((x * 7 + y) % 256)
bytes[at + 1] = (u8)((y * 3) % 256)
bytes[at + 2] = (u8)((x * y) % 251)
bytes[at + 3] = (u8)(255 - (x + y) % 128)
let picture = try Image.from_rgba8(width, height, bytes)
defer picture.release()
try picture.value().save("build/stream.png")
try picture.value().save("build/stream-strips.tif")
try picture.value().save("build/stream-tiles.tif", tile = 256)
let opaque = try picture.value().convert("RGB")
defer opaque.release()
try opaque.value().save("build/stream.jpg", quality = 85)
try streams_as_whole("build/stream.png", width, height)
try streams_as_whole("build/stream-strips.tif", width, height)
try streams_as_whole("build/stream-tiles.tif", width, height)
try streams_as_whole("build/stream.jpg", width, height)
test "a picture opened as a document becomes tiles a band at a time, exactly":
let width: usize = 600
let height: usize = 530
let bytes = try new u8[width * height * 4] --- in memory.heap
defer free(bytes) in memory.heap
for index in 0..<bytes.length:
bytes[index] = (u8)((index * 13) % 256) if index % 4 != 3 else 255
let source = try Image.from_rgba8(width, height, bytes)
defer source.release()
try source.value().save("build/stream-open.png")
let opened = try Canvas.open("build/stream-open.png")
defer opened.release()
var canvas = opened.value()
canvas.bind_headless() catch failure:
assert(failure.code == gpu.unavailable)
return
let record = canvas.records[0]
let document = canvas.document else trap("bound")
let layer = document.find(record.id) else trap("a layer")
let tiles = layer.tiles() else trap("pixels")
let samples = try new f32[256 * 256 * 4] --- in memory.heap
defer free(samples) in memory.heap
let expected = try new f32[width * height * 4] --- in memory.heap
defer free(expected) in memory.heap
let whole = try Image.open("build/stream-open.png")
defer whole.release()
try whole.value().linear_rgba(expected)
for row in 0..<tiles.rows():
for column in 0..<tiles.columns():
try tiles.read_cell(column, row, samples)
let area = tiles.region(column, row)
for y in 0..<(usize)area.height:
for x in 0..<(usize)area.width:
let at = (((usize)row * 256 + y) * width + (usize)column * 256 + x) * 4
for channel in 0..<(usize)4:
assert(math.abs((f64)samples[(y * 256 + x) * 4 + channel] - (f64)expected[at + channel]) < 0.002)
test "a picture that opens but cannot be decoded fails the bind that loads it, as an error":
let width: usize = 400
let height: usize = 300
let bytes = try new u8[width * height * 4] --- in memory.heap
defer free(bytes) in memory.heap
for index in 0..<bytes.length:
bytes[index] = (u8)((index * 31) % 256)
let source = try Image.from_rgba8(width, height, bytes)
defer source.release()
let opaque = try source.value().convert("RGB")
defer opaque.release()
try opaque.value().save("build/stream-broken.jpg")
# Its headers stay, so opening it (which reads just those) succeeds; its
# compressed pixels end halfway.
let data = try files.read((c_api.str)"build/stream-broken.jpg")
defer data.release()
try files.write_atomic((c_api.str)"build/stream-broken.jpg", data.value[..<data.value.length // 2])
let opened = try Canvas.open("build/stream-broken.jpg")
defer opened.release()
var canvas = opened.value()
var failed = false
canvas.bind_headless() catch failure:
if failure.code == gpu.unavailable:
return
failed = true
# The first draw's bind reports it (the window reports a draw's failure);
# the document stays bound, its layer empty, and closes cleanly.
assert(failed and canvas.is_bound() and canvas.layer_count() == 1)
## Two gradient layers over a 1500 by 1100 document.
func painted_pair(canvas: Canvas*) -> !:
let first = try canvas.add_layer("First")
let second = try canvas.add_layer("Second")
try canvas.fill_gradient(first, 0.0, 0.0, 1500.0, 1100.0, 1.0, 0.2, 0.1, 1.0, 0.1, 0.3, 0.9, 1.0)
try canvas.fill_gradient(second, 750.0, 550.0, 1300.0, 900.0, 0.9, 0.9, 0.2, 0.8, 0.2, 0.9, 0.4, 0.3, radial = true)
test "a frame never waits for tiles coming back: a coarser level stands in, and the next frames draw them exactly":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
defer target.destroy()
var reference: u8[196608]
var seen: u8[196608]
# The same picture on a document that keeps everything, at 100%.
var plain = try Canvas(1500, 1100)
defer plain.close()
try frame_pixels(&plain, &target, 1.0, 0.0, 0.0, reference)
try painted_pair(&plain)
try frame_pixels(&plain, &target, 1.0, -600.0, -500.0, reference)
var canvas = try Canvas(1500, 1100)
defer canvas.close()
defer residency_budgets(0, 0)
try frame_pixels(&canvas, &target, 1.0, 0.0, 0.0, seen)
try painted_pair(&canvas)
# Seen whole once (its coarse levels kept), then every layer tile packed
# and moved out of the GPU and RAM.
try frame_pixels(&canvas, &target, 256.0 / 1500.0, 0.0, 0.0, seen)
Canvas.set_compressed_tier(true)
defer Canvas.set_compressed_tier(false)
Canvas.set_progressive_loading(true)
defer Canvas.set_progressive_loading(false)
try canvas.set_memory_budgets(24 * 524288, 524288)
try canvas.settle_memory()
assert(canvas.memory_packs() > 0)
# The first frame at 100% shows the coarse level and asks for more.
try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
assert(canvas.busy())
var frames: usize = 1
while canvas.busy() and frames < 500:
thread.sleep(1)
try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
frames += 1
assert(not canvas.busy())
assert(seen == reference)