2bc41aeb8602
inputs.rs
//! The harness inputs: ground-truth vector art (drawn in a 256-unit square, rasterised at several
//! sizes) and two continuous-tone images computed per pixel.
use kurbo::{Affine, BezPath, Circle, Ellipse, Point, RoundedRect, Shape};
use vectorcraft_trace::{Raster, TracedShape};
use crate::raster::{self, noise};
/// What an input tells about a trace.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Class {
/// Curved one-colour shapes: a circle, ellipses, a rounded badge with a hole, a letter.
Shape,
/// Straight-edged one-colour shapes: polygons, a star, a letter.
Poly,
/// Thin lines, 0.5 to 5 units wide.
Lines,
/// Straight-edged shapes and lines a degree or two off level and upright, as a scan or a
/// screenshot taken a little askew has them.
Askew,
/// Plain shapes apart from each other: a circle, an ellipse, rectangles, a regular polygon.
Plain,
/// Flat art in several colours, with regions that touch.
Flat,
/// Continuous tone: a gradient and a photo-like image.
Tone,
/// Linear gradients whose line and stops are known: one over the whole image, one in a disc.
Ramp,
}
pub const CLASSES: [Class; 8] = [Class::Shape, Class::Poly, Class::Lines, Class::Askew, Class::Plain, Class::Flat, Class::Tone, Class::Ramp];
impl Class {
pub fn name(self) -> &'static str {
match self {
Class::Shape => "curved shapes",
Class::Poly => "polygons",
Class::Lines => "thin lines",
Class::Askew => "askew shapes",
Class::Plain => "plain shapes",
Class::Flat => "flat colour art",
Class::Tone => "gradient, photo",
Class::Ramp => "linear gradients",
}
}
}
/// How an input is degraded after it is drawn.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Variant {
Clean,
/// One hard sample per pixel: no anti-aliasing (a GIF, a 1-bit scan).
Hard,
Blur,
Noise,
Scan,
}
pub const VARIANTS: [Variant; 5] = [Variant::Clean, Variant::Hard, Variant::Blur, Variant::Noise, Variant::Scan];
impl Variant {
pub fn name(self) -> &'static str {
match self {
Variant::Clean => "clean",
Variant::Hard => "aliased",
Variant::Blur => "blurred",
Variant::Noise => "noisy",
Variant::Scan => "scanned",
}
}
/// The colour a flat `c` of the clean image has in this variant (noise and shading aside).
pub fn color(self, c: [u8; 3]) -> [u8; 3] {
if self == Variant::Scan { raster::scan_color(c) } else { c }
}
}
/// A colour of a continuous-tone input at `(u, v)` in the unit square; `x`, `y` are the pixel.
type Tone = fn(f64, f64, u32, u32) -> [f64; 3];
pub struct Input {
pub name: &'static str,
pub class: Class,
/// The art, bottom first, in 256-unit coordinates. Shapes nest or abut, never partly overlap,
/// so every outline is a visible edge.
pub shapes: Vec<(BezPath, [u8; 3])>,
pub bg: [u8; 3],
/// Anchor points the art itself has.
pub anchors: usize,
/// Its sharp corners.
pub corners: Vec<Point>,
/// The plain shapes it is made of, where it is made of them.
pub plain: Vec<TracedShape>,
/// Its lines, where it is lines: each one's two ends and its width.
pub strokes: Vec<(Point, Point, f64)>,
/// The linear gradient it is, where it is one.
pub ramp: Option<Ramp>,
tone: Option<Tone>,
}
/// A linear gradient: its line (256-unit coordinates) and its stops along it (0 to 1).
#[derive(Clone)]
pub struct Ramp {
pub start: Point,
pub end: Point,
pub stops: Vec<(f64, [f64; 3])>,
}
impl Ramp {
pub fn color_at(&self, p: Point) -> [f64; 3] {
let d = self.end - self.start;
let t = ((p - self.start).dot(d) / d.hypot2()).clamp(0.0, 1.0);
let after = self.stops.iter().position(|s| s.0 >= t).unwrap().max(1);
let (a, b) = (self.stops[after - 1], self.stops[after]);
let k = (t - a.0) / (b.0 - a.0);
[0, 1, 2].map(|c| a.1[c] + (b.1[c] - a.1[c]) * k)
}
}
/// Dark blue to yellow across the whole image, 25° down from level.
fn two_stop_ramp() -> Ramp {
let dir = kurbo::Vec2::from_angle(25f64.to_radians());
let reach = kurbo::Vec2::new(128.0, 128.0).dot(dir);
let centre = Point::new(128.0, 128.0);
Ramp { start: centre - dir * reach, end: centre + dir * reach, stops: vec![(0.0, [24.0, 40.0, 150.0]), (1.0, [250.0, 215.0, 60.0])] }
}
/// Red through white to green across a disc, 110° from level.
fn three_stop_ramp() -> Ramp {
let dir = kurbo::Vec2::from_angle(110f64.to_radians());
let centre = Point::new(128.0, 128.0);
Ramp {
start: centre - dir * DISC,
end: centre + dir * DISC,
stops: vec![(0.0, [200.0, 30.0, 40.0]), (0.4, [245.0, 240.0, 230.0]), (1.0, [20.0, 120.0, 70.0])],
}
}
/// The radius of the disc the three-stop gradient fills.
const DISC: f64 = 90.0;
fn two_stop(u: f64, v: f64, _: u32, _: u32) -> [f64; 3] {
two_stop_ramp().color_at(Point::new(u * 256.0, v * 256.0))
}
fn three_stop(u: f64, v: f64, x: u32, _: u32) -> [f64; 3] {
let p = Point::new(u * 256.0, v * 256.0);
let inside = three_stop_ramp().color_at(p);
// The disc's edge, anti-aliased: how much of the pixel (256 / size units wide) is in it.
let pixel = 256.0 * u / (f64::from(x) + 0.5);
let cover = (0.5 + (DISC - p.distance(Point::new(128.0, 128.0))) / pixel).clamp(0.0, 1.0);
[0, 1, 2].map(|c| 255.0 + (inside[c] - 255.0) * cover)
}
const WHITE: [u8; 3] = [255, 255, 255];
const INK: [u8; 3] = [0, 0, 0];
fn poly(pts: &[(f64, f64)]) -> BezPath {
let mut p = BezPath::new();
for (i, &pt) in pts.iter().enumerate() {
if i == 0 { p.move_to(pt) } else { p.line_to(pt) }
}
p.close_path();
p
}
fn regular(cx: f64, cy: f64, r: f64, n: usize, rot: f64) -> Vec<(f64, f64)> {
(0..n)
.map(|i| {
let a = rot + std::f64::consts::TAU * i as f64 / n as f64;
(cx + r * a.cos(), cy + r * a.sin())
})
.collect()
}
fn points(pts: &[(f64, f64)]) -> Vec<Point> {
pts.iter().map(|&p| p.into()).collect()
}
/// `outer` with `holes` cut out (wound the other way: the rasteriser fills non-zero).
fn with_holes(outer: BezPath, holes: &[BezPath]) -> BezPath {
let mut p = outer;
for h in holes {
p.extend(h.reverse_subpaths());
}
p
}
/// Half of a disc, left or right of the vertical line through its centre (3 anchors).
fn half_disc(c: Point, r: f64, left: bool) -> BezPath {
let (s, k) = (if left { -r } else { r }, 0.552_284_75 * r);
let ks = if left { -k } else { k };
let mut p = BezPath::new();
p.move_to((c.x, c.y - r));
p.curve_to((c.x + ks, c.y - r), (c.x + s, c.y - k), (c.x + s, c.y));
p.curve_to((c.x + s, c.y + k), (c.x + ks, c.y + r), (c.x, c.y + r));
p.close_path();
p
}
fn gradient(u: f64, v: f64, _: u32, _: u32) -> [f64; 3] {
let glow = (-((u - 0.7).powi(2) + (v - 0.3).powi(2)) / 0.05).exp();
[40.0 + 190.0 * u + 25.0 * glow, 70.0 + 120.0 * v + 60.0 * glow, 200.0 - 150.0 * u * v + 40.0 * glow]
}
/// Photo-like: sky to ground across a soft horizon, soft-edged objects, shading, texture and
/// sensor noise.
fn photo(u: f64, v: f64, x: u32, y: u32) -> [f64; 3] {
let soft = |d: f64, width: f64| 1.0 / (1.0 + (-d / width).exp());
let mix = |a: [f64; 3], b: [f64; 3], t: f64| [0, 1, 2].map(|i| a[i] + (b[i] - a[i]) * t);
let sky = mix([70.0, 120.0, 200.0], [190.0, 210.0, 235.0], v / 0.55);
let ground = mix([95.0, 120.0, 60.0], [50.0, 70.0, 40.0], (v - 0.55) / 0.45);
let mut c = mix(sky, ground, soft(v - 0.55 - 0.03 * (u * 9.0).sin(), 0.006));
// Objects: (centre, radius, colour, edge softness).
let blobs = [
(0.28, 0.42, 0.17, [200.0, 80.0, 60.0], 0.004),
(0.66, 0.50, 0.22, [230.0, 190.0, 120.0], 0.012),
(0.80, 0.22, 0.08, [250.0, 240.0, 200.0], 0.02),
(0.45, 0.78, 0.12, [60.0, 50.0, 90.0], 0.003),
];
for (bx, by, r, col, edge) in blobs {
let d = ((u - bx).powi(2) + (v - by).powi(2)).sqrt();
// Shaded like a lit ball.
let lit = 1.0 - 0.45 * ((u - bx + 0.4 * r) / r).clamp(-1.0, 1.0).abs();
c = mix(c, col.map(|k| k * lit), soft(r - d, edge));
}
let texture = 6.0 * ((u * 61.0).sin() * (v * 47.0).cos()) + 4.0 * ((u + v) * 173.0).sin();
[0, 1, 2].map(|i| c[i] + texture + 5.0 * noise(x, y, 31 + i as u32))
}
/// Every input, in report order.
pub fn inputs() -> Vec<Input> {
let art = |name, class, shapes: Vec<(BezPath, [u8; 3])>, anchors, corners: Vec<Point>| Input {
name,
class,
shapes,
bg: WHITE,
anchors,
corners,
strokes: vec![],
plain: vec![],
ramp: None,
tone: None,
};
let tone = |name, f: Tone| Input {
name,
class: Class::Tone,
shapes: vec![],
bg: WHITE,
anchors: 0,
corners: vec![],
strokes: vec![],
plain: vec![],
ramp: None,
tone: Some(f),
};
let ink = |p: BezPath| vec![(p, INK)];
let mut ellipses = Ellipse::new((90.3, 99.6), (60.0, 30.0), 0.0).to_path(1e-3);
ellipses.extend(Ellipse::new((165.4, 190.2), (70.0, 25.0), 0.6).to_path(1e-3));
let badge = with_holes(RoundedRect::new(40.5, 56.5, 215.5, 199.5, 28.0).to_path(1e-3), &[Circle::new((128.2, 127.7), 36.0).to_path(1e-3)]);
// A "D": a straight stem joined smoothly to a bowl, with its counter.
let mut d = BezPath::new();
d.move_to((60.4, 60.3));
d.line_to((110.0, 60.3));
d.curve_to((170.0, 60.3), (200.0, 86.0), (200.0, 128.0));
d.curve_to((200.0, 170.0), (170.0, 195.7), (110.0, 195.7));
d.line_to((60.4, 195.7));
d.close_path();
let mut counter = BezPath::new();
counter.move_to((84.4, 84.3));
counter.line_to((108.0, 84.3));
counter.curve_to((150.0, 84.3), (172.0, 100.0), (172.0, 128.0));
counter.curve_to((172.0, 156.0), (150.0, 171.7), (108.0, 171.7));
counter.line_to((84.4, 171.7));
counter.close_path();
let d_corners = points(&[(60.4, 60.3), (60.4, 195.7), (84.4, 84.3), (84.4, 171.7)]);
let tri = [(40.3, 40.6), (120.7, 60.2), (60.4, 120.8)];
let square = regular(180.3, 80.6, 46.0, 4, 0.35);
let hexagon = regular(128.4, 185.3, 50.0, 6, 0.17);
let mut polygons = poly(&tri);
polygons.extend(poly(&square));
polygons.extend(poly(&hexagon));
let star: Vec<(f64, f64)> = (0..10)
.map(|i| {
let (a, r) = (-1.4 + std::f64::consts::PI * i as f64 / 5.0, if i % 2 == 0 { 100.0 } else { 40.0 });
(128.3 + r * a.cos(), 128.6 + r * a.sin())
})
.collect();
let a_outer = [(128.2, 40.4), (210.3, 216.5), (176.0, 216.5), (160.0, 176.4), (96.0, 176.4), (80.0, 216.5), (46.1, 216.5)];
let a_counter = [(128.2, 96.0), (148.3, 150.4), (108.1, 150.4)];
// Five lines 200 long, 0.5 to 5 wide, at small angles to the pixel grid.
let mut lines = BezPath::new();
let mut strokes = vec![];
for (i, (deg, width)) in [(0.0f64, 0.5), (6.0, 1.0), (-9.0, 2.0), (12.0, 3.0), (-4.0, 5.0)].into_iter().enumerate() {
let (hw, hl) = (width / 2.0, 100.0);
let mut strip = poly(&[(-hl, -hw), (hl, -hw), (hl, hw), (-hl, hw)]);
let place = Affine::translate((128.3, 36.4 + 46.0 * i as f64)) * Affine::rotate(deg.to_radians());
strip.apply_affine(place);
strokes.push((place * Point::new(-hl, 0.0), place * Point::new(hl, 0.0), width));
lines.extend(strip);
}
// A rectangle 1.5° off level, a plus sign 1° off the other way, and two lines 1° and 2° off.
let turned = |p: BezPath, deg: f64, about: (f64, f64)| Affine::rotate_about(deg.to_radians(), Point::new(about.0, about.1)) * p;
let plus = [
(150.0, 150.0),
(170.0, 150.0),
(170.0, 180.0),
(200.0, 180.0),
(200.0, 200.0),
(170.0, 200.0),
(170.0, 230.0),
(150.0, 230.0),
(150.0, 200.0),
(120.0, 200.0),
(120.0, 180.0),
(150.0, 180.0),
];
let mut askew = turned(poly(&[(40.3, 30.6), (200.7, 30.6), (200.7, 110.4), (40.3, 110.4)]), 1.5, (120.0, 70.0));
askew.extend(turned(poly(&plus), -1.0, (160.0, 190.0)));
askew.extend(turned(poly(&[(20.0, 150.3), (100.0, 150.3), (100.0, 153.3), (20.0, 153.3)]), 1.0, (60.0, 152.0)));
askew.extend(turned(poly(&[(60.4, 170.0), (62.4, 170.0), (62.4, 240.0), (60.4, 240.0)]), 2.0, (61.0, 205.0)));
// A circle, a rectangle, a square, a rounded rectangle, an ellipse and a hexagon.
let plain = vec![
TracedShape::Ellipse { center: Point::new(50.3, 50.6), rx: 30.0, ry: 30.0, rotation: 0.0 },
TracedShape::Rectangle { center: Point::new(170.4, 50.3), width: 110.0, height: 60.0, radius: 0.0, rotation: 0.0 },
TracedShape::Rectangle { center: Point::new(50.6, 140.4), width: 60.0, height: 60.0, radius: 0.0, rotation: 0.0 },
TracedShape::Rectangle { center: Point::new(170.3, 140.6), width: 100.0, height: 50.0, radius: 12.0, rotation: 0.0 },
TracedShape::Ellipse { center: Point::new(70.4, 220.3), rx: 45.0, ry: 18.0, rotation: 0.0 },
TracedShape::Polygon { center: Point::new(190.6, 215.4), radius: 30.0, sides: 6, rotation: 10.0 },
];
let mut plain_art = BezPath::new();
for shape in &plain {
plain_art.extend(shape.path().to_bezpath());
}
let centre = Point::new(128.4, 128.3);
let touching = vec![(half_disc(centre, 90.0, true), [200, 40, 50]), (half_disc(centre, 90.0, false), [30, 90, 200])];
let bar = [(60.3, 180.4), (196.6, 180.4), (196.6, 206.7), (60.3, 206.7)];
let multicolor = vec![
(RoundedRect::new(30.4, 30.6, 226.3, 226.5, 30.0).to_path(1e-3), [20, 40, 90]),
(Circle::new((128.3, 104.6), 50.0).to_path(1e-3), [250, 200, 40]),
(Circle::new((128.3, 104.6), 20.0).to_path(1e-3), [240, 110, 30]),
(poly(&bar), [40, 160, 90]),
];
let mut all = vec![
art("circle", Class::Shape, ink(Circle::new((128.3, 127.6), 80.4).to_path(1e-3)), 4, vec![]),
art("ellipses", Class::Shape, ink(ellipses), 8, vec![]),
art("badge with a hole", Class::Shape, ink(badge), 12, vec![]),
art("letter D", Class::Shape, ink(with_holes(d, &[counter])), 10, d_corners),
art("polygons", Class::Poly, ink(polygons), 13, points(&[&tri[..], &square, &hexagon].concat())),
art("star", Class::Poly, ink(poly(&star)), 10, points(&star)),
art("letter A", Class::Poly, ink(with_holes(poly(&a_outer), &[poly(&a_counter)])), 10, points(&[&a_outer[..], &a_counter].concat())),
art("lines", Class::Lines, ink(lines), 20, vec![]),
art("askew shapes and lines", Class::Askew, ink(askew), 24, vec![]),
art("plain shapes", Class::Plain, ink(plain_art), 30, vec![]),
art("two touching halves", Class::Flat, touching, 6, vec![(centre.x, centre.y - 90.0).into(), (centre.x, centre.y + 90.0).into()]),
art("four-colour badge", Class::Flat, multicolor, 20, points(&bar)),
tone("gradient", gradient),
tone("photo-like", photo),
Input { class: Class::Ramp, ramp: Some(two_stop_ramp()), ..tone("two-stop gradient", two_stop) },
Input { class: Class::Ramp, ramp: Some(three_stop_ramp()), ..tone("three-stop gradient in a disc", three_stop) },
];
if let Some(input) = all.iter_mut().find(|i| i.name == "plain shapes") {
input.plain = plain;
}
if let Some(input) = all.iter_mut().find(|i| i.name == "lines") {
input.strokes = strokes;
}
all
}
impl Input {
/// The input drawn `size` pixels square as `variant`.
pub fn draw(&self, size: u32, variant: Variant) -> Raster {
// Art is drawn anti-aliased from 6 × 6 samples per pixel; the aliased variant takes one.
let img = self.draw_sampled(size, if variant == Variant::Hard { 1 } else { 6 });
match variant {
Variant::Clean | Variant::Hard => img,
Variant::Blur => raster::blur(&img),
Variant::Noise => raster::noisy(&img),
Variant::Scan => raster::scanned(&img),
}
}
fn draw_sampled(&self, size: u32, samples: usize) -> Raster {
let n = size as usize;
match self.tone {
Some(f) => Raster::from_fn(size, size, |x, y| {
let c = f((f64::from(x) + 0.5) / f64::from(size), (f64::from(y) + 0.5) / f64::from(size), x, y);
[c[0].round().clamp(0.0, 255.0) as u8, c[1].round().clamp(0.0, 255.0) as u8, c[2].round().clamp(0.0, 255.0) as u8, 255]
}),
None => raster::render_truth(&self.scaled(size), self.bg, n, n, samples),
}
}
/// The art in the pixel coordinates of a `size`-pixel drawing.
pub fn scaled(&self, size: u32) -> Vec<(BezPath, [u8; 3])> {
let k = Affine::scale(f64::from(size) / 256.0);
self.shapes.iter().map(|(p, c)| (k * p.clone(), *c)).collect()
}
/// Its lines in the pixel coordinates of a `size`-pixel drawing.
pub fn scaled_strokes(&self, size: u32) -> Vec<(Point, Point, f64)> {
let k = f64::from(size) / 256.0;
self.strokes.iter().map(|(a, b, w)| ((a.to_vec2() * k).to_point(), (b.to_vec2() * k).to_point(), w * k)).collect()
}
/// Its plain shapes' outlines in the pixel coordinates of a `size`-pixel drawing.
pub fn scaled_plain(&self, size: u32) -> Vec<BezPath> {
let k = Affine::scale(f64::from(size) / 256.0);
self.plain.iter().map(|s| k * s.path().to_bezpath()).collect()
}
pub fn scaled_corners(&self, size: u32) -> Vec<Point> {
self.corners.iter().map(|p| (p.to_vec2() * (f64::from(size) / 256.0)).to_point()).collect()
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.