Display multiple images implementation, some minor fixes

examples/display_image.rs

@@ -21,7 +21,7 @@ fn main() {
         .expect("No image found at provided path")
         .to_rgba();
 
-    display_image("", &image, 10, 10);
+    display_image("", &image, 500, 500);
 }
 
 #[cfg(not(feature = "display-window"))]

examples/display_multiple_images.rs

@@ -0,0 +1,41 @@
+//! An example of displaying an image in a window using the display_image function.
+//! Run this example from your root directory, enabled the display_image feature and
+//! provide a path to an image file as an argument.
+//!
+//! `cargo run --release --features display-window --example display_image examples/wrench.jpg`
+
+#[cfg(feature = "display-window")]
+fn main() {
+    use imageproc::window::display_multiple_images;
+    use std::env;
+
+    let first_image_path = match env::args().nth(1) {
+        Some(path) => path,
+        None => {
+            println!("No path provided for first image. Using default image.");
+            "examples/wrench.jpg".to_owned()
+        }
+    };
+
+    let second_image_path = match env::args().nth(2) {
+        Some(path) => path,
+        None => {
+            println!("No path provided for second image. Using default image.");
+            "examples/empire-state-building.jpg".to_owned()
+        }
+    };
+
+    let first_image = image::open(&first_image_path)
+        .expect("No image found at provided path")
+        .to_rgba();
+    let second_image = image::open(&second_image_path)
+        .expect("No image found at provided path")
+        .to_rgba();
+
+    display_multiple_images("", &vec![&first_image, &second_image], 500, 500);
+}
+
+#[cfg(not(feature = "display-window"))]
+fn main() {
+    panic!("Displaying images is only supported if the display-window feature is enabled.");
+}

examples/multiple_image_displays.rs

@@ -0,0 +1,41 @@
+//! An example of displaying an image in a window using the display_image function.
+//! Run this example from your root directory, enabled the display_image feature and
+//! provide a path to an image file as an argument.
+//!
+//! `cargo run --release --features display-window --example display_image examples/wrench.jpg`
+
+#[cfg(feature = "display-window")]
+fn main() {
+    use imageproc::window::display_multiple_images;
+    use std::env;
+
+    let first_image_path = match env::args().nth(1) {
+        Some(path) => path,
+        None => {
+            println!("No path provided for first image. Using default image.");
+            "examples/wrench.jpg".to_owned()
+        }
+    };
+
+    let second_image_path = match env::args().nth(2) {
+        Some(path) => path,
+        None => {
+            println!("No path provided for second image. Using default image.");
+            "examples/empire-state-building.jpg".to_owned()
+        }
+    };
+
+    let first_image = image::open(&first_image_path)
+        .expect("No image found at provided path")
+        .to_rgba();
+    let second_image = image::open(&second_image_path)
+        .expect("No image found at provided path")
+        .to_rgba();
+
+    display_multiple_images("", &vec![&first_image, &second_image], 500, 500);
+}
+
+#[cfg(not(feature = "display-window"))]
+fn main() {
+    panic!("Displaying images is only supported if the display-window feature is enabled.");
+}

src/window.rs

@@ -1,19 +1,38 @@
 //! Displays an image in a window created by sdl2.
 
