Fix spiky polygons

Author: UdHo

src/map/mapvas_egui/layer/geometry_highlighting.rs

@@ -3,10 +3,17 @@ use crate::map::{
   geometry_collection::{DEFAULT_STYLE, Geometry, Metadata},
 };
 use egui::{
-  Color32, Painter, Shape, Stroke,
+  Color32, ColorImage, Painter, Pos2, Rect, Shape, Stroke,
   epaint::{CircleShape, PathShape, PathStroke},
 };
 use std::collections::HashMap;
+use tiny_skia::{
+  FillRule, LineCap, LineJoin, Paint, PathBuilder, Pixmap, Stroke as SkiaStroke,
+  Transform as SkiaTransform,
+};
+
+/// Bold highlight stroke width, in screen pixels.
+const HIGHLIGHT_STROKE_WIDTH: f32 = 6.0;
 
 /// Manages geometry highlighting with unique IDs
 pub struct GeometryHighlighter {
@@ -118,18 +125,15 @@ pub fn draw_highlighted_geometry(
     Geometry::LineString(coords, metadata) => {
       draw_highlighted_linestring(coords, metadata, painter, transform);
     }
-    Geometry::Polygon(coords, metadata) => {
-      draw_highlighted_polygon(coords, metadata, painter, transform);
+    Geometry::Polygon(_, _) | Geometry::Heatmap(_, _) => {
+      // Polygons render via tiny-skia (`rasterize_highlighted_polygons`);
+      // heatmaps are not individually highlightable.
     }
     Geometry::GeometryCollection(geometries, _) => {
-      // Draw all geometries in the collection as highlighted
       for nested_geometry in geometries {
         draw_highlighted_geometry(nested_geometry, painter, transform, false);
       }
     }
-    Geometry::Heatmap(_, _) => {
-      // Heatmaps are not individually highlightable.
-    }
   }
 }
 
@@ -175,25 +179,132 @@ fn draw_highlighted_linestring(
   painter.add(shape);
 }
 
-/// Draw a highlighted polygon
-fn draw_highlighted_polygon(
-  coords: &[PixelCoordinate],
-  metadata: &Metadata,
-  painter: &Painter,
+/// Rasterize all polygons inside `geometry` (recursively) into a pixmap
+/// clipped to `viewport`, drawing each polygon's fill and bold solid stroke
+/// via tiny-skia. egui can't draw these correctly: its fan-triangulator
+/// produces fold-overs on concave/bridged polygons, and its `PathStroke` has
+/// no `LineJoin` control so sharp angles produce miter spikes. tiny-skia
+/// uses winding-rule fill and `LineJoin::Round`, so neither happens.
+pub fn rasterize_highlighted_polygons(
+  geometry: &Geometry<PixelCoordinate>,
   transform: &Transform,
-) {
-  let style = metadata.style.as_ref().unwrap_or(&DEFAULT_STYLE);
-  let base_color = style.color();
+  viewport: Rect,
+) -> Option<(ColorImage, Rect)> {
+  let mut bbox: Option<Rect> = None;
+  collect_polygon_bbox(geometry, transform, &mut bbox);
+  // Pad for the stroke half-width plus a feathering margin.
+  let pad = HIGHLIGHT_STROKE_WIDTH * 0.5 + 1.0;
+  let bbox = bbox?.expand(pad);
+  let clipped = bbox.intersect(viewport);
+  if clipped.width() <= 0.0 || clipped.height() <= 0.0 {
+    return None;
+  }
+  #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+  let w = clipped.width().ceil() as u32;
+  #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+  let h = clipped.height().ceil() as u32;
+  if w == 0 || h == 0 {
+    return None;
+  }
+  let mut pixmap = Pixmap::new(w, h)?;
+  fill_polygons_into_pixmap(geometry, transform, &mut pixmap, clipped.min);
 
-  // Draw highlighted polygon with solid colors - fill matches stroke color
-  let highlight_stroke = base_color; // Solid stroke in original color
-  let highlight_fill = base_color; // Fill always matches stroke color
+  // tiny-skia stores premultiplied RGBA; un-premultiply for ColorImage.
+  let mut straight = Vec::with_capacity(pixmap.data().len());
+  for p in pixmap.data().chunks_exact(4) {
+    let a = p[3];
+    if a == 0 {
+      straight.extend_from_slice(&[0, 0, 0, 0]);
+    } else {
+      let inv = 255.0_f32 / f32::from(a);
+      #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+      {
+        straight.push((f32::from(p[0]) * inv).min(255.0) as u8);
+        straight.push((f32::from(p[1]) * inv).min(255.0) as u8);
+        straight.push((f32::from(p[2]) * inv).min(255.0) as u8);
+      }
+      straight.push(a);
+    }
+  }
+  Some((
+    ColorImage::from_rgba_unmultiplied([w as usize, h as usize], &straight),
+    clipped,
+  ))
+}
 
-  let shape = Shape::Path(PathShape {
-    points: coords.iter().map(|c| transform.apply(*c).into()).collect(),
-    closed: true,
-    fill: highlight_fill,
-    stroke: PathStroke::new(6.0, highlight_stroke),
-  });
-  painter.add(shape);
+fn collect_polygon_bbox(
+  geometry: &Geometry<PixelCoordinate>,
+  transform: &Transform,
+  acc: &mut Option<Rect>,
+) {
+  match geometry {
+    Geometry::Polygon(coords, _) => {
+      for c in coords {
+        let p: Pos2 = transform.apply(*c).into();
+        let r = Rect::from_min_max(p, p);
+        *acc = Some(acc.map_or(r, |a| a.union(r)));
+      }
+    }
+    Geometry::GeometryCollection(geoms, _) => {
+      for g in geoms {
+        collect_polygon_bbox(g, transform, acc);
+      }
+    }
+    _ => {}
+  }
+}
+
+fn fill_polygons_into_pixmap(
+  geometry: &Geometry<PixelCoordinate>,
+  transform: &Transform,
+  pixmap: &mut Pixmap,
+  origin: Pos2,
+) {
+  match geometry {
+    Geometry::Polygon(coords, metadata) => {
+      let style = metadata.style.as_ref().unwrap_or(&DEFAULT_STYLE);
+      let color = style.color();
+      let mut iter = coords.iter();
+      let Some(first) = iter.next() else { return };
+      let mut pb = PathBuilder::new();
+      let p: Pos2 = transform.apply(*first).into();
+      pb.move_to(p.x - origin.x, p.y - origin.y);
+      for c in iter {
+        let p: Pos2 = transform.apply(*c).into();
+        pb.line_to(p.x - origin.x, p.y - origin.y);
+      }
+      pb.close();
+      let Some(path) = pb.finish() else { return };
+      let mut paint = Paint::default();
+      paint.set_color(tiny_skia::Color::from_rgba8(
+        color.r(),
+        color.g(),
+        color.b(),
+        color.a(),
+      ));
+      paint.anti_alias = true;
+      pixmap.fill_path(
+        &path,
+        &paint,
+        FillRule::Winding,
+        SkiaTransform::identity(),
+        None,
+      );
+      // Bold solid stroke with round joins to suppress miter spikes on
+      // bridged-multipolygon path reversals.
+      let stroke = SkiaStroke {
+        width: HIGHLIGHT_STROKE_WIDTH,
+        line_cap: LineCap::Round,
+        line_join: LineJoin::Round,
+        ..SkiaStroke::default()
+      };
+      pixmap.stroke_path(&path, &paint, &stroke, SkiaTransform::identity(), None);
+    }
+    Geometry::GeometryCollection(geoms, _) => {
+      for g in geoms {
+        fill_polygons_into_pixmap(g, transform, pixmap, origin);
+      }
+    }
+    _ => {}
+  }
 }

src/map/mapvas_egui/layer/shape_layer.rs

@@ -106,6 +106,23 @@ pub struct ShapeLayer {
   /// Shared shape info cache that the HTTP endpoint reads directly.
   shape_info:
     Arc<std::sync::RwLock<std::collections::HashMap<String, Vec<crate::remote::ShapeInfo>>>>,
+  /// Cached pixmap+texture for the polygon fills of the currently highlighted
+  /// geometry. Avoids re-rasterizing every frame on a static hover.
+  highlight_texture: Option<HighlightTextureCache>,
+}
+
+#[derive(PartialEq, Eq)]
+struct HighlightCacheKey {
+  geometry_path: (String, usize, Vec<usize>),
+  viewport: [u32; 4],
+  transform: [u32; 3],
+  version: u64,
+}
+
+struct HighlightTextureCache {
+  key: HighlightCacheKey,
+  texture: egui::TextureHandle,
+  screen_rect: egui::Rect,
 }
 
 fn truncate_label_by_width(ui: &egui::Ui, label: &str, available_width: f32) -> (String, bool) {
@@ -303,6 +320,7 @@ impl ShapeLayer {
       shape_vis_receiver,
       shape_vis_sender,
       shape_info,
+      highlight_texture: None,
     }
   }
 
@@ -1771,6 +1789,88 @@ impl ShapeLayer {
     draw_highlighted_geometry(geometry, painter, transform, false);
   }
 
+  /// Render the hover-highlight for the currently selected geometry.
+  /// Polygon fills are rasterized via tiny-skia and cached as a texture;
+  /// strokes/points/lines are added as egui shapes.
+  fn draw_highlight_overlay(&mut self, ui: &mut egui::Ui, transform: &Transform, rect: Rect) {
+    let Some((layer_id, shape_idx, nested_path)) =
+      self.geometry_highlighter.get_highlighted_geometry()
+    else {
+      self.highlight_texture = None;
+      return;
+    };
+    if !nested_path.is_empty() {
+      // The render loop only handles top-level highlights; preserve that.
+      self.highlight_texture = None;
+      return;
+    }
+    if !*self.layer_visibility.get(&layer_id).unwrap_or(&true) {
+      self.highlight_texture = None;
+      return;
+    }
+    if !*self
+      .geometry_visibility
+      .get(&(layer_id.clone(), shape_idx))
+      .unwrap_or(&true)
+    {
+      self.highlight_texture = None;
+      return;
+    }
+    let Some(shape) = self
+      .shape_map
+      .get(&layer_id)
+      .and_then(|s| s.get(shape_idx))
+      .cloned()
+    else {
+      self.highlight_texture = None;
+      return;
+    };
+
+    let key = HighlightCacheKey {
+      geometry_path: (layer_id, shape_idx, nested_path),
+      viewport: [
+        rect.min.x.to_bits(),
+        rect.min.y.to_bits(),
+        rect.max.x.to_bits(),
+        rect.max.y.to_bits(),
+      ],
+      transform: [
+        transform.zoom.to_bits(),
+        transform.trans.x.to_bits(),
+        transform.trans.y.to_bits(),
+      ],
+      version: self.version,
+    };
+
+    let needs_rebuild = self.highlight_texture.as_ref().is_none_or(|c| c.key != key);
+    if needs_rebuild {
+      use super::geometry_highlighting::rasterize_highlighted_polygons;
+      if let Some((image, screen_rect)) = rasterize_highlighted_polygons(&shape, transform, rect) {
+        let handle =
+          ui.ctx()
+            .load_texture("highlight_polygon", image, egui::TextureOptions::LINEAR);
+        self.highlight_texture = Some(HighlightTextureCache {
+          key,
+          texture: handle,
+          screen_rect,
+        });
+      } else {
+        self.highlight_texture = None;
+      }
+    }
+
+    let painter = ui.painter_at(rect);
+    if let Some(cache) = &self.highlight_texture {
+      painter.image(
+        cache.texture.id(),
+        cache.screen_rect,
+        Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)),
+        Color32::WHITE,
+      );
+    }
+    Self::draw_highlighted_geometry(&shape, &painter, transform, false);
+  }
+
   fn show_delete_collection_button(
     &mut self,
     ui: &mut egui::Ui,
@@ -2322,26 +2422,10 @@ impl Layer for ShapeLayer {
       }
     }
 
