mappings: split coord mapping from pixel mapping

src/mappings.rs

@@ -4,55 +4,16 @@ use crate::lib8::interpolate::scale8;
 
 use std::cmp::{max, min};
 use std::fmt::{Formatter, Debug};
-use ansi_term::Color;
-use rgb::Rgb;
 
-pub trait CoordinateView: Debug {
+pub trait CoordinateView<'a>: Debug {
     type Space: CoordinateSpace;
     fn next(&mut self) -> Option<(Coordinates<Virtual>, Coordinates<Self::Space>)>;
 }
 
-pub trait PixelMapping {
+pub trait Select<'a> {
     type Space: CoordinateSpace;
-    fn select(&self, rect: &Rectangle<Virtual>) -> impl CoordinateView<Space = Self::Space>;
-    fn to_idx(&self, coords: &Coordinates<Self::Space>) -> usize;
-}
-
-pub trait DisplayDump<T: PixelMapping> {
-    fn dump(&self, map: &T);
-}
-
-impl<const PIXEL_NUM: usize> DisplayDump<LinearPixelMapping> for [Rgb<u8>; PIXEL_NUM] {
-    fn dump(&self, _map: &LinearPixelMapping) {
-        for ref pixel in self {
-            print!("{}", Color::RGB(pixel.r, pixel.g, pixel.b).paint("█"));
-        }
-        println!();
-    }
-}
-
-impl<const PIXEL_NUM: usize> DisplayDump<StrideMapping> for [Rgb<u8>; PIXEL_NUM] {
-    fn dump(&self, map: &StrideMapping) {
-        for y in 0..map.stride_count {
-            let stride = &map.strides[y];
-            for x in 0..stride.length {
-                let idx = if stride.reverse {
-                    stride.physical_idx + stride.length as usize - x as usize
-                } else {
-                    stride.physical_idx + x as usize
-                };
-                if idx >= self.len() {
-                    println!();
-                    println!("frame!!!");
-                    return;
-                }
-                let pixel = &self[idx];
-                print!("{}", Color::RGB(pixel.r, pixel.g, pixel.b).paint("█"));
-            }
-            println!();
-        }
-        println!("frame!!!");
-    }
+    type View: CoordinateView<'a>;
+    fn select(&'a self, rect: &Rectangle<Virtual>) -> Self::View;
 }
 
 #[derive(Debug)]
@@ -68,7 +29,7 @@ impl CoordinateSpace for LinearSpace {
 
 pub type LinearCoords = Coordinates<LinearSpace>;
 
-impl CoordinateView for LinearCoordView {
+impl<'a> CoordinateView<'a> for LinearCoordView {
     type Space = LinearSpace;
     fn next(&mut self) -> Option<(VirtualCoordinates, LinearCoords)> {
         if self.idx as u8 == self.rect.bottom_right.x {
@@ -94,18 +55,15 @@ impl LinearPixelMapping {
     }
 }
 
-impl PixelMapping for LinearPixelMapping {
+impl<'a> Select<'a> for LinearPixelMapping {
     type Space = LinearSpace;
-    fn select(&self, rect: &Rectangle<Virtual>) -> impl CoordinateView<Space = Self::Space> {
+    type View = LinearCoordView;
+    fn select(&'a self, rect: &Rectangle<Virtual>) -> Self::View {
         LinearCoordView {
             rect: rect.clone(),
             idx: 0,
         }
     }
-
-    fn to_idx(&self, coords: &Coordinates<LinearSpace>) -> usize {
-        coords.x
-    }
 }
 
 #[derive(Default, Clone, Copy, Debug, PartialEq, Eq)]
@@ -190,7 +148,7 @@ impl<const STRIDE_NUM: usize> StrideMapping<STRIDE_NUM> {
         let mut strides = [Stride::default(); STRIDE_NUM];
         let stride_count = stride_json.len();
         let mut physical_idx = 0;
-        let mut size: Option<Rectangle<StrideSpace>> = None;//Rectangle::new(Coordinates::new(usize::MAX, usize::MAX), Coordinates::new(0, 0));
+        let mut size: Option<Rectangle<StrideSpace>> = None;
         for stride_idx in 0..stride_count {
             let json_data = stride_json[stride_idx];
             let x = json_data.0;
@@ -237,15 +195,12 @@ impl<const STRIDE_NUM: usize> StrideMapping<STRIDE_NUM> {
     }
 }
 
-impl PixelMapping for StrideMapping {
+impl<'a> Select<'a> for StrideMapping {
     type Space = StrideSpace;
-    fn select(&self, rect: &Rectangle<Virtual>) -> impl CoordinateView<Space = StrideSpace> {
+    type View = StrideView<'a>;
+    fn select(&'a self, rect: &Rectangle<Virtual>) -> Self::View {
         StrideView::new(self, rect)
     }
-
-    fn to_idx(&self, coords: &Coordinates<StrideSpace>) -> usize {
-        self.strides[coords.x as usize].pixel_idx_for_offset(coords.y)
-    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -255,8 +210,8 @@ impl CoordinateSpace for StrideSpace {
 }
 pub type StrideCoords = Coordinates<StrideSpace>;
 
-struct StrideView<'a> {
-    map: &'a StrideMapping,
+pub struct StrideView<'a> {
+    pub map: &'a StrideMapping,
     range: Rectangle<StrideSpace>,
     cur: StrideCoords,
     step_size: VirtualCoordinates
@@ -310,7 +265,7 @@ impl<'a> StrideView<'a> {
     }
 }
 
-impl<'a> CoordinateView for StrideView<'a> {
+impl<'a> CoordinateView<'a> for StrideView<'a> {
     type Space = StrideSpace;
     fn next(&mut self) -> Option<(VirtualCoordinates, StrideCoords)> {
         // Keep scanning until we reach the far right of the range