a770fa5a5e5f
raster.rs
//! CPU rasteriser: draws a display list with tiny-skia (PNG export, plot preview, tests).
use cadcraft_color::Rgb;
use cadcraft_geom::{Bounds2, Vec2};
use tiny_skia::{FillRule, LineCap, LineJoin, Paint, PathBuilder, Pixmap, Stroke, Transform};
use crate::{DImage, DisplayList, Kind};
/// A 2D view: world point at the image centre and pixels per drawing unit.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct View {
pub center: Vec2,
pub scale: f64,
pub width: u32,
pub height: u32,
}
impl View {
pub fn to_screen(&self, p: Vec2) -> (f32, f32) {
let x = (p.x - self.center.x) * self.scale + f64::from(self.width) / 2.0;
let y = f64::from(self.height) / 2.0 - (p.y - self.center.y) * self.scale;
(x as f32, y as f32)
}
/// Fit `b` with a margin fraction.
pub fn fit(b: &Bounds2, width: u32, height: u32, margin: f64) -> View {
if b.is_empty() {
return View { center: Vec2::ZERO, scale: 1.0, width, height };
}
let w = b.width().max(1e-9);
let h = b.height().max(1e-9);
let s = (f64::from(width) / w).min(f64::from(height) / h) * (1.0 - margin);
View { center: b.center(), scale: if s.is_finite() && s > 0.0 { s } else { 1.0 }, width, height }
}
/// The view of `window` (drawing units), filling the image: `width` × `height` pixels when both
/// are given; otherwise the side given (default 1600 wide) with the other matching the window's
/// shape, each side 16..=8192.
pub fn of_window(window: &Bounds2, width: Option<u32>, height: Option<u32>) -> View {
let aspect = if window.width() > 1e-12 && window.height() > 1e-12 { window.width() / window.height() } else { 1.0 };
let side = |v: f64| v.round().clamp(16.0, 8192.0) as u32;
let (w, h) = match (width, height) {
(Some(w), Some(h)) => (side(f64::from(w)), side(f64::from(h))),
(None, Some(h)) => (side(f64::from(h) * aspect), side(f64::from(h))),
(w, None) => {
let w = f64::from(w.unwrap_or(1600));
(side(w), side(w / aspect))
}
};
View::fit(window, w, h, 0.0)
}
pub fn world_bounds(&self) -> Bounds2 {
let hw = f64::from(self.width) / 2.0 / self.scale;
let hh = f64::from(self.height) / 2.0 / self.scale;
Bounds2::new(self.center - Vec2::new(hw, hh), self.center + Vec2::new(hw, hh))
}
}
#[derive(Clone, Copy, Debug)]
pub struct RasterOptions {
pub background: Rgb,
/// Line width in pixels for zero-lineweight lines.
pub hairline: f32,
/// Pixels per mm for lineweights (0 = ignore lineweights).
pub px_per_mm: f32,
pub antialias: bool,
}
impl RasterOptions {
/// The dark canvas a render draws on by default.
pub const DARK_BACKGROUND: Rgb = Rgb(33, 40, 48);
}
impl Default for RasterOptions {
fn default() -> Self {
RasterOptions { background: Self::DARK_BACKGROUND, hairline: 1.0, px_per_mm: 0.0, antialias: true }
}
}
/// Render to a pixmap. Returns `None` for zero or absurd sizes.
pub fn render(list: &DisplayList, view: &View, o: &RasterOptions) -> Option<Pixmap> {
if view.width == 0 || view.height == 0 || view.width > 16384 || view.height > 16384 {
return None;
}
let mut pm = Pixmap::new(view.width, view.height)?;
pm.fill(tiny_skia::Color::from_rgba8(o.background.0, o.background.1, o.background.2, 255));
let vis = view.world_bounds();
let mut hairlines = Hairlines::default();
let mut screen: Vec<(f32, f32)> = Vec::new();
for p in &list.prims {
let c = p.display_rgb(o.background);
let mut paint = Paint::default();
// A transparent object blends with what is drawn under it.
paint.set_color_rgba8(c.0, c.1, c.2, p.alpha());
paint.anti_alias = o.antialias;
let pts = list.points(p);
if p.kind != Kind::Polyline {
hairlines.flush(&mut pm, o.antialias);
}
match p.kind {
Kind::Polyline => {
let bb = Bounds2::from_points(pts.iter().copied());
if !bb.intersects(&vis) {
continue;
}
let w = if o.px_per_mm > 0.0 && p.lw > 0.0 { (p.lw * o.px_per_mm).max(o.hairline) } else { o.hairline };
screen.clear();
screen.extend(pts.iter().map(|q| view.to_screen(*q)));
if is_hairline(w, o.antialias) && screen.len() >= 2 && screen.iter().all(|&(x, y)| batchable(x) && batchable(y)) {
hairlines.add(&mut pm, [c.0, c.1, c.2, p.alpha()], w, &screen, o.antialias);
continue;
}
hairlines.flush(&mut pm, o.antialias);
let mut pb = PathBuilder::new();
for (i, (x, y)) in screen.iter().enumerate() {
if i == 0 {
pb.move_to(*x, *y);
} else {
pb.line_to(*x, *y);
}
}
if let Some(path) = pb.finish() {
let stroke = Stroke { width: w, line_cap: LineCap::Round, line_join: LineJoin::Round, ..Default::default() };
pm.stroke_path(&path, &paint, &stroke, Transform::identity(), None);
}
}
Kind::Tris | Kind::Mask => {
if p.kind == Kind::Mask {
paint.set_color_rgba8(o.background.0, o.background.1, o.background.2, 255);
}
let mut pb = PathBuilder::new();
for t in pts.chunks(3) {
if let [a, b, c] = t {
let (ax, ay) = view.to_screen(*a);
let (bx, by) = view.to_screen(*b);
let (cx, cy) = view.to_screen(*c);
pb.move_to(ax, ay);
pb.line_to(bx, by);
pb.line_to(cx, cy);
pb.close();
}
}
if let Some(path) = pb.finish() {
pm.fill_path(&path, &paint, FillRule::Winding, Transform::identity(), None);
}
}
Kind::Point => {
if let Some(q) = pts.first() {
let (x, y) = view.to_screen(*q);
// Filled as a path: tiny-skia's anti-aliased `fill_rect` trips a debug
// assertion on rects under two pixels wide whose sides both fall mid-pixel.
if let Some(r) = tiny_skia::Rect::from_xywh(x - 0.5, y - 0.5, 1.5, 1.5) {
pm.fill_path(&PathBuilder::from_rect(r), &paint, FillRule::Winding, Transform::identity(), None);
}
}
}
Kind::Image { index } => {
if let Some(img) = list.images.get(index as usize)
&& Bounds2::from_points(pts.iter().copied()).intersects(&vis)
{
image(&mut pm, img, view, p.alpha(), o.antialias);
}
}
Kind::Infinite { ray } => {
let (Some(base), Some(dir)) = (pts.first(), pts.get(1)) else { continue };
let far = (vis.width() + vis.height()) * 2.0 + base.dist(vis.center());
let a = if ray { *base } else { *base - *dir * far };
let b = *base + *dir * far;
let mut pb = PathBuilder::new();
let (ax, ay) = view.to_screen(a);
let (bx, by) = view.to_screen(b);
pb.move_to(ax, ay);
pb.line_to(bx, by);
if let Some(path) = pb.finish() {
pm.stroke_path(&path, &paint, &Stroke { width: o.hairline, ..Default::default() }, Transform::identity(), None);
}
}
}
}
hairlines.flush(&mut pm, o.antialias);
Some(pm)
}
/// Whether tiny-skia strokes a line `width` pixels wide (untransformed) as a hairline: zero
/// width, or at most one pixel when anti-aliased.
fn is_hairline(width: f32, antialias: bool) -> bool {
width == 0.0 || (antialias && width <= 1.0)
}
/// Largest screen coordinate (pixels) of a polyline stroked together with others. Beyond it a
/// path's integer bounds could overflow, so such a polyline is stroked on its own as before.
const MAX_BATCH_COORD: f32 = 1.0e8;
fn batchable(v: f32) -> bool {
v.is_finite() && v.abs() <= MAX_BATCH_COORD
}
/// Consecutive hairline polylines with the same colour, alpha and width, stroked as one path.
///
/// tiny-skia draws a hairline segment by segment straight onto the pixmap (each segment with
/// its own caps, a polyline's first and last segment extended for round caps), so one path of
/// several polylines paints exactly the pixels, in the same order, as stroking them one by one;
/// it saves building a paint pipeline and a path per polyline. Thicker strokes are filled
/// outlines, where overlaps would cover once instead of twice, and are never batched.
#[derive(Default)]
struct Hairlines {
key: Option<([u8; 4], f32)>,
pb: PathBuilder,
}
impl Hairlines {
fn add(&mut self, pm: &mut Pixmap, rgba: [u8; 4], width: f32, pts: &[(f32, f32)], antialias: bool) {
if self.key.is_some_and(|k| k != (rgba, width)) {
self.flush(pm, antialias);
}
self.key = Some((rgba, width));
for (i, (x, y)) in pts.iter().enumerate() {
if i == 0 {
self.pb.move_to(*x, *y);
} else {
self.pb.line_to(*x, *y);
}
}
}
fn flush(&mut self, pm: &mut Pixmap, antialias: bool) {
let Some(([r, g, b, a], width)) = self.key.take() else { return };
let pb = std::mem::take(&mut self.pb);
let Some(path) = pb.finish() else { return };
let mut paint = Paint::default();
paint.set_color_rgba8(r, g, b, a);
paint.anti_alias = antialias;
let stroke = Stroke { width, line_cap: LineCap::Round, line_join: LineJoin::Round, ..Default::default() };
pm.stroke_path(&path, &paint, &stroke, Transform::identity(), None);
self.pb = path.clear();
}
}
/// Blank (white) everything outside `printable`, a rectangle in paper units with the origin at the
/// sheet's bottom-left, on a pixmap showing the whole sheet at `px_per_unit` pixels per paper unit.
/// A placed plot is clipped to the printable area this way, in the PNG plot and in the preview.
pub fn blank_outside_printable(pm: &mut Pixmap, printable: &Bounds2, px_per_unit: f64) {
let ph = f64::from(pm.height());
blank_outside_pixels(
pm,
(printable.min.x * px_per_unit, ph - printable.max.y * px_per_unit),
(printable.max.x * px_per_unit, ph - printable.min.y * px_per_unit),
);
}
/// Blank (white) everything outside the pixel rectangle from `top_left` to `bottom_right` (image
/// coordinates, y down; rounded and clamped to the image). For a pixmap whose view does not map
/// the sheet onto the whole image, map the printable corners through `View::to_screen`.
pub fn blank_outside_pixels(pm: &mut Pixmap, top_left: (f64, f64), bottom_right: (f64, f64)) {
let (pw, ph) = (pm.width(), pm.height());
let col = |x: f64| x.round().clamp(0.0, f64::from(pw)) as usize;
let row = |y: f64| y.round().clamp(0.0, f64::from(ph)) as usize;
let (x0, x1) = (col(top_left.0), col(bottom_right.0));
let (y0, y1) = (row(top_left.1), row(bottom_right.1));
let stride = pw as usize * 4;
for (r, line) in pm.data_mut().chunks_exact_mut(stride.max(4)).enumerate() {
for (c, px) in line.as_chunks_mut::<4>().0.iter_mut().enumerate() {
if r < y0 || r >= y1 || c < x0 || c >= x1 {
px.copy_from_slice(&[255, 255, 255, 255]);
}
}
}
}
/// Draw `img` with the object opacity `alpha`, cut to its clip outlines.
fn image(pm: &mut Pixmap, img: &DImage, view: &View, alpha: u8, antialias: bool) {
let r = &img.raster;
let Some(to_screen) = grid_to_screen(img, view) else { return };
let Ok(mask) = clip_mask(pm, img, view, antialias) else { return };
// tiny-skia wants premultiplied pixels; opaque ones already are.
let owned;
let pixels = if r.opaque() {
tiny_skia::PixmapRef::from_bytes(r.rgba(), r.width(), r.height())
} else {
owned = premultiplied(r);
owned.as_ref().map(Pixmap::as_ref)
};
let Some(pixels) = pixels else { return };
let paint = Paint {
shader: tiny_skia::Pattern::new(
pixels,
tiny_skia::SpreadMode::Pad,
tiny_skia::FilterQuality::Bilinear,
img.opacity(alpha),
Transform::identity(),
),
anti_alias: antialias,
..Paint::default()
};
// The picture's own rectangle in its pixel grid, carried to the screen by `to_screen`.
// Filled as a path: tiny-skia's anti-aliased `fill_rect` trips a debug assertion on narrow
// rects (see the points above), which a one-pixel image drawn at its own size would be.
if let Some(rect) = tiny_skia::Rect::from_xywh(0.0, 0.0, r.width() as f32, r.height() as f32) {
pm.fill_path(&PathBuilder::from_rect(rect), &paint, FillRule::Winding, to_screen, mask.as_ref());
}
}
/// The transform from `img`'s pixel grid (x right, y down) to screen pixels; `None` when the
/// image has no area on screen or lies out of number range.
fn grid_to_screen(img: &DImage, view: &View) -> Option<Transform> {
let s = view.scale;
let (x, y) = view.to_screen(img.origin);
// Screen y runs down, world y up.
let ts = Transform::from_row((img.right.x * s) as f32, (-img.right.y * s) as f32, (img.down.x * s) as f32, (-img.down.y * s) as f32, x, y);
(ts.is_finite() && ts.invert().is_some()).then_some(ts)
}
/// The image has a clip outline without area: nothing of it shows.
struct Hidden;
/// The part of the picture `img`'s clip outlines leave visible: `None` for all of it.
fn clip_mask(pm: &Pixmap, img: &DImage, view: &View, antialias: bool) -> Result<Option<tiny_skia::Mask>, Hidden> {
let mut mask: Option<tiny_skia::Mask> = None;
for outline in &img.clips {
let path = outline_path(outline, view).ok_or(Hidden)?;
match &mut mask {
// The first outline starts the mask; each further one narrows it.
None => {
let mut m = tiny_skia::Mask::new(pm.width(), pm.height()).ok_or(Hidden)?;
m.fill_path(&path, FillRule::EvenOdd, antialias, Transform::identity());
mask = Some(m);
}
Some(m) => m.intersect_path(&path, FillRule::EvenOdd, antialias, Transform::identity()),
}
}
Ok(mask)
}
/// A closed world-space outline as a screen path.
fn outline_path(outline: &[Vec2], view: &View) -> Option<tiny_skia::Path> {
let mut pb = PathBuilder::new();
for (i, q) in outline.iter().enumerate() {
let (x, y) = view.to_screen(*q);
if i == 0 {
pb.move_to(x, y);
} else {
pb.line_to(x, y);
}
}
pb.close();
pb.finish()
}
/// The pixels of `r` with each colour multiplied by its alpha.
fn premultiplied(r: &cadcraft_doc::Raster) -> Option<Pixmap> {
let mut data = Vec::with_capacity(r.rgba().len());
for [red, green, blue, a] in r.rgba().as_chunks::<4>().0 {
let m = |c: &u8| ((u16::from(*c) * u16::from(*a) + 127) / 255) as u8;
data.extend_from_slice(&[m(red), m(green), m(blue), *a]);
}
Pixmap::from_vec(data, tiny_skia::IntSize::from_wh(r.width(), r.height())?)
}
/// Write straight-alpha RGBA8 pixels as PNG a row at a time.
pub fn write_rgba_png(mut output: impl std::io::Write, width: u32, height: u32, pixels: &[u8]) -> Option<()> {
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
let stride = usize::try_from(width).ok()?.checked_mul(4).filter(|n| *n > 0)?;
let expected = stride.checked_mul(usize::try_from(height).ok()?)?;
if height == 0 || pixels.len() != expected {
return None;
}
let mut rows = pixels.chunks_exact(stride);
let row = |data: &[u8]| Image::from_u8(width, 1, ChannelLayout::Rgba, data.to_vec()).ok();
let first = row(rows.next()?)?;
let mut encoder = PngRows::new(&mut output, &first, height, &EncodeOptions::default()).ok()?;
encoder.push(&first).ok()?;
for data in rows {
encoder.push(&row(data)?).ok()?;
}
encoder.finish().ok()
}
/// Encode a premultiplied pixmap as PNG without a second full-frame copy.
pub fn encode_png(pixmap: &Pixmap) -> Option<Vec<u8>> {
use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, PngRows};
let width = usize::try_from(pixmap.width()).ok()?.max(1);
let mut rows = pixmap.pixels().chunks_exact(width);
let make_row = |row: &[tiny_skia::PremultipliedColorU8]| {
let rgba = row
.iter()
.flat_map(|p| {
let c = p.demultiply();
[c.red(), c.green(), c.blue(), c.alpha()]
})
.collect();
Image::from_u8(pixmap.width(), 1, ChannelLayout::Rgba, rgba).ok()
};
let first = make_row(rows.next()?)?;
let mut out = Vec::new();
let mut encoder = PngRows::new(&mut out, &first, pixmap.height(), &EncodeOptions::default()).ok()?;
encoder.push(&first).ok()?;
for row in rows {
encoder.push(&make_row(row)?).ok()?;
}
encoder.finish().ok()?;
Some(out)
}
/// Render and encode as PNG.
pub fn render_png(list: &DisplayList, view: &View, o: &RasterOptions) -> Option<Vec<u8>> {
encode_png(&render(list, view, o)?)
}
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.