aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/layer.rs116
-rw-r--r--src/renderer.rs40
2 files changed, 19 insertions, 137 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(())
}
diff --git a/src/renderer.rs b/src/renderer.rs
index 6e17304..cece8f3 100644
--- a/src/renderer.rs
+++ b/src/renderer.rs
@@ -1,9 +1,8 @@
-use std::{fs, mem, path::Path};
+use std::{fs, path::Path};
use color_eyre::eyre::{bail, Result};
-use image::{ImageBuffer, Luma, Pixel, Rgba, RgbaImage};
+use image::{ImageBuffer, Luma, Pixel, RgbaImage};
use nalgebra::{vector, Vector2};
-use num_traits::identities::Zero;
use super::{
gpx::Coordinates,
@@ -12,8 +11,6 @@ use super::{
pub type HeatCounter = TileLayer<Luma<u8>>;
-pub type HeatMap = TileLayer<Rgba<u8>>;
-
fn render_circle<P: Pixel>(layer: &mut TileLayer<P>, center: (u64, u64), radius: u64, pixel: P) {
let topleft = (center.0 - radius, center.1 - radius);
let rad_32: u32 = radius.try_into().unwrap();
@@ -59,14 +56,14 @@ fn render_line<P: Pixel>(
fn unsigned_add(a: Vector2<u64>, b: Vector2<i32>) -> Vector2<u64> {
let x = if b[0] < 0 {
- a[0] - b[0].abs() as u64
+ a[0] - u64::from(b[0].unsigned_abs())
} else {
- a[0] + b[0] as u64
+ a[0] + u64::try_from(b[0]).unwrap()
};
let y = if b[1] < 0 {
- a[1] - b[1].abs() as u64
+ a[1] - u64::from(b[1].unsigned_abs())
} else {
- a[1] + b[1] as u64
+ a[1] + u64::try_from(b[1]).unwrap()
};
vector![x, y]
}
@@ -130,19 +127,6 @@ fn colorize_tile(tile: &ImageBuffer<Luma<u8>, Vec<u8>>, max: u32) -> RgbaImage {
result
}
-pub fn colorize_heatcounter(layer: &HeatCounter) -> HeatMap {
- let max = layer.pixels().map(|l| l.0[0]).max().unwrap_or_default();
- let mut result = TileLayer::from_pixel(layer.width(), layer.height(), [0, 0, 0, 0].into());
- if max == 0 {
- return result;
- }
- for (tile_x, tile_y, tile) in layer.enumerate_tiles() {
- let colorized = colorize_tile(&tile, max.into());
- *result.tile_mut(tile_x, tile_y) = colorized;
- }
- result
-}
-
/// Lazily colorizes a [`HeatCounter`] by colorizing it tile-by-tile and saving a tile before
/// rendering the next one.
///
@@ -159,15 +143,15 @@ pub fn lazy_colorization<P: AsRef<Path>, F: FnMut(usize)>(
}
for (tile_x, tile_y, tile) in layer.enumerate_tiles() {
- let colorized = colorize_tile(&tile, max.into());
- let folder = base_dir.join(&tile_x.to_string());
+ let colorized = colorize_tile(tile, max.into());
+ let folder = base_dir.join(tile_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!("{tile_y}.png"));
+ let file = folder.join(format!("{tile_y}.png"));
layer::compress_png(&colorized, file)?;
progress_callback(1);
}
@@ -180,12 +164,10 @@ pub fn render_heatcounter<F: FnMut(usize)>(
tracks: &[Vec<Coordinates>],
mut progress_callback: F,
) -> HeatCounter {
- let size = 256 * 2u64.pow(zoom);
-
- let mut heatcounter = TileLayer::from_pixel(size, size, [0].into());
+ let mut heatcounter = TileLayer::from_pixel([0].into());
for track in tracks {
- let mut layer = TileLayer::from_pixel(size, size, [0].into());
+ let mut layer = TileLayer::from_pixel([0].into());
let points = track
.iter()
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 01:01:34 +0000