dymokomi/luce-image
Source of release 0.45.1
0.45.1 / src / canvas / selection_timing_tests.lucb
#==============================================================================================
#
# canvas/selection_timing_tests - Select and Mask and Transform Selection at 15000 by 24000
#
#==============================================================================================
## Milliseconds since `started`.
func since(started: u64) -> u64:
return (time.now() - started) // 1000000
## Whether `started` was under `most` ms ago, stretched by `pace`.
func paced_under(started: u64, most: f64, pace: f64) -> bool:
return (f64)since(started) < most * pace
## Soft blobs everywhere, as Color Range picks from a photograph: an edge in
## every cell of the document, the worst a selection's previews meet.
func select_blobs(canvas: Canvas*) -> !:
let width: usize = 15000
let height: usize = 24000
let coverage = try new u8[width * height] --- in memory.heap
defer free(coverage) in memory.heap
for y in 0..<height:
let wave_y = (i64)(y % 1800) - 900
let ty = wave_y if wave_y >= 0 else -wave_y
for x in 0..<width:
let wave_x = (i64)(x % 1400) - 700
let tx = wave_x if wave_x >= 0 else -wave_x
let value = (tx + ty - 700) * 255 // 300 + 128
coverage[y * width + x] = (u8)math.imin(255, math.imax(0, value))
try canvas.live().from_coverage(coverage, Mode.replace)
## One frame of a 64-point view at 100% from the document's corner, and the
## selection tiles its ants draw with (a window's frame draws them in its own format).
func ants_frame(canvas: Canvas*, target: gpu.Texture*) -> !:
_ = try shown_at(canvas, target, 0, 0)
let document = canvas.document else trap("drawn")
_ = try document.selection_tiles_within(shown_cells(canvas, gpu.Rect(width = 64.0, height = 64.0), 1.0, 0.0, 0.0), ants_extra_cells)
test "select and mask and transform selection keep up with a 15000 by 24000 selection edged everywhere":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
defer target.destroy()
var canvas = try Canvas(15000, 24000)
defer canvas.close()
let layer = try canvas.add_layer("Paint")
_ = try shown_at(&canvas, &target, 0, 0)
try canvas.fill_gradient(layer, 0.0, 0.0, 15000.0, 24000.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0)
try select_blobs(&canvas)
let pace = build_pace()
# The whole document fitted (level 5), and 1:1 on 2000 by 1500 pixels.
let fit = Scope(level = 5, box = CellBox(everything = false, left = 0, top = 0, right = 512, bottom = 768))
let near = Scope(level = 0, box = CellBox(everything = false, left = 6912, top = 11008, right = 8960, bottom = 12544))
try canvas.begin_refine()
let session = canvas.select_mask else trap("Select and Mask is open")
for scope in [fit, near]:
for radius in [(i64)0, 50]:
for feather in [(i64)10, 250]:
let started = time.now()
try canvas.preview_refine(radius, 5, feather, 30.0, 20.0)
try prepare_refine_preview(&canvas, scope)
# The frame asking never waits for the work.
assert(paced_under(started, 250.0, pace))
try collect_refine(session, true)
assert(paced_under(started, 3000.0, pace) and session.shown.level == scope.level)
var started = time.now()
try canvas.end_refine(true, 50, 5, 20, 30.0, 20.0, background = true)
# OK returns while the refine thread works (it took 3.2 s on the calling thread).
let returned = since(started)
assert(paced_under(started, 1000.0, pace) and canvas.refine_keeping())
# Edits are refused meanwhile, as while a picture opens; progress shows.
var refused = false
canvas.select_rectangle(0, 0, 10, 10) catch _:
refused = true
assert(refused and canvas.refine_percent() < 100)
# Each frame moves it on without holding the frame up.
var percent = canvas.refine_percent()
var slowest: u64 = 0
while canvas.refine_keeping():
let now = canvas.refine_percent()
assert(now >= percent and now <= 100)
percent = now
let frame = time.now()
try canvas.continue_refine()
let spent = since(frame)
slowest = spent if spent > slowest else slowest
thread.sleep(5)
assert((f64)slowest < 60.0 * pace)
# Every cell worked out at full size (it was 13.6 s before windows were shared).
let refined = since(started)
assert(paced_under(started, 20000.0, pace) and canvas.undo_name() == "Select and Mask" and not canvas.refining())
# The kept selection's edge reaches the GPU the cells a view shows first
# (at 100%, a few), the rest a few a frame while the view keeps drawing.
_ = try shown_at(&canvas, &target, 0, 0)
started = time.now()
try ants_frame(&canvas, &target)
let ants = since(started)
assert(paced_under(started, 150.0, pace) and canvas.busy())
var frames: usize = 1
while canvas.busy() and frames < 1000:
try ants_frame(&canvas, &target)
frames += 1
assert(not canvas.busy())
print(f"select and mask OK: returned {returned} ms, slowest frame {slowest} ms, refined {refined} ms, first ants {ants} ms, all edge cells in after {frames} frames")
try canvas.begin_selection_transform()
let warping = canvas.selection_warping else trap("a transform is under way")
for step in 1..<(i64)4:
started = time.now()
try canvas.preview_selection_transform(1.0 + 0.02 * (f64)step, 1.0, 3.0 * (f64)step, 10.0 * (f64)step, 0.0, 7500.0, 12000.0)
try prepare_selection_warp(warping, fit)
try prepare_selection_warp(warping, near)
assert(paced_under(started, 500.0, pace))
started = time.now()
try canvas.end_selection_transform(true)
assert(paced_under(started, 5000.0, pace) and canvas.undo_name() == "Transform Selection")