splitting

1 files changed, 42 insertions, 9 deletions

diff --git a/evc/src/frame.rs b/evc/src/frame.rs
index 1c18620..1906555 100644
--- a/evc/src/frame.rs
+++ b/evc/src/frame.rs
@@ -28,24 +28,29 @@ impl Frame {
         }
         Ok(frame)
     }
+    pub fn view<'a>(&'a self, offset: (usize, usize), size: (usize, usize)) -> View<'a> {
+        View::new(self, offset, size)
+    }
 }
 
 impl Index<(usize, usize)> for Frame {
     type Output = Pixel;
+    #[inline]
     fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
         &self.buffer[x][y]
     }
 }
 impl IndexMut<(usize, usize)> for Frame {
+    #[inline]
     fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Self::Output {
         &mut self.buffer[x][y]
     }
 }
 
 pub struct View<'a> {
-    frame: &'a Frame,
-    offset: (usize, usize),
-    size: (usize, usize),
+    pub frame: &'a Frame,
+    pub offset: (usize, usize),
+    pub size: (usize, usize),
 }
 
 impl<'a> View<'a> {
@@ -56,22 +61,50 @@ impl<'a> View<'a> {
             size,
         }
     }
-    pub fn diff(&self, rhs: &Self) -> f64 {
-        assert_eq!(self.size, rhs.size);
+    pub fn diff(va: &Self, vb: &Self) -> f64 {
+        assert_eq!(va.size, vb.size);
         let mut acc = 0.0;
-        for x in 0..self.size.0 {
-            for y in 0..self.size.1 {
-                let a = self[(x, y)];
-                let b = rhs[(x, y)];
+        for x in 0..va.size.0 {
+            for y in 0..va.size.1 {
+                let a = va[(x, y)];
+                let b = vb[(x, y)];
                 acc += Pixel::distance(a, b);
             }
         }
         acc
     }
+    pub fn split(&self) -> [Self; 2] {
+        let vert = self.size.0 > self.size.1;
+        [
+            Self {
+                frame: self.frame,
+                offset: self.offset,
+                size: if vert {
+                    (self.size.0 / 2, self.size.1)
+                } else {
+                    (self.size.0, self.size.1 / 2)
+                },
+            },
+            Self {
+                frame: self.frame,
+                offset: if vert {
+                    (self.offset.0 + self.size.0 / 2, self.offset.1)
+                } else {
+                    (self.offset.0, self.offset.1 + self.size.1 / 2)
+                },
+                size: if vert {
+                    (self.size.0 - self.size.0 / 2, self.size.1)
+                } else {
+                    (self.size.0, self.size.1 - self.size.1 / 2)
+                },
+            },
+        ]
+    }
 }
 
 impl Index<(usize, usize)> for View<'_> {
     type Output = Pixel;
+    #[inline]
     fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
         &self.frame[(x + self.offset.0, y + self.offset.1)]
     }