diff options
Diffstat (limited to 'src/layer.rs')
| -rw-r--r-- | src/layer.rs | 86 |
1 files changed, 74 insertions, 12 deletions
diff --git a/src/layer.rs b/src/layer.rs index 1c14df3..74c36e0 100644 --- a/src/layer.rs +++ b/src/layer.rs @@ -3,7 +3,11 @@ //! 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::{self, File}, + io::BufWriter, + path::Path, +}; use color_eyre::eyre::{bail, Result}; use fnv::FnvHashMap; @@ -11,6 +15,7 @@ use image::{ codecs::png::{CompressionType, FilterType, PngEncoder}, ColorType, ImageBuffer, ImageEncoder, Pixel, Rgba, RgbaImage, }; +use num_traits::Zero; pub const TILE_HEIGHT: u64 = 256; pub const TILE_WIDTH: u64 = 256; @@ -45,18 +50,23 @@ impl<P: Pixel> TileLayer<P> { 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()), + ( + (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>>)> { + pub fn enumerate_tiles( + &self, + ) -> impl Iterator<Item = (u64, u64, &ImageBuffer<P, Vec<P::Subpixel>>)> { self.tiles.iter().map(|((x, y), t)| (*x, *y, t)) } pub fn tile_mut(&mut self, tile_x: u64, tile_y: u64) -> &mut ImageBuffer<P, Vec<P::Subpixel>> { - self.tiles - .entry((tile_x, tile_y)) - .or_insert_with(|| ImageBuffer::from_pixel(TILE_WIDTH as u32, TILE_HEIGHT as u32, self.default_pixel)) + self.tiles.entry((tile_x, tile_y)).or_insert_with(|| { + ImageBuffer::from_pixel(TILE_WIDTH as u32, TILE_HEIGHT as u32, self.default_pixel) + }) } pub fn tile_for_mut(&mut self, x: u64, y: u64) -> &mut ImageBuffer<P, Vec<P::Subpixel>> { @@ -73,7 +83,7 @@ impl<P: Pixel> TileLayer<P> { self.tiles .get(&outer_idx) .map(|tile| tile.get_pixel(inner_x, inner_y)) - .or_else(|| Some(&self.default_pixel)) + .or(Some(&self.default_pixel)) } pub fn get_pixel(&self, x: u64, y: u64) -> &P { @@ -101,16 +111,26 @@ impl<P: Pixel> TileLayer<P> { /// 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)| { - tile.enumerate_pixels() - .map(move |(x, y, p)| (u64::from(x) + tx * TILE_WIDTH, u64::from(y) + ty * TILE_HEIGHT, p)) + tile.enumerate_pixels().map(move |(x, y, p)| { + ( + u64::from(x) + tx * TILE_WIDTH, + u64::from(y) + ty * TILE_HEIGHT, + 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)) + tile.enumerate_pixels_mut().map(move |(x, y, p)| { + ( + u64::from(x) + tx * TILE_WIDTH, + u64::from(y) + ty * TILE_HEIGHT, + p, + ) + }) }) } @@ -125,6 +145,43 @@ impl<P: Pixel> TileLayer<P> { pub fn tile_count(&self) -> usize { self.tiles.len() } + + /// Copies the non-zero pixels from `source` to `self`. + /// + /// A zero-pixel is identified by comparing all its channels' values with `Zero::zero()`. If + /// any channel is non-zero, the pixel is considered non-zero and is copied. + /// + /// The top-left pixel of `source` is copied to `(x, y)`. + /// + /// This method is more efficient than repeatedly calling [`get_pixel_mut`], as it groups + /// pixels by tile and only does one tile lookup. + pub fn blit_nonzero(&mut self, x: u64, y: u64, source: &ImageBuffer<P, Vec<P::Subpixel>>) { + let zero = zero_pixel::<P>(); + let source_width = u64::from(source.width()); + let source_height = u64::from(source.height()); + for tx in x / TILE_WIDTH..=(x + source_width) / TILE_WIDTH { + for ty in y / TILE_HEIGHT..=(y + source_height) / TILE_HEIGHT { + let tile = self.tile_mut(tx, ty); + let offset_x = (tx * TILE_WIDTH).saturating_sub(x); + let offset_y = (ty * TILE_HEIGHT).saturating_sub(y); + let local_min_x = x.saturating_sub(tx * TILE_WIDTH); + let local_min_y = y.saturating_sub(ty * TILE_HEIGHT); + let local_max_x = TILE_WIDTH.min(x + source_width - tx * TILE_WIDTH); + let local_max_y = TILE_HEIGHT.min(y + source_height - ty * TILE_HEIGHT); + // Keep x in the inner loop for better cache locality! + for (y, source_y) in (local_min_y..local_max_y).zip(offset_y..) { + for (x, source_x) in (local_min_x..local_max_x).zip(offset_x..) { + let pixel = source + .get_pixel(source_x.try_into().unwrap(), source_y.try_into().unwrap()); + if pixel.channels() != zero.channels() { + *tile.get_pixel_mut(x.try_into().unwrap(), y.try_into().unwrap()) = + *pixel; + } + } + } + } + } + } } impl TileLayer<Rgba<u8>> { @@ -137,7 +194,7 @@ impl TileLayer<Rgba<u8>> { 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)?; @@ -156,3 +213,8 @@ pub fn compress_png<P: AsRef<Path>>(image: &RgbaImage, path: P) -> Result<()> { Ok(()) } + +fn zero_pixel<P: Pixel>() -> P { + let zeroes = vec![Zero::zero(); P::CHANNEL_COUNT as usize]; + *P::from_slice(&zeroes) +} |