Heatmap rendering

Author: UdHo

src/bin/mapcat/main.rs

@@ -1,9 +1,12 @@
+use std::collections::BTreeMap;
 use std::path::Path;
 use std::str::FromStr;
 
 use clap::Parser as CliParser;
 use log::error;
-use mapvas::map::map_event::{Color, MapEvent};
+use mapvas::map::coordinates::PixelCoordinate;
+use mapvas::map::geometry_collection::{Geometry, Metadata};
+use mapvas::map::map_event::{Color, Layer, MapEvent};
 use mapvas::parser::{
   AutoFileParser, FileParser, GeoJsonParser, GpxParser, GrepParser, JsonParser, KmlParser,
   TTJsonParser,
@@ -13,8 +16,59 @@ use std::io::{BufRead, BufReader, Read};
 
 mod sender;
 
+/// Walk a geometry tree and append every coordinate it contains to `out`.
+fn collect_coords(geometry: &Geometry<PixelCoordinate>, out: &mut Vec<PixelCoordinate>) {
+  match geometry {
+    Geometry::Point(c, _) => out.push(*c),
+    Geometry::LineString(coords, _) | Geometry::Polygon(coords, _) => {
+      out.extend(coords.iter().copied());
+    }
+    Geometry::Heatmap(coords, _) => out.extend(coords.iter().copied()),
+    Geometry::GeometryCollection(geometries, _) => {
+      for g in geometries {
+        collect_coords(g, out);
+      }
+    }
+  }
+}
+
+/// Replace every `MapEvent::Layer` in `events` with a single `Geometry::Heatmap`
+/// per layer id, accumulating all the coordinates from the original geometries.
+fn convert_to_heatmap(events: Vec<MapEvent>) -> Vec<MapEvent> {
+  let mut heatmap_coords: BTreeMap<String, Vec<PixelCoordinate>> = BTreeMap::new();
+  let mut other = Vec::new();
+
+  for event in events {
+    if let MapEvent::Layer(Layer { id, geometries }) = event {
+      let entry = heatmap_coords.entry(id).or_default();
+      for g in &geometries {
+        collect_coords(g, entry);
+      }
+    } else {
+      other.push(event);
+    }
+  }
+
+  let mut result = Vec::with_capacity(other.len() + heatmap_coords.len());
+  for (id, coords) in heatmap_coords {
+    if coords.is_empty() {
+      continue;
+    }
+    result.push(MapEvent::Layer(Layer {
+      id,
+      geometries: vec![Geometry::Heatmap(
+        std::sync::Arc::new(coords),
+        Metadata::default(),
+      )],
+    }));
+  }
+  result.extend(other);
+  result
+}
+
 #[derive(clap::Parser, Debug)]
 #[command(author, version, about, long_about = None)]
+#[allow(clippy::struct_excessive_bools)]
 struct Args {
   /// Which parser to use. Values: auto (file extension based with fallbacks), grep, ttjson, json, geojson, gpx, kml.
   #[arg(short, long, default_value = "auto")]
@@ -45,6 +99,10 @@ struct Args {
   #[arg(short, long, default_value = "")]
   screenshot: String,
 
+  /// Render all input coordinates as a heatmap instead of individual shapes.
+  #[arg(short = 'H', long)]
+  heatmap: bool,
+
   /// Render directly to an image file instead of sending to mapvas
   #[arg(short, long)]
   output: Option<std::path::PathBuf>,
@@ -93,6 +151,10 @@ fn render_output(args: &Args) {
     }
   }
 
+  if args.heatmap {
+    events = convert_to_heatmap(events);
+  }
+
   // Always focus on data in output mode
   events.push(MapEvent::Focus);
 
@@ -152,6 +214,19 @@ 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);
+      }
+    }
+  };
+
   if args.parser == "auto" {
     if args.files.is_empty() {
       // Use content-based auto-parser for stdin
@@ -165,16 +240,15 @@ async fn main() {
       let content_parser = mapvas::parser::ContentAutoParser::new(content)
         .with_label_pattern(&args.label_pattern)
         .with_invert_coordinates(args.invert_coordinates);
-      for event in content_parser.parse() {
-        sender.send_event(event);
-      }
+      send_events(Box::new(content_parser.parse().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)
           .with_label_pattern(&args.label_pattern)
           .with_invert_coordinates(args.invert_coordinates);
-        auto_parser.parse().for_each(|e| sender.send_event(e));
+        let events: Vec<MapEvent> = auto_parser.parse().collect();
+        send_events(Box::new(events.into_iter()));
       }
     }
   } else {
@@ -201,7 +275,8 @@ async fn main() {
     let readers = readers(&args.files);
     for reader in readers {
       let mut parser = parser();
-      parser.parse(reader).for_each(|e| sender.send_event(e));
+      let events: Vec<MapEvent> = parser.parse(reader).collect();
+      send_events(Box::new(events.into_iter()));
     }
   }
 

src/map/distance.rs

@@ -14,6 +14,9 @@ pub fn distance_to_geometry(
       .iter()
       .filter_map(|geom| distance_to_geometry(geom, click_coord))
       .min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)),
+    // Heatmaps are not individually hover-selectable — walking every point on
+    // every mouse move freezes the UI for large datasets.
+    Geometry::Heatmap(_, _) => None,
   }
 }
 

