The design language that makes your AI harness better at design.
JavaScript
//! JS: skill/scripts/lib/raster.mjs
//!
//! Small RGBA raster toolkit: create, crop, resize (area-averaging down,
//! bilinear up), composite, fills, rectangles, and a 5x7 bitmap-font label.
//! An image is `{ width, height, data }` with RGBA8 data.
use crate::jsnum::{round, u8w};
/// RGBA8 raster. `data.len() == width * height * 4`.
#[derive(Clone, Debug)]
pub struct Image {
pub width: usize,
pub height: usize,
pub data: Vec<u8>,
}
impl Image {
#[inline]
pub fn new(width: usize, height: usize) -> Self {
Image { width, height, data: vec![0u8; width * height * 4] }
}
}
/// JS: createImage(width, height, fill=[0,0,0,0]).
pub fn create_image(width: usize, height: usize, fill: [u8; 4]) -> Image {
let mut img = Image::new(width, height);
if fill[0] != 0 || fill[1] != 0 || fill[2] != 0 || fill[3] != 0 {
let mut i = 0;
while i < img.data.len() {
img.data[i] = fill[0];
img.data[i + 1] = fill[1];
img.data[i + 2] = fill[2];
img.data[i + 3] = fill[3];
i += 4;
}
}
img
}
pub struct Rect {
pub x: usize,
pub y: usize,
pub w: usize,
pub h: usize,
}
/// JS: clampRect. Rounds then clamps to image bounds; returns a non-negative box.
pub fn clamp_rect(img: &Image, x: f64, y: f64, w: f64, h: f64) -> Rect {
let iw = img.width as f64;
let ih = img.height as f64;
let x0 = 0f64.max(iw.min(round(x)));
let y0 = 0f64.max(ih.min(round(y)));
let x1 = x0.max(iw.min(round(x + w)));
let y1 = y0.max(ih.min(round(y + h)));
Rect { x: x0 as usize, y: y0 as usize, w: (x1 - x0) as usize, h: (y1 - y0) as usize }
}
/// JS: crop(img, x, y, w, h).
pub fn crop(img: &Image, x: f64, y: f64, w: f64, h: f64) -> Image {
let r = clamp_rect(img, x, y, w, h);
let mut out = Image::new(r.w.max(1), r.h.max(1));
for yy in 0..r.h {
let src = ((r.y + yy) * img.width + r.x) * 4;
let dst = yy * out.width * 4;
out.data[dst..dst + r.w * 4].copy_from_slice(&img.data[src..src + r.w * 4]);
}
out
}
/// JS: resize(img, width, height). Area averaging shrinking, bilinear growing.
pub fn resize(img: &Image, width: f64, height: f64) -> Image {
let width = (1f64.max(round(width))) as usize;
let height = (1f64.max(round(height))) as usize;
if width == img.width && height == img.height {
return img.clone();
}
let mut out = Image::new(width, height);
let sx = img.width as f64 / width as f64;
let sy = img.height as f64 / height as f64;
if sx >= 1.0 && sy >= 1.0 {
for y in 0..height {
let y0 = (y as f64 * sy).floor() as usize;
let y1 = (img.height).min((y0 + 1).max(((y + 1) as f64 * sy).floor() as usize));
for x in 0..width {
let x0 = (x as f64 * sx).floor() as usize;
let x1 = (img.width).min((x0 + 1).max(((x + 1) as f64 * sx).floor() as usize));
let (mut r, mut g, mut b, mut a) = (0f64, 0f64, 0f64, 0f64);
let mut n = 0f64;
for yy in y0..y1 {
let mut p = (yy * img.width + x0) * 4;
for _xx in x0..x1 {
r += img.data[p] as f64;
g += img.data[p + 1] as f64;
b += img.data[p + 2] as f64;
a += img.data[p + 3] as f64;
n += 1.0;
p += 4;
}
}
let o = (y * width + x) * 4;
out.data[o] = u8w(r / n);
out.data[o + 1] = u8w(g / n);
out.data[o + 2] = u8w(b / n);
out.data[o + 3] = u8w(a / n);
}
}
return out;
}
for y in 0..height {
let fy = ((img.height - 1) as f64).min((y as f64 + 0.5) * sy - 0.5);
let y0 = 0f64.max(fy.floor()) as usize;
let y1 = (img.height - 1).min(y0 + 1);
let wy = fy - y0 as f64;
for x in 0..width {
let fx = ((img.width - 1) as f64).min((x as f64 + 0.5) * sx - 0.5);
let x0 = 0f64.max(fx.floor()) as usize;
let x1 = (img.width - 1).min(x0 + 1);
let wx = fx - x0 as f64;
let o = (y * width + x) * 4;
for c in 0..4 {
let p00 = img.data[(y0 * img.width + x0) * 4 + c] as f64;
let p10 = img.data[(y0 * img.width + x1) * 4 + c] as f64;
let p01 = img.data[(y1 * img.width + x0) * 4 + c] as f64;
let p11 = img.data[(y1 * img.width + x1) * 4 + c] as f64;
let v = (p00 * (1.0 - wx) + p10 * wx) * (1.0 - wy)
+ (p01 * (1.0 - wx) + p11 * wx) * wy;
out.data[o + c] = u8w(v);
}
}
}
out
}
/// JS: fit(img, maxW, maxH, allowUpscale=false).
pub fn fit(img: &Image, max_w: f64, max_h: f64, allow_upscale: bool) -> Image {
let s = (max_w / img.width as f64).min(max_h / img.height as f64);
if s >= 1.0 && !allow_upscale {
return img.clone();
}
resize(img, img.width as f64 * s, img.height as f64 * s)
}
/// JS: blit(dst, src, x, y). Alpha-composite src onto dst.
pub fn blit(dst: &mut Image, src: &Image, x: f64, y: f64) {
let x = round(x) as i64;
let y = round(y) as i64;
for yy in 0..src.height as i64 {
let dy = y + yy;
if dy < 0 || dy >= dst.height as i64 {
continue;
}
for xx in 0..src.width as i64 {
let dx = x + xx;
if dx < 0 || dx >= dst.width as i64 {
continue;
}
let s = ((yy as usize) * src.width + xx as usize) * 4;
let d = ((dy as usize) * dst.width + dx as usize) * 4;
let a = src.data[s + 3] as f64 / 255.0;
if a >= 1.0 {
dst.data[d] = src.data[s];
dst.data[d + 1] = src.data[s + 1];
dst.data[d + 2] = src.data[s + 2];
dst.data[d + 3] = 255;
continue;
}
if a <= 0.0 {
continue;
}
let da = dst.data[d + 3] as f64 / 255.0;
let oa = a + da * (1.0 - a);
for c in 0..3 {
let v = (src.data[s + c] as f64 * a + dst.data[d + c] as f64 * da * (1.0 - a))
/ if oa != 0.0 { oa } else { 1.0 };
dst.data[d + c] = u8w(v);
}
dst.data[d + 3] = u8w(oa * 255.0);
}
}
}
/// JS: fillRect(img, x, y, w, h, rgba). rgba is [r,g,b] or [r,g,b,a].
pub fn fill_rect(img: &mut Image, x: f64, y: f64, w: f64, h: f64, rgba: [f64; 4]) {
let r = clamp_rect(img, x, y, w, h);
let a = rgba[3] / 255.0;
for yy in r.y..r.y + r.h {
for xx in r.x..r.x + r.w {
let o = (yy * img.width + xx) * 4;
if a >= 1.0 {
img.data[o] = u8w(rgba[0]);
img.data[o + 1] = u8w(rgba[1]);
img.data[o + 2] = u8w(rgba[2]);
img.data[o + 3] = 255;
} else {
for c in 0..3 {
img.data[o + c] = u8w(rgba[c] * a + img.data[o + c] as f64 * (1.0 - a));
}
img.data[o + 3] = u8w((img.data[o + 3] as f64).max(a * 255.0));
}
}
}
}
/// A [r,g,b] fill (alpha defaults to 255, as JS `rgba[3] ?? 255`).
#[inline]
pub fn rgb(c: [u8; 3]) -> [f64; 4] {
[c[0] as f64, c[1] as f64, c[2] as f64, 255.0]
}
/// JS: strokeRect(img, x, y, w, h, rgba, thickness=2).
pub fn stroke_rect(img: &mut Image, x: f64, y: f64, w: f64, h: f64, rgba: [f64; 4], thickness: f64) {
fill_rect(img, x, y, w, thickness, rgba);
fill_rect(img, x, y + h - thickness, w, thickness, rgba);
fill_rect(img, x, y, thickness, h, rgba);
fill_rect(img, x + w - thickness, y, thickness, h, rgba);
}
/// JS: textWidth(text, scale=2).
pub fn text_width(text: &str, scale: f64) -> f64 {
text.chars().count() as f64 * 6.0 * scale
}
/// JS: drawText(img, text, x, y, rgba, scale=2). Uppercases; unknown -> '?'.
pub fn draw_text(img: &mut Image, text: &str, x: f64, y: f64, rgba: [f64; 4], scale: f64) -> f64 {
let mut cx = round(x);
for ch in text.to_uppercase().chars() {
let g = glyph(ch);
for r in 0..7usize {
let row = g[r].as_bytes();
for c in 0..5usize {
if row[c] == b'1' {
fill_rect(img, cx + c as f64 * scale, y + r as f64 * scale, scale, scale, rgba);
}
}
}
cx += 6.0 * scale;
}
cx - x
}
pub struct LabelSize {
pub w: f64,
pub h: f64,
}
/// JS: drawLabel(img, text, x, y, {fg, bg, scale, pad}).
pub fn draw_label(
img: &mut Image,
text: &str,
x: f64,
y: f64,
fg: [f64; 4],
bg: [f64; 4],
scale: f64,
pad: f64,
) -> LabelSize {
let w = text_width(text, scale) + pad * 2.0;
let h = 7.0 * scale + pad * 2.0;
fill_rect(img, x, y, w, h, bg);
draw_text(img, text, x + pad, y + pad, fg, scale);
LabelSize { w, h }
}
/// The 5x7 bitmap font. Unknown chars fall back to '?', as in the JS.
fn glyph(ch: char) -> &'static [&'static str; 7] {
match ch {
'A' => &["01110", "10001", "10001", "11111", "10001", "10001", "10001"],
'B' => &["11110", "10001", "10001", "11110", "10001", "10001", "11110"],
'C' => &["01110", "10001", "10000", "10000", "10000", "10001", "01110"],
'D' => &["11110", "10001", "10001", "10001", "10001", "10001", "11110"],
'E' => &["11111", "10000", "10000", "11110", "10000", "10000", "11111"],
'F' => &["11111", "10000", "10000", "11110", "10000", "10000", "10000"],
'G' => &["01110", "10001", "10000", "10111", "10001", "10001", "01111"],
'H' => &["10001", "10001", "10001", "11111", "10001", "10001", "10001"],
'I' => &["11111", "00100", "00100", "00100", "00100", "00100", "11111"],
'J' => &["00111", "00010", "00010", "00010", "00010", "10010", "01100"],
'K' => &["10001", "10010", "10100", "11000", "10100", "10010", "10001"],
'L' => &["10000", "10000", "10000", "10000", "10000", "10000", "11111"],
'M' => &["10001", "11011", "10101", "10101", "10001", "10001", "10001"],
'N' => &["10001", "10001", "11001", "10101", "10011", "10001", "10001"],
'O' => &["01110", "10001", "10001", "10001", "10001", "10001", "01110"],
'P' => &["11110", "10001", "10001", "11110", "10000", "10000", "10000"],
'Q' => &["01110", "10001", "10001", "10001", "10101", "10010", "01101"],
'R' => &["11110", "10001", "10001", "11110", "10100", "10010", "10001"],
'S' => &["01111", "10000", "10000", "01110", "00001", "00001", "11110"],
'T' => &["11111", "00100", "00100", "00100", "00100", "00100", "00100"],
'U' => &["10001", "10001", "10001", "10001", "10001", "10001", "01110"],
'V' => &["10001", "10001", "10001", "10001", "10001", "01010", "00100"],
'W' => &["10001", "10001", "10001", "10101", "10101", "10101", "01010"],
'X' => &["10001", "10001", "01010", "00100", "01010", "10001", "10001"],
'Y' => &["10001", "10001", "01010", "00100", "00100", "00100", "00100"],
'Z' => &["11111", "00001", "00010", "00100", "01000", "10000", "11111"],
'0' => &["01110", "10001", "10011", "10101", "11001", "10001", "01110"],
'1' => &["00100", "01100", "00100", "00100", "00100", "00100", "01110"],
'2' => &["01110", "10001", "00001", "00010", "00100", "01000", "11111"],
'3' => &["11110", "00001", "00001", "01110", "00001", "00001", "11110"],
'4' => &["00010", "00110", "01010", "10010", "11111", "00010", "00010"],
'5' => &["11111", "10000", "11110", "00001", "00001", "10001", "01110"],
'6' => &["00110", "01000", "10000", "11110", "10001", "10001", "01110"],
'7' => &["11111", "00001", "00010", "00100", "01000", "01000", "01000"],
'8' => &["01110", "10001", "10001", "01110", "10001", "10001", "01110"],
'9' => &["01110", "10001", "10001", "01111", "00001", "00010", "01100"],
' ' => &["00000", "00000", "00000", "00000", "00000", "00000", "00000"],
'.' => &["00000", "00000", "00000", "00000", "00000", "01100", "01100"],
':' => &["00000", "01100", "01100", "00000", "01100", "01100", "00000"],
'-' => &["00000", "00000", "00000", "11111", "00000", "00000", "00000"],
'/' => &["00001", "00010", "00010", "00100", "01000", "01000", "10000"],
'%' => &["11001", "11010", "00010", "00100", "01000", "01011", "10011"],
'(' => &["00010", "00100", "01000", "01000", "01000", "00100", "00010"],
')' => &["01000", "00100", "00010", "00010", "00010", "00100", "01000"],
'#' => &["01010", "01010", "11111", "01010", "11111", "01010", "01010"],
'_' => &["00000", "00000", "00000", "00000", "00000", "00000", "11111"],
'?' => &["01110", "10001", "00001", "00010", "00100", "00000", "00100"],
'=' => &["00000", "00000", "11111", "00000", "11111", "00000", "00000"],
'+' => &["00000", "00100", "00100", "11111", "00100", "00100", "00000"],
',' => &["00000", "00000", "00000", "00000", "01100", "00100", "01000"],
_ => &["01110", "10001", "00001", "00010", "00100", "00000", "00100"], // '?'
}
}