bring single-threaded branch up to date

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "mandelbrot"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Jim Blandy <jimb@red-bean.com>"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
+image = "0.25"
 num = "0.4"
-image = "0.13.0"

src/main.rs

@@ -36,39 +36,43 @@ use std::str::FromStr;
 fn parse_pair<T: FromStr>(s: &str, separator: char) -> Option<(T, T)> {
     match s.find(separator) {
         None => None,
-        Some(index) => {
-            match (T::from_str(&s[..index]), T::from_str(&s[index + 1..])) {
-                (Ok(l), Ok(r)) => Some((l, r)),
-                _ => None
-            }
-        }
+        Some(index) => match (T::from_str(&s[..index]), T::from_str(&s[index + 1..])) {
+            (Ok(l), Ok(r)) => Some((l, r)),
+            _ => None,
+        },
     }
 }
 
 #[test]
 fn test_parse_pair() {
-    assert_eq!(parse_pair::<i32>("",        ','), None);
-    assert_eq!(parse_pair::<i32>("10,",     ','), None);
-    assert_eq!(parse_pair::<i32>(",10",     ','), None);
-    assert_eq!(parse_pair::<i32>("10,20",   ','), Some((10, 20)));
+    assert_eq!(parse_pair::<i32>("", ','), None);
+    assert_eq!(parse_pair::<i32>("10,", ','), None);
+    assert_eq!(parse_pair::<i32>(",10", ','), None);
+    assert_eq!(parse_pair::<i32>("10,20", ','), Some((10, 20)));
     assert_eq!(parse_pair::<i32>("10,20xy", ','), None);
-    assert_eq!(parse_pair::<f64>("0.5x",    'x'), None);
+    assert_eq!(parse_pair::<f64>("0.5x", 'x'), None);
     assert_eq!(parse_pair::<f64>("0.5x1.5", 'x'), Some((0.5, 1.5)));
 }
 
 /// Parse a pair of floating-point numbers separated by a comma as a complex
 /// number.
 fn parse_complex(s: &str) -> Option<Complex<f64>> {
+    #[allow(clippy::manual_map)]
     match parse_pair(s, ',') {
         Some((re, im)) => Some(Complex { re, im }),
-        None => None
+        None => None,
     }
 }
 
 #[test]
 fn test_parse_complex() {
-    assert_eq!(parse_complex("1.25,-0.0625"),
-               Some(Complex { re: 1.25, im: -0.0625 }));
+    assert_eq!(
+        parse_complex("1.25,-0.0625"),
+        Some(Complex {
+            re: 1.25,
+            im: -0.0625
+        })
+    );
     assert_eq!(parse_complex(",-0.0625"), None);
 }
 