src/map/geometry_collection.rs

@@ -1,9 +1,10 @@
 use std::iter::once;
+use std::sync::Arc;
 
 use chrono::{DateTime, Utc};
 use egui::Color32;
 use itertools::Either;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use super::coordinates::{BoundingBox, Coordinate, PixelCoordinate, WGS84Coordinate};
 
@@ -285,6 +286,30 @@ pub enum Geometry<C: Coordinate> {
   Point(C, Metadata),
   LineString(Vec<C>, Metadata),
   Polygon(Vec<C>, Metadata),
+  /// Heatmap density layer. Wrapped in `Arc` so the (potentially huge)
+  /// coordinate buffer is shared across tile-render clones rather than copied.
+  Heatmap(
+    #[serde(serialize_with = "serialize_arc_vec")]
+    #[serde(deserialize_with = "deserialize_arc_vec")]
+    Arc<Vec<C>>,
+    Metadata,
+  ),
+}
+
+fn serialize_arc_vec<S, T>(arc: &Arc<Vec<T>>, ser: S) -> Result<S::Ok, S::Error>
+where
+  S: Serializer,
+  T: Serialize,
+{
+  arc.as_ref().serialize(ser)
+}
+
+fn deserialize_arc_vec<'de, D, T>(de: D) -> Result<Arc<Vec<T>>, D::Error>
+where
+  D: Deserializer<'de>,
+  T: Deserialize<'de>,
+{
+  Ok(Arc::new(Vec::<T>::deserialize(de)?))
 }
 
 impl From<Geometry<WGS84Coordinate>> for Geometry<PixelCoordinate> {
@@ -309,6 +334,15 @@ impl From<Geometry<WGS84Coordinate>> for Geometry<PixelCoordinate> {
           .collect(),
         metadata,
       ),
+      Geometry::Heatmap(coords, metadata) => Geometry::Heatmap(
+        Arc::new(
+          coords
+            .iter()
+            .map(super::coordinates::Coordinate::as_pixel_coordinate)
+            .collect::<Vec<_>>(),
+        ),
+        metadata,
+      ),
     }
   }
 }
@@ -338,6 +372,10 @@ impl<C: Coordinate> Geometry<C> {
         .iter()
         .map(|c| BoundingBox::from_iterator(once(*c)))
         .fold(BoundingBox::default(), |acc, b| acc.extend(&b)),
+      Geometry::Heatmap(coords, _) => coords
+        .iter()
+        .map(|c| BoundingBox::from_iterator(once(*c)))
+        .fold(BoundingBox::default(), |acc, b| acc.extend(&b)),
     }
   }
 
@@ -346,7 +384,8 @@ impl<C: Coordinate> Geometry<C> {
       Geometry::GeometryCollection(_, metadata)
       | Geometry::Point(_, metadata)
       | Geometry::Polygon(_, metadata)
-      | Geometry::LineString(_, metadata) => metadata.style.as_ref().is_none_or(|s| s.visible),
+      | Geometry::LineString(_, metadata)
+      | Geometry::Heatmap(_, metadata) => metadata.style.as_ref().is_none_or(|s| s.visible),
     }
   }
 
@@ -362,7 +401,8 @@ impl<C: Coordinate> Geometry<C> {
       }
       Geometry::Point(_, metadata)
       | Geometry::LineString(_, metadata)
-      | Geometry::Polygon(_, metadata) => {
+      | Geometry::Polygon(_, metadata)
+      | Geometry::Heatmap(_, metadata) => {
         self.is_visible() && metadata.is_visible_at_time(current_time)
       }
     }
@@ -392,7 +432,8 @@ impl<C: Coordinate> Geometry<C> {
       Geometry::GeometryCollection(_, metadata)
       | Geometry::Point(_, metadata)
       | Geometry::Polygon(_, metadata)
-      | Geometry::LineString(_, metadata) => {
+      | Geometry::LineString(_, metadata)
+      | Geometry::Heatmap(_, metadata) => {
         metadata.style = Some(style.clone());
       }
     }
@@ -405,7 +446,8 @@ impl<C: Coordinate> Geometry<C> {
       Geometry::GeometryCollection(_, metadata)
       | Geometry::Point(_, metadata)
       | Geometry::Polygon(_, metadata)
-      | Geometry::LineString(_, metadata) => &metadata.style,
+      | Geometry::LineString(_, metadata)
+      | Geometry::Heatmap(_, metadata) => &metadata.style,
     }
   }
 }
@@ -675,6 +717,57 @@ mod tests {
     assert!(geom.is_visible());
   }
 
