From 4e8ce5bbaf5aa71f7e00e7a131fc6b25e623c992 Mon Sep 17 00:00:00 2001 From: Daniel Schadt Date: Sat, 11 Mar 2023 19:38:16 +0100 Subject: abstract away tile rendering logic This is in prepration for the tilehunt mode, where we want to render tiles differently. --- src/main.rs | 30 +++++-- src/renderer.rs | 228 ------------------------------------------------ src/renderer/heatmap.rs | 209 ++++++++++++++++++++++++++++++++++++++++++++ src/renderer/mod.rs | 90 +++++++++++++++++++ 4 files changed, 322 insertions(+), 235 deletions(-) delete mode 100644 src/renderer.rs create mode 100644 src/renderer/heatmap.rs create mode 100644 src/renderer/mod.rs (limited to 'src') diff --git a/src/main.rs b/src/main.rs index e5b835e..6c110e2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,13 +1,13 @@ use std::{io, path::PathBuf}; -use clap::Parser; +use clap::{Parser, ValueEnum}; use color_eyre::{ eyre::{bail, eyre, Result}, Report, }; use hittekaart::{ gpx::{self, Compression}, - renderer, + renderer::{self, heatmap, Renderer}, storage::{Folder, Sqlite, Storage}, }; use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressStyle}; @@ -17,6 +17,13 @@ use rayon::{ ThreadPoolBuilder, }; +/// Tile generation mode. +#[derive(ValueEnum, Debug, Clone, Copy, PartialEq, Eq, Hash)] +enum Mode { + Heatmap, + Tilehunt, +} + #[derive(Parser, Debug, Clone)] #[command(author, version, about)] struct Args { @@ -45,6 +52,10 @@ struct Args { /// filename. #[arg(long)] sqlite: bool, + + /// Generation mode. + #[arg(value_enum, long, short, default_value_t = Mode::Heatmap)] + mode: Mode, } fn main() -> Result<()> { @@ -60,6 +71,10 @@ fn main() -> Result<()> { .num_threads(args.threads) .build_global()?; + run::(args) +} + +fn run(args: Args) -> Result<()> { let progress_style = ProgressStyle::with_template("[{elapsed}] {prefix:.cyan} {wide_bar} {pos:.green}/{len}")?; let zoom_style = @@ -112,18 +127,19 @@ fn main() -> Result<()> { let bar = make_bar(tracks.len().try_into().unwrap()).with_style(progress_style.clone()); multibar.insert_from_back(1, bar.clone()); bar.set_prefix("Rendering heat zones"); - let counter = - renderer::render_heatcounter(zoom, &tracks, |x| bar.inc(x.try_into().unwrap())); + let counter = renderer::prepare::(zoom, &tracks, || { + bar.inc(1); + Ok(()) + })?; bar.finish(); multibar.remove(&bar); storage.prepare_zoom(zoom)?; - let bar = - make_bar(counter.tile_count().try_into().unwrap()).with_style(progress_style.clone()); + let bar = make_bar(R::tile_count(&counter)?).with_style(progress_style.clone()); multibar.insert_from_back(1, bar.clone()); bar.set_prefix("Saving heat tiles"); - renderer::lazy_colorization(counter, |rendered_tile| { + renderer::colorize::(counter, |rendered_tile| { storage.store(zoom, rendered_tile.x, rendered_tile.y, &rendered_tile.data)?; bar.inc(1); Ok(()) diff --git a/src/renderer.rs b/src/renderer.rs deleted file mode 100644 index d7aefe4..0000000 --- a/src/renderer.rs +++ /dev/null @@ -1,228 +0,0 @@ -//! Actual rendering functions for heatmaps. -//! -//! We begin the rendering by using [`render_heatcounter`] to turn a list of GPX tracks into a -//! [`HeatCounter`], which is basically a grayscale heatmap, where each pixel represents the number -//! of tracks that goes through this pixel. -//! -//! We then render the colored heatmap tiles using [`lazy_colorization`], which provides us with -//! colorful PNG data. -use std::thread; - -use color_eyre::{eyre::Result, Report}; -use image::{ImageBuffer, Luma, Pixel, RgbaImage}; -use nalgebra::{vector, Vector2}; -use rayon::iter::ParallelIterator; - -use super::{ - gpx::Coordinates, - layer::{self, TileLayer}, -}; - -/// Represents a fully rendered tile. -#[derive(Debug, Clone)] -pub struct RenderedTile { - /// The `x` coordinate of the tile. - pub x: u64, - /// The `y` coordinate of the tile. - pub y: u64, - /// The encoded (PNG) image data, ready to be saved to disk. - pub data: Vec, -} - -/// Type for the intermediate heat counters. -pub type HeatCounter = TileLayer>; - -fn render_circle(layer: &mut TileLayer