@@ -79,28 +83,37 @@ fn test_parse_complex() {
 /// `pixel` is a (column, row) pair indicating a particular pixel in that image.
 /// The `upper_left` and `lower_right` parameters are points on the complex
 /// plane designating the area our image covers.
-fn pixel_to_point(bounds: (usize, usize),
-                  pixel: (usize, usize),
-                  upper_left: Complex<f64>,
-                  lower_right: Complex<f64>)
-    -> Complex<f64>
-{
-    let (width, height) = (lower_right.re - upper_left.re,
-                           upper_left.im - lower_right.im);
+fn pixel_to_point(
+    bounds: (usize, usize),
+    pixel: (usize, usize),
+    upper_left: Complex<f64>,
+    lower_right: Complex<f64>,
+) -> Complex<f64> {
+    let (width, height) = (
+        lower_right.re - upper_left.re,
+        upper_left.im - lower_right.im,
+    );
     Complex {
-        re: upper_left.re + pixel.0 as f64 * width  / bounds.0 as f64,
-        im: upper_left.im - pixel.1 as f64 * height / bounds.1 as f64
-        // Why subtraction here? pixel.1 increases as we go down,
-        // but the imaginary component increases as we go up.
+        re: upper_left.re + pixel.0 as f64 * width / bounds.0 as f64,
+        im: upper_left.im - pixel.1 as f64 * height / bounds.1 as f64, // Why subtraction here? pixel.1 increases as we go down,
+                                                                       // but the imaginary component increases as we go up.
     }
 }
 
 #[test]
 fn test_pixel_to_point() {
-    assert_eq!(pixel_to_point((100, 200), (25, 175),
-                              Complex { re: -1.0, im:  1.0 },
-                              Complex { re:  1.0, im: -1.0 }),
-               Complex { re: -0.5, im: -0.75 });
+    assert_eq!(
+        pixel_to_point(
+            (100, 200),
+            (25, 175),
+            Complex { re: -1.0, im: 1.0 },
+            Complex { re: 1.0, im: -1.0 }
+        ),
+        Complex {
+            re: -0.5,
+            im: -0.75
+        }
+    );
 }
 
 /// Render a rectangle of the Mandelbrot set into a buffer of pixels.
@@ -109,41 +122,40 @@ fn test_pixel_to_point() {
 /// which holds one grayscale pixel per byte. The `upper_left` and `lower_right`
 /// arguments specify points on the complex plane corresponding to the upper-
 /// left and lower-right corners of the pixel buffer.
-fn render(pixels: &mut [u8],
-          bounds: (usize, usize),
-          upper_left: Complex<f64>,
-          lower_right: Complex<f64>)
-{
+fn render(
+    pixels: &mut [u8],
+    bounds: (usize, usize),
+    upper_left: Complex<f64>,
+    lower_right: Complex<f64>,
+) {
     assert!(pixels.len() == bounds.0 * bounds.1);
 
     for row in 0..bounds.1 {
         for column in 0..bounds.0 {
-            let point = pixel_to_point(bounds, (column, row),
-                                       upper_left, lower_right);
-            pixels[row * bounds.0 + column] =
-                match escape_time(point, 255) {
-                    None => 0,
-                    Some(count) => 255 - count as u8
-                };
+            let point = pixel_to_point(bounds, (column, row), upper_left, lower_right);
+            pixels[row * bounds.0 + column] = match escape_time(point, 255) {
+                None => 0,
+                Some(count) => 255 - count as u8,
+            };
         }
     }
 }
 
-use image::ColorType;
-use image::png::PNGEncoder;
+use image::{codecs::png::PngEncoder, error::ImageResult, ExtendedColorType, ImageEncoder};
 use std::fs::File;
 
 /// Write the buffer `pixels`, whose dimensions are given by `bounds`, to the
 /// file named `filename`.
-fn write_image(filename: &str, pixels: &[u8], bounds: (usize, usize))
-    -> Result<(), std::io::Error>
-{
+fn write_image(filename: &str, pixels: &[u8], bounds: (usize, usize)) -> ImageResult<()> {
     let output = File::create(filename)?;
 
-    let encoder = PNGEncoder::new(output);
-    encoder.encode(&pixels,
-                   bounds.0 as u32, bounds.1 as u32,
-                   ColorType::Gray(8))?;
+    let encoder = PngEncoder::new(output);
+    encoder.write_image(
+        pixels,
+        bounds.0 as u32,
+        bounds.1 as u32,
+        ExtendedColorType::L8,
+    )?;
 
     Ok(())
 }
@@ -154,24 +166,21 @@ fn main() {
     let args: Vec<String> = env::args().collect();
 
     if args.len() != 5 {
-        eprintln!("Usage: {} FILE PIXELS UPPERLEFT LOWERRIGHT",
-                  args[0]);
-        eprintln!("Example: {} mandel.png 1000x750 -1.20,0.35 -1,0.20",
-                  args[0]);
+        eprintln!("Usage: {} FILE PIXELS UPPERLEFT LOWERRIGHT", args[0]);
+        eprintln!(
+            "Example: {} mandel.png 1000x750 -1.20,0.35 -1,0.20",
+            args[0]
+        );
         std::process::exit(1);
     }
 
-    let bounds = parse_pair(&args[2], 'x')
-        .expect("error parsing image dimensions");
-    let upper_left = parse_complex(&args[3])
-        .expect("error parsing upper left corner point");
-    let lower_right = parse_complex(&args[4])
-        .expect("error parsing lower right corner point");
+    let bounds = parse_pair(&args[2], 'x').expect("error parsing image dimensions");
+    let upper_left = parse_complex(&args[3]).expect("error parsing upper left corner point");
+    let lower_right = parse_complex(&args[4]).expect("error parsing lower right corner point");
 
     let mut pixels = vec![0; bounds.0 * bounds.1];
 
     render(&mut pixels, bounds, upper_left, lower_right);
 
-    write_image(&args[1], &pixels, bounds)
-        .expect("error writing PNG file");
+    write_image(&args[1], &pixels, bounds).expect("error writing PNG file");
 }