+  #[test]
+  fn heatmap_bounding_box_unions_all_points() {
+    let geom = Geometry::Heatmap(
+      Arc::new(vec![
+        PixelCoordinate::new(1.0, 2.0),
+        PixelCoordinate::new(5.0, 8.0),
+        PixelCoordinate::new(-3.0, 4.0),
+      ]),
+      Metadata::default(),
+    );
+    let bbox = geom.bounding_box();
+    assert!(bbox.is_valid());
+    assert!((bbox.min_x() - -3.0).abs() < 1e-6);
+    assert!((bbox.max_x() - 5.0).abs() < 1e-6);
+    assert!((bbox.min_y() - 2.0).abs() < 1e-6);
+    assert!((bbox.max_y() - 8.0).abs() < 1e-6);
+  }
+
+  #[test]
+  fn heatmap_visibility_respects_style() {
+    let geom = Geometry::Heatmap(
+      Arc::new(vec![PixelCoordinate::new(0.0, 0.0)]),
+      Metadata::default().with_style(Style::default().with_visible(false)),
+    );
+    assert!(!geom.is_visible());
+  }
+
+  #[test]
+  fn heatmap_wgs84_to_pixel_conversion() {
+    let geom: Geometry<WGS84Coordinate> = Geometry::Heatmap(
+      Arc::new(vec![WGS84Coordinate { lat: 0.0, lon: 0.0 }]),
+      Metadata::default(),
+    );
+    let pixel: Geometry<PixelCoordinate> = geom.into();
+    assert!(matches!(pixel, Geometry::Heatmap(_, _)));
+  }
+
+  #[test]
+  fn heatmap_clone_shares_buffer() {
+    let geom = Geometry::Heatmap(
+      Arc::new(vec![PixelCoordinate::new(0.0, 0.0); 1024]),
+      Metadata::default(),
+    );
+    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");
+    } else {
+      panic!("expected Heatmap variants");
+    }
+  }
+
   #[test]
   fn geometry_is_visible_with_hidden_style() {
     let geom = Geometry::Point(

src/map/mapvas_egui/layer/commands/external_cmd.rs

@@ -599,6 +599,7 @@ impl ExternalCommand {
           lines += l;
           polygons += poly;
         }
+        Geometry::Heatmap(_, _) => {}
       }
     }
 
@@ -927,6 +928,18 @@ impl ExternalCommand {
           }
         }
       }
+      Geometry::Heatmap(coords, metadata) => {
+        let heatmap_text = format!("🔥 Heatmap ({} pts)", coords.len());
+        let available_width = (ui.available_width() - 80.0).max(30.0);
+        let (truncated, _) = super::truncate_label_by_width(ui, &heatmap_text, available_width);
+        ui.label(truncated);
+        if let Some(label) = &metadata.label {
+          let available_width = (ui.available_width() - 40.0).max(100.0);
+          let (truncated_label, _) =
+            super::truncate_label_by_width(ui, &label.short(), available_width);
+          ui.small(format!("  Label: {truncated_label}"));
+        }
+      }
       Geometry::GeometryCollection(geometries, metadata) => {
         let (points, lines, polygons) = Self::count_geometry_types(geometries);
         let collection_text = format!("📦 {points}p {lines}l {polygons}poly");
@@ -953,6 +966,9 @@ impl ExternalCommand {
               Geometry::GeometryCollection(nested, _) => {
                 format!("  {}: Collection ({} items)", i + 1, nested.len())
               }
+              Geometry::Heatmap(coords, _) => {
+                format!("  {}: Heatmap ({} points)", i + 1, coords.len())
+              }
             })
             .collect::<Vec<_>>()
             .join("\n");

src/map/mapvas_egui/layer/drawable.rs

@@ -138,6 +138,10 @@ impl<C: Coordinate + 'static> Drawable for Geometry<C> {
             stroke: PathStroke::new(DEFAULT_STROKE_WIDTH, style.color().gamma_multiply(0.7)), // More visible outline
           })
         }
+        Geometry::Heatmap(_, _) => {
+          // Heatmaps are rendered through the tile rasterizer only.
+          Shape::Noop
+        }
       };
       painter.add(shape);
     }
@@ -178,6 +182,15 @@ impl<C: Coordinate> Geometry<C> {
           .collect(),
         metadata.clone(),
       ),
+      Geometry::Heatmap(coords, metadata) => Geometry::Heatmap(
+        std::sync::Arc::new(
+          coords
+            .iter()
+            .map(Coordinate::as_pixel_coordinate)
+            .collect::<Vec<_>>(),
+        ),
+        metadata.clone(),
+      ),
     }
   }
 }

src/map/mapvas_egui/layer/geometry_highlighting.rs

@@ -127,6 +127,9 @@ pub fn draw_highlighted_geometry(
         draw_highlighted_geometry(nested_geometry, painter, transform, false);
       }
     }
+    Geometry::Heatmap(_, _) => {
+      // Heatmaps are not individually highlightable.
+    }
   }
 }