feat(render): output the image as BMP format

Author: corrieriluca

Cargo.lock

@@ -5,4 +5,5 @@ authors = ["Luca Corrieri"]
 edition = "2018"
 
 [dependencies]
+image = { version = "0.23.14", default-features = false, features = ["bmp"] }
 rand = "0.8.4"

Cargo.toml

@@ -5,13 +5,16 @@ Simple path tracer made in Rust based on Peter Shirley's book
 
 To-do:
 - [x] _Ray Tracing in One Weekend_ (actually in more than one weekend...)
-- [ ] Refactor the code
+- [x] Refactor the code
 - [ ] Command line arguments
 - [ ] Progress bar
 - [ ] Parallelism (multithreading)
+- [x] Save to a better image format (BMP)
 
 ## Usage
 
 ```shell
-$ cargo run --release > image.ppm
+$ cargo run --release
 ```
+
+The resulting image is in `./image.bmp`.

README.md

@@ -1,23 +1,25 @@
 use crate::vec3::Vec3;
-use std::io::Write;
+use image::{Rgb, RgbImage};
 
 /// Alias of Vec3 representing a color
 pub type Color = Vec3;
 
 impl Color {
-    pub fn write(&self, stream: &mut impl Write, samples_per_pixel: i32) -> std::io::Result<()> {
+    pub fn write(&self, img: &mut RgbImage, x: u32, y: u32, samples_per_pixel: i32) {
         // Divide the color by the number of samples
         let scale = 1.0 / samples_per_pixel as f64;
         let r = (self.x() * scale).sqrt();
         let g = (self.y() * scale).sqrt();
         let b = (self.z() * scale).sqrt();
 
-        writeln!(
-            stream,
-            "{} {} {}",
-            (255.99 * r.clamp(0.0, 0.999)) as i32,
-            (255.99 * g.clamp(0.0, 0.999)) as i32,
-            (255.99 * b.clamp(0.0, 0.999)) as i32
-        )
+        img.put_pixel(
+            x,
+            y,
+            Rgb([
+                (255.99 * r.clamp(0.0, 0.999)) as u8,
+                (255.99 * g.clamp(0.0, 0.999)) as u8,
+                (255.99 * b.clamp(0.0, 0.999)) as u8,
+            ]),
+        );
     }
 }

src/color.rs

@@ -5,12 +5,13 @@ use crate::hittable::Hittable;
 use crate::random::canonical_random;
 use crate::ray::Ray;
 use crate::vec3::Vec3;
-use std::io::Write;
+
+use image::DynamicImage;
 
 /// Represent an image to be rendered
 pub struct Image {
-    image_width: i32,
-    image_height: i32,
+    image_width: u32,
+    image_height: u32,
     world: HittableList,
     camera: Camera,
 }
@@ -20,7 +21,7 @@ impl Image {
     /// with its camera
     pub fn new(
         aspect_ratio: f64,
-        image_width: i32,
+        image_width: u32,
         world: HittableList,
         lookfrom: Vec3,
         lookat: Vec3,
@@ -29,7 +30,7 @@ impl Image {
         aperture: f64,
         vertical_fov: f64,
     ) -> Image {
-        let image_height = (image_width as f64 / aspect_ratio) as i32;
+        let image_height = (image_width as f64 / aspect_ratio) as u32;
         let camera = Camera::new(
             lookfrom,
             lookat,
@@ -72,17 +73,8 @@ impl Image {
 
     /// Renders the image to the PPM format to the specified stream
     /// (may be a file or just standard output)
-    pub fn render_image(
-        &self,
-        stream: &mut impl Write,
-        samples_per_pixel: i32,
-        max_depth: i32,
-    ) -> std::io::Result<()> {
-        write!(
-            stream,
-            "P3\n{} {}\n255\n",
-            self.image_width, self.image_height
-        )?;
+    pub fn render_image(&self, samples_per_pixel: i32, max_depth: i32) -> DynamicImage {
+        let mut img = DynamicImage::new_rgb8(self.image_width, self.image_height);
 
         for j in (0..self.image_height).rev() {
             eprint!("\rLines remaining: {} ", j);
@@ -94,10 +86,10 @@ impl Image {
                     let r = self.camera.get_ray(u, v);
                     pixel_color += self.ray_color(r, max_depth);
                 }
-                pixel_color.write(stream, samples_per_pixel)?
+                pixel_color.write(img.as_mut_rgb8().unwrap(), i, j, samples_per_pixel);
             }
         }
 
-        Ok(())
+        img
     }
 }

src/image.rs

@@ -8,7 +8,7 @@ use crate::material::metal::Metal;
 use crate::random::{canonical_random, random_range};
 use crate::vec3::{Point3, Vec3};
 
-use std::io::stdout;
+use std::path::Path;
 use std::rc::Rc;
 
 mod camera;
@@ -116,8 +116,10 @@ fn main() {
     let max_depth = 50;
 
     image
-        .render_image(&mut stdout(), samples_per_pixel, max_depth)
-        .expect("An error occurred while writing to standard output");
+        .render_image(samples_per_pixel, max_depth)
+        .flipv()
+        .save_with_format(Path::new("./image.bmp"), ::image::ImageFormat::Bmp)
+        .expect("An error occurred while writing the image to the file.");
 
     eprintln!("\nDone!");
 }