Heatmap

Author: UdHo

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Heatmap rendering: `mapcat -H data.geojson` or `mapcat data.geojson:heatmap` renders point data as a colour-gradient heatmap (blue → cyan → green → yellow → red).
+- Per-file heatmap suffix: append `:heatmap` to any file argument to render that file as a heatmap while other files render normally (e.g. `mapcat routes.geojson points.geojson:heatmap`).
+
 ## [0.2.10] - 2026-04-18
 
 - Headless rendering: `mapcat -o file.png` renders maps directly to PNG (file or stdin input, configurable dimensions, auto-detects format).

README.md

@@ -50,6 +50,21 @@ curl 'https://api.example.com/geo' | mapcat   # From API
 
 Or just drag and drop files onto the map window.
 
+## Heatmap
+
+Render point data as a colour-gradient heatmap instead of individual shapes:
+
+```bash
+# All inputs as heatmap
+mapcat -H points.geojson
+
+# Mix: one file as heatmap, another normal
+mapcat routes.geojson points.geojson:heatmap
+
+# Headless heatmap
+mapcat -o map.png -H points.geojson
+```
+
 ## Headless Rendering
 
 Render maps directly to PNG without opening a window:
@@ -58,11 +73,17 @@ Render maps directly to PNG without opening a window:
 # Render a file
 mapcat -o map.png data.geojson
 
+# Multiple files
+mapcat -o map.png routes.geojson points.geojson
+
 # Pipe data
 cat data.geojson | mapcat -o map.png
 
 # Custom image size
 mapcat -o map.png data.geojson --width 3200 --height 2400
