fix(macos): make sure the right left side pixels are not causing an issue on macos

 - refactor how transparency is identified into a dedicated function
 - refactor crop into a dedicated function
 - write some tests that work with some test data (frames)
 - refactor feature gate name for all tests that need a real display to `e2e_tests`
 - remove all unused frames that are not used in tests

Author: sassman

Cargo.toml

@@ -40,4 +40,4 @@ core-foundation-sys = "0.8.2"
 x11rb = "0.7.0"
 
 [features]
-test_against_real_display = []
+e2e_tests = []

src/common/identify_transparency.rs

@@ -0,0 +1,87 @@
+use crate::{Image, Margin, Result};
+use image::flat::View;
+use image::{Bgra, GenericImageView};
+
+///
+/// this helps to identify outer transparent regions
+/// since some backends provides transparency either from a compositor effect like drop shadow on ubuntu / GNOME
+/// or some strange right side strip on MacOS
+pub fn identify_transparency(image: Image) -> Result<Option<Margin>> {
+    let image: View<_, Bgra<u8>> = image.as_view()?;
+    let (width, height) = image.dimensions();
+    let half_width = width / 2;
+    let half_height = height / 2;
+    // > 3/4 transparency is good enough to declare the end of transparent regions
+    let transparency_end: u8 = 0xff - (0xff / 4);
+
+    let mut margin = Margin::zero();
+    // identify top margin
+    for y in 0..half_height {
+        let Bgra([_, _, _, a]) = image.get_pixel(half_width, y);
+        if a > transparency_end {
+            // the end of the transparent area
+            margin.top = y as u16;
+            dbg!(margin.top);
+            break;
+        }
+    }
+    // identify bottom margin
+    for y in (half_height..height).rev() {
+        let Bgra([_, _, _, a]) = image.get_pixel(half_width, y);
+        if a > transparency_end {
+            // the end of the transparent area
+            margin.bottom = (height - y - 1) as u16;
+            dbg!(margin.bottom);
+            break;
+        }
+    }
+    // identify left margin
+    for x in 0..half_width {
+        let Bgra([_, _, _, a]) = image.get_pixel(x, half_height);
+        if a > transparency_end {
+            // the end of the transparent area
+            margin.left = x as u16;
+            dbg!(margin.left);
+            break;
+        }
+    }
+    // identify right margin
+    for x in (half_width..width).rev() {
+        let Bgra([_, _, _, a]) = image.get_pixel(x, half_height);
+        if a > transparency_end {
+            // the end of the transparent area
+            margin.right = (width - x - 1) as u16;
+            dbg!(margin.right);
+            break;
+        }
+    }
+
+    Ok(Some(margin))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn should_identify_macos_right_side_issue() -> Result<()> {
+        // given an screen capture with transparency on the right side
+        let image_org = image::open("tests/frames/frame-macos-right-side-issue.tga")?;
+        let image = image_org.into_bgra8();
+        let (width, height) = image.dimensions();
+        let Bgra([blue, green, red, alpha]) = image.get_pixel(width - 1, height / 2);
+        assert_eq!(alpha, &0, "the test image was not transparent");
+        assert_eq!(red, &0, "the test image is not as expected");
+        assert_eq!(green, &0, "the test image is not as expected");
+        assert_eq!(blue, &0, "the test image is not as expected");
+
+        // when
+        let image_raw = image.into_flat_samples();
+        let margin = identify_transparency(image_raw)?;
+
+        // then
+        assert_eq!(margin, Some(Margin::new(0, 14, 0, 0)));
+
+        Ok(())
+    }
+}

src/common/image.rs

