[0.6.5][rasterize] better argument names

Author: aslpavel

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rasterize"
-version = "0.6.4"
+version = "0.6.5"
 authors = ["Pavel Aslanov <asl.pavel@gmail.com>"]
 description = "Simple and small 2D rendering library"
 edition = "2024"

examples/rasterize.rs

@@ -5,8 +5,7 @@ use rasterize::*;
 use std::{
     env,
     fs::File,
-    io::{BufReader, BufWriter, Read, Write},
-    str::FromStr,
+    io::{BufReader, BufWriter, Read},
     sync::Arc,
 };
 use tracing_subscriber::{EnvFilter, fmt::format::FmtSpan};
@@ -19,47 +18,11 @@ enum RasterizerType {
     SignedDifference,
 }
 
-#[derive(Debug, Clone, Copy)]
-enum OutputFormat {
-    Bmp,
-    Rgba,
-    #[cfg(feature = "png")]
-    Png,
-}
-
-impl OutputFormat {
-    fn write(self, image: &Layer<LinColor>, out: impl Write) -> Result<(), Error> {
-        match self {
-            OutputFormat::Bmp => image.write_bmp(out)?,
-            #[cfg(feature = "png")]
-            OutputFormat::Png => image.write_png(out)?,
-            OutputFormat::Rgba => image.write_rgba(out)?,
-        }
-        Ok(())
-    }
-}
-
-impl FromStr for OutputFormat {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "bmp" => Ok(OutputFormat::Bmp),
-            "rgba" => Ok(OutputFormat::Rgba),
-            #[cfg(feature = "png")]
-            "png" => Ok(OutputFormat::Png),
-            #[cfg(not(feature = "png"))]
-            "png" => Err("png feature is disabled".into()),
-            _ => Err(format!("Invalid output format: {s}").into()),
-        }
-    }
-}
-
 #[derive(Debug)]
 struct Args {
     input_file: String,
     output_file: String,
-    output_format: OutputFormat,
+    output_format: ImageWriteFormat,
     outline: bool,
     size: Size,
     stroke: Option<Scalar>,
@@ -84,7 +47,7 @@ impl Args {
         let mut result = Args {
             input_file: String::new(),
             output_file: String::new(),
-            output_format: OutputFormat::Bmp,
+            output_format: ImageWriteFormat::Bmp,
             outline: false,
             size: Size {
                 height: 0,
@@ -109,8 +72,8 @@ impl Args {
                 "-w" => {
                     result.size.width = args.next().ok_or("-w requires argument")?.parse()?;
                 }
-                "-b" => {
-                    let view_box = args.next().ok_or("-b requires argument")?;
+                "-v" => {
+                    let view_box = args.next().ok_or("-v requires argument")?;
                     result.view_box.replace(view_box.parse()?);
                 }
                 "-t" => {
@@ -121,21 +84,8 @@ impl Args {
                     let stroke = args.next().ok_or("-s requres argument")?;
                     result.stroke.replace(stroke.parse()?);
                 }
-                "-o" => {
-                    result.outline = true;
-                }
-                "-of" => {
-                    result.output_format = args.next().ok_or("-of requries argument")?.parse()?;
-                }
-                "-a" => {
-                    result.rasterizer = RasterizerType::ActiveEdge;
-                }
                 "-f" => {
-                    let flatness: Scalar = args.next().ok_or("-f requres argument")?.parse()?;
-                    if flatness < EPSILON {
-                        return Err("flatness is too small".into());
-                    }
-                    result.flatness = flatness;
+                    result.output_format = args.next().ok_or("-of requries argument")?.parse()?;
                 }
                 "-fg" => {
                     let fg = args
@@ -151,6 +101,19 @@ impl Args {
                         .parse()?;
                     result.bg.replace(bg);
                 }
+                "-ro" => {
+                    result.outline = true;
+                }
+                "-ra" => {
+                    result.rasterizer = RasterizerType::ActiveEdge;
+                }
+                "-rf" => {
+                    let flatness: Scalar = args.next().ok_or("-rf requres argument")?.parse()?;
+                    if flatness < EPSILON {
+                        return Err("flatness is too small".into());
+                    }
+                    result.flatness = flatness;
+                }
                 _ => {
                     positional += 1;
                     match positional {
@@ -163,35 +126,38 @@ impl Args {
         }
         if positional < 2 {
             eprintln!(
-                "Very simple tool that accepts SVG path as an input and produces rasterized image"
+                "Very simple tool that accepts SVG path as an input and produces rasterized image",
             );
             eprintln!("\nUSAGE:");
             eprintln!(
-                "    rasterize [-h <height>] [-w <width>] [-b <bbox>] [-t <transform>] [-s <stroke>]",
+                "    rasterize [-h <height>] [-w <width>] [-v <view_box>] [-t <transform>] [-s <stroke>]",
             );
             eprintln!(
-                "              [-f <flatness>] [-o] [-of <format>] [-a] [-fg <color>] [-bg <color>]",
+                "              [-fg <color>] [-bg <color>] [-f <format>] [-rf <flatness>] [-ro] [-ra]",
             );
             eprintln!("              <input_file> <output_file>");
             eprintln!("\nARGS:");
             eprintln!("    -h <height>        height in pixels of the output image");
             eprintln!("    -w <width>         width in pixels of the output image");
-            eprintln!("    -b <view_box>      view box");
+            eprintln!("    -v <view_box>      view box");
             eprintln!("    -t <transform>     apply transform");
             eprintln!("    -s <stroke_width>  stroke path before rendering");
-            eprintln!("    -o                 show outline with control points instead of filling");
-            eprintln!("    -of <format>       output file format (bmp, png, rgba)");
-            eprintln!(
-                "    -a                 use active-edge instead of signed-difference rasterizer"
-            );
+            eprintln!("    -f <format>        output file format (bmp, png, rgba)");
             eprintln!("    -fg <color>        foreground color");
             eprintln!("    -bg <color>        background color");
             eprintln!(
-                "    -f <flatness>      flatness used by rasterizer (defualt: {})",
+                "    -rf <flatness>     flatness used by rasterizer (defualt: {})",
                 DEFAULT_FLATNESS
             );
+            eprintln!(
+                "    -ro                rasterize outline with control points instead of filling"
+            );
+            eprintln!(
+                "    -ra                rasterize active-edge instead of signed-difference rasterizer"
+            );
             eprintln!("    <input_file>       file containing SVG path ('-' means stdin)");
             eprintln!("    <output_file>      image rendered in the BMP format ('-' means stdout)");
+            eprintln!("\nVERSION: {}", env!("CARGO_PKG_VERSION"));
             std::process::exit(1);
         }
         Ok(result)
@@ -350,9 +316,9 @@ fn main() -> Result<(), Error> {
         let _ = save.enter();
         if args.output_file != "-" {
             let mut image_file = BufWriter::new(File::create(args.output_file)?);
-            args.output_format.write(&image, &mut image_file)?;
+            image.write(args.output_format, &mut image_file)?;
         } else {
-            args.output_format.write(&image, std::io::stdout())?;
+            image.write(args.output_format, std::io::stdout())?;
         }
     }
 

examples/scene.rs

@@ -3,7 +3,7 @@
 use rasterize::*;
 use std::{
     fs::File,
-    io::{BufReader, BufWriter},
+    io::{BufReader, BufWriter, Read},
 };
 use tracing::debug_span;
 use tracing_subscriber::{EnvFilter, fmt::format::FmtSpan};
@@ -14,29 +14,38 @@ type Error = Box<dyn std::error::Error>;
 struct Args {
     input_file: String,
     output_file: String,
-    tr: Transform,
+    tr: Option<Transform>,
+    view_box: Option<BBox>,
     bg: Option<LinColor>,
-    width: Option<usize>,
+    size: Size,
+    output_format: ImageWriteFormat,
 }
 
 impl Args {
     fn parse() -> Result<Self, Error> {
         let mut result = Self::default();
         let mut args = std::env::args();
         let mut positional = 0;
-        let cmd = args.next().unwrap_or_else(|| "scene".to_string());
+        let _cmd = args.next().unwrap_or_else(|| "scene".to_string());
         while let Some(arg) = args.next() {
             match arg.as_ref() {
                 "-h" => {
-                    positional = 0;
-                    break;
+                    result.size.height = args.next().ok_or("-h requires argument")?.parse()?;
                 }
                 "-w" => {
-                    let width = args.next().ok_or("-w requires argument")?;
-                    result.width = Some(width.parse()?);
+                    result.size.width = args.next().ok_or("-w requires argument")?.parse()?;
+                }
+                "-v" => {
+                    let view_box = args.next().ok_or("-v requires argument")?;
+                    result.view_box.replace(view_box.parse()?);
                 }
                 "-t" => {
-                    result.tr = args.next().ok_or("-t requires argument")?.parse()?;
+                    result
+                        .tr
+                        .replace(args.next().ok_or("-t requires argument")?.parse()?);
+                }
+                "-f" => {
+                    result.output_format = args.next().ok_or("-of requries argument")?.parse()?;
                 }
                 "-bg" => {
                     let bg = args
@@ -60,17 +69,19 @@ impl Args {
             eprintln!("Render scene from JSON serialized representation");
             eprintln!();
             eprintln!("USAGE:");
-            eprintln!(
-                "    {} [-w <width>] [-bg <color>] [-t <transform>] <scene> <output>",
-                cmd
-            );
+            eprintln!("    scene [-h <height>] [-w <width>] [-v <view_box>] [-t <transform>]",);
+            eprintln!("          [-f <format>] [-bg <color>] <scene> <output>",);
             eprintln!();
             eprintln!("ARGS:");
+            eprintln!("    -h <height>     height in pixels of the output image");
             eprintln!("    -w <width>      width in pixels of the output image");
+            eprintln!("    -v <view_box>   view box");
             eprintln!("    -t <transform>  apply transform");
+            eprintln!("    -f <format>     output file format (bmp, png, rgba)");
             eprintln!("    -bg <color>     background color");
             eprintln!("    <scene>         file containing JSON scene ('-' means stdin)");
             eprintln!("    <output>        rendered scene ('-' means stdout)");
+            eprintln!("\nVERSION: {}", env!("CARGO_PKG_VERSION"));
             std::process::exit(1);
         }
 
@@ -87,35 +98,39 @@ fn main() -> Result<(), Error> {
 
     let args = Args::parse()?;
 
-    let scene: Scene = if args.input_file != "-" {
-        let input = BufReader::new(File::open(args.input_file)?);
-        serde_json::from_reader(input)?
-    } else {
-        serde_json::from_reader(BufReader::new(std::io::stdin()))?
+    // scene
+    let scene: Scene = {
+        let file: &mut dyn Read = match args.input_file.as_str() {
+            "-" => &mut std::io::stdin(),
+            input_file => &mut File::open(input_file)?,
+        };
+        serde_json::from_reader(BufReader::new(file))?
+    };
+    let scene = match args.tr {
+        None => scene,
+        Some(tr) => scene.transform(tr),
     };
 
-    let tr = match args.width {
-        Some(width) if width > 2 => {
-            let src_bbox = scene.bbox(args.tr).ok_or("scene is empty")?;
-            let width = width as Scalar;
-            let height = src_bbox.height() * width / src_bbox.width();
-            let dst_bbox = BBox::new(Point::new(1.0, 1.0), Point::new(width - 1.0, height - 1.0));
-            Transform::fit_bbox(src_bbox, dst_bbox, Align::Mid) * args.tr
-        }
-        _ => args.tr,
+    // render transform
+    let Some(view_box) = args.view_box.or_else(|| scene.bbox(Transform::identity())) else {
+        return Err("nothing to render".into());
     };
+    let (size, tr) = Transform::fit_size(view_box, args.size, Align::Mid);
+    let bbox = BBox::new((0.0, 0.0), (size.width as Scalar, size.height as Scalar));
 
+    // render
     let image = debug_span!("[render]")
-        .in_scope(|| scene.render(&ActiveEdgeRasterizer::default(), tr, None, args.bg));
+        .in_scope(|| scene.render(&ActiveEdgeRasterizer::default(), tr, Some(bbox), args.bg));
 
+    // save
     let save = debug_span!("[save]");
     {
         let _ = save.enter();
         if args.output_file != "-" {
             let mut image_file = BufWriter::new(File::create(args.output_file)?);
-            image.write_bmp(&mut image_file)?;
+            image.write(args.output_format, &mut image_file)?;
         } else {
-            image.write_bmp(std::io::stdout())?;
+            image.write(args.output_format, std::io::stdout())?;
         }
     }
 

src/image.rs

@@ -1,5 +1,5 @@
 use crate::{Color, Size};
-use std::{any::type_name, fmt, io::Write, sync::Arc};
+use std::{any::type_name, fmt, io::Write, str::FromStr, sync::Arc};
 
 /// Shape defines size and layout of the data inside an image
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -118,6 +118,20 @@ pub trait Image {
         }
     }
 
+    fn write(self, fmt: ImageWriteFormat, out: impl Write) -> Result<(), std::io::Error>
+    where
+        Self::Pixel: Color,
+        Self: Sized,
+    {
+        match fmt {
+            ImageWriteFormat::Bmp => self.write_bmp(out)?,
+            #[cfg(feature = "png")]
+            ImageWriteFormat::Png => self.write_png(out)?,
+            ImageWriteFormat::Rgba => self.write_rgba(out)?,
+        }
+        Ok(())
+    }
+
     /// Write raw (height, width, RGBA...) data
     fn write_rgba<W>(&self, mut out: W) -> Result<(), std::io::Error>
     where
@@ -217,6 +231,31 @@ pub trait Image {
     }
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+pub enum ImageWriteFormat {
+    #[default]
+    Bmp,
+    Rgba,
+    #[cfg(feature = "png")]
+    Png,
+}
+
+impl FromStr for ImageWriteFormat {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "bmp" => Ok(ImageWriteFormat::Bmp),
+            "rgba" => Ok(ImageWriteFormat::Rgba),
+            #[cfg(feature = "png")]
+            "png" => Ok(ImageWriteFormat::Png),
+            #[cfg(not(feature = "png"))]
+            "png" => Err("png feature is disabled".into()),
+            _ => Err(format!("Invalid output format: {s}")),
+        }
+    }
+}
+
 /// Immutable iterator over pixels
 pub struct ImageIter<'a, P> {
     index: usize,

src/lib.rs

@@ -52,7 +52,8 @@ pub use geometry::{
 };
 pub use grad::{GradLinear, GradRadial, GradSpread, GradStop, GradStops};
 pub use image::{
-    Image, ImageIter, ImageMut, ImageMutIter, ImageMutRef, ImageOwned, ImageRef, Shape,
+    Image, ImageIter, ImageMut, ImageMutIter, ImageMutRef, ImageOwned, ImageRef, ImageWriteFormat,
+    Shape,
 };
 pub use path::{
     DEFAULT_FLATNESS, FillRule, LineCap, LineJoin, Path, PathBuilder, StrokeStyle, SubPath,