mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 09:26:43 +00:00
157 lines
7.3 KiB
Rust
157 lines
7.3 KiB
Rust
//! Liquify / Puppet / Perspective timings on a 24 MP image.
|
||
//!
|
||
//! ```sh
|
||
//! cargo run --release -p photocraft-algo --example bench_liquify
|
||
//! ```
|
||
|
||
use std::time::Instant;
|
||
|
||
use photocraft_algo::liquify::{LiquifyField, LiquifyStroke, LiquifyTool, ProxyImage, apply_liquify, auto_cell};
|
||
use photocraft_algo::perspective::{PerspectiveMap, Plane};
|
||
use photocraft_algo::puppet::{PuppetDensity, PuppetMode, PuppetPin, PuppetWarp, deform, render};
|
||
use photocraft_algo::transform::Interp;
|
||
use photocraft_algo::warp::warp_mesh_surface;
|
||
use photocraft_color::PixelFormat;
|
||
use photocraft_geom::Rect;
|
||
use photocraft_raster::Surface;
|
||
|
||
fn main() {
|
||
let (w, h) = (6000, 4000);
|
||
let b = Rect::new(0, 0, w, h);
|
||
let mut s = Surface::new(PixelFormat::RGBA8);
|
||
let mut row = vec![0.0f32; w as usize * 4];
|
||
for y in 0..h {
|
||
for x in 0..w as usize {
|
||
let v = (((x / 37) + (y as usize / 41)) % 2) as f32;
|
||
row[x * 4..x * 4 + 4].copy_from_slice(&[v, x as f32 / w as f32, y as f32 / h as f32, 1.0]);
|
||
}
|
||
s.write_region(Rect::new(0, y, w, y + 1), &row);
|
||
}
|
||
let cell = auto_cell(b);
|
||
println!("24 MP RGBA8, field cell {cell} px");
|
||
|
||
// Interactive: proxy + per-dab update.
|
||
let t = Instant::now();
|
||
let proxy = ProxyImage::new(&s, b, 1600);
|
||
println!("proxy {}×{} built in {:.1} ms", proxy.w, proxy.h, t.elapsed().as_secs_f64() * 1e3);
|
||
let mut out = vec![[0u8; 4]; proxy.w * proxy.h];
|
||
let t = Instant::now();
|
||
proxy.render(&LiquifyField::new(b, cell), [0, 0, proxy.w, proxy.h], &mut out);
|
||
println!("full proxy render {:.1} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
let t = Instant::now();
|
||
let mut field = LiquifyField::new(b, cell);
|
||
println!("field alloc {:.1} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
let mut st = LiquifyStroke::new(LiquifyTool::ForwardWarp, 600.0);
|
||
let mut worst = 0.0f64;
|
||
let mut total = 0.0;
|
||
let n = 60;
|
||
let mut prev = [2000.0, 2000.0, 1.0];
|
||
field.stroke_begin(&st, prev);
|
||
for k in 1..=n {
|
||
let p = [2000.0 + k as f64 * 25.0, 2000.0 + (k as f64 * 0.3).sin() * 200.0, 1.0];
|
||
let t = Instant::now();
|
||
let dirty = field.stroke_segment(&st, prev, p);
|
||
let r = proxy.proxy_rect(dirty);
|
||
proxy.render(&field, r, &mut out);
|
||
let ms = t.elapsed().as_secs_f64() * 1e3;
|
||
worst = worst.max(ms);
|
||
total += ms;
|
||
prev = p;
|
||
}
|
||
println!("forward-warp segment (600 px brush, 25 px moves) + proxy update: mean {:.2} ms, worst {:.2} ms", total / n as f64, worst);
|
||
// One 3000 px drag with a 200 px brush (a straight leg, then a diagonal one), as a slow
|
||
// (every 2 px) and a fast (every 60 px) pointer reports it: the field cost of the whole
|
||
// stroke, and how far the two results differ.
|
||
let mut drag = LiquifyStroke::new(LiquifyTool::ForwardWarp, 200.0);
|
||
let mut fields = Vec::new();
|
||
let along = |d: f64| if d <= 1500.0 { vec![1500.0 + d, 2000.0] } else { vec![3000.0 + (d - 1500.0) * 0.6, 2000.0 + (d - 1500.0) * 0.8] };
|
||
for step in [2.0, 60.0] {
|
||
drag.points = (0..=(3000.0 / step) as usize).map(|k| along(k as f64 * step)).collect();
|
||
let t = Instant::now();
|
||
let mut f = LiquifyField::new(b, cell);
|
||
f.apply_stroke(&drag);
|
||
println!("forward-warp 3000 px drag (200 px brush), an event every {step} px: {:.1} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
fields.push(f);
|
||
}
|
||
let diff = fields[0].d.iter().zip(&fields[1].d).map(|(p, q)| (p[0] - q[0]).abs().max((p[1] - q[1]).abs())).fold(0.0f32, f32::max);
|
||
println!(" slow vs fast pointer: fields differ by at most {diff:.3} px (max displacement {:.1} px)", fields[0].max_displacement());
|
||
st.tool = LiquifyTool::Bloat;
|
||
let t = Instant::now();
|
||
let mut d = Rect::EMPTY;
|
||
for _ in 0..20 {
|
||
d = field.stroke_segment(&st, [3000.0, 1500.0, 1.0], [3000.0, 1500.0, 1.0]);
|
||
}
|
||
println!("bloat dab alone: {:.2} ms", t.elapsed().as_secs_f64() * 1e3 / 20.0);
|
||
let t = Instant::now();
|
||
for _ in 0..20 {
|
||
proxy.render(&field, proxy.proxy_rect(d), &mut out);
|
||
}
|
||
println!("dab-sized proxy update alone: {:.2} ms", t.elapsed().as_secs_f64() * 1e3 / 20.0);
|
||
let t = Instant::now();
|
||
for _ in 0..20 {
|
||
let d = field.stroke_segment(&st, [3000.0, 1500.0, 1.0], [3000.0, 1500.0, 1.0]);
|
||
proxy.render(&field, proxy.proxy_rect(d), &mut out);
|
||
}
|
||
println!("bloat dab (600 px) + proxy update: {:.2} ms", t.elapsed().as_secs_f64() * 1e3 / 20.0);
|
||
|
||
let t = Instant::now();
|
||
let res = apply_liquify(&s, &field);
|
||
println!("apply on 24 MP (touched tiles only): {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
// Worst case: every tile displaced.
|
||
let mut all = LiquifyField::new(b, cell);
|
||
for v in all.d.iter_mut() {
|
||
*v = [1.3, -0.7];
|
||
}
|
||
let t = Instant::now();
|
||
let _ = apply_liquify(&s, &all);
|
||
println!("apply on 24 MP (whole field displaced): {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
drop(res);
|
||
|
||
// Puppet warp on a 24 MP layer.
|
||
let pw = PuppetWarp {
|
||
pins: vec![
|
||
PuppetPin { src: [1000.0, 2000.0], dst: [1000.0, 2000.0], rotate: None, depth: 0 },
|
||
PuppetPin { src: [5000.0, 2000.0], dst: [4800.0, 1200.0], rotate: None, depth: 0 },
|
||
PuppetPin { src: [3000.0, 3500.0], dst: [3100.0, 3500.0], rotate: None, depth: 0 },
|
||
],
|
||
mode: PuppetMode::Normal,
|
||
density: PuppetDensity::Normal,
|
||
expansion: 2.0,
|
||
};
|
||
let t = Instant::now();
|
||
let (solver, v, order) = deform(&s, b, &pw, photocraft_algo::puppet::ITERATIONS);
|
||
println!(
|
||
"puppet mesh {} verts / {} tris + ARAP ({} rounds): {:.1} ms",
|
||
solver.mesh.verts.len(),
|
||
solver.mesh.tris.len(),
|
||
photocraft_algo::puppet::ITERATIONS,
|
||
t.elapsed().as_secs_f64() * 1e3
|
||
);
|
||
// Compare the old path-dependent preview with the command-equivalent drag solve, using
|
||
// changing destinations and the same cached factorization (no remeshing per event).
|
||
for (label, rounds, warm) in [("6 warm rounds", 6, true), ("canonical cold solve", photocraft_algo::puppet::ITERATIONS, false)] {
|
||
let mut previous = v.clone();
|
||
let mut times = Vec::new();
|
||
for step in 1..=60 {
|
||
let mut dst: Vec<[f64; 2]> = pw.pins.iter().map(|p| p.dst).collect();
|
||
dst[1][0] -= f64::from(step) * 10.0;
|
||
dst[1][1] += (f64::from(step) * 0.1).sin() * 400.0;
|
||
let t = Instant::now();
|
||
let (next, _) = solver.solve(&dst, &[None; 3], pw.mode, rounds, warm.then_some(previous.as_slice()));
|
||
times.push(t.elapsed().as_secs_f64() * 1e3);
|
||
previous = std::hint::black_box(next);
|
||
}
|
||
times.sort_by(f64::total_cmp);
|
||
println!("puppet drag ({label}, 60 moves): median {:.2} ms, p95 {:.2} ms, max {:.2} ms", times[30], times[56], times[59]);
|
||
}
|
||
let t = Instant::now();
|
||
let _ = render(&s, b, &solver.mesh, &v, &order, Interp::Bicubic);
|
||
println!("puppet render 24 MP: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
|
||
let q = [[0.0, 0.0], [6000.0, 0.0], [6000.0, 4000.0], [0.0, 4000.0]];
|
||
let m = PerspectiveMap::new(&[Plane { src: q, dst: [[400.0, 0.0], [5600.0, 200.0], [6000.0, 4000.0], [0.0, 4000.0]] }]).unwrap();
|
||
let t = Instant::now();
|
||
let _ = warp_mesh_surface(&s, b, &|x, y| m.map(x, y), Interp::Bicubic);
|
||
println!("perspective warp 24 MP: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
|
||
}
|