-    // Draw highlighted geometries on top using egui shapes (per-frame, follows mouse).
-    for (layer_id, shapes) in &self.shape_map {
-      if !*self.layer_visibility.get(layer_id).unwrap_or(&true) {
-        continue;
-      }
-      for (shape_idx, shape) in shapes.iter().enumerate() {
-        let geometry_key = (layer_id.clone(), shape_idx);
-        if !*self.geometry_visibility.get(&geometry_key).unwrap_or(&true) {
-          continue;
-        }
-        let highlight_key = (layer_id.clone(), shape_idx, Vec::new());
-        if self.geometry_highlighter.is_highlighted(
-          &highlight_key.0,
-          highlight_key.1,
-          &highlight_key.2,
-        ) {
-          Self::draw_highlighted_geometry(shape, ui.painter(), transform, false);
-        }
-      }
-    }
+    // Draw highlight overlay for the currently-hovered geometry.
+    // Polygon fills go through tiny-skia (cached as a texture) to avoid egui's
+    // fan-triangulation; points, lines, and polygon strokes go through egui.
+    self.draw_highlight_overlay(ui, transform, rect);
 
     // Handle pending detail popup from double-click as lightweight positioned window
     // This needs to be in draw() so it shows regardless of sidebar state
@@ -3238,6 +3322,7 @@ mod tests {
           s
         },
         shape_info: Arc::new(std::sync::RwLock::new(std::collections::HashMap::new())),
+        highlight_texture: None,
       }
     }
   }