, center: (u64, u64), radius: u64, pixel: P) { - let topleft = (center.0 - radius, center.1 - radius); - let rad_32: u32 = radius.try_into().unwrap(); - let mut circle = ImageBuffer::>::new(rad_32 * 2 + 1, rad_32 * 2 + 1); - imageproc::drawing::draw_filled_circle_mut( - &mut circle, - ( - i32::try_from(radius).unwrap(), - i32::try_from(radius).unwrap(), - ), - radius.try_into().unwrap(), - pixel, - ); - layer.blit_nonzero(topleft.0, topleft.1, &circle); -} - -fn direction_vector(a: (u64, u64), b: (u64, u64)) -> Vector2 { - let dx = if b.0 > a.0 { - (b.0 - a.0) as f64 - } else { - -((a.0 - b.0) as f64) - }; - let dy = if b.1 > a.1 { - (b.1 - a.1) as f64 - } else { - -((a.1 - b.1) as f64) - }; - vector![dx, dy] -} - -fn render_line( - layer: &mut TileLayer

, - start: (u64, u64), - end: (u64, u64), - thickness: u64, - pixel: P, -) { - use imageproc::point::Point; - - if start == end { - return; - } - - fn unsigned_add(a: Vector2, b: Vector2) -> Vector2 { - let x = if b[0] < 0 { - a[0] - u64::from(b[0].unsigned_abs()) - } else { - a[0] + u64::try_from(b[0]).unwrap() - }; - let y = if b[1] < 0 { - a[1] - u64::from(b[1].unsigned_abs()) - } else { - a[1] + u64::try_from(b[1]).unwrap() - }; - vector![x, y] - } - - let r = direction_vector(start, end); - let normal = vector![r[1], -r[0]].normalize(); - - let start = vector![start.0, start.1]; - let end = vector![end.0, end.1]; - - let displacement = normal * thickness as f64; - let displacement = displacement.map(|x| x as i32); - if displacement == vector![0, 0] { - return; - } - let polygon = [ - unsigned_add(start, displacement), - unsigned_add(end, displacement), - unsigned_add(end, -displacement), - unsigned_add(start, -displacement), - ]; - let min_x = polygon.iter().map(|p| p[0]).min().unwrap(); - let min_y = polygon.iter().map(|p| p[1]).min().unwrap(); - let max_x = polygon.iter().map(|p| p[0]).max().unwrap(); - let max_y = polygon.iter().map(|p| p[1]).max().unwrap(); - - let mut overlay = ImageBuffer::>::new( - (max_x - min_x).try_into().unwrap(), - (max_y - min_y).try_into().unwrap(), - ); - let adjusted_poly = polygon - .into_iter() - .map(|p| Point::new((p[0] - min_x) as i32, (p[1] - min_y) as i32)) - .collect::>(); - imageproc::drawing::draw_polygon_mut(&mut overlay, &adjusted_poly, pixel); - - layer.blit_nonzero(min_x, min_y, &overlay); -} - -fn merge_heat_counter(base: &mut HeatCounter, overlay: &HeatCounter) { - for (tx, ty, source) in overlay.enumerate_tiles() { - let target = base.tile_mut(tx, ty); - for (x, y, source) in source.enumerate_pixels() { - let target = target.get_pixel_mut(x, y); - target[0] += source[0]; - } - } -} - -fn colorize_tile(tile: &ImageBuffer, Vec>, max: u32) -> RgbaImage { - let gradient = colorgrad::yl_or_rd(); - let mut result = ImageBuffer::from_pixel(tile.width(), tile.height(), [0, 0, 0, 0].into()); - for (x, y, pixel) in tile.enumerate_pixels() { - if pixel[0] > 0 { - let alpha = pixel[0] as f64 / max as f64; - let color = gradient.at(1.0 - alpha); - let target = result.get_pixel_mut(x, y); - *target = color.to_rgba8().into(); - } - } - result -} - -/// Lazily colorizes a [`HeatCounter`] by colorizing it tile-by-tile and saving a tile before -/// rendering the next one. -/// -/// This function calls the given callback with each rendered tile, and the function is responsible -/// for saving it. If the callback returns an `Err(...)`, the error is passed through. -/// -/// Note that this function internally uses `rayon` for parallization. If you want to limit the -/// number of threads used, set up the global [`rayon::ThreadPool`] first. -pub fn lazy_colorization Result<()> + Send>( - layer: HeatCounter, - mut save_callback: F, -) -> Result<()> { - let max = layer.pixels().map(|l| l.0[0]).max().unwrap_or_default(); - if max == 0 { - return Ok(()); - } - - let (tx, rx) = crossbeam_channel::bounded::(30); - - thread::scope(|s| { - let saver = s.spawn(move || loop { - let Ok(tile) = rx.recv() else { return Ok::<_, Report>(()) }; - save_callback(tile)?; - }); - - layer - .into_parallel_tiles() - .try_for_each_with(tx, |tx, (tile_x, tile_y, tile)| { - let colorized = colorize_tile(&tile, max.into()); - let data = layer::compress_png_as_bytes(&colorized)?; - tx.send(RenderedTile { - x: tile_x, - y: tile_y, - data, - })?; - Ok::<(), Report>(()) - })?; - - saver.join().unwrap()?; - Ok::<_, Report>(()) - })?; - - Ok(()) -} - -/// Renders the heat counter for the given zoom level and track points. -/// -/// The given callback will be called when a track has been rendered and merged into the -/// accumulator, to allow for UI feedback. The passed parameter is the number of tracks that have -/// been rendered since the last call. -pub fn render_heatcounter( - zoom: u32, - tracks: &[Vec], - progress_callback: F, -) -> HeatCounter { - let mut heatcounter = TileLayer::from_pixel([0].into()); - - for track in tracks { - let mut layer = TileLayer::from_pixel([0].into()); - - let points = track - .iter() - .map(|coords| coords.web_mercator(zoom)) - .collect::>(); - - for point in points.iter() { - render_circle(&mut layer, *point, (zoom as u64 / 4).max(2) - 1, [1].into()); - } - - for (a, b) in points.iter().zip(points.iter().skip(1)) { - render_line(&mut layer, *a, *b, (zoom as u64 / 4).max(1), [1].into()); - } - - merge_heat_counter(&mut heatcounter, &layer); - progress_callback(1); - } - heatcounter -} diff --git a/src/renderer/heatmap.rs b/src/renderer/heatmap.rs new file mode 100644 index 0000000..c4af7a6 --- /dev/null +++ b/src/renderer/heatmap.rs @@ -0,0 +1,209 @@ +//! Actual rendering functions for heatmaps. +//! +//! We begin the rendering by using [`render_heatcounter`] to turn a list of GPX tracks into a +//! [`HeatCounter`], which is basically a grayscale heatmap, where each pixel represents the number +//! of tracks that goes through this pixel. +//! +//! We then render the colored heatmap tiles using [`lazy_colorization`], which provides us with +//! colorful PNG data. +use color_eyre::{eyre::Result, Report}; +use crossbeam_channel::Sender; +use image::{ImageBuffer, Luma, Pixel, RgbaImage}; +use nalgebra::{vector, Vector2}; +use rayon::iter::ParallelIterator; + +use super::{ + super::{ + gpx::Coordinates, + layer::{self, TileLayer}, + }, + RenderedTile, +}; + +/// Type for the intermediate heat counters. +pub type HeatCounter = TileLayer>; + +fn render_circle(layer: &mut TileLayer