+
+# Black background, no map tiles
+mapcat -o map.png --no-map data.geojson
 ```
 
 ## Basic Controls

src/bin/mapcat/main.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use std::str::FromStr;
 
 use clap::Parser as CliParser;
+use egui::Color32;
 use log::error;
 use mapvas::map::coordinates::PixelCoordinate;
 use mapvas::map::geometry_collection::{Geometry, Metadata};
@@ -16,6 +17,29 @@ use std::io::{BufRead, BufReader, Read};
 
 mod sender;
 
+#[derive(Debug, Clone)]
+struct FileArg {
+  path: std::path::PathBuf,
+  heatmap: bool,
+}
+
+impl std::str::FromStr for FileArg {
+  type Err = std::convert::Infallible;
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    if let Some(path) = s.strip_suffix(":heatmap") {
+      Ok(Self {
+        path: path.into(),
+        heatmap: true,
+      })
+    } else {
+      Ok(Self {
+        path: s.into(),
+        heatmap: false,
+      })
+    }
+  }
+}
+
 /// Walk a geometry tree and append every coordinate it contains to `out`.
 fn collect_coords(geometry: &Geometry<PixelCoordinate>, out: &mut Vec<PixelCoordinate>) {
   match geometry {
@@ -107,6 +131,10 @@ struct Args {
   #[arg(short, long)]
   output: Option<std::path::PathBuf>,
 
+  /// Render without map background (black background, only geometries). Only with --output.
+  #[arg(long)]
+  no_map: bool,
+
   /// Image width in pixels (only with --output)
   #[arg(long, default_value_t = 1980)]
   width: u32,
@@ -116,7 +144,8 @@ struct Args {
   height: u32,
 
   /// Files to parse. stdin is used if not provided.
-  files: Vec<std::path::PathBuf>,
+  /// Append `:heatmap` to a file to render it as a heatmap (e.g. `points.geojson:heatmap`).
+  files: Vec<FileArg>,
 }
 
 fn render_output(args: &Args) {
@@ -128,7 +157,13 @@ fn render_output(args: &Args) {
   let config = Config::new();
   init_style_config(config.vector_style_file.as_deref());
 
-  let renderer = HeadlessRenderer::with_config(config);
+  let renderer = if args.no_map {
+    HeadlessRenderer::with_config(config)
+      .without_map()
+      .with_background_color(Color32::BLACK)
+  } else {
+    HeadlessRenderer::with_config(config)
+  };
 
   let mut events: Vec<MapEvent> = Vec::new();
   if args.files.is_empty() {
@@ -143,15 +178,20 @@ fn render_output(args: &Args) {
       .with_invert_coordinates(args.invert_coordinates);
     events.extend(content_parser.parse());
   } else {
-    for path in &args.files {
-      let mut parser = AutoFileParser::new(path)
+    for file_arg in &args.files {
+      let mut parser = AutoFileParser::new(&file_arg.path)
         .with_label_pattern(&args.label_pattern)
         .with_invert_coordinates(args.invert_coordinates);
-      events.extend(parser.parse());
+      let file_events: Vec<MapEvent> = parser.parse().collect();
+      if args.heatmap || file_arg.heatmap {
+        events.extend(convert_to_heatmap(file_events));
+      } else {
+        events.extend(file_events);
+      }
     }
   }
 
-  if args.heatmap {
+  if args.files.is_empty() && args.heatmap {
     events = convert_to_heatmap(events);
   }
 
@@ -173,16 +213,16 @@ fn render_output(args: &Args) {
   );
 }
 
-fn readers(paths: &[std::path::PathBuf]) -> Vec<Box<dyn BufRead>> {
-  let mut res: Vec<Box<dyn BufRead>> = Vec::new();
-  if paths.is_empty() {
-    res.push(Box::new(std::io::stdin().lock()));
+fn readers(files: &[FileArg]) -> Vec<(Box<dyn BufRead>, bool)> {
+  let mut res: Vec<(Box<dyn BufRead>, bool)> = Vec::new();
+  if files.is_empty() {
+    res.push((Box::new(std::io::stdin().lock()), false));
   } else {
-    for f in paths {
-      match File::open(f) {
-        Ok(file) => res.push(Box::new(BufReader::new(file))),
+    for f in files {
+      match File::open(&f.path) {
+        Ok(file) => res.push((Box::new(BufReader::new(file)), f.heatmap)),
         Err(e) => {
-          eprintln!("Error: Failed to open file '{}': {}", f.display(), e);
+          eprintln!("Error: Failed to open file '{}': {}", f.path.display(), e);
           std::process::exit(1);
         }
       }
@@ -215,15 +255,8 @@ async fn main() {
   let (sender, _) = sender::MapSender::new().await;
 
   let send_events = |events: Box<dyn Iterator<Item = MapEvent>>| {
-    if args.heatmap {
-      let collected: Vec<MapEvent> = events.collect();
-      for event in convert_to_heatmap(collected) {
-        sender.send_event(event);
-      }
-    } else {
-      for event in events {
-        sender.send_event(event);
-      }
+    for event in events {
+      sender.send_event(event);
     }
   };
 
@@ -240,15 +273,24 @@ async fn main() {
       let content_parser = mapvas::parser::ContentAutoParser::new(content)
         .with_label_pattern(&args.label_pattern)
         .with_invert_coordinates(args.invert_coordinates);
-      send_events(Box::new(content_parser.parse().into_iter()));
+      let events: Vec<MapEvent> = content_parser.parse();
+      if args.heatmap {
+        send_events(Box::new(convert_to_heatmap(events).into_iter()));
+      } else {
+        send_events(Box::new(events.into_iter()));
+      }
     } else {
       // Use file-based auto-parser for each file
-      for file_path in &args.files {
-        let mut auto_parser = AutoFileParser::new(file_path)
+      for file_arg in &args.files {
+        let mut auto_parser = AutoFileParser::new(&file_arg.path)
           .with_label_pattern(&args.label_pattern)
           .with_invert_coordinates(args.invert_coordinates);
         let events: Vec<MapEvent> = auto_parser.parse().collect();
-        send_events(Box::new(events.into_iter()));
+        if args.heatmap || file_arg.heatmap {
+          send_events(Box::new(convert_to_heatmap(events).into_iter()));
+        } else {
+          send_events(Box::new(events.into_iter()));
+        }
       }
     }
   } else {
@@ -273,10 +315,14 @@ async fn main() {
     };
 
     let readers = readers(&args.files);
-    for reader in readers {
+    for (reader, file_heatmap) in readers {
       let mut parser = parser();
       let events: Vec<MapEvent> = parser.parse(reader).collect();
-      send_events(Box::new(events.into_iter()));
+      if args.heatmap || file_heatmap {
+        send_events(Box::new(convert_to_heatmap(events).into_iter()));
+      } else {
+        send_events(Box::new(events.into_iter()));
+      }
     }
   }
 

src/headless.rs

@@ -19,6 +19,8 @@ use crate::{
 pub struct HeadlessRenderer {
   config: Config,
   wait_for_tiles: bool,
+  no_map: bool,
+  background_color: Option<egui::Color32>,
 }
 
 impl HeadlessRenderer {
@@ -28,6 +30,8 @@ impl HeadlessRenderer {
     Self {
       config: Config::new(),
       wait_for_tiles: true,
+      no_map: false,
+      background_color: None,
     }
   }
 
@@ -37,6 +41,8 @@ impl HeadlessRenderer {
     Self {
       config,
       wait_for_tiles: true,
+      no_map: false,
+      background_color: None,
     }
   }
 
@@ -46,6 +52,19 @@ impl HeadlessRenderer {
     self
   }
 
+  #[must_use]
+  pub fn without_map(mut self) -> Self {
+    self.no_map = true;
+    self.wait_for_tiles = false;
+    self
+  }
+
+  #[must_use]
+  pub fn with_background_color(mut self, color: egui::Color32) -> Self {
+    self.background_color = Some(color);
+    self
+  }
+
   /// Render map with the given events to an image.
   ///
   /// Loads geometries from the provided `MapEvent`s, focuses the view,
@@ -61,7 +80,17 @@ impl HeadlessRenderer {
   #[must_use]
   pub fn render(&self, events: &[MapEvent], width: u32, height: u32) -> image::RgbaImage {
     let ctx = egui::Context::default();
-    let (mut map, remote, data_holder) = Map::new(ctx, self.config.clone());
+    if let Some(color) = self.background_color {
+      ctx.global_style_mut(|s| {
+        s.visuals.panel_fill = color;
+        s.visuals.window_fill = color;
+      });
+    }
+    let (mut map, remote, data_holder) = if self.no_map {
+      Map::new_without_tiles(ctx, self.config.clone())
+    } else {
+      Map::new(ctx, self.config.clone())
+    };
     map.set_headless();
 
     for event in events {

src/map/geometry_collection.rs

@@ -762,7 +762,10 @@ mod tests {
     );
     let cloned = geom.clone();
     if let (Geometry::Heatmap(a, _), Geometry::Heatmap(b, _)) = (&geom, &cloned) {
-      assert!(Arc::ptr_eq(a, b), "cloning Heatmap must share the Arc buffer");
+      assert!(
+        Arc::ptr_eq(a, b),
+        "cloning Heatmap must share the Arc buffer"
+      );
     } else {
       panic!("expected Heatmap variants");
     }

src/map/mapvas_egui.rs

@@ -60,7 +60,27 @@ impl Map {
     ctx: egui::Context,
     cfg: crate::config::Config,
   ) -> (Self, Remote, Rc<dyn MapLayerHolder>) {
-    let tile_layer = layer::TileLayer::from_config(ctx.clone(), &cfg);
+    Self::new_impl(ctx, cfg, false)
+  }
+
+  #[must_use]
+  pub fn new_without_tiles(
+    ctx: egui::Context,
+    cfg: crate::config::Config,
+  ) -> (Self, Remote, Rc<dyn MapLayerHolder>) {
+    Self::new_impl(ctx, cfg, true)
+  }
+
+  fn new_impl(
+    ctx: egui::Context,
+    cfg: crate::config::Config,
+    no_tile_layer: bool,
+  ) -> (Self, Remote, Rc<dyn MapLayerHolder>) {
+    let tile_layer = if no_tile_layer {
+      None
+    } else {
+      Some(layer::TileLayer::from_config(ctx.clone(), &cfg))
+    };
     let shape_info = std::sync::Arc::new(std::sync::RwLock::new(std::collections::HashMap::new()));
     let shape_layer = layer::ShapeLayer::new(cfg.clone(), ctx.clone(), shape_info.clone());
     let shape_layer_sender = shape_layer.get_sender();
@@ -84,12 +104,14 @@ impl Map {
       acc
     });
 
-    let layers: Rc<Mutex<Vec<Box<dyn Layer>>>> = Rc::new(Mutex::new(vec![
-      Box::new(tile_layer),
-      Box::new(shape_layer),
-      Box::new(command),
-      Box::new(screenshot_layer),
-    ]));
+    let mut layer_vec: Vec<Box<dyn Layer>> = Vec::new();
+    if let Some(tl) = tile_layer {
+      layer_vec.push(Box::new(tl));
+    }
+    layer_vec.push(Box::new(shape_layer));
+    layer_vec.push(Box::new(command));
+    layer_vec.push(Box::new(screenshot_layer));
+    let layers: Rc<Mutex<Vec<Box<dyn Layer>>>> = Rc::new(Mutex::new(layer_vec));
 
     let map_data_holder = Rc::new(MapLayerHolderImpl::new(layers.clone(), timeline.clone()));