-use image::{RgbaImage, imageops::resize};
+use image::{imageops::resize, RgbaImage};
 use sdl2::{
     event::{Event, WindowEvent},
     keyboard::Keycode,
     pixels::{Color, PixelFormatEnum},
     rect::Rect,
-    surface::Surface
+    render::{Canvas, TextureCreator, WindowCanvas},
+    surface::Surface,
+    video::{Window, WindowContext},
 };
 
 /// Displays the provided RGBA image in a new window.
 ///
 /// The minimum window width or height is 150 pixels - input values less than this
 /// will be rounded up to the minimum.
 pub fn display_image(title: &str, image: &RgbaImage, window_width: u32, window_height: u32) {
+    display_multiple_images(title, &vec![image], window_width, window_height);
+}
+
+/// Displays the provided RGBA images in new windows.
+///
+/// The minimum window width or height is 150 pixels - input values less than this
+/// will be rounded up to the minimum.
+pub fn display_multiple_images(
+    title: &str,
+    images: &[&RgbaImage],
+    window_width: u32,
+    window_height: u32,
+) {
+    if images.len() == 0 {
+        return;
+    }
+
     // Enforce minimum window size
     const MIN_WINDOW_DIMENSION: u32 = 150;
     let window_width = window_width.max(MIN_WINDOW_DIMENSION);
@@ -23,53 +42,118 @@ pub fn display_image(title: &str, image: &RgbaImage, window_width: u32, window_h
     let sdl = sdl2::init().expect("couldn't create sdl2 context");
     let video_subsystem = sdl.video().expect("couldn't create video subsystem");
 
-    let mut window = video_subsystem
-        .window(title, window_width, window_height)
-        .position_centered()
-        .resizable()
-        .build()
-        .expect("couldn't create window");
+    let mut windows: Vec<Window> = Vec::with_capacity(images.len());
+    let mut window_visibility: Vec<bool> = Vec::with_capacity(images.len());
+    for _ in 0..images.len() {
+        let mut window = video_subsystem
+            .window(title, window_width, window_height)
+            .resizable()
+            .allow_highdpi()
+            .build()
+            .expect("couldn't create window");
+
+        window
+            .set_minimum_size(MIN_WINDOW_DIMENSION, MIN_WINDOW_DIMENSION)
+            .expect("invalid minimum size for window");
+
+        windows.push(window);
+        window_visibility.push(true);
+    }
 
-    window
-        .set_minimum_size(MIN_WINDOW_DIMENSION, MIN_WINDOW_DIMENSION)
-        .expect("invalid minimum size for window");
+    {
+        use sdl2::video::WindowPos::Positioned;
+
+        let (base_position_x, base_position_y) = windows[0].position();
+        for (i, window) in windows.iter_mut().enumerate() {
+            let multiplier = 1.0 + i as f32 / 20.0;
+            window.set_position(
+                Positioned((base_position_x as f32 * multiplier) as i32),
+                Positioned(base_position_y),
+            );
+
+            let (window_pos_x, _window_pos_y) = window.position();
+            let display_bounds = video_subsystem
+                .display_bounds(0)
+                .expect("No bounds found for that display.");
+            let screen_width = display_bounds.w;
+            if window_pos_x + window_width as i32 > screen_width {
+                window.set_position(
+                    Positioned(screen_width - window_width as i32),
+                    Positioned(base_position_y),
+                );
+            }
+        }
+    }
 
-    let mut canvas = window.into_canvas()
-        .build()
-        .expect("couldn't create canvas");
+    let mut canvases: Vec<WindowCanvas> = Vec::with_capacity(images.len());
+    for window in windows.into_iter() {
+        let canvas = window
+            .into_canvas()
+            .software()
+            .build()
+            .expect("couldn't create canvas");
+        canvases.push(canvas);
+    }
 
-    let texture_creator = canvas.texture_creator();
+    let mut texture_creators: Vec<TextureCreator<WindowContext>> = Vec::with_capacity(images.len());
+    for canvas in canvases.iter() {
+        let texture_creator = canvas.texture_creator();
+        texture_creators.push(texture_creator);
+    }
 
     // Shrinks input image to fit if required and renders to the sdl canvas
-    let mut render_image_to_canvas = |image, window_width, window_height| {
-        let scaled_image = resize_to_fit(image, window_width, window_height);
-        let (image_width, image_height) = scaled_image.dimensions();
-
-        let mut buffer = scaled_image.into_raw();
-        const CHANNEL_COUNT: u32 = 4;
-
-        let surface = Surface::from_data(
-            &mut buffer,
-            image_width,
-            image_height,
-            image_width * CHANNEL_COUNT,
-            PixelFormatEnum::ABGR8888 // sdl2 expects bits from highest to lowest
-        ).expect("couldn't create surface");
-
-        let texture = texture_creator
-            .create_texture_from_surface(surface)
-            .expect("couldn't create texture from surface");
-
-        canvas.set_draw_color(Color::RGB(255, 255, 255));
-        canvas.clear();
-
-        let left = ((window_width - image_width) as f32 / 2f32) as i32;
-        let top = ((window_height - image_height) as f32 / 2f32) as i32;
-        canvas.copy(&texture, None, Rect::new(left, top, image_width, image_height)).unwrap();
-        canvas.present();
-    };
+    let render_image_to_canvas =
+        |image,
+         window_width,
+         window_height,
+         canvas: &mut Canvas<Window>,
+         texture_creator: &TextureCreator<WindowContext>| {
+            let scaled_image = resize_to_fit(image, window_width, window_height);
+
+            let (image_width, image_height) = scaled_image.dimensions();
+            let mut buffer = scaled_image.into_raw();
+            const CHANNEL_COUNT: u32 = 4;
+            let surface = Surface::from_data(
+                &mut buffer,
+                image_width,
+                image_height,
+                image_width * CHANNEL_COUNT,
+                PixelFormatEnum::ABGR8888, // sdl2 expects bits from highest to lowest
+            )
+            .expect("couldn't create surface");
+
+            let texture = texture_creator
+                .create_texture_from_surface(surface)
+                .expect("couldn't create texture from surface");
+
+            canvas.set_draw_color(Color::RGB(255, 255, 255));
+            canvas.clear();
+
+            let left = ((window_width - image_width) as f32 / 2f32) as i32;
+            let top = ((window_height - image_height) as f32 / 2f32) as i32;
+            canvas
+                .copy(
+                    &texture,
+                    None,
+                    Rect::new(left, top, image_width, image_height),
+                )
+                .unwrap();
+            canvas.present();
+        };
+
+    for (i, (canvas, texture_creator)) in
+        canvases.iter_mut().zip(texture_creators.iter()).enumerate()
+    {
+        render_image_to_canvas(
+            images[i],
+            window_width,
+            window_height,
+            canvas,
+            texture_creator,
+        );
+    }
 
-    render_image_to_canvas(image, window_width, window_height);
+    let mut hidden_count = 0;
 
     // Create and start event loop to keep window open until Esc
     let mut event_pump = sdl.event_pump().unwrap();
@@ -82,11 +166,56 @@ pub fn display_image(title: &str, image: &RgbaImage, window_width: u32, window_h
                     keycode: Some(Keycode::Escape),
                     ..
                 } => break 'running,
+                Event::KeyDown {
+                    keycode: Some(Keycode::Q),
+                    window_id,
+                    ..
+                } => {
+                    for (i, canvas) in canvases.iter_mut().enumerate() {
+                        if window_id == canvas.window().id() {
+                            canvas.window_mut().hide();
+                            window_visibility[i] = false;
+                            hidden_count += 1;
+                        }
+                        if hidden_count == images.len() {
+                            break 'running;
+                        }
+                    }
+                }
+                Event::Window {
+                    win_event: WindowEvent::Close,
+                    window_id,
+                    ..
+                } => {
+                    for (i, canvas) in canvases.iter_mut().enumerate() {
+                        if window_id == canvas.window().id() {
+                            canvas.window_mut().hide();
+                            window_visibility[i] = false;
+                            hidden_count += 1;
+                        }
+                        if hidden_count == images.len() {
+                            break 'running;
+                        }
+                    }
+                }
                 Event::Window {
                     win_event: WindowEvent::Resized(w, h),
+                    window_id,
                     ..
                 } => {
-                    render_image_to_canvas(image, w as u32, h as u32);
+                    for (i, (canvas, texture_creator)) in
+                        canvases.iter_mut().zip(texture_creators.iter()).enumerate()
+                    {
+                        if window_id == canvas.window().id() {
+                            render_image_to_canvas(
+                                images[i],
+                                w as u32,
+                                h as u32,
+                                canvas,
+                                texture_creator,
+                            );
+                        }
+                    }
                 }
                 _ => {}
             }