, center: (u64, u64), radius: u64, pixel: P) { + let topleft = (center.0 - radius, center.1 - radius); + let rad_32: u32 = radius.try_into().unwrap(); + let mut circle = ImageBuffer::>::new(rad_32 * 2 + 1, rad_32 * 2 + 1); + imageproc::drawing::draw_filled_circle_mut( + &mut circle, + ( + i32::try_from(radius).unwrap(), + i32::try_from(radius).unwrap(), + ), + radius.try_into().unwrap(), + pixel, + ); + layer.blit_nonzero(topleft.0, topleft.1, &circle); +} + +fn direction_vector(a: (u64, u64), b: (u64, u64)) -> Vector2 { + let dx = if b.0 > a.0 { + (b.0 - a.0) as f64 + } else { + -((a.0 - b.0) as f64) + }; + let dy = if b.1 > a.1 { + (b.1 - a.1) as f64 + } else { + -((a.1 - b.1) as f64) + }; + vector![dx, dy] +} + +fn render_line( + layer: &mut TileLayer

, + start: (u64, u64), + end: (u64, u64), + thickness: u64, + pixel: P, +) { + use imageproc::point::Point; + + if start == end { + return; + } + + fn unsigned_add(a: Vector2, b: Vector2) -> Vector2 { + let x = if b[0] < 0 { + a[0] - u64::from(b[0].unsigned_abs()) + } else { + a[0] + u64::try_from(b[0]).unwrap() + }; + let y = if b[1] < 0 { + a[1] - u64::from(b[1].unsigned_abs()) + } else { + a[1] + u64::try_from(b[1]).unwrap() + }; + vector![x, y] + } + + let r = direction_vector(start, end); + let normal = vector![r[1], -r[0]].normalize(); + + let start = vector![start.0, start.1]; + let end = vector![end.0, end.1]; + + let displacement = normal * thickness as f64; + let displacement = displacement.map(|x| x as i32); + if displacement == vector![0, 0] { + return; + } + let polygon = [ + unsigned_add(start, displacement), + unsigned_add(end, displacement), + unsigned_add(end, -displacement), + unsigned_add(start, -displacement), + ]; + let min_x = polygon.iter().map(|p| p[0]).min().unwrap(); + let min_y = polygon.iter().map(|p| p[1]).min().unwrap(); + let max_x = polygon.iter().map(|p| p[0]).max().unwrap(); + let max_y = polygon.iter().map(|p| p[1]).max().unwrap(); + + let mut overlay = ImageBuffer::>::new( + (max_x - min_x).try_into().unwrap(), + (max_y - min_y).try_into().unwrap(), + ); + let adjusted_poly = polygon + .into_iter() + .map(|p| Point::new((p[0] - min_x) as i32, (p[1] - min_y) as i32)) + .collect::>(); + imageproc::drawing::draw_polygon_mut(&mut overlay, &adjusted_poly, pixel); + + layer.blit_nonzero(min_x, min_y, &overlay); +} + +fn merge_heat_counter(base: &mut HeatCounter, overlay: &HeatCounter) { + for (tx, ty, source) in overlay.enumerate_tiles() { + let target = base.tile_mut(tx, ty); + for (x, y, source) in source.enumerate_pixels() { + let target = target.get_pixel_mut(x, y); + target[0] += source[0]; + } + } +} + +fn colorize_tile(tile: &ImageBuffer, Vec>, max: u32) -> RgbaImage { + let gradient = colorgrad::yl_or_rd(); + let mut result = ImageBuffer::from_pixel(tile.width(), tile.height(), [0, 0, 0, 0].into()); + for (x, y, pixel) in tile.enumerate_pixels() { + if pixel[0] > 0 { + let alpha = pixel[0] as f64 / max as f64; + let color = gradient.at(1.0 - alpha); + let target = result.get_pixel_mut(x, y); + *target = color.to_rgba8().into(); + } + } + result +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct Renderer; + +impl super::Renderer for Renderer { + type Prepared = HeatCounter; + + /// Renders the heat counter for the given zoom level and track points. + /// + /// The given callback will be called when a track has been rendered and merged into the + /// accumulator, to allow for UI feedback. The passed parameter is the number of tracks that have + /// been rendered since the last call. + fn prepare(zoom: u32, tracks: &[Vec], tick: Sender<()>) -> Result { + let mut heatcounter = TileLayer::from_pixel([0].into()); + + for track in tracks { + let mut layer = TileLayer::from_pixel([0].into()); + + let points = track + .iter() + .map(|coords| coords.web_mercator(zoom)) + .collect::>(); + + for point in points.iter() { + render_circle(&mut layer, *point, (zoom as u64 / 4).max(2) - 1, [1].into()); + } + + for (a, b) in points.iter().zip(points.iter().skip(1)) { + render_line(&mut layer, *a, *b, (zoom as u64 / 4).max(1), [1].into()); + } + + merge_heat_counter(&mut heatcounter, &layer); + tick.send(()).unwrap(); + } + Ok(heatcounter) + } + + /// Lazily colorizes a [`HeatCounter`] by colorizing it tile-by-tile and saving a tile before + /// rendering the next one. + /// + /// This function calls the given callback with each rendered tile, and the function is responsible + /// for saving it. If the callback returns an `Err(...)`, the error is passed through. + /// + /// Note that this function internally uses `rayon` for parallization. If you want to limit the + /// number of threads used, set up the global [`rayon::ThreadPool`] first. + fn colorize(layer: HeatCounter, tx: Sender) -> Result<()> { + let max = layer.pixels().map(|l| l.0[0]).max().unwrap_or_default(); + if max == 0 { + return Ok(()); + } + + layer + .into_parallel_tiles() + .try_for_each_with(tx, |tx, (tile_x, tile_y, tile)| { + let colorized = colorize_tile(&tile, max.into()); + let data = layer::compress_png_as_bytes(&colorized)?; + tx.send(RenderedTile { + x: tile_x, + y: tile_y, + data, + })?; + Ok::<(), Report>(()) + }) + } + + fn tile_count(layer: &HeatCounter) -> Result { + Ok(layer.tile_count().try_into().unwrap()) + } +} diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs new file mode 100644 index 0000000..927c6ed --- /dev/null +++ b/src/renderer/mod.rs @@ -0,0 +1,90 @@ +//! Generic "tile rendering" methods. +use std::thread; + +use color_eyre::Result; +use crossbeam_channel::Sender; + +use super::gpx::Coordinates; + +pub mod heatmap; + +const CHANNEL_SIZE: usize = 30; + +/// Represents a fully rendered tile. +#[derive(Debug, Clone)] +pub struct RenderedTile { + /// The `x` coordinate of the tile. + pub x: u64, + /// The `y` coordinate of the tile. + pub y: u64, + /// The encoded (PNG) image data, ready to be saved to disk. + pub data: Vec, +} + +/// An object that is responsible for turning raw GPX tracks into a representation. +/// +/// This is done in two steps, preparation and actual rendering. This allows different feedback for +/// the user. +pub trait Renderer { + type Prepared: Send; + + /// Prepare the rendered data. + /// + /// The `tick` channel is used to provide user-feedback, for every finished track a tick should + /// be sent. + fn prepare(zoom: u32, tracks: &[Vec], tick: Sender<()>) -> Result; + + /// Actually produce the colored tiles, using the previously prepared data. + /// + /// The `saver` channel is used to send the finished tiles to a thread that is responsible for + /// saving them. + fn colorize(prepared: Self::Prepared, saver: Sender) -> Result<()>; + + /// Returns the tile count of the prepared data. + /// + /// This is used for the user interface, to scale progress bars appropriately. + fn tile_count(prepared: &Self::Prepared) -> Result; +} + +/// A convenience wrapper to call [`Renderer::prepare`]. +/// +/// This function takes the same arguments, but provides the ability to use a callback closure +/// instead of having to set up a channel. The callback is always called on the same thread. +pub fn prepare Result<()>>( + zoom: u32, + tracks: &[Vec], + mut tick: F, +) -> Result { + thread::scope(|s| { + let (sender, receiver) = crossbeam_channel::bounded(CHANNEL_SIZE); + + let preparer = s.spawn(|| R::prepare(zoom, tracks, sender)); + + for _ in receiver { + tick()?; + } + + preparer.join().unwrap() + }) +} + +/// A convenience wrapper to call [`Renderer::colorize`]. +/// +/// This function takes the same arguments, but provides the ability to use a callback closure +/// instead of having to set up a channel. The callback is always called on the same thread. +pub fn colorize Result<()>>( + prepared: R::Prepared, + mut saver: F, +) -> Result<()> { + thread::scope(|s| { + let (sender, receiver) = crossbeam_channel::bounded(CHANNEL_SIZE); + + let colorizer = s.spawn(|| R::colorize(prepared, sender)); + + for tile in receiver { + saver(tile)?; + } + + colorizer.join().unwrap() + }) +} -- cgit v1.2.3