@@ -0,0 +1,56 @@
+use crate::common::Margin;
+use crate::{Image, ImageOnHeap, Result};
+use image::flat::View;
+use image::{imageops, Bgra, GenericImageView, ImageBuffer};
+
+///
+/// specialized version of crop for [`ImageOnHeap`] and [`Margin`]
+///
+#[cfg_attr(not(macos), allow(dead_code))]
+pub fn crop(image: Image, margin: &Margin) -> Result<ImageOnHeap> {
+    let mut img2: View<_, Bgra<u8>> = image.as_view()?;
+    let (width, height) = (
+        img2.width() - (margin.left + margin.right) as u32,
+        img2.height() - (margin.top + margin.bottom) as u32,
+    );
+    let image_cropped = imageops::crop(
+        &mut img2,
+        margin.left as u32,
+        margin.top as u32,
+        width,
+        height,
+    );
+    let mut buf = ImageBuffer::new(image_cropped.width(), image_cropped.height());
+
+    for y in 0..height {
+        for x in 0..width {
+            buf.put_pixel(x, y, image_cropped.get_pixel(x, y));
+        }
+    }
+
+    Ok(Box::new(buf.into_flat_samples()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use image::open;
+
+    #[test]
+    fn should_crop() -> Result<()> {
+        // given
+        let image_org = open("tests/frames/frame-macos-right-side-issue.tga")?;
+        let image = image_org.into_bgra8();
+        let image_raw = ImageOnHeap::new(image.into_flat_samples());
+        let (width, height) = (image_raw.layout.width, image_raw.layout.height);
+
+        // when
+        let cropped = crop(*image_raw, &Margin::new(1, 1, 1, 1))?;
+
+        // then
+        assert_eq!(cropped.layout.width, width - 2);
+        assert_eq!(cropped.layout.height, height - 2);
+
+        Ok(())
+    }
+}

src/common/mod.rs

@@ -1,3 +1,6 @@
+pub mod identify_transparency;
+pub mod image;
+
 use crate::{ImageOnHeap, Result, WindowId, WindowList};
 
 pub trait PlatformApi: Send {
@@ -9,3 +12,70 @@ pub trait PlatformApi: Send {
     fn capture_window_screenshot(&self, window_id: WindowId) -> Result<ImageOnHeap>;
     fn get_active_window(&self) -> Result<WindowId>;
 }
+
+#[derive(Debug, PartialEq)]
+pub struct Margin {
+    pub top: u16,
+    pub right: u16,
+    pub bottom: u16,
+    pub left: u16,
+}
+
+impl Margin {
+    pub fn new(top: u16, right: u16, bottom: u16, left: u16) -> Self {
+        Self {
+            top,
+            right,
+            bottom,
+            left,
+        }
+    }
+
+    pub fn new_equal(margin: u16) -> Self {
+        Self::new(margin, margin, margin, margin)
+    }
+
+    pub fn zero() -> Self {
+        Self::new_equal(0)
+    }
+
+    pub fn is_zero(&self) -> bool {
+        self.top == 0
+            && self.right == self.left
+            && self.left == self.bottom
+            && self.bottom == self.top
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn margin_new() {
+        let m = Margin::new(1, 2, 3, 4);
+        assert_eq!(m.top, 1);
+        assert_eq!(m.right, 2);
+        assert_eq!(m.bottom, 3);
+        assert_eq!(m.left, 4);
+    }
+
+    #[test]
+    fn margin_new_equal() {
+        let m = Margin::new_equal(1);
+        assert_eq!(m.top, 1);
+        assert_eq!(m.right, 1);
+        assert_eq!(m.bottom, 1);
+        assert_eq!(m.left, 1);
+    }
+
+    #[test]
+    fn margin_zero() {
+        let m = Margin::zero();
+        assert_eq!(m.top, 0);
+        assert_eq!(m.right, 0);
+        assert_eq!(m.bottom, 0);
+        assert_eq!(m.left, 0);
+        assert!(m.is_zero());
+    }
+}

src/linux/mod.rs

@@ -8,70 +8,3 @@ pub fn setup() -> Result<Box<dyn PlatformApi>> {
 }
 
 pub const DEFAULT_SHELL: &str = "/bin/sh";
-
-#[derive(Debug)]
-pub struct Margin {
-    pub top: u16,
-    pub right: u16,
-    pub bottom: u16,
-    pub left: u16,
-}
-
-impl Margin {
-    pub fn new(top: u16, right: u16, bottom: u16, left: u16) -> Self {
-        Self {
-            top,
-            right,
-            bottom,
-            left,
-        }
-    }
-
-    pub fn new_equal(margin: u16) -> Self {
-        Self::new(margin, margin, margin, margin)
-    }
-
-    pub fn zero() -> Self {
-        Self::new_equal(0)
-    }
-
-    pub fn is_zero(&self) -> bool {
-        self.top == 0
-            && self.right == self.left
-            && self.left == self.bottom
-            && self.bottom == self.top
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn margin_new() {
-        let m = Margin::new(1, 2, 3, 4);
-        assert_eq!(m.top, 1);
-        assert_eq!(m.right, 2);
-        assert_eq!(m.bottom, 3);
-        assert_eq!(m.left, 4);
-    }
-
-    #[test]
-    fn margin_new_equal() {
-        let m = Margin::new_equal(1);
-        assert_eq!(m.top, 1);
-        assert_eq!(m.right, 1);
-        assert_eq!(m.bottom, 1);
-        assert_eq!(m.left, 1);
-    }
-
-    #[test]
-    fn margin_zero() {
-        let m = Margin::zero();
-        assert_eq!(m.top, 0);
-        assert_eq!(m.right, 0);
-        assert_eq!(m.bottom, 0);
-        assert_eq!(m.left, 0);
-        assert!(m.is_zero());
-    }
-}