dymokomi/luce-image
Source of release 0.45.1
0.45.1 / src / canvas / preview_tests.lucb
#==============================================================================================
#
# canvas/preview_tests - Previews drawn at the view's level, against what keeping makes
#
#==============================================================================================
## The canvas drawn at `zoom` from (`offset_x`, `offset_y`) over black into
## `target`, read back into `pixels` (RGBA bytes, the target's size).
func drawn(canvas: Canvas*, target: gpu.Texture*, zoom: f64, offset_x: f64, offset_y: f64, pixels: u8[]) -> !:
let frame = try target.frame()
defer frame.release()
let root = try frame.value().target()
defer root.release()
let width = (f64)(try target.width())
let height = (f64)(try target.height())
try canvas.draw(root, gpu.Rect(width = width, height = height), zoom, offset_x, offset_y)
_ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
try target.read(pixels)
## How far apart two drawings are: the share of pixels differing by more than
## `slack` in some channel, in percent, and the mean difference.
struct Apart:
var percent: f64
var mean: f64
func apart(first: const u8[], second: const u8[], slack: i64) -> Apart:
var off: usize = 0
var total: f64 = 0.0
for at in 0..<first.length // 4:
var worst: i64 = 0
for channel in 0..<(usize)3:
let difference = math.iabs((i64)first[at * 4 + channel] - (i64)second[at * 4 + channel])
total += (f64)difference
worst = difference if difference > worst else worst
if worst > slack:
off += 1
let count = (f64)(first.length // 4)
return Apart(percent = (f64)off * 100.0 / count, mean = total / (count * 3.0))
## Three rectangles of color on layer `layer` of a 2048 by 1536 canvas.
func paint_rectangles(canvas: Canvas*, layer: i64) -> !:
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.1, 0.1, false)
try canvas.select_rectangle(200, 150, 700, 500, 0)
try canvas.fill(layer, false)
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 0.1, 0.9, 0.2, false)
try canvas.select_rectangle(900, 300, 600, 900, 0)
try canvas.fill(layer, false)
try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 0.2, 0.3, 1.0, false)
try canvas.select_rectangle(300, 1000, 1400, 300, 0)
try canvas.fill(layer, false)
try canvas.deselect()
test "a transform preview drawn at a coarse level looks like the kept transform, and keeping matches a transform made at once":
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("Paint")
# An eighth: level 3, 256 by 192 texels.
var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
defer target.destroy()
let size = (usize)256 * 192 * 4
let before = try new u8[size] --- in memory.heap
defer free(before) in memory.heap
let previewed = try new u8[size] --- in memory.heap
defer free(previewed) in memory.heap
let kept = try new u8[size] --- in memory.heap
defer free(kept) in memory.heap
try drawn(&canvas, &target, 0.125, 0.0, 0.0, before)
try paint_rectangles(&canvas, layer)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, before)
try canvas.begin_transform(layer)
try canvas.preview_transform(0.6, 0.8, 25.0, 120.0, -60.0, 1024.0, 768.0)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, previewed)
# The preview shows the transform: the drawing moved.
assert(apart(before, previewed, 40).percent > 10.0)
# Full size at 100%, where the preview is made at level 0.
var close_target = try gpu.Texture.create(device, 128, 128, gpu.Format.rgba8_linear)
defer close_target.destroy()
let close_size = (usize)128 * 128 * 4
let close_previewed = try new u8[close_size] --- in memory.heap
defer free(close_previewed) in memory.heap
let close_kept = try new u8[close_size] --- in memory.heap
defer free(close_kept) in memory.heap
try drawn(&canvas, &close_target, 1.0, -900.0, -600.0, close_previewed)
# The layer itself is as it was until the transform is kept.
let untouched = try layer_texel(&canvas, layer, 250, 200)
assert(untouched[0] > 0.99 and untouched[3] > 0.99)
try canvas.end_transform(true)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, kept)
let coarse = apart(previewed, kept, 40)
assert(coarse.percent < 3.0 and coarse.mean < 4.0)
try drawn(&canvas, &close_target, 1.0, -900.0, -600.0, close_kept)
let close = apart(close_previewed, close_kept, 2)
assert(close.percent < 0.5)
# Keeping made what a transform made at once makes.
var other = try Canvas(2048, 1536)
defer other.close()
let other_layer = try other.add_layer("Paint")
try drawn(&other, &target, 0.125, 0.0, 0.0, before)
try paint_rectangles(&other, other_layer)
try other.transform_layer(other_layer, 0.6, 0.8, 25.0, 120.0, -60.0, 1024.0, 768.0)
var y: u32 = 5
while y < 1536:
var x: u32 = 7
while x < 2048:
let here = try layer_texel(&canvas, layer, x, y)
let there = try layer_texel(&other, other_layer, x, y)
for channel in 0..<(usize)4:
assert(here[channel] == there[channel])
x += 61
y += 53
test "a floating selection's transform preview at a coarse level looks like the kept one":
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("Paint")
var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
defer target.destroy()
let size = (usize)256 * 192 * 4
let previewed = try new u8[size] --- in memory.heap
defer free(previewed) in memory.heap
let kept = try new u8[size] --- in memory.heap
defer free(kept) in memory.heap
try drawn(&canvas, &target, 0.125, 0.0, 0.0, kept)
try paint_rectangles(&canvas, layer)
try canvas.select_rectangle(800, 200, 800, 700, 0)
try canvas.begin_transform(layer)
try canvas.preview_transform(0.7, 0.7, -15.0, -300.0, 250.0, 1200.0, 550.0)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, previewed)
# At 100%, across where the pixels leave and where they land.
var close_target = try gpu.Texture.create(device, 256, 256, gpu.Format.rgba8_linear)
defer close_target.destroy()
let close_size = (usize)256 * 256 * 4
let close_previewed = try new u8[close_size] --- in memory.heap
defer free(close_previewed) in memory.heap
let close_kept = try new u8[close_size] --- in memory.heap
defer free(close_kept) in memory.heap
try drawn(&canvas, &close_target, 1.0, -700.0, -550.0, close_previewed)
try canvas.end_transform(true)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, kept)
let coarse = apart(previewed, kept, 40)
assert(coarse.percent < 3.0 and coarse.mean < 4.0)
try drawn(&canvas, &close_target, 1.0, -700.0, -550.0, close_kept)
assert(apart(close_previewed, close_kept, 2).percent < 0.5)
test "filter previews drawn at a coarse level look like the kept filter, inside the selection only":
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("Paint")
var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
defer target.destroy()
let size = (usize)256 * 192 * 4
let before = try new u8[size] --- in memory.heap
defer free(before) in memory.heap
let previewed = try new u8[size] --- in memory.heap
defer free(previewed) in memory.heap
let kept = try new u8[size] --- in memory.heap
defer free(kept) in memory.heap
try drawn(&canvas, &target, 0.125, 0.0, 0.0, before)
try paint_rectangles(&canvas, layer)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, before)
# Motion blur, Gaussian blur and lens correction, each previewed then kept and undone.
for kind in 0..<(i64)3:
try canvas.begin_preview(layer)
if kind == 0:
try canvas.preview_filter(0, 30.0, 400.0, 0.0)
elif kind == 1:
try canvas.preview_blur(120.0)
else:
try canvas.preview_filter(1, 0.8, 0.5, -0.5)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, previewed)
assert(apart(before, previewed, 40).percent > 1.0)
try canvas.end_preview(true)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, kept)
let coarse = apart(previewed, kept, 40)
assert(coarse.percent < 3.0 and coarse.mean < 4.0)
try canvas.undo()
# Within a selection: outside it the preview and the kept blur leave the picture alone.
try canvas.select_rectangle(0, 0, 1024, 1536, 0)
try canvas.begin_preview(layer)
try canvas.preview_filter(0, 0.0, 300.0, 0.0)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, previewed)
try canvas.end_preview(true)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, kept)
let coarse = apart(previewed, kept, 40)
assert(coarse.percent < 3.0 and coarse.mean < 4.0)
# The right half (from texel 136 on, clear of the edge's blend) is as it was.
for y in 0..<(usize)192:
for x in 136..<(usize)256:
for channel in 0..<(usize)3:
let at = (y * 256 + x) * 4 + channel
assert(math.iabs((i64)previewed[at] - (i64)before[at]) <= 1 and math.iabs((i64)kept[at] - (i64)before[at]) <= 1)
# Dropped, the layer shows as it was.
try canvas.undo()
try canvas.begin_preview(layer)
try canvas.preview_blur(80.0)
try canvas.end_preview(false)
try drawn(&canvas, &target, 0.125, 0.0, 0.0, previewed)
assert(apart(before, previewed, 1).percent == 0.0)