1 files changed, 8 insertions, 108 deletions

diff --git a/src/layer.rs b/src/layer.rs
index 74c36e0..a8057a0 100644
--- a/src/layer.rs
+++ b/src/layer.rs
@@ -3,60 +3,36 @@
 //! This supports OSM-style "tiled" images, but not all of the tiles have to be present. If a tile
 //! is not present, a default pixel is returned. The tile is allocated with the first call to a
 //! mutating operation.
-use std::{
-    fs::{self, File},
-    io::BufWriter,
-    path::Path,
-};
+use std::{fs::File, io::BufWriter, path::Path};
 
-use color_eyre::eyre::{bail, Result};
+use color_eyre::eyre::Result;
 use fnv::FnvHashMap;
 use image::{
     codecs::png::{CompressionType, FilterType, PngEncoder},
-    ColorType, ImageBuffer, ImageEncoder, Pixel, Rgba, RgbaImage,
+    ColorType, ImageBuffer, ImageEncoder, Pixel, RgbaImage,
 };
 use num_traits::Zero;
 
 pub const TILE_HEIGHT: u64 = 256;
 pub const TILE_WIDTH: u64 = 256;
 
+type TileIndex = (u64, u64);
+
 /// Main "lazy image buffer" struct.
 #[derive(Debug, Clone)]
 pub struct TileLayer<P: Pixel> {
-    tiles: FnvHashMap<(u64, u64), ImageBuffer<P, Vec<P::Subpixel>>>,
+    tiles: FnvHashMap<TileIndex, ImageBuffer<P, Vec<P::Subpixel>>>,
     default_pixel: P,
-    width: u64,
-    height: u64,
 }
 
 impl<P: Pixel> TileLayer<P> {
-    pub fn from_pixel(width: u64, height: u64, pixel: P) -> Self {
+    pub fn from_pixel(pixel: P) -> Self {
         TileLayer {
             tiles: Default::default(),
             default_pixel: pixel,
-            width,
-            height,
         }
     }
 
-    pub fn width(&self) -> u64 {
-        self.width
-    }
-
-    pub fn height(&self) -> u64 {
-        self.height
-    }
-
-    fn index(&self, x: u64, y: u64) -> ((u64, u64), (u32, u32)) {
-        (
-            (x / TILE_WIDTH, y / TILE_HEIGHT),
-            (
-                (x % TILE_WIDTH).try_into().unwrap(),
-                (y % TILE_HEIGHT).try_into().unwrap(),
-            ),
-        )
-    }
-
     pub fn enumerate_tiles(
         &self,
     ) -> impl Iterator<Item = (u64, u64, &ImageBuffer<P, Vec<P::Subpixel>>)> {
@@ -69,45 +45,6 @@ impl<P: Pixel> TileLayer<P> {
         })
     }
 
-    pub fn tile_for_mut(&mut self, x: u64, y: u64) -> &mut ImageBuffer<P, Vec<P::Subpixel>> {
-        let ((tx, ty), _) = self.index(x, y);
-        self.tile_mut(tx, ty)
-    }
-
-    pub fn get_pixel_checked(&self, x: u64, y: u64) -> Option<&P> {
-        if x >= self.width || y >= self.height {
-            return None;
-        }
-
-        let (outer_idx, (inner_x, inner_y)) = self.index(x, y);
-        self.tiles
-            .get(&outer_idx)
-            .map(|tile| tile.get_pixel(inner_x, inner_y))
-            .or(Some(&self.default_pixel))
-    }
-
-    pub fn get_pixel(&self, x: u64, y: u64) -> &P {
-        // This is kinda cheating, but we care about the API for now, not the speed. We can
-        // optimize this later.
-        self.get_pixel_checked(x, y).unwrap()
-    }
-
-    pub fn get_pixel_mut_checked(&mut self, x: u64, y: u64) -> Option<&mut P> {
-        if x >= self.width || y >= self.height {
-            return None;
-        }
-
-        let ((outer_x, outer_y), (inner_x, inner_y)) = self.index(x, y);
-        Some(
-            self.tile_mut(outer_x, outer_y)
-                .get_pixel_mut(inner_x, inner_y),
-        )
-    }
-
-    pub fn get_pixel_mut(&mut self, x: u64, y: u64) -> &mut P {
-        self.get_pixel_mut_checked(x, y).unwrap()
-    }
-
     /// Enumerate all pixels that are explicitely set in this layer.
     pub fn enumerate_pixels(&self) -> impl Iterator<Item = (u64, u64, &P)> {
         self.tiles.iter().flat_map(|((tx, ty), tile)| {
@@ -121,27 +58,10 @@ impl<P: Pixel> TileLayer<P> {
         })
     }
 
-    /// Mutably enumerate all pixels that are explicitely set in this layer.
-    pub fn enumerate_pixels_mut(&mut self) -> impl Iterator<Item = (u64, u64, &mut P)> {
-        self.tiles.iter_mut().flat_map(|((tx, ty), tile)| {
-            tile.enumerate_pixels_mut().map(move |(x, y, p)| {
-                (
-                    u64::from(x) + tx * TILE_WIDTH,
-                    u64::from(y) + ty * TILE_HEIGHT,
-                    p,
-                )
-            })
-        })
-    }
-
     pub fn pixels(&self) -> impl Iterator<Item = &P> {
         self.enumerate_pixels().map(|x| x.2)
     }
 
-    pub fn pixels_mut(&mut self) -> impl Iterator<Item = &mut P> {
-        self.enumerate_pixels_mut().map(|x| x.2)
-    }
-
     pub fn tile_count(&self) -> usize {
         self.tiles.len()
     }
@@ -184,32 +104,12 @@ impl<P: Pixel> TileLayer<P> {
     }
 }
 
-impl TileLayer<Rgba<u8>> {
-    pub fn save_to_directory<S: AsRef<Path>>(&self, path: S) -> Result<()> {
-        let path = path.as_ref();
-
-        for ((x, y), tile) in self.tiles.iter() {
-            let folder = path.join(&x.to_string());
-            let metadata = folder.metadata();
-            match metadata {
-                Err(_) => fs::create_dir(&folder)?,
-                Ok(m) if !m.is_dir() => bail!("Output path is not a directory"),
-                _ => {}
-            }
-            let file = folder.join(&format!("{y}.png"));
-            compress_png(tile, file)?;
-        }
-
-        Ok(())
-    }
-}
-
 pub fn compress_png<P: AsRef<Path>>(image: &RgbaImage, path: P) -> Result<()> {
     let outstream = BufWriter::new(File::create(path)?);
     let encoder =
         PngEncoder::new_with_quality(outstream, CompressionType::Best, FilterType::Adaptive);
 
-    encoder.write_image(&image, image.width(), image.height(), ColorType::Rgba8)?;
+    encoder.write_image(image, image.width(), image.height(), ColorType::Rgba8)?;
 
     Ok(())
 }