Part of gap 2: Effect › Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize)
Four Photoshop-style raster effects on the pixel-filter pipeline (vectorcraft_effects::pixel::pixelate), under a new Effect › Pixelate submenu between Blur and Sharpen in the Raster Effects section: - Color Halftone (maxRadius 4..127, default 8; channel1..channel4 screen angles -360..360, defaults 108/162/90/45): each colour channel is screened at its angle in square cells sized so a dot of Max. Radius fills one; each cell's dot covers the share of the cell that is the channel's coverage-weighted mean there (white stays white, black black). RGB documents screen R, G, B (channels 1 to 3); CMYK documents screen C, M, Y, K inks (channels 1 to 4), also when they are drawn ink plane by ink plane (the K plane uses channel 4). - Crystallize (cellSize 3..300, default 10): every pixel takes the colour at the nearest of one jittered point per cell (exact Voronoi over a 5 x 5 neighbourhood, pruned by distance). - Mezzotint (type: Fine/Medium/Grainy/Coarse Dots, Short/Medium/Long Lines, Short/Medium/Long Strokes; default Fine Dots; a dropdown in the dialog): each channel is turned fully on or off against its own random threshold pattern, so the object becomes pure colours. - Pointillize (cellSize 3..300, default 5): one dot of random size per cell at a jittered point, coloured by the softened object there and as opaque as the object at its centre, stacked in random order over a white canvas where the object is. Lengths are in points (Scale Strokes & Effects scales them) and every pattern lies in document space around the object's centre, so the result is the same at any zoom or raster resolution, moves with the object, and is identical on every redraw (hash noise of the pattern's cell indices, no state). Work per pixel is bounded whatever the parameters, which are clamped to their ranges and finite-checked; the halftone's cell grid is capped by the raster's size and a screen finer than 3 pixels leaves the image as it is (its average). PixelSpace gains `channels` so the renderer tells the filters what the channels hold. Catalogue rows with parameter docs, outsets and reaches for cropping, menu entries, dialog labels (Max. Radius, Channel 1-4, Cell Size), the Mezzotint Type dropdown, translations, and tests: parameters and clamping, tone and coverage, CMYK inks, polygon crystals, pure-colour mezzotints with ten distinct patterns, dots on a white canvas, the same result at twice the resolution and when moved, the canvas, PDF and SVG through the engine, the command sweep with junk parameters, the dialogs and the menu. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
bflatastic
parent
2d6014583a
commit
9bad0a24ca
15
ROADMAP.md
15
ROADMAP.md
File diff suppressed because one or more lines are too long
|
|
@ -6,7 +6,8 @@
|
|||
//! - **Geometry effects** (Distort & Transform, Path, Convert to Shape, Round Corners, Scribble,
|
||||
//! Warp) rewrite a path: [`apply_geometry`] evaluates them in stack order.
|
||||
//! - **Raster effects** (Drop Shadow, Inner/Outer Glow, Feather, Gaussian Blur, and the
|
||||
//! Photoshop-style filters of [`pixel`]: Radial Blur, Smart Blur, Unsharp Mask and Glowing Edges) are described by
|
||||
//! Photoshop-style filters of [`pixel`]: Radial Blur, Smart Blur, Color Halftone, Crystallize, Mezzotint, Pointillize,
|
||||
//! Unsharp Mask and Glowing Edges) are described by
|
||||
//! [`raster_effects`] and painted by the renderer; [`outset`] says how far they reach beyond
|
||||
//! the geometry.
|
||||
//! - **Stroke geometry** ([`stroke`]): arrowheads, dash patterns and width profiles, shared by the
|
||||
|
|
@ -27,7 +28,8 @@
|
|||
//! renderer and the exporters.
|
||||
//!
|
||||
//! Everything is deterministic: "random" effects (Roughen, Tweak, Scribble) use a seeded hash
|
||||
//! noise (`seed` parameter, default 0).
|
||||
//! noise (`seed` parameter, default 0); the random Pixelate filters hash their pattern's cells,
|
||||
//! anchored at the object's centre.
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
mod adjust;
|
||||
|
|
@ -126,6 +128,8 @@ fn lengths_of(id: &str) -> Lengths {
|
|||
"stylize.dropShadow" => always(&["x", "y", "blur"]),
|
||||
"stylize.innerGlow" | "stylize.outerGlow" => always(&["blur"]),
|
||||
"stylize.glowingEdges" => always(&["edgeWidth", "smoothness"]),
|
||||
"pixelate.colorHalftone" => always(&["maxRadius"]),
|
||||
"pixelate.crystallize" | "pixelate.pointillize" => always(&["cellSize"]),
|
||||
_ => Lengths::default(),
|
||||
}
|
||||
}
|
||||
|
|
@ -139,6 +143,7 @@ const STYLIZE: &[&str] = &["Effect", "Stylize"];
|
|||
const WARP: &[&str] = &["Effect", "Warp"];
|
||||
const BLUR: &[&str] = &["Effect", "Blur"];
|
||||
const SHARPEN: &[&str] = &["Effect", "Sharpen"];
|
||||
const PIXELATE: &[&str] = &["Effect", "Pixelate"];
|
||||
const PATHFINDER: &[&str] = &["Effect", "Pathfinder"];
|
||||
const PLUGINS: &[&str] = &["Effect", "Plug-ins"];
|
||||
const ADJUST: &[&str] = &["Effect", "Color Adjustments"];
|
||||
|
|
@ -298,6 +303,34 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
|
|||
"{edgeWidth: pt 1..14 (2), edgeBrightness: 0..20 (6), smoothness: pt 1..15 (5)} finds alpha-weighted Sobel edges and draws bright coloured outlines on black",
|
||||
json!({"edgeWidth": 2.0, "edgeBrightness": 6.0, "smoothness": 5.0}),
|
||||
),
|
||||
r(
|
||||
"pixelate.colorHalftone",
|
||||
"Color Halftone…",
|
||||
PIXELATE,
|
||||
"{maxRadius: pt 4..127 (8; the radius of a dot at full strength, which fills its square cell), channel1: screen angle deg -360..360 (108), channel2: deg (162), channel3: deg (90), channel4: deg (45)} screens each colour channel (red, green, blue: channels 1 to 3; in CMYK documents cyan, magenta, yellow, black: 1 to 4) at its angle into dots whose area follows the channel's mean over their cell",
|
||||
json!({"maxRadius": 8.0, "channel1": 108.0, "channel2": 162.0, "channel3": 90.0, "channel4": 45.0}),
|
||||
),
|
||||
r(
|
||||
"pixelate.crystallize",
|
||||
"Crystallize…",
|
||||
PIXELATE,
|
||||
"{cellSize: pt 3..300 (10)} redraws the object as polygon crystals of solid colour around random points about cellSize apart",
|
||||
json!({"cellSize": 10.0}),
|
||||
),
|
||||
r(
|
||||
"pixelate.mezzotint",
|
||||
"Mezzotint…",
|
||||
PIXELATE,
|
||||
"{type: \"fineDots\"|\"mediumDots\"|\"grainyDots\"|\"coarseDots\"|\"shortLines\"|\"mediumLines\"|\"longLines\"|\"shortStrokes\"|\"mediumStrokes\"|\"longStrokes\" (\"fineDots\")} turns each colour channel fully on or off against a random pattern of dots, lines or strokes: fully saturated colours",
|
||||
json!({"type": "fineDots"}),
|
||||
),
|
||||
r(
|
||||
"pixelate.pointillize",
|
||||
"Pointillize…",
|
||||
PIXELATE,
|
||||
"{cellSize: pt 3..300 (5)} redraws the object as randomly placed dots of its colours on a white canvas",
|
||||
json!({"cellSize": 5.0}),
|
||||
),
|
||||
];
|
||||
v.extend([
|
||||
g(
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
//! Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Sharpen › Unsharp
|
||||
//! Mask, and Stylize › Glowing Edges): filters over premultiplied RGBA8 pixels.
|
||||
//! Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate › Color
|
||||
//! Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, and Stylize › Glowing
|
||||
//! Edges): filters over premultiplied RGBA8 pixels.
|
||||
//!
|
||||
//! - Every distance is in document units (points) and becomes pixels through the raster's
|
||||
//! [`PixelSpace::px`], so an effect looks the same at any zoom and at any Document Raster Effects
|
||||
|
|
@ -10,6 +11,7 @@
|
|||
|
||||
mod blur;
|
||||
mod edges;
|
||||
mod pixelate;
|
||||
mod sharpen;
|
||||
|
||||
use serde_json::Value;
|
||||
|
|
@ -17,8 +19,19 @@ use vectorcraft_geom::{Affine, Point, Rect};
|
|||
|
||||
use crate::util::{num, text};
|
||||
|
||||
pub use pixelate::{MEZZOTINT_TYPES, Mezzotint};
|
||||
|
||||
/// The Photoshop-style effect ids (all raster effects, see [`crate::is_raster`]).
|
||||
pub const PIXEL_EFFECTS: [&str; 4] = ["blur.radial", "blur.smart", "sharpen.unsharpMask", "stylize.glowingEdges"];
|
||||
pub const PIXEL_EFFECTS: [&str; 8] = [
|
||||
"blur.radial",
|
||||
"blur.smart",
|
||||
"pixelate.colorHalftone",
|
||||
"pixelate.crystallize",
|
||||
"pixelate.mezzotint",
|
||||
"pixelate.pointillize",
|
||||
"sharpen.unsharpMask",
|
||||
"stylize.glowingEdges",
|
||||
];
|
||||
|
||||
/// A Photoshop-style raster effect with its parameters read and clamped to their ranges. Lengths
|
||||
/// are in document units.
|
||||
|
|
@ -36,6 +49,31 @@ pub enum PixelFx {
|
|||
UnsharpMask { amount: f64, radius: f64, threshold: f64 },
|
||||
/// Stylize › Glowing Edges: bright coloured Sobel outlines on black.
|
||||
GlowingEdges { width: f64, brightness: f64, smoothness: f64 },
|
||||
/// Pixelate › Color Halftone: each colour channel screened at its angle (`angles`° of channels
|
||||
/// 1 to 4) into dots of up to `max_radius`, whose area follows the channel's strength.
|
||||
ColorHalftone { max_radius: f64, angles: [f64; 4] },
|
||||
/// Pixelate › Crystallize: polygons of solid colour around random points about `cell` apart.
|
||||
Crystallize { cell: f64 },
|
||||
/// Pixelate › Mezzotint: every colour channel fully on or off against a random pattern.
|
||||
Mezzotint { kind: Mezzotint },
|
||||
/// Pixelate › Pointillize: random dots about `cell` across of the object's colours on a white
|
||||
/// canvas.
|
||||
Pointillize { cell: f64 },
|
||||
}
|
||||
|
||||
/// What a raster's colour channels hold, for the filters that treat them apart (Color Halftone
|
||||
/// screens each channel, Mezzotint thresholds each).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub enum Channels {
|
||||
/// Red, green and blue light.
|
||||
#[default]
|
||||
Rgb,
|
||||
/// Screen colours of a CMYK document: treated as its cyan, magenta, yellow and black inks.
|
||||
Cmyk,
|
||||
/// The complemented C, M and Y inks (a CMYK document drawn ink plane by ink plane).
|
||||
CmyPlane,
|
||||
/// The complemented K ink, as a grey.
|
||||
KPlane,
|
||||
}
|
||||
|
||||
/// Where a raster's pixels lie in the document.
|
||||
|
|
@ -46,8 +84,11 @@ pub struct PixelSpace {
|
|||
pub to_doc: Affine,
|
||||
/// The size of a pixel in document units.
|
||||
pub px: f64,
|
||||
/// The object's centre (document coordinates): where Radial Blur blurs around.
|
||||
/// The object's centre (document coordinates): where Radial Blur blurs around, and where the
|
||||
/// Pixelate filters' patterns are anchored (so they move with the object).
|
||||
pub center: Point,
|
||||
/// What the colour channels hold.
|
||||
pub channels: Channels,
|
||||
}
|
||||
|
||||
/// Effect `id`'s parameters `p` (defaults merged in) as a [`PixelFx`]; `None` for other effects.
|
||||
|
|
@ -77,6 +118,14 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option<PixelFx> {
|
|||
brightness: num(p, "edgeBrightness", 6.0).clamp(0.0, 20.0),
|
||||
smoothness: num(p, "smoothness", 5.0).clamp(1.0, 15.0),
|
||||
},
|
||||
"pixelate.colorHalftone" => PixelFx::ColorHalftone {
|
||||
max_radius: num(p, "maxRadius", 8.0).clamp(4.0, 127.0),
|
||||
angles: [("channel1", 108.0), ("channel2", 162.0), ("channel3", 90.0), ("channel4", 45.0)]
|
||||
.map(|(k, d)| num(p, k, d).clamp(-360.0, 360.0)),
|
||||
},
|
||||
"pixelate.crystallize" => PixelFx::Crystallize { cell: num(p, "cellSize", 10.0).clamp(3.0, 300.0) },
|
||||
"pixelate.mezzotint" => PixelFx::Mezzotint { kind: Mezzotint::parse(text(p, "type", "fineDots")) },
|
||||
"pixelate.pointillize" => PixelFx::Pointillize { cell: num(p, "cellSize", 5.0).clamp(3.0, 300.0) },
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
|
@ -94,6 +143,9 @@ impl PixelFx {
|
|||
PixelFx::SmartBlur { radius, .. } => radius,
|
||||
PixelFx::UnsharpMask { .. } => 0.0,
|
||||
PixelFx::GlowingEdges { width, smoothness, .. } => width.max(smoothness * 3.0),
|
||||
PixelFx::ColorHalftone { .. } | PixelFx::Mezzotint { .. } => 0.0,
|
||||
// A crystal's or dot's point inside the object reaches out by up to its cell.
|
||||
PixelFx::Crystallize { cell } | PixelFx::Pointillize { cell } => 1.5 * cell,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -105,6 +157,12 @@ impl PixelFx {
|
|||
PixelFx::SmartBlur { radius, .. } => Some(radius),
|
||||
PixelFx::UnsharpMask { radius, .. } => Some(3.0 * radius),
|
||||
PixelFx::GlowingEdges { width, smoothness, .. } => Some(width.max(smoothness * 3.0)),
|
||||
// The cells around the pixel's, and the cells around theirs.
|
||||
PixelFx::ColorHalftone { max_radius, .. } => Some(3.0 * std::f64::consts::SQRT_2 * max_radius),
|
||||
PixelFx::Crystallize { cell } => Some(1.5 * cell),
|
||||
PixelFx::Mezzotint { .. } => Some(0.0),
|
||||
// The dots' points, and the softened colour around them.
|
||||
PixelFx::Pointillize { cell } => Some(2.5 * cell),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -118,6 +176,10 @@ impl PixelFx {
|
|||
PixelFx::SmartBlur { radius, threshold, samples } => blur::smart(px, w, h, to_px(radius), threshold, samples),
|
||||
PixelFx::UnsharpMask { amount, radius, threshold } => sharpen::unsharp(px, w, h, amount, to_px(radius), threshold),
|
||||
PixelFx::GlowingEdges { width, brightness, smoothness } => edges::glow(px, w, h, to_px(width), brightness, to_px(smoothness)),
|
||||
PixelFx::ColorHalftone { max_radius, angles } => pixelate::color_halftone(px, w, h, space, max_radius, angles),
|
||||
PixelFx::Crystallize { cell } => pixelate::crystallize(px, w, h, space, cell),
|
||||
PixelFx::Mezzotint { kind } => pixelate::mezzotint(px, w, h, space, kind),
|
||||
PixelFx::Pointillize { cell } => pixelate::pointillize(px, w, h, space, cell),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,531 @@
|
|||
//! Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize.
|
||||
//!
|
||||
//! Their patterns (screens, crystals, grains and dots) lie in document space around the object's
|
||||
//! centre, so they keep their size at any zoom or resolution and move with the object. The random
|
||||
//! ones hash the pattern's cell indices: every redraw gives the same result.
|
||||
|
||||
use std::sync::OnceLock;
|
||||
|
||||
use vectorcraft_geom::{Affine, Point};
|
||||
|
||||
use super::{Channels, PixelSpace, gaussian, to16};
|
||||
use crate::util::noise;
|
||||
|
||||
/// Mezzotint's patterns, in its Type menu's order: (label, parameter value).
|
||||
pub const MEZZOTINT_TYPES: [(&str, &str); 10] = [
|
||||
("Fine Dots", "fineDots"),
|
||||
("Medium Dots", "mediumDots"),
|
||||
("Grainy Dots", "grainyDots"),
|
||||
("Coarse Dots", "coarseDots"),
|
||||
("Short Lines", "shortLines"),
|
||||
("Medium Lines", "mediumLines"),
|
||||
("Long Lines", "longLines"),
|
||||
("Short Strokes", "shortStrokes"),
|
||||
("Medium Strokes", "mediumStrokes"),
|
||||
("Long Strokes", "longStrokes"),
|
||||
];
|
||||
|
||||
/// A Mezzotint pattern ([`MEZZOTINT_TYPES`]): random dots, or horizontal lines or strokes.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Mezzotint {
|
||||
/// Dots `size` points across (smooth blobs when `smooth`), plus fine grain when `grainy`.
|
||||
Dots { size: u8, smooth: bool, grainy: bool },
|
||||
/// Horizontal streaks about `length` points long and `width` points thick.
|
||||
Lines { length: u8, width: u8 },
|
||||
}
|
||||
|
||||
/// The patterns of [`MEZZOTINT_TYPES`], in the same order.
|
||||
const MEZZOTINT_KINDS: [Mezzotint; 10] = {
|
||||
const fn dots(size: u8, smooth: bool, grainy: bool) -> Mezzotint {
|
||||
Mezzotint::Dots { size, smooth, grainy }
|
||||
}
|
||||
const fn lines(length: u8, width: u8) -> Mezzotint {
|
||||
Mezzotint::Lines { length, width }
|
||||
}
|
||||
[
|
||||
dots(1, false, false),
|
||||
dots(2, true, false),
|
||||
dots(3, true, true),
|
||||
dots(4, true, false),
|
||||
lines(4, 1),
|
||||
lines(8, 1),
|
||||
lines(16, 1),
|
||||
lines(6, 2),
|
||||
lines(12, 2),
|
||||
lines(24, 2),
|
||||
]
|
||||
};
|
||||
|
||||
impl Mezzotint {
|
||||
/// Fine Dots, the first type.
|
||||
pub const FINE_DOTS: Mezzotint = Mezzotint::Dots { size: 1, smooth: false, grainy: false };
|
||||
|
||||
/// The pattern of Type `value` (a [`MEZZOTINT_TYPES`] value, any case); Fine Dots otherwise.
|
||||
pub fn parse(value: &str) -> Self {
|
||||
MEZZOTINT_TYPES.iter().zip(MEZZOTINT_KINDS).find(|((_, v), _)| v.eq_ignore_ascii_case(value)).map_or(Self::FINE_DOTS, |(_, kind)| kind)
|
||||
}
|
||||
}
|
||||
|
||||
/// Seeds of the filters' noise ("PIXELATE" and a filter number).
|
||||
const SEED: u64 = 0x5049_5845_4C41_5445;
|
||||
|
||||
/// A random number in [0, 1) for cell (`i`, `j`) of pattern `salt`; `k` picks one of several.
|
||||
fn rand(salt: u64, i: i64, j: i64, k: u64) -> f64 {
|
||||
0.5 * (noise(SEED ^ salt, i as u64, j as u64, k) + 1.0)
|
||||
}
|
||||
|
||||
/// The cell holding coordinate `v` (in cells); `None` far beyond any raster (or not finite).
|
||||
fn cell(v: f64) -> Option<i64> {
|
||||
let f = v.floor();
|
||||
(f.abs() < 1e15).then_some(f as i64)
|
||||
}
|
||||
|
||||
/// Where a raster's pixels lie relative to the object's centre, in document units.
|
||||
struct Place {
|
||||
/// Pixel coordinates → document coordinates relative to the centre.
|
||||
to_rel: Affine,
|
||||
/// The other way.
|
||||
to_px: Affine,
|
||||
/// A pixel's size in document units.
|
||||
px: f64,
|
||||
w: usize,
|
||||
h: usize,
|
||||
}
|
||||
|
||||
impl Place {
|
||||
fn new(space: &PixelSpace, w: usize, h: usize) -> Option<Self> {
|
||||
let to_rel = Affine::translate(-space.center.to_vec2()) * space.to_doc;
|
||||
let to_px = to_rel.inverse();
|
||||
(to_rel.is_finite() && to_px.is_finite() && space.px.is_finite() && space.px > 0.0).then_some(Self { to_rel, to_px, px: space.px, w, h })
|
||||
}
|
||||
|
||||
/// The centre of pixel (`x`, `y`).
|
||||
fn at(&self, x: usize, y: usize) -> Point {
|
||||
self.to_rel * Point::new(x as f64 + 0.5, y as f64 + 0.5)
|
||||
}
|
||||
|
||||
/// The index of the pixel holding point `p`; `None` outside the raster.
|
||||
fn index(&self, p: Point) -> Option<usize> {
|
||||
let q = self.to_px * p;
|
||||
(q.x >= 0.0 && q.y >= 0.0 && q.x < self.w as f64 && q.y < self.h as f64).then(|| q.y as usize * self.w + q.x as usize)
|
||||
}
|
||||
|
||||
/// Run `f(x, y, pixel)` on every pixel.
|
||||
fn each(&self, px: &mut [[u8; 4]], mut f: impl FnMut(usize, usize, &mut [u8; 4])) {
|
||||
for (y, row) in px.chunks_exact_mut(self.w.max(1)).enumerate().take(self.h) {
|
||||
for (x, p) in row.iter_mut().enumerate() {
|
||||
f(x, y, p);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The cells around a pixel's cell, in the order they can hold its nearest random point: the
|
||||
/// cell itself, its 8 neighbours, then the ring around them.
|
||||
const AROUND: [(i64, i64); 25] = [
|
||||
(0, 0),
|
||||
(-1, 0),
|
||||
(1, 0),
|
||||
(0, -1),
|
||||
(0, 1),
|
||||
(-1, -1),
|
||||
(1, -1),
|
||||
(-1, 1),
|
||||
(1, 1),
|
||||
(-2, -2),
|
||||
(-1, -2),
|
||||
(0, -2),
|
||||
(1, -2),
|
||||
(2, -2),
|
||||
(-2, -1),
|
||||
(2, -1),
|
||||
(-2, 0),
|
||||
(2, 0),
|
||||
(-2, 1),
|
||||
(2, 1),
|
||||
(-2, 2),
|
||||
(-1, 2),
|
||||
(0, 2),
|
||||
(1, 2),
|
||||
(2, 2),
|
||||
];
|
||||
|
||||
/// What the cells [`AROUND`] one cell hold, made when first asked for and kept while consecutive
|
||||
/// pixels stay in that cell.
|
||||
struct Around<T> {
|
||||
cell: Option<(i64, i64)>,
|
||||
items: [Option<T>; 25],
|
||||
}
|
||||
|
||||
impl<T: Copy> Around<T> {
|
||||
fn new() -> Self {
|
||||
Self { cell: None, items: [None; 25] }
|
||||
}
|
||||
|
||||
/// Item `k` of [`AROUND`] cell (`i`, `j`): `make(cell i', j')`.
|
||||
fn get(&mut self, (i, j): (i64, i64), k: usize, make: impl FnOnce(i64, i64) -> T) -> Option<T> {
|
||||
if self.cell != Some((i, j)) {
|
||||
self.cell = Some((i, j));
|
||||
self.items = [None; 25];
|
||||
}
|
||||
let (di, dj) = AROUND.get(k)?;
|
||||
let slot = self.items.get_mut(k)?;
|
||||
Some(*slot.get_or_insert_with(|| make(i.wrapping_add(*di), j.wrapping_add(*dj))))
|
||||
}
|
||||
}
|
||||
|
||||
/// The random point of cell (`i`, `j`) of pattern `salt`, in cells.
|
||||
fn point_in(salt: u64, i: i64, j: i64) -> Point {
|
||||
Point::new(i as f64 + rand(salt, i, j, 0), j as f64 + rand(salt, i, j, 1))
|
||||
}
|
||||
|
||||
/// Crystallize: every pixel takes the colour at the nearest of one random point per `cell` ×
|
||||
/// `cell` square (a Voronoi diagram over a jittered grid): polygon crystals of solid colour.
|
||||
pub(super) fn crystallize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, cell_size: f64) {
|
||||
let Some(place) = Place::new(space, w, h) else { return };
|
||||
if !(cell_size.is_finite() && cell_size > 0.0) {
|
||||
return;
|
||||
}
|
||||
let src = px.to_vec();
|
||||
let mut around = Around::new();
|
||||
// How far cell `c` lies from coordinate `t` (in cells) along one axis.
|
||||
let gap = |c: i64, t: f64| (c as f64 - t).max(t - c as f64 - 1.0).max(0.0);
|
||||
place.each(px, |x, y, out| {
|
||||
let q = place.at(x, y);
|
||||
let (u, v) = (q.x / cell_size, q.y / cell_size);
|
||||
let (Some(i), Some(j)) = (cell(u), cell(v)) else { return };
|
||||
let mut best = (f64::INFINITY, None);
|
||||
for (k, (di, dj)) in AROUND.iter().enumerate() {
|
||||
// A cell farther than the best point so far can't hold a nearer one.
|
||||
let (ci, cj) = (i.wrapping_add(*di), j.wrapping_add(*dj));
|
||||
if gap(ci, u).hypot(gap(cj, v)) >= best.0 {
|
||||
continue;
|
||||
}
|
||||
if let Some(p) = around.get((i, j), k, |a, b| point_in(1, a, b)) {
|
||||
let d = (p.x - u).hypot(p.y - v);
|
||||
if d < best.0 {
|
||||
best = (d, Some(p));
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(p) = best.1 {
|
||||
let at = Point::new(p.x * cell_size, p.y * cell_size);
|
||||
*out = place.index(at).and_then(|i| src.get(i)).copied().unwrap_or([0; 4]);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// One of Pointillize's dots: where (in cells), its radius (document units), its stacking order
|
||||
/// and its colour (premultiplied, 0..1).
|
||||
#[derive(Clone, Copy)]
|
||||
struct Dot {
|
||||
at: Point,
|
||||
radius: f64,
|
||||
z: f64,
|
||||
colour: [f32; 4],
|
||||
}
|
||||
|
||||
/// The smallest dot radius and the spread above it, in cells.
|
||||
const DOT_RADIUS: (f64, f64) = (0.45, 0.25);
|
||||
|
||||
/// Pointillize: a dot at one random point per `cell` × `cell` square, of random size around the
|
||||
/// cell's, coloured by the (softened) object there, over a white canvas where the object is.
|
||||
pub(super) fn pointillize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, cell_size: f64) {
|
||||
let Some(place) = Place::new(space, w, h) else { return };
|
||||
if !(cell_size.is_finite() && cell_size > 0.0) {
|
||||
return;
|
||||
}
|
||||
// Each dot takes the colour around its centre, not of a single pixel there, and is as opaque
|
||||
// as the object at its centre (whole dots on the object, none beside it).
|
||||
let alpha: Vec<u8> = px.iter().map(|p| p[3]).collect();
|
||||
let mut soft = to16(px);
|
||||
gaussian(&mut soft, w, cell_size / place.px / 4.0);
|
||||
let dot = |i: i64, j: i64| {
|
||||
let at = point_in(2, i, j);
|
||||
let k = place.index(Point::new(at.x * cell_size, at.y * cell_size));
|
||||
let a = k.and_then(|k| alpha.get(k)).map_or(0.0, |a| f32::from(*a) / 255.0);
|
||||
let colour = match k.and_then(|k| soft.get(k)) {
|
||||
Some(p) if p[3] > 0 => {
|
||||
let s = a / f32::from(p[3]);
|
||||
[f32::from(p[0]) * s, f32::from(p[1]) * s, f32::from(p[2]) * s, a]
|
||||
}
|
||||
_ => [0.0; 4],
|
||||
};
|
||||
Dot { at, radius: (DOT_RADIUS.0 + DOT_RADIUS.1 * rand(2, i, j, 2)) * cell_size, z: rand(2, i, j, 3), colour }
|
||||
};
|
||||
let mut around = Around::new();
|
||||
place.each(px, |x, y, out| {
|
||||
let q = place.at(x, y);
|
||||
let (u, v) = (q.x / cell_size, q.y / cell_size);
|
||||
let (Some(i), Some(j)) = (cell(u), cell(v)) else { return };
|
||||
// The dots covering the pixel (only the 3 × 3 cells around it reach it), bottom first.
|
||||
let mut hits: [(f64, f32, [f32; 4]); 9] = [(0.0, 0.0, [0.0; 4]); 9];
|
||||
let mut n = 0;
|
||||
for k in 0..9 {
|
||||
let Some(d) = around.get((i, j), k, dot) else { continue };
|
||||
let dist = (d.at.x - u).hypot(d.at.y - v) * cell_size;
|
||||
let cover = ((d.radius - dist) / place.px + 0.5).clamp(0.0, 1.0) as f32;
|
||||
if cover > 0.0
|
||||
&& d.colour[3] > 0.0
|
||||
&& let Some(slot) = hits.get_mut(n)
|
||||
{
|
||||
*slot = (d.z, cover, d.colour);
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
let hits = hits.get_mut(..n).unwrap_or_default();
|
||||
hits.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||||
let alpha = f32::from(out[3]) / 255.0;
|
||||
let mut acc = [alpha; 4];
|
||||
for (_, cover, c) in hits.iter() {
|
||||
let keep = 1.0 - c[3] * cover;
|
||||
for (a, v) in acc.iter_mut().zip(c) {
|
||||
*a = v * cover + *a * keep;
|
||||
}
|
||||
}
|
||||
let a = (acc[3].clamp(0.0, 1.0) * 255.0).round();
|
||||
let v = |c: f32| (c.clamp(0.0, 1.0) * 255.0).round().min(a) as u8;
|
||||
*out = [v(acc[0]), v(acc[1]), v(acc[2]), a as u8];
|
||||
});
|
||||
}
|
||||
|
||||
/// A pixel's colour as the channels the Pixelate filters treat apart (straight, 0..1; see
|
||||
/// [`Channels`]), and how many of the four there are.
|
||||
fn split(p: [u8; 4], channels: Channels) -> ([f32; 4], usize) {
|
||||
let a = f32::from(p[3]);
|
||||
let [r, g, b] = [p[0], p[1], p[2]].map(|v| if a > 0.0 { (f32::from(v) / a).min(1.0) } else { 0.0 });
|
||||
match channels {
|
||||
Channels::Rgb => ([r, g, b, 0.0], 3),
|
||||
Channels::Cmyk => {
|
||||
// A light black generation, as separations print: black ink takes over in the
|
||||
// shadows, coloured inks build the midtones.
|
||||
let k = (1.0 - r.max(g).max(b)).powi(2);
|
||||
let ink = |v: f32| if k < 1.0 { ((1.0 - v - k) / (1.0 - k)).clamp(0.0, 1.0) } else { 0.0 };
|
||||
([ink(r), ink(g), ink(b), k], 4)
|
||||
}
|
||||
Channels::CmyPlane => ([1.0 - r, 1.0 - g, 1.0 - b, 0.0], 3),
|
||||
Channels::KPlane => ([1.0 - r, 0.0, 0.0, 0.0], 1),
|
||||
}
|
||||
}
|
||||
|
||||
/// The pixel of channel values `v` ([`split`]'s) at coverage `alpha` (premultiplied).
|
||||
fn join(v: [f32; 4], channels: Channels, alpha: u8) -> [u8; 4] {
|
||||
let [a, b, c, d] = v.map(|x| x.clamp(0.0, 1.0));
|
||||
let rgb = match channels {
|
||||
Channels::Rgb => [a, b, c],
|
||||
Channels::Cmyk => [(1.0 - a) * (1.0 - d), (1.0 - b) * (1.0 - d), (1.0 - c) * (1.0 - d)],
|
||||
Channels::CmyPlane => [1.0 - a, 1.0 - b, 1.0 - c],
|
||||
Channels::KPlane => [1.0 - a; 3],
|
||||
};
|
||||
let al = f32::from(alpha);
|
||||
let [r, g, b] = rgb.map(|x| (x * al).round().clamp(0.0, al) as u8);
|
||||
[r, g, b, alpha]
|
||||
}
|
||||
|
||||
/// Which of Color Halftone's four screen angles channel `i` of `channels` uses: the K plane's
|
||||
/// only channel is the fourth (black) one.
|
||||
fn angle_of(channels: Channels, i: usize) -> usize {
|
||||
if channels == Channels::KPlane { 3 } else { i }
|
||||
}
|
||||
|
||||
/// The share of a `1` × `1` square that a circle of radius `rho` around its centre covers.
|
||||
fn circle_in_square(rho: f64) -> f64 {
|
||||
let half = 0.5;
|
||||
if rho <= half {
|
||||
std::f64::consts::PI * rho * rho
|
||||
} else if rho < std::f64::consts::FRAC_1_SQRT_2 {
|
||||
// The circle less the four caps beyond the square's sides.
|
||||
let cap = rho * rho * (half / rho).acos() - half * (rho * rho - half * half).sqrt();
|
||||
std::f64::consts::PI * rho * rho - 4.0 * cap
|
||||
} else {
|
||||
1.0
|
||||
}
|
||||
}
|
||||
|
||||
/// The radius (in cells) of the dot that covers share `v` of its cell.
|
||||
fn dot_radius(v: f64) -> f64 {
|
||||
const STEPS: usize = 256;
|
||||
static TABLE: OnceLock<[f64; STEPS + 1]> = OnceLock::new();
|
||||
let table = TABLE.get_or_init(|| {
|
||||
std::array::from_fn(|k| {
|
||||
let target = k as f64 / STEPS as f64;
|
||||
let (mut lo, mut hi) = (0.0, std::f64::consts::FRAC_1_SQRT_2);
|
||||
for _ in 0..48 {
|
||||
let mid = 0.5 * (lo + hi);
|
||||
if circle_in_square(mid) < target {
|
||||
lo = mid;
|
||||
} else {
|
||||
hi = mid;
|
||||
}
|
||||
}
|
||||
hi
|
||||
})
|
||||
});
|
||||
let x = if v.is_finite() { v.clamp(0.0, 1.0) * STEPS as f64 } else { 0.0 };
|
||||
let k = (x.floor() as usize).min(STEPS - 1);
|
||||
let (a, b) = (table.get(k).copied().unwrap_or(0.0), table.get(k + 1).copied().unwrap_or(0.0));
|
||||
a + (b - a) * (x - k as f64)
|
||||
}
|
||||
|
||||
/// One channel's halftone screen: square cells at an angle, each with the dot of its mean value.
|
||||
struct Screen {
|
||||
/// Document coordinates relative to the centre → cells.
|
||||
to_cells: Affine,
|
||||
/// The first cell's indices and the grid's size in cells.
|
||||
origin: (i64, i64),
|
||||
size: (usize, usize),
|
||||
/// Per cell: the channel's sum (× coverage) and the coverage's (then the dot's radius in
|
||||
/// document units, in `sums[k][0]`).
|
||||
sums: Vec<[f32; 2]>,
|
||||
}
|
||||
|
||||
impl Screen {
|
||||
/// The screen at `angle`° with cells `side` wide over the raster `place` covers; `None` when
|
||||
/// it would have more than `limit` cells.
|
||||
fn new(place: &Place, angle: f64, side: f64, limit: usize) -> Option<Self> {
|
||||
let to_cells = Affine::scale(1.0 / side) * Affine::rotate(angle.to_radians());
|
||||
let corners = [(0.0, 0.0), (place.w as f64, 0.0), (0.0, place.h as f64), (place.w as f64, place.h as f64)];
|
||||
let pts = corners.map(|(x, y)| to_cells * (place.to_rel * Point::new(x, y)));
|
||||
let (lo, hi) = pts.iter().fold(((f64::INFINITY, f64::INFINITY), (f64::NEG_INFINITY, f64::NEG_INFINITY)), |(lo, hi), p| {
|
||||
((lo.0.min(p.x), lo.1.min(p.y)), (hi.0.max(p.x), hi.1.max(p.y)))
|
||||
});
|
||||
let (i0, j0, i1, j1) = (cell(lo.0)?.checked_sub(1)?, cell(lo.1)?.checked_sub(1)?, cell(hi.0)?.checked_add(1)?, cell(hi.1)?.checked_add(1)?);
|
||||
let gw = usize::try_from(i1.checked_sub(i0)?.checked_add(1)?).ok()?;
|
||||
let gh = usize::try_from(j1.checked_sub(j0)?.checked_add(1)?).ok()?;
|
||||
(gw.checked_mul(gh)? <= limit).then(|| Self { to_cells, origin: (i0, j0), size: (gw, gh), sums: vec![[0.0; 2]; gw * gh] })
|
||||
}
|
||||
|
||||
/// The index of cell (`i`, `j`) in the grid.
|
||||
fn slot(&self, i: i64, j: i64) -> Option<usize> {
|
||||
let x = usize::try_from(i.checked_sub(self.origin.0)?).ok().filter(|x| *x < self.size.0)?;
|
||||
let y = usize::try_from(j.checked_sub(self.origin.1)?).ok().filter(|y| *y < self.size.1)?;
|
||||
Some(y * self.size.0 + x)
|
||||
}
|
||||
}
|
||||
|
||||
/// Color Halftone: each channel screened at its angle in square cells sized so that a dot of
|
||||
/// `max_radius` fills one; each cell's dot covers the share of it that is the channel's mean
|
||||
/// there (white stays white, black black). Coverage stays as it is.
|
||||
pub(super) fn color_halftone(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, max_radius: f64, angles: [f64; 4]) {
|
||||
let Some(place) = Place::new(space, w, h) else { return };
|
||||
let side = max_radius * std::f64::consts::SQRT_2;
|
||||
// Cells under 3 pixels can't show their dots: on average a screen is the image itself.
|
||||
if !(side.is_finite() && side / place.px >= 3.0) {
|
||||
return;
|
||||
}
|
||||
let channels = space.channels;
|
||||
let n = split([0; 4], channels).1;
|
||||
let limit = w.saturating_mul(h).saturating_add(4096);
|
||||
let mut screens = Vec::with_capacity(n);
|
||||
for i in 0..n {
|
||||
let angle = angles.get(angle_of(channels, i)).copied().unwrap_or(0.0);
|
||||
let Some(s) = Screen::new(&place, angle, side, limit) else { return };
|
||||
screens.push(s);
|
||||
}
|
||||
// Each cell's mean of each channel, weighted by coverage.
|
||||
place.each(px, |x, y, p| {
|
||||
if p[3] == 0 {
|
||||
return;
|
||||
}
|
||||
let (v, _) = split(*p, channels);
|
||||
let a = f32::from(p[3]) / 255.0;
|
||||
let q = place.at(x, y);
|
||||
for (s, v) in screens.iter_mut().zip(v) {
|
||||
let c = s.to_cells * q;
|
||||
if let (Some(i), Some(j)) = (cell(c.x), cell(c.y))
|
||||
&& let Some(sum) = s.slot(i, j).and_then(|k| s.sums.get_mut(k))
|
||||
{
|
||||
sum[0] += v * a;
|
||||
sum[1] += a;
|
||||
}
|
||||
}
|
||||
});
|
||||
for s in &mut screens {
|
||||
for sum in &mut s.sums {
|
||||
let mean = if sum[1] > 1e-6 { f64::from(sum[0] / sum[1]) } else { 0.0 };
|
||||
// Full strength fills the cell, corners too; none leaves no speck.
|
||||
let radius = match mean {
|
||||
m if m >= 254.5 / 255.0 => f64::INFINITY,
|
||||
m if m <= 0.5 / 255.0 => 0.0,
|
||||
m => dot_radius(m) * side,
|
||||
};
|
||||
sum[0] = radius as f32;
|
||||
}
|
||||
}
|
||||
place.each(px, |x, y, p| {
|
||||
if p[3] == 0 {
|
||||
return;
|
||||
}
|
||||
let q = place.at(x, y);
|
||||
let mut v = [0.0f32; 4];
|
||||
for (s, out) in screens.iter().zip(v.iter_mut()) {
|
||||
let c = s.to_cells * q;
|
||||
let (Some(i), Some(j)) = (cell(c.x), cell(c.y)) else { continue };
|
||||
// A dot reaches past its cell into the neighbours on the pixel's side only.
|
||||
let (si, sj) = (if c.x - (i as f64) < 0.5 { -1 } else { 1 }, if c.y - (j as f64) < 0.5 { -1 } else { 1 });
|
||||
for (di, dj) in [(0, 0), (si, 0), (0, sj), (si, sj)] {
|
||||
let (ci, cj) = (i.wrapping_add(di), j.wrapping_add(dj));
|
||||
let radius = s.slot(ci, cj).and_then(|k| s.sums.get(k)).map_or(0.0, |sum| f64::from(sum[0]));
|
||||
if radius <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
let dist = (c.x - (ci as f64 + 0.5)).hypot(c.y - (cj as f64 + 0.5)) * side;
|
||||
*out = out.max(((radius - dist) / place.px + 0.5).clamp(0.0, 1.0) as f32);
|
||||
}
|
||||
}
|
||||
*p = join(v, channels, p[3]);
|
||||
});
|
||||
}
|
||||
|
||||
/// Mezzotint: every channel turned fully on or off where it is above or below a random threshold
|
||||
/// pattern (each channel its own), so the image becomes dots or streaks of pure colours.
|
||||
pub(super) fn mezzotint(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, kind: Mezzotint) {
|
||||
let Some(place) = Place::new(space, w, h) else { return };
|
||||
let channels = space.channels;
|
||||
place.each(px, |x, y, p| {
|
||||
if p[3] == 0 {
|
||||
return;
|
||||
}
|
||||
let q = place.at(x, y);
|
||||
let (mut v, n) = split(*p, channels);
|
||||
for (c, value) in v.iter_mut().enumerate().take(n) {
|
||||
let t = threshold(kind, 16 + c as u64, q);
|
||||
*value = if f64::from(*value) > t { 1.0 } else { 0.0 };
|
||||
}
|
||||
*p = join(v, channels, p[3]);
|
||||
});
|
||||
}
|
||||
|
||||
/// Mezzotint's threshold in [0, 1) at point `q` (document units around the centre) of pattern
|
||||
/// `salt`.
|
||||
fn threshold(kind: Mezzotint, salt: u64, q: Point) -> f64 {
|
||||
let smooth = |t: f64| t * t * (3.0 - 2.0 * t);
|
||||
// Random values at whole coordinates, blended smoothly between them along x (and y).
|
||||
let blend = |x: f64, y: f64, along_y: bool| {
|
||||
let (Some(i), Some(j)) = (cell(x), cell(y)) else { return 0.5 };
|
||||
let (fx, fy) = (smooth(x - i as f64), smooth(y - j as f64));
|
||||
let at = |di: i64, dj: i64| rand(salt, i.wrapping_add(di), j.wrapping_add(dj), 0);
|
||||
let top = at(0, 0) + (at(1, 0) - at(0, 0)) * fx;
|
||||
if !along_y {
|
||||
return top;
|
||||
}
|
||||
let bottom = at(0, 1) + (at(1, 1) - at(0, 1)) * fx;
|
||||
top + (bottom - top) * fy
|
||||
};
|
||||
let grain = |size: f64| match (cell(q.x / size), cell(q.y / size)) {
|
||||
(Some(i), Some(j)) => rand(salt, i, j, 1),
|
||||
_ => 0.5,
|
||||
};
|
||||
match kind {
|
||||
Mezzotint::Dots { size, smooth: false, .. } => grain(f64::from(size)),
|
||||
Mezzotint::Dots { size, grainy, .. } => {
|
||||
let s = f64::from(size);
|
||||
let blob = blend(q.x / s, q.y / s, true);
|
||||
if grainy { 0.5 * (blob + grain(1.0)) } else { blob }
|
||||
}
|
||||
Mezzotint::Lines { length, width } => {
|
||||
let row = (q.y / f64::from(width)).floor();
|
||||
blend(q.x / f64::from(length), row, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -7,7 +7,7 @@ use crate::{RasterFx, raster_effects};
|
|||
|
||||
/// A `w` × `h` raster whose pixels are document points (origin top-left).
|
||||
fn space(w: usize, h: usize) -> PixelSpace {
|
||||
PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(w as f64 / 2.0, h as f64 / 2.0) }
|
||||
PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(w as f64 / 2.0, h as f64 / 2.0), channels: Channels::Rgb }
|
||||
}
|
||||
|
||||
fn image(w: usize, h: usize, f: impl Fn(usize, usize) -> [u8; 4]) -> Vec<u8> {
|
||||
|
|
@ -224,7 +224,7 @@ fn lengths_are_document_units() {
|
|||
let edge = |scale: usize| image(40 * scale, 4, move |x, _| grey(if x < 20 * scale { 100 } else { 150 }));
|
||||
let run = |scale: usize| {
|
||||
let mut d = edge(scale);
|
||||
let s = PixelSpace { to_doc: Affine::scale(1.0 / scale as f64), px: 1.0 / scale as f64, center: Point::ZERO };
|
||||
let s = PixelSpace { to_doc: Affine::scale(1.0 / scale as f64), px: 1.0 / scale as f64, center: Point::ZERO, channels: Channels::Rgb };
|
||||
fx("sharpen.unsharpMask", json!({"amount": 100, "radius": 2})).apply(&mut d, 40 * scale, 4, &s);
|
||||
(0..40 * scale).filter(|x| at(&d, 40 * scale, *x, 2)[0] < 99).count()
|
||||
};
|
||||
|
|
@ -253,7 +253,7 @@ fn gaussian_and_plane_blurs_keep_their_mass() {
|
|||
fn pixel_timings() {
|
||||
let (w, h) = (2000, 2000);
|
||||
let src = image(w, h, |x, y| [(x % 256) as u8, (y % 256) as u8, ((x ^ y) % 256) as u8, 255]);
|
||||
let s = PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(1000.0, 1000.0) };
|
||||
let s = PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(1000.0, 1000.0), channels: Channels::Rgb };
|
||||
let cases = [
|
||||
("blur.radial", json!({"quality": "draft"})),
|
||||
("blur.radial", json!({"quality": "good"})),
|
||||
|
|
@ -261,6 +261,12 @@ fn pixel_timings() {
|
|||
("blur.smart", json!({"quality": "low"})),
|
||||
("blur.smart", json!({"quality": "high", "radius": 30})),
|
||||
("sharpen.unsharpMask", json!({"radius": 20})),
|
||||
("pixelate.colorHalftone", json!({"maxRadius": 4})),
|
||||
("pixelate.crystallize", json!({"cellSize": 3})),
|
||||
("pixelate.crystallize", json!({"cellSize": 300})),
|
||||
("pixelate.mezzotint", json!({"type": "grainyDots"})),
|
||||
("pixelate.pointillize", json!({"cellSize": 3})),
|
||||
("pixelate.pointillize", json!({"cellSize": 300})),
|
||||
];
|
||||
for (id, p) in cases {
|
||||
let mut d = src.clone();
|
||||
|
|
@ -269,3 +275,205 @@ fn pixel_timings() {
|
|||
println!("{id} {p}: {:?}", t.elapsed());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pixelate_params_take_defaults_and_stay_in_range() {
|
||||
assert_eq!(fx("pixelate.colorHalftone", json!({})), PixelFx::ColorHalftone { max_radius: 8.0, angles: [108.0, 162.0, 90.0, 45.0] });
|
||||
assert_eq!(
|
||||
fx("pixelate.colorHalftone", json!({"maxRadius": 1e9, "channel1": -1e9, "channel2": 30, "channel4": "x"})),
|
||||
PixelFx::ColorHalftone { max_radius: 127.0, angles: [-360.0, 30.0, 90.0, 45.0] }
|
||||
);
|
||||
assert_eq!(fx("pixelate.colorHalftone", json!({"maxRadius": 0})), PixelFx::ColorHalftone { max_radius: 4.0, angles: [108.0, 162.0, 90.0, 45.0] });
|
||||
assert_eq!(fx("pixelate.crystallize", json!({})), PixelFx::Crystallize { cell: 10.0 });
|
||||
assert_eq!(fx("pixelate.crystallize", json!({"cellSize": -4})), PixelFx::Crystallize { cell: 3.0 });
|
||||
assert_eq!(fx("pixelate.pointillize", json!({})), PixelFx::Pointillize { cell: 5.0 });
|
||||
assert_eq!(fx("pixelate.pointillize", json!({"cellSize": 1e300})), PixelFx::Pointillize { cell: 300.0 });
|
||||
assert_eq!(fx("pixelate.mezzotint", json!({})), PixelFx::Mezzotint { kind: Mezzotint::FINE_DOTS });
|
||||
assert_eq!(fx("pixelate.mezzotint", json!({"type": "LONGSTROKES"})), PixelFx::Mezzotint { kind: Mezzotint::Lines { length: 24, width: 2 } });
|
||||
for junk in [json!({"type": 7}), json!({"type": "nonsense"})] {
|
||||
assert_eq!(fx("pixelate.mezzotint", junk), PixelFx::Mezzotint { kind: Mezzotint::FINE_DOTS });
|
||||
}
|
||||
// Every Type is a pattern of its own, documented in the catalogue.
|
||||
let doc = crate::effect_info("pixelate.mezzotint").unwrap().params;
|
||||
let kinds: Vec<Mezzotint> = MEZZOTINT_TYPES.iter().map(|(_, v)| Mezzotint::parse(v)).collect();
|
||||
for (i, (_, v)) in MEZZOTINT_TYPES.iter().enumerate() {
|
||||
assert!(doc.contains(&format!("\"{v}\"")), "{v}");
|
||||
assert!(kinds.iter().skip(i + 1).all(|k| *k != kinds[i]), "{v}");
|
||||
}
|
||||
// Dots and crystals reach beyond the object; screens and grain stay on it.
|
||||
let b = Rect::new(0.0, 0.0, 100.0, 50.0);
|
||||
assert_eq!(fx("pixelate.crystallize", json!({"cellSize": 20})).outset(b), 30.0);
|
||||
assert_eq!(fx("pixelate.pointillize", json!({"cellSize": 20})).outset(b), 30.0);
|
||||
assert_eq!(fx("pixelate.colorHalftone", json!({})).outset(b), 0.0);
|
||||
assert_eq!(fx("pixelate.mezzotint", json!({})).reach(), Some(0.0));
|
||||
}
|
||||
|
||||
/// Fraction of `d`'s pixels for which `f` holds.
|
||||
fn share(d: &[u8], f: impl Fn(&[u8; 4]) -> bool) -> f64 {
|
||||
let px = d.as_chunks::<4>().0;
|
||||
px.iter().filter(|p| f(p)).count() as f64 / px.len() as f64
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn color_halftone_screens_midtones_into_dots_and_keeps_white_and_black() {
|
||||
let (w, h) = (64, 64);
|
||||
let halftone = fx("pixelate.colorHalftone", json!({}));
|
||||
for v in [0, 255] {
|
||||
let mut d = image(w, h, |_, _| grey(v));
|
||||
halftone.apply(&mut d, w, h, &space(w, h));
|
||||
assert_eq!(d, image(w, h, |_, _| grey(v)), "{v} stays");
|
||||
}
|
||||
// Mid grey: each channel's dots cover about half its screen, so the tone stays.
|
||||
let mut d = image(w, h, |_, _| grey(128));
|
||||
halftone.apply(&mut d, w, h, &space(w, h));
|
||||
let px = d.as_chunks::<4>().0;
|
||||
for c in 0..3 {
|
||||
let mean = px.iter().map(|p| f64::from(p[c])).sum::<f64>() / px.len() as f64;
|
||||
assert!((mean - 128.0).abs() < 16.0, "channel {c}: {mean}");
|
||||
}
|
||||
assert!(share(&d, |p| p[0] == 255) > 0.25 && share(&d, |p| p[0] == 0) > 0.25, "dots, not grey");
|
||||
assert!(share(&d, |p| p[0] != p[1]) > 0.1, "the channels' screens lie at different angles");
|
||||
assert!(px.iter().all(|p| p[3] == 255), "coverage stays");
|
||||
// Transparency stays transparent.
|
||||
let mut half = image(w, h, |x, _| if x < 32 { grey(160) } else { [0; 4] });
|
||||
halftone.apply(&mut half, w, h, &space(w, h));
|
||||
assert!((0..h).all(|y| (32..w).all(|x| at(&half, w, x, y) == [0; 4])));
|
||||
// Dots are bigger where the image is brighter.
|
||||
let mut ramp = image(w, h, |x, _| grey((x * 4) as u8));
|
||||
halftone.apply(&mut ramp, w, h, &space(w, h));
|
||||
let lit = |x0: usize| (0..h).flat_map(|y| (x0..x0 + 16).map(move |x| (x, y))).filter(|(x, y)| at(&ramp, w, *x, *y)[0] > 127).count();
|
||||
assert!(lit(8) < lit(40), "{} < {}", lit(8), lit(40));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn color_halftone_screens_inks_in_cmyk_documents() {
|
||||
let (w, h) = (64, 64);
|
||||
let halftone = fx("pixelate.colorHalftone", json!({}));
|
||||
let cmyk = PixelSpace { channels: Channels::Cmyk, ..space(w, h) };
|
||||
// A neutral grey prints with all four inks: dots of each on white paper, black where they
|
||||
// all overlap.
|
||||
let mut d = image(w, h, |_, _| grey(128));
|
||||
halftone.apply(&mut d, w, h, &cmyk);
|
||||
assert!(share(&d, |p| *p == grey(255)) > 0.02 && share(&d, |p| *p == grey(0)) > 0.02);
|
||||
for (ink, colour) in [("cyan", [0, 255, 255, 255]), ("magenta", [255, 0, 255, 255]), ("yellow", [255, 255, 0, 255])] {
|
||||
assert!(share(&d, |p| *p == colour) > 0.0, "{ink} dots alone");
|
||||
}
|
||||
// White paper stays bare; pure cyan ink fills its cells.
|
||||
let mut white = image(w, h, |_, _| grey(255));
|
||||
halftone.apply(&mut white, w, h, &cmyk);
|
||||
assert_eq!(white, image(w, h, |_, _| grey(255)));
|
||||
let mut cyan = image(w, h, |_, _| [0, 255, 255, 255]);
|
||||
halftone.apply(&mut cyan, w, h, &cmyk);
|
||||
assert_eq!(cyan, image(w, h, |_, _| [0, 255, 255, 255]));
|
||||
// Ink planes: the complemented K plane screens one grey channel at the black angle (45°,
|
||||
// the same in every quarter turn).
|
||||
let mut k = image(w, h, |_, _| grey(128));
|
||||
halftone.apply(&mut k, w, h, &PixelSpace { channels: Channels::KPlane, ..space(w, h) });
|
||||
assert!(k.as_chunks::<4>().0.iter().all(|p| p[0] == p[1] && p[1] == p[2]), "one grey channel");
|
||||
assert!(share(&k, |p| p[0] == 255) > 0.25 && share(&k, |p| p[0] == 0) > 0.25);
|
||||
let mut turned = image(w, h, |_, _| grey(128));
|
||||
fx("pixelate.colorHalftone", json!({"channel4": 135})).apply(&mut turned, w, h, &PixelSpace { channels: Channels::KPlane, ..space(w, h) });
|
||||
let mut other = image(w, h, |_, _| grey(128));
|
||||
fx("pixelate.colorHalftone", json!({"channel4": 30})).apply(&mut other, w, h, &PixelSpace { channels: Channels::KPlane, ..space(w, h) });
|
||||
assert_eq!(turned, k, "channel 4 sets the K plane's angle");
|
||||
assert_ne!(other, k);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn crystallize_redraws_in_solid_polygons() {
|
||||
let (w, h) = (48, 48);
|
||||
let crystals = fx("pixelate.crystallize", json!({"cellSize": 6}));
|
||||
// One colour stays that colour (away from the raster's edges, where crystals around points
|
||||
// beyond it take the transparency there).
|
||||
let mut d = image(w, h, |_, _| [200, 100, 50, 255]);
|
||||
crystals.apply(&mut d, w, h, &space(w, h));
|
||||
assert!((9..39).all(|y| (9..39).all(|x| at(&d, w, x, y) == [200, 100, 50, 255])));
|
||||
// Two halves: every pixel takes one of the colours, and the border between them zigzags.
|
||||
let (red, blue) = ([200, 0, 0, 255], [0, 0, 200, 255]);
|
||||
let src = image(w, h, |x, _| if x < 24 { red } else { blue });
|
||||
let mut d = src.clone();
|
||||
crystals.apply(&mut d, w, h, &space(w, h));
|
||||
assert!((9..39).all(|y| (9..39).all(|x| [red, blue].contains(&at(&d, w, x, y)))));
|
||||
let crossed = (9..39).flat_map(|y| (9..39).map(move |x| (x, y))).filter(|(x, y)| at(&d, w, *x, *y) != at(&src, w, *x, *y)).count();
|
||||
assert!(crossed > 10, "{crossed}");
|
||||
let border: std::collections::BTreeSet<usize> = (9..39).map(|y| (9..39).find(|x| at(&d, w, *x, y) == blue).unwrap()).collect();
|
||||
assert!(border.len() > 2, "{border:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mezzotint_turns_channels_fully_on_or_off() {
|
||||
let (w, h) = (64, 64);
|
||||
let grey_square = image(w, h, |x, y| if (8..56).contains(&x) && (8..56).contains(&y) { grey(128) } else { [0; 4] });
|
||||
let mut seen = Vec::new();
|
||||
for (_, kind) in MEZZOTINT_TYPES {
|
||||
let f = fx("pixelate.mezzotint", json!({ "type": kind }));
|
||||
for v in [0, 255] {
|
||||
let mut d = image(w, h, |_, _| grey(v));
|
||||
f.apply(&mut d, w, h, &space(w, h));
|
||||
assert_eq!(d, image(w, h, |_, _| grey(v)), "{kind}: {v} stays");
|
||||
}
|
||||
let mut d = grey_square.clone();
|
||||
f.apply(&mut d, w, h, &space(w, h));
|
||||
let px = d.as_chunks::<4>().0;
|
||||
assert!(px.iter().all(|p| p[..3].iter().all(|c| *c == 0 || *c == p[3])), "{kind}: pure colours");
|
||||
let on = px.iter().filter(|p| p[3] > 0 && p[0] > 0).count() as f64 / (48.0 * 48.0);
|
||||
assert!((0.25..0.75).contains(&on), "{kind}: {on}");
|
||||
assert!(px.iter().any(|p| p[3] > 0 && p[0] != p[1]), "{kind}: each channel its own pattern");
|
||||
assert!(d.iter().zip(&grey_square).skip(3).step_by(4).all(|(a, b)| a == b), "{kind}: coverage stays");
|
||||
assert!(!seen.contains(&d), "{kind}: a pattern of its own");
|
||||
seen.push(d);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pointillize_paints_dots_on_a_white_canvas() {
|
||||
let (w, h) = (80, 80);
|
||||
let red = [200, 0, 0, 255];
|
||||
let src = image(w, h, |x, y| if (20..60).contains(&x) && (20..60).contains(&y) { red } else { [0; 4] });
|
||||
let mut d = src.clone();
|
||||
fx("pixelate.pointillize", json!({})).apply(&mut d, w, h, &space(w, h));
|
||||
let inside: Vec<[u8; 4]> = (26..54).flat_map(|y| (26..54).map(move |x| (x, y))).map(|(x, y)| at(&d, w, x, y)).collect();
|
||||
let canvas = inside.iter().filter(|p| **p == grey(255)).count();
|
||||
let dots = inside.iter().filter(|p| **p == red).count();
|
||||
assert!(canvas > inside.len() / 20 && dots > inside.len() / 3, "{canvas} canvas, {dots} dots of {}", inside.len());
|
||||
assert!(inside.iter().all(|p| p[3] == 255 && p[1] == p[2] && p[0] >= p[1]), "red over white only");
|
||||
// Dots at the edges reach a little past the object; far from it stays transparent.
|
||||
assert!((0..h).any(|y| (14..20).any(|x| at(&d, w, x, y)[3] > 0)));
|
||||
assert!((0..h).all(|y| (0..10).all(|x| at(&d, w, x, y) == [0; 4])));
|
||||
assert!(d.as_chunks::<4>().0.iter().all(|p| p[0] <= p[3] && p[1] <= p[3] && p[2] <= p[3]));
|
||||
}
|
||||
|
||||
/// The patterns lie in document space around the object's centre: the same at twice the
|
||||
/// resolution, and moving with the object.
|
||||
#[test]
|
||||
fn pixelate_patterns_follow_the_object_at_any_resolution() {
|
||||
let (w, h) = (40, 40);
|
||||
let art = |x: f64, y: f64| -> [u8; 4] {
|
||||
if (8.0..32.0).contains(&x) && (8.0..32.0).contains(&y) { [(x * 6.0) as u8, (y * 6.0) as u8, 120, 255] } else { [0; 4] }
|
||||
};
|
||||
for (id, p) in [
|
||||
("pixelate.colorHalftone", json!({"maxRadius": 4})),
|
||||
("pixelate.crystallize", json!({"cellSize": 4})),
|
||||
("pixelate.mezzotint", json!({"type": "coarseDots"})),
|
||||
("pixelate.pointillize", json!({"cellSize": 4})),
|
||||
] {
|
||||
let f = fx(id, p);
|
||||
let mut one = image(w, h, |x, y| art(x as f64 + 0.5, y as f64 + 0.5));
|
||||
f.apply(&mut one, w, h, &space(w, h));
|
||||
// Twice the pixels for the same art, averaged back down.
|
||||
let mut two = image(2 * w, 2 * h, |x, y| art((x as f64 + 0.5) / 2.0, (y as f64 + 0.5) / 2.0));
|
||||
let fine = PixelSpace { to_doc: Affine::scale(0.5), px: 0.5, ..space(w, h) };
|
||||
f.apply(&mut two, 2 * w, 2 * h, &fine);
|
||||
let down = image(w, h, |x, y| {
|
||||
let q = [(0, 0), (1, 0), (0, 1), (1, 1)].map(|(dx, dy)| at(&two, 2 * w, 2 * x + dx, 2 * y + dy));
|
||||
std::array::from_fn(|c| (q.iter().map(|p| u32::from(p[c])).sum::<u32>() / 4) as u8)
|
||||
});
|
||||
let diff = one.iter().zip(&down).map(|(a, b)| f64::from(a.abs_diff(*b))).sum::<f64>() / one.len() as f64;
|
||||
assert!(diff < 24.0, "{id}: {diff}");
|
||||
// The object and its raster 7 × 3 points further: the same pixels.
|
||||
let moved = PixelSpace { to_doc: Affine::translate((7.0, 3.0)), center: Point::new(27.0, 23.0), ..space(w, h) };
|
||||
let mut shifted = image(w, h, |x, y| art(x as f64 + 0.5, y as f64 + 0.5));
|
||||
f.apply(&mut shifted, w, h, &moved);
|
||||
assert_eq!(shifted, one, "{id}");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
//! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Sharpen ›
|
||||
//! Unsharp Mask): applied and edited as commands, listed in the catalogue, drawn on the canvas,
|
||||
//! and written to PDF and SVG as images of the effected object.
|
||||
//! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate ›
|
||||
//! Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask): applied and
|
||||
//! edited as commands, listed in the catalogue, drawn on the canvas, and written to PDF and SVG
|
||||
//! as images of the effected object.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::NodeKind;
|
||||
|
|
@ -16,6 +17,10 @@ const EFFECTS: [(&str, &str); 3] = [
|
|||
("sharpen.unsharpMask", r#"{"amount": 300, "radius": 3}"#),
|
||||
];
|
||||
|
||||
/// Effect › Pixelate, at their defaults.
|
||||
const PIXELATE: [(&str, &str); 4] =
|
||||
[("pixelate.colorHalftone", "{}"), ("pixelate.crystallize", "{}"), ("pixelate.mezzotint", "{}"), ("pixelate.pointillize", "{}")];
|
||||
|
||||
/// A group of a red square and a darker red stripe across it; returns the group's id.
|
||||
fn striped() -> (Session, u64) {
|
||||
let mut s = Session::new();
|
||||
|
|
@ -52,6 +57,10 @@ fn listed_applied_edited_and_undone() {
|
|||
let menus: Vec<Value> =
|
||||
EFFECTS.iter().map(|(id, _)| list["catalog"].as_array().unwrap().iter().find(|e| e["id"] == *id).unwrap()["menu"].clone()).collect();
|
||||
assert_eq!(menus, [json!(["Effect", "Blur"]), json!(["Effect", "Blur"]), json!(["Effect", "Sharpen"])]);
|
||||
for (id, _) in PIXELATE {
|
||||
let e = list["catalog"].as_array().unwrap().iter().find(|e| e["id"] == id).unwrap_or_else(|| panic!("{id} listed"));
|
||||
assert_eq!((&e["raster"], &e["menu"]), (&json!(true), &json!(["Effect", "Pixelate"])), "{id}");
|
||||
}
|
||||
// Junk parameters are stored as given and read clamped; the canvas still draws.
|
||||
for (id, _) in EFFECTS {
|
||||
s.execute("effect.apply", &json!({"effect": id, "ids": [g], "params": {"amount": 1e308, "radius": -1e308, "threshold": "x", "quality": 7}}))
|
||||
|
|
@ -71,7 +80,7 @@ fn listed_applied_edited_and_undone() {
|
|||
|
||||
#[test]
|
||||
fn each_effect_changes_the_canvas_and_draws_the_same_twice() {
|
||||
for (id, params) in EFFECTS {
|
||||
for (id, params) in EFFECTS.into_iter().chain(PIXELATE) {
|
||||
let (mut s, g) = striped();
|
||||
let plain = render(&s);
|
||||
let params: Value = serde_json::from_str(params).unwrap();
|
||||
|
|
@ -100,7 +109,7 @@ fn spin_blur_reaches_past_the_corners() {
|
|||
|
||||
#[test]
|
||||
fn pdf_and_svg_write_the_effected_object_as_an_image() {
|
||||
for (id, params) in EFFECTS {
|
||||
for (id, params) in EFFECTS.into_iter().chain(PIXELATE) {
|
||||
let (mut s, g) = striped();
|
||||
let params: Value = serde_json::from_str(params).unwrap();
|
||||
s.execute("effect.apply", &json!({"effect": id, "ids": [g], "params": params})).unwrap();
|
||||
|
|
|
|||
|
|
@ -278,6 +278,10 @@ fn structured_junk() {
|
|||
("effect.apply", json!({"effect": "blur.radial", "params": {"amount": 1e308, "method": 5, "quality": "best"}})),
|
||||
("effect.apply", json!({"effect": "blur.smart", "params": {"radius": 1e308, "threshold": -1e308, "quality": null}})),
|
||||
("effect.apply", json!({"effect": "sharpen.unsharpMask", "params": {"amount": -1, "radius": "1e999", "threshold": 1e308}})),
|
||||
("effect.apply", json!({"effect": "pixelate.colorHalftone", "params": {"maxRadius": 1e308, "channel1": "1e999", "channel4": null}})),
|
||||
("effect.apply", json!({"effect": "pixelate.crystallize", "params": {"cellSize": -1e308}})),
|
||||
("effect.apply", json!({"effect": "pixelate.mezzotint", "params": {"type": 5}})),
|
||||
("effect.apply", json!({"effect": "pixelate.pointillize", "params": {"cellSize": "NaN"}})),
|
||||
("effect.apply", json!({"effect": "no.such.effect"})),
|
||||
("effect.remove", json!({"index": 99})),
|
||||
("effect.setParams", json!({"index": 0, "params": null})),
|
||||
|
|
|
|||
|
|
@ -595,7 +595,13 @@ impl Renderer {
|
|||
off.flush();
|
||||
let mut pm = vello_cpu::Pixmap::new(wu, hu);
|
||||
off.render(&mut pm, &mut self.resources);
|
||||
let space = effects::PixelSpace { to_doc, px, center: content.reach.center() };
|
||||
let channels = match f.ink {
|
||||
Ink::Cmy => effects::pixel::Channels::CmyPlane,
|
||||
Ink::K => effects::pixel::Channels::KPlane,
|
||||
Ink::Display if f.doc.color_mode == vectorcraft_doc::ColorMode::Cmyk => effects::pixel::Channels::Cmyk,
|
||||
Ink::Display => effects::pixel::Channels::Rgb,
|
||||
};
|
||||
let space = effects::PixelSpace { to_doc, px, center: content.reach.center(), channels };
|
||||
let (wz, hz) = (wu as usize, hu as usize);
|
||||
for fx in chain {
|
||||
match fx {
|
||||
|
|
|
|||
|
|
@ -159,6 +159,7 @@ fn choices(effect: &str, key: &str) -> Option<form::Choices> {
|
|||
("blur.radial", "method") => Some(&[("Spin", "spin"), ("Zoom", "zoom")]),
|
||||
("blur.radial", "quality") => Some(&[("Draft", "draft"), ("Good", "good"), ("Best", "best")]),
|
||||
("blur.smart", "quality") => Some(&[("Low", "low"), ("Medium", "medium"), ("High", "high")]),
|
||||
("pixelate.mezzotint", "type") => Some(&vectorcraft_effects::pixel::MEZZOTINT_TYPES),
|
||||
("path.offsetPath", "joins") => Some(&[("Miter", "miter"), ("Round", "round"), ("Bevel", "bevel")]),
|
||||
("distort.roughen" | "distort.zigZag", "points") => Some(&[("Smooth", "smooth"), ("Corner", "corner")]),
|
||||
_ => None,
|
||||
|
|
|
|||
|
|
@ -350,6 +350,11 @@ pub(super) fn humanize(k: &str) -> String {
|
|||
"Sy" => "Vertical %".into(),
|
||||
"Radius1" => "Radius 1".into(),
|
||||
"Radius2" => "Radius 2".into(),
|
||||
"Max Radius" => "Max. Radius:".into(),
|
||||
"Channel1" => "Channel 1:".into(),
|
||||
"Channel2" => "Channel 2:".into(),
|
||||
"Channel3" => "Channel 3:".into(),
|
||||
"Channel4" => "Channel 4:".into(),
|
||||
"Include Cmy Blacks" => "Include Blacks with CMY:".into(),
|
||||
"Align To Path" => "Align to Path:".into(),
|
||||
_ => format!("{s}:"),
|
||||
|
|
|
|||
|
|
@ -168,7 +168,15 @@ fn effect_preview_is_kept_as_one_undo_step() {
|
|||
|
||||
#[test]
|
||||
fn raster_filter_dialogs_preview_and_apply() {
|
||||
for (effect, key, value) in [("blur.radial", "method", "zoom"), ("blur.smart", "quality", "high"), ("sharpen.unsharpMask", "amount", "120")] {
|
||||
for (effect, key, value) in [
|
||||
("blur.radial", "method", "zoom"),
|
||||
("blur.smart", "quality", "high"),
|
||||
("sharpen.unsharpMask", "amount", "120"),
|
||||
("pixelate.colorHalftone", "channel1", "30"),
|
||||
("pixelate.crystallize", "cellSize", "20"),
|
||||
("pixelate.mezzotint", "type", "longLines"),
|
||||
("pixelate.pointillize", "cellSize", "12"),
|
||||
] {
|
||||
let mut app = app();
|
||||
let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
|
||||
app.run("select.all", json!({})).unwrap();
|
||||
|
|
@ -188,6 +196,13 @@ fn raster_filter_dialogs_preview_and_apply() {
|
|||
let ranks: Vec<usize> = ["radius", "threshold", "quality"].iter().map(|k| super::effect::doc_rank(doc, k)).collect();
|
||||
assert!(ranks.windows(2).all(|w| w[0] < w[1]), "{ranks:?}");
|
||||
assert_eq!(super::effect::doc_rank(doc, "nope"), usize::MAX);
|
||||
let doc = vectorcraft_effects::effect_info("pixelate.colorHalftone").unwrap().params;
|
||||
let ranks: Vec<usize> = ["maxRadius", "channel1", "channel2", "channel3", "channel4"].iter().map(|k| super::effect::doc_rank(doc, k)).collect();
|
||||
assert!(ranks.windows(2).all(|w| w[0] < w[1]) && ranks[4] < usize::MAX, "{ranks:?}");
|
||||
// Labels as the dialogs show them.
|
||||
assert_eq!(super::form::humanize("maxRadius"), "Max. Radius:");
|
||||
assert_eq!(super::form::humanize("channel3"), "Channel 3:");
|
||||
assert_eq!(super::form::humanize("cellSize"), "Cell Size:");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -652,3 +652,8 @@
|
|||
Smart Blur… Chytré rozostření…
|
||||
Sharpen Zostření
|
||||
Unsharp Mask… Maska rozostření…
|
||||
Pixelate Pixelizace
|
||||
Color Halftone… Barevný polotón…
|
||||
Crystallize… Krystalizace…
|
||||
Mezzotint… Mezzotinta…
|
||||
Pointillize… Pointilismus…
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -21,6 +21,31 @@
|
|||
Smart Blur… Desenfoque inteligente…
|
||||
Sharpen Enfocar
|
||||
Unsharp Mask… Máscara de enfoque…
|
||||
Pixelate Pixelizar
|
||||
Color Halftone… Semitono de color…
|
||||
Crystallize… Cristalizar…
|
||||
Mezzotint… Grabado a media tinta…
|
||||
Pointillize… Puntillismo…
|
||||
Color Halftone Semitono de color
|
||||
Crystallize Cristalizar
|
||||
Mezzotint Grabado a media tinta
|
||||
Pointillize Puntillismo
|
||||
Max. Radius Radio máx.
|
||||
Channel 1 Canal 1
|
||||
Channel 2 Canal 2
|
||||
Channel 3 Canal 3
|
||||
Channel 4 Canal 4
|
||||
Cell Size Tamaño de celda
|
||||
Fine Dots Puntos finos
|
||||
Medium Dots Puntos medios
|
||||
Grainy Dots Puntos granulados
|
||||
Coarse Dots Puntos gruesos
|
||||
Short Lines Líneas cortas
|
||||
Medium Lines Líneas medias
|
||||
Long Lines Líneas largas
|
||||
Short Strokes Trazos cortos
|
||||
Medium Strokes Trazos medios
|
||||
Long Strokes Trazos largos
|
||||
Radial Blur Desenfoque radial
|
||||
Smart Blur Desenfoque inteligente
|
||||
Unsharp Mask Máscara de enfoque
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -22,6 +22,31 @@
|
|||
Smart Blur… Flou intelligent…
|
||||
Sharpen Netteté
|
||||
Unsharp Mask… Masque de netteté…
|
||||
Pixelate Pixellisation
|
||||
Color Halftone… Demi-teintes couleur…
|
||||
Crystallize… Cristalliser…
|
||||
Mezzotint… Manière noire…
|
||||
Pointillize… Pointillisme…
|
||||
Color Halftone Demi-teintes couleur
|
||||
Crystallize Cristalliser
|
||||
Mezzotint Manière noire
|
||||
Pointillize Pointillisme
|
||||
Max. Radius Rayon max.
|
||||
Channel 1 Couche 1
|
||||
Channel 2 Couche 2
|
||||
Channel 3 Couche 3
|
||||
Channel 4 Couche 4
|
||||
Cell Size Taille de cellule
|
||||
Fine Dots Points fins
|
||||
Medium Dots Points moyens
|
||||
Grainy Dots Points granuleux
|
||||
Coarse Dots Gros points
|
||||
Short Lines Lignes courtes
|
||||
Medium Lines Lignes moyennes
|
||||
Long Lines Lignes longues
|
||||
Short Strokes Traits courts
|
||||
Medium Strokes Traits moyens
|
||||
Long Strokes Traits longs
|
||||
Radial Blur Flou radial
|
||||
Smart Blur Flou intelligent
|
||||
Unsharp Mask Masque de netteté
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -21,6 +21,31 @@
|
|||
Smart Blur… Sfocatura intelligente…
|
||||
Sharpen Nitidezza
|
||||
Unsharp Mask… Maschera di contrasto…
|
||||
Pixelate Effetto pixel
|
||||
Color Halftone… Mezzetinte colore…
|
||||
Crystallize… Cristallizza…
|
||||
Mezzotint… Mezzatinta…
|
||||
Pointillize… Puntinismo…
|
||||
Color Halftone Mezzetinte colore
|
||||
Crystallize Cristallizza
|
||||
Mezzotint Mezzatinta
|
||||
Pointillize Puntinismo
|
||||
Max. Radius Raggio max.
|
||||
Channel 1 Canale 1
|
||||
Channel 2 Canale 2
|
||||
Channel 3 Canale 3
|
||||
Channel 4 Canale 4
|
||||
Cell Size Dimensione cella
|
||||
Fine Dots Punti fini
|
||||
Medium Dots Punti medi
|
||||
Grainy Dots Punti granulosi
|
||||
Coarse Dots Punti grossi
|
||||
Short Lines Linee corte
|
||||
Medium Lines Linee medie
|
||||
Long Lines Linee lunghe
|
||||
Short Strokes Tratti corti
|
||||
Medium Strokes Tratti medi
|
||||
Long Strokes Tratti lunghi
|
||||
Radial Blur Sfocatura radiale
|
||||
Smart Blur Sfocatura intelligente
|
||||
Unsharp Mask Maschera di contrasto
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -3217,6 +3217,31 @@ theme Appearance 外観
|
|||
Smart Blur… ぼかし (詳細)…
|
||||
Sharpen シャープ
|
||||
Unsharp Mask… アンシャープマスク…
|
||||
Pixelate ピクセレート
|
||||
Color Halftone… カラーハーフトーン…
|
||||
Crystallize… 結晶化…
|
||||
Mezzotint… メゾティント…
|
||||
Pointillize… 点描…
|
||||
Color Halftone カラーハーフトーン
|
||||
Crystallize 結晶化
|
||||
Mezzotint メゾティント
|
||||
Pointillize 点描
|
||||
Max. Radius 最大半径
|
||||
Channel 1 チャンネル 1
|
||||
Channel 2 チャンネル 2
|
||||
Channel 3 チャンネル 3
|
||||
Channel 4 チャンネル 4
|
||||
Cell Size セルの大きさ
|
||||
Fine Dots 細かい点
|
||||
Medium Dots 中程度の点
|
||||
Grainy Dots 粒状の点
|
||||
Coarse Dots 粗い点
|
||||
Short Lines 短い線
|
||||
Medium Lines 中程度の線
|
||||
Long Lines 長い線
|
||||
Short Strokes 短いストローク
|
||||
Medium Strokes 中程度のストローク
|
||||
Long Strokes 長いストローク
|
||||
Radial Blur ぼかし (放射状)
|
||||
Smart Blur ぼかし (詳細)
|
||||
Unsharp Mask アンシャープマスク
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -2713,3 +2713,8 @@
|
|||
Smart Blur… Desfoque Inteligente…
|
||||
Sharpen Nitidez
|
||||
Unsharp Mask… Máscara de Nitidez…
|
||||
Pixelate Pixelizar
|
||||
Color Halftone… Meio-Tom Colorido…
|
||||
Crystallize… Cristalizar…
|
||||
Mezzotint… Meia-Tinta…
|
||||
Pointillize… Pontilhar…
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 6 and column 47.
|
|
|
@ -19,6 +19,31 @@
|
|||
Smart Blur… Умное размытие…
|
||||
Sharpen Резкость
|
||||
Unsharp Mask… Нерезкая маска…
|
||||
Pixelate Пикселизация
|
||||
Color Halftone… Цветные полутона…
|
||||
Crystallize… Кристаллизация…
|
||||
Mezzotint… Меццо-тинто…
|
||||
Pointillize… Пуантилизм…
|
||||
Color Halftone Цветные полутона
|
||||
Crystallize Кристаллизация
|
||||
Mezzotint Меццо-тинто
|
||||
Pointillize Пуантилизм
|
||||
Max. Radius Макс. радиус
|
||||
Channel 1 Канал 1
|
||||
Channel 2 Канал 2
|
||||
Channel 3 Канал 3
|
||||
Channel 4 Канал 4
|
||||
Cell Size Размер ячейки
|
||||
Fine Dots Мелкие точки
|
||||
Medium Dots Средние точки
|
||||
Grainy Dots Зернистые точки
|
||||
Coarse Dots Крупные точки
|
||||
Short Lines Короткие линии
|
||||
Medium Lines Средние линии
|
||||
Long Lines Длинные линии
|
||||
Short Strokes Короткие штрихи
|
||||
Medium Strokes Средние штрихи
|
||||
Long Strokes Длинные штрихи
|
||||
Radial Blur Радиальное размытие
|
||||
Smart Blur Умное размытие
|
||||
Unsharp Mask Нерезкая маска
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -20,6 +20,31 @@
|
|||
Smart Blur… Розумне розмиття…
|
||||
Sharpen Різкість
|
||||
Unsharp Mask… Нерізка маска…
|
||||
Pixelate Пікселізація
|
||||
Color Halftone… Кольорові півтони…
|
||||
Crystallize… Кристалізація…
|
||||
Mezzotint… Меццо-тинто…
|
||||
Pointillize… Пуантилізм…
|
||||
Color Halftone Кольорові півтони
|
||||
Crystallize Кристалізація
|
||||
Mezzotint Меццо-тинто
|
||||
Pointillize Пуантилізм
|
||||
Max. Radius Макс. радіус
|
||||
Channel 1 Канал 1
|
||||
Channel 2 Канал 2
|
||||
Channel 3 Канал 3
|
||||
Channel 4 Канал 4
|
||||
Cell Size Розмір комірки
|
||||
Fine Dots Дрібні точки
|
||||
Medium Dots Середні точки
|
||||
Grainy Dots Зернисті точки
|
||||
Coarse Dots Великі точки
|
||||
Short Lines Короткі лінії
|
||||
Medium Lines Середні лінії
|
||||
Long Lines Довгі лінії
|
||||
Short Strokes Короткі штрихи
|
||||
Medium Strokes Середні штрихи
|
||||
Long Strokes Довгі штрихи
|
||||
Radial Blur Радіальне розмиття
|
||||
Smart Blur Розумне розмиття
|
||||
Unsharp Mask Нерізка маска
|
||||
|
|
|
|||
|
Can't render this file because it has a wrong number of fields in line 13.
|
|
|
@ -3468,6 +3468,31 @@ axis Both 两者
|
|||
Smart Blur… 智能模糊…
|
||||
Sharpen 锐化
|
||||
Unsharp Mask… 反锐化遮罩…
|
||||
Pixelate 像素化
|
||||
Color Halftone… 彩色半调…
|
||||
Crystallize… 晶格化…
|
||||
Mezzotint… 铜版雕刻…
|
||||
Pointillize… 点彩…
|
||||
Color Halftone 彩色半调
|
||||
Crystallize 晶格化
|
||||
Mezzotint 铜版雕刻
|
||||
Pointillize 点彩
|
||||
Max. Radius 最大半径
|
||||
Channel 1 色版 1
|
||||
Channel 2 色版 2
|
||||
Channel 3 色版 3
|
||||
Channel 4 色版 4
|
||||
Cell Size 单元格大小
|
||||
Fine Dots 细点
|
||||
Medium Dots 中等点
|
||||
Grainy Dots 颗粒点
|
||||
Coarse Dots 粗点
|
||||
Short Lines 短线
|
||||
Medium Lines 中等线
|
||||
Long Lines 长线
|
||||
Short Strokes 短笔画
|
||||
Medium Strokes 中等笔画
|
||||
Long Strokes 长笔画
|
||||
Radial Blur 径向模糊
|
||||
Smart Blur 智能模糊
|
||||
Unsharp Mask 反锐化遮罩
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 2 and column 73.
|
|
|
@ -3246,6 +3246,31 @@ axis Both 兩者
|
|||
Smart Blur… 智慧型模糊…
|
||||
Sharpen 銳利化
|
||||
Unsharp Mask… 反銳利化遮罩…
|
||||
Pixelate 像素化
|
||||
Color Halftone… 彩色半色調…
|
||||
Crystallize… 結晶化…
|
||||
Mezzotint… 網線銅版…
|
||||
Pointillize… 點描…
|
||||
Color Halftone 彩色半色調
|
||||
Crystallize 結晶化
|
||||
Mezzotint 網線銅版
|
||||
Pointillize 點描
|
||||
Max. Radius 最大半徑
|
||||
Channel 1 色版 1
|
||||
Channel 2 色版 2
|
||||
Channel 3 色版 3
|
||||
Channel 4 色版 4
|
||||
Cell Size 單元大小
|
||||
Fine Dots 細點
|
||||
Medium Dots 中等點
|
||||
Grainy Dots 顆粒點
|
||||
Coarse Dots 粗點
|
||||
Short Lines 短線
|
||||
Medium Lines 中等線
|
||||
Long Lines 長線
|
||||
Short Strokes 短筆畫
|
||||
Medium Strokes 中等筆畫
|
||||
Long Strokes 長筆畫
|
||||
Radial Blur 放射狀模糊
|
||||
Smart Blur 智慧型模糊
|
||||
Unsharp Mask 反銳利化遮罩
|
||||
|
|
|
|||
|
Can't render this file because it contains an unexpected character in line 6 and column 47.
|
|
|
@ -3305,7 +3305,8 @@ fn font_items(english_names: bool) -> Vec<Item> {
|
|||
|
||||
/// The raster effects' submenus of the Effect menu (the Photoshop-style effects, below the
|
||||
/// vector effects): (submenu, the catalogue's menu path of its effects).
|
||||
const RASTER_MENUS: [(&str, &[&str]); 2] = [("Blur", &["Effect", "Blur"]), ("Sharpen", &["Effect", "Sharpen"])];
|
||||
const RASTER_MENUS: [(&str, &[&str]); 3] =
|
||||
[("Blur", &["Effect", "Blur"]), ("Pixelate", &["Effect", "Pixelate"]), ("Sharpen", &["Effect", "Sharpen"])];
|
||||
|
||||
/// The Effect menu, built from the effects catalogue (vector effects), plus raster effects.
|
||||
fn effect_menu() -> Vec<Item> {
|
||||
|
|
|
|||
|
|
@ -50,6 +50,20 @@ fn effect_menu_has_a_vector_effects_section() {
|
|||
assert!(effect.iter().any(|i| matches!(i, Item::Header("Vector Effects"))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn effect_menu_lists_the_pixelate_filters_between_blur_and_sharpen() {
|
||||
let app = app();
|
||||
let entries = menus::menu_entries(&app);
|
||||
let pixelate: Vec<_> = entries.iter().filter(|e| e.path == ["Effect", "Pixelate"]).collect();
|
||||
let labels: Vec<&str> = pixelate.iter().map(|e| e.label.as_str()).collect();
|
||||
assert_eq!(labels, ["Color Halftone…", "Crystallize…", "Mezzotint…", "Pointillize…"]);
|
||||
assert!(pixelate.iter().all(|e| e.command.as_deref() == Some("effect.dialog")));
|
||||
let raster: Vec<&str> =
|
||||
entries.iter().filter_map(|e| e.path.get(1).filter(|_| e.path.len() == 2 && e.path[0] == "Effect")).map(String::as_str).collect();
|
||||
let at = |name: &str| raster.iter().position(|s| *s == name).unwrap();
|
||||
assert!(at("Blur") < at("Pixelate") && at("Pixelate") < at("Sharpen"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn library_submenus_are_disabled_placeholders() {
|
||||
let app = app();
|
||||
|
|
|
|||
Loading…
Reference in New Issue