A drawing app built for agent/human collaboration
Rust
use crate::layers;
use anyhow::{Result, bail};
use klad_brush::BrushSet;
use klad_core::bundle::{Bundle, write_atomic};
use klad_render::export::{Options, Target, png8, png16, render};
use std::path::{Path, PathBuf};
use std::time::Instant;
pub struct Export {
pub layer: Option<String>,
pub frame: u32,
pub scale: f32,
pub depth: u8,
pub background: bool,
pub references: bool,
pub variant: Option<String>,
pub out: Option<PathBuf>,
}
pub(crate) fn scale_tag(scale: f32) -> String {
if (scale - 1.0).abs() < f32::EPSILON {
return String::new();
}
let text = format!("{scale:.3}");
format!("@{}x", text.trim_end_matches('0').trim_end_matches('.'))
}
pub fn default_path(bundle: &Bundle, layer: Option<&str>, frame: u32, scale: f32, variant: Option<&str>) -> PathBuf {
let root = bundle.root.components().collect::<PathBuf>();
let stem = root
.file_stem()
.map_or("export".into(), |s| s.to_string_lossy().to_string());
let layer = layer.map_or(String::new(), |l| format!("-{l}"));
let frame = if bundle.doc.timeline.frames > 1 {
format!("-f{frame}")
} else {
String::new()
};
root.parent().unwrap_or(Path::new(".")).join(format!(
"{stem}{}{layer}{frame}{}.png",
layers::variant_tag(variant),
scale_tag(scale)
))
}
pub fn run(path: &Path, opts: Export) -> Result<()> {
let start = Instant::now();
let bundle = Bundle::open(path)?;
let doc = &bundle.doc;
if opts.frame >= doc.timeline.frames {
bail!(
"frame {} is past the last frame {}",
opts.frame,
doc.timeline.frames - 1
);
}
let layer = opts.layer.as_deref().map(|key| doc.find_layer(key)).transpose()?;
klad_render::export::check_scale(doc, opts.scale)?;
let detail = klad_render::export::detail_of(doc, opts.scale);
let brushes = BrushSet::for_bundle(&bundle)?;
let dress = layers::dress_of(doc, opts.variant.as_deref())?;
let rasters = layers::dressed(
&bundle,
&brushes,
layers::load_at(&bundle, opts.frame, &brushes, detail)?,
&dress,
)?;
let target = match layer {
Some(l) => Target::Layer(l),
None => Target::Frame,
};
let options = Options {
scale: opts.scale,
background: opts.background,
references: opts.references,
detail,
};
let image = render(doc, opts.frame, &rasters, &target, options)?;
let rendered = start.elapsed().as_secs_f64() * 1000.0;
let bytes = match opts.depth {
8 => png8(&image)?,
16 => png16(&image)?,
other => bail!("--depth takes 8 or 16, not {other}"),
};
let name = layer.map(|l| {
if l.name.is_empty() {
l.id.as_str()
} else {
l.name.as_str()
}
});
let usual = default_path(&bundle, name, opts.frame, opts.scale, opts.variant.as_deref());
let out = match opts.out {
Some(folder) if folder.is_dir() => folder.join(usual.file_name().unwrap_or_default()),
Some(file) => file,
None => usual,
};
write_atomic(&out, &bytes)?;
println!("{}", out.display());
eprintln!(
"{}x{} {}-bit{} {} KB rendered {rendered:.0} ms, {:.0} ms in all",
image.width(),
image.height(),
opts.depth,
if opts.depth == 8 { " dithered" } else { "" },
bytes.len() / 1024,
start.elapsed().as_secs_f64() * 1000.0
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use klad_core::doc::{Document, Layer};
#[test]
fn exports_land_next_to_the_bundle_with_layer_frame_and_scale_in_the_name() {
let dir = std::env::temp_dir().join(format!("draw-export-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let mut doc = Document::new(64, 32);
doc.layers.push(Layer::paint("l1", "ink", "c1"));
let bundle = Bundle::create(dir.join("art.klad/"), doc).unwrap();
assert_eq!(default_path(&bundle, None, 0, 1.0, None), dir.join("art.png"));
assert_eq!(
default_path(&bundle, Some("ink"), 0, 2.0, Some("Blue team")),
dir.join("[email protected]")
);
assert_eq!(
default_path(&bundle, None, 0, 0.5, Some("base")),
dir.join("[email protected]")
);
let out = dir.join("out/ink.png");
run(
&dir.join("art.klad"),
Export {
layer: Some("ink".into()),
frame: 0,
scale: 4.0,
depth: 16,
background: false,
references: false,
variant: None,
out: Some(out.clone()),
},
)
.unwrap();
let png = std::fs::read(&out).unwrap();
assert_eq!(
(png[24], u32::from_be_bytes(png[16..20].try_into().unwrap())),
(16, 256)
);
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn an_export_above_full_size_draws_the_strokes_again_at_that_size() {
let dir = std::env::temp_dir().join(format!("draw-export-sharp-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let mut doc = Document::new(120, 60);
doc.layers.push(Layer::paint("l1", "ink", "c1"));
let mut bundle = Bundle::create(dir.join("art.klad/"), doc).unwrap();
bundle
.apply(
&klad_core::ops::parse_lines(
r##"{"op":"stroke","layer":"l1","brush":"ink","size":6,"color":"#101010","path":"M10 20 L110 26","taper":[0,0]}"##,
)
.unwrap(),
)
.unwrap();
let brushes = BrushSet::for_bundle(&bundle).unwrap();
let edge = |detail: f32| {
let rasters = layers::load_at(&bundle, 0, &brushes, detail).unwrap();
let options = Options {
scale: 4.0,
background: false,
references: false,
detail,
};
let image = render(&bundle.doc, 0, &rasters, &Target::Frame, options).unwrap();
let frame = klad_render::read_rgba8(&image).unwrap();
(40..140)
.filter(|&y| (12..243).contains(&frame.pixel(240, y)[3]))
.count()
};
let (stretched, drawn) = (edge(1.0), edge(4.0));
assert!(
drawn <= 4 && stretched >= drawn + 3,
"soft pixels across the line: stretched {stretched}, drawn {drawn}"
);
assert_eq!(klad_render::export::detail_for(4.0), 4.0);
assert_eq!(klad_render::export::detail_for(0.5), 1.0);
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn a_pixel_drawing_exports_its_palette_colours_exactly_and_stays_hard_when_larger() {
use klad_core::bundle::Blank;
let dir = std::env::temp_dir().join(format!("draw-export-pixel-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let mut bundle = Bundle::blank(
dir.join("art.klad"),
&Blank {
width: 16,
height: 17,
pixel: true,
..Blank::default()
},
"cli",
)
.unwrap();
let layer = bundle.doc.layers[0].id.clone();
let colour = |i: u32| [i as u8, (255 - i) as u8, ((i * 7) % 256) as u8];
let lines: Vec<String> = (0..256u32)
.map(|i| {
let [r, g, b] = colour(i);
format!(
r##"{{"op":"pixel","layer":"{layer}","color":"#{r:02x}{g:02x}{b:02x}","cells":[[{},{}]]}}"##,
i % 16,
i / 16
)
})
.collect();
bundle
.apply(&klad_core::ops::parse_lines(&lines.join("\n")).unwrap())
.unwrap();
assert_eq!(bundle.doc.palette.len(), 256);
let brushes = BrushSet::for_bundle(&bundle).unwrap();
let pixels = |scale: f32| {
let detail = klad_render::export::detail_of(&bundle.doc, scale);
assert_eq!(detail, 1.0, "a pixel drawing is drawn at its real size, then enlarged");
let rasters = layers::load_at(&bundle, 0, &brushes, detail).unwrap();
let options = Options {
scale,
background: false,
references: false,
detail,
};
let image = render(&bundle.doc, 0, &rasters, &Target::Frame, options).unwrap();
(image.width() as usize, klad_render::export::dither8(&image).unwrap())
};
let (w, flat) = pixels(1.0);
(0..256usize).for_each(|i| {
let at = ((i / 16) * w + i % 16) * 4;
let [r, g, b] = colour(i as u32);
assert_eq!(flat[at..at + 4], [r, g, b, 255], "colour {i} at real size");
});
assert!(flat[16 * w * 4..].iter().all(|v| *v == 0), "the empty row stays empty");
let (w, big) = pixels(3.0);
(0..256usize).for_each(|i| {
let [r, g, b] = colour(i as u32);
(0..9).for_each(|k| {
let at = (((i / 16) * 3 + k / 3) * w + (i % 16) * 3 + k % 3) * 4;
assert_eq!(big[at..at + 4], [r, g, b, 255], "colour {i} at 3x, block pixel {k}");
});
});
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn a_pixel_drawing_is_enlarged_pixel_for_pixel() {
use klad_core::bundle::Blank;
let dir = std::env::temp_dir().join(format!("draw-export-pixel-sharp-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let mut bundle = Bundle::blank(
dir.join("art.klad"),
&Blank {
width: 6,
height: 4,
pixel: true,
..Blank::default()
},
"cli",
)
.unwrap();
let layer = bundle.doc.layers[0].id.clone();
bundle
.apply(
&klad_core::ops::parse_lines(&format!(
r##"{{"op":"pixel","layer":"{layer}","color":"#ef233c","cells":[[1,1],[3,2],[4,2]]}}"##
))
.unwrap(),
)
.unwrap();
let doc = &bundle.doc;
let brushes = BrushSet::for_bundle(&bundle).unwrap();
let rasters = layers::load_at(&bundle, 0, &brushes, 1.0).unwrap();
let shown = |scale: f32| {
let options = Options {
scale,
background: false,
references: false,
detail: klad_render::export::detail_of(doc, scale),
};
let image = render(doc, 0, &rasters, &Target::Frame, options).unwrap();
(image.width() as usize, klad_render::export::dither8(&image).unwrap())
};
let (_, real) = shown(1.0);
let (wide, big) = shown(5.0);
assert_eq!(wide, 30);
(0..20usize).for_each(|y| {
(0..30usize).for_each(|x| {
let from = ((y / 5) * 6 + x / 5) * 4;
let at = (y * 30 + x) * 4;
assert_eq!(
big[at..at + 4],
real[from..from + 4],
"pixel {x},{y} of the enlarged picture"
);
});
});
assert_eq!(real[(6 + 1) * 4..(6 + 1) * 4 + 4], [0xef, 0x23, 0x3c, 255]);
let whole = |scale: f32| klad_render::export::check_scale(doc, scale);
assert!(whole(64.0).is_ok() && whole(1.0).is_ok());
assert!(whole(1.5).is_err() && whole(0.5).is_err() && whole(65.0).is_err());
let mut wide_doc = doc.clone();
wide_doc.canvas.width = 1024;
assert_eq!(
klad_render::export::pixel_most(&wide_doc),
16.0,
"no side goes past 16384 px"
);
let mut painting = doc.clone();
painting.layers.iter_mut().for_each(|l| {
if let klad_core::doc::LayerContent::Paint { pixel, .. } = &mut l.content {
*pixel = false;
}
});
assert!(!painting.pixel_art());
assert!(klad_render::export::check_scale(&painting, 2.5).is_ok());
assert!(klad_render::export::check_scale(&painting, 9.0).is_err());
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn a_keyed_pixel_layer_moves_by_whole_pixels_and_stays_hard() {
use klad_core::bundle::Blank;
let dir = std::env::temp_dir().join(format!("draw-export-pixel-key-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let mut bundle = Bundle::blank(
dir.join("art.klad"),
&Blank {
width: 12,
height: 4,
pixel: true,
frames: 5,
..Blank::default()
},
"cli",
)
.unwrap();
let layer = bundle.doc.layers[0].id.clone();
bundle
.apply(
&klad_core::ops::parse_lines(&format!(
"{}\n{}\n{}",
format_args!(r##"{{"op":"pixel","layer":"{layer}","color":"#ef233c","cells":[[1,1],[2,1]]}}"##),
format_args!(r##"{{"op":"key","id":"{layer}","frame":0,"x":0}}"##),
format_args!(r##"{{"op":"key","id":"{layer}","frame":4,"x":6}}"##),
))
.unwrap(),
)
.unwrap();
let brushes = BrushSet::for_bundle(&bundle).unwrap();
let reds = |frame: u32| -> Vec<usize> {
let rasters = layers::load_at(&bundle, frame, &brushes, 1.0).unwrap();
let options = Options {
scale: 1.0,
background: false,
references: false,
detail: 1.0,
};
let image = render(&bundle.doc, frame, &rasters, &Target::Frame, options).unwrap();
let pixels = klad_render::export::dither8(&image).unwrap();
(0..12)
.filter(|x| {
let at = (12 + x) * 4;
let px = &pixels[at..at + 4];
assert!(
px == [0xef, 0x23, 0x3c, 255] || px == [0, 0, 0, 0],
"frame {frame}, pixel {x} is {px:?}: neither the colour nor empty"
);
px[3] == 255
})
.collect()
};
assert_eq!(reds(0), [1, 2]);
assert_eq!(reds(1), [3, 4], "a quarter of the way is 1.5 pixels: it lands on 2");
assert_eq!(reds(2), [4, 5]);
assert_eq!(reds(4), [7, 8]);
std::fs::remove_dir_all(&dir).unwrap();
}
}