Add OSM cache and make smaller queries to OSM when possible

Author: CorruptComputer

Alidade.Osm/AlidadeOsmModule.cs

@@ -14,6 +14,7 @@ public class AlidadeOsmModule : Module
     protected override void Load(ContainerBuilder builder)
     {
         builder.RegisterType<EditBufferStateService>().AsSelf().SingleInstance();
+        builder.RegisterType<OsmCacheService>().As<IOsmCacheService>().SingleInstance();
 
         builder.RegisterType<PresetService>().AsSelf().InstancePerLifetimeScope();
         builder.RegisterType<NsiService>().AsSelf().InstancePerLifetimeScope();

Alidade.Osm/Models/CacheBounds.cs

@@ -0,0 +1,12 @@
+namespace Alidade.Osm.Models;
+
+/// <summary>
+///   An axis-aligned geographic bounding box used by <see cref="IOsmCacheService"/>.
+///   Equivalent to <c>Alidade.Map.Models.MapBounds</c> without the zoom level, since the
+///   cache layer operates purely on geographic extent.
+/// </summary>
+/// <param name="West">Western longitude bound in decimal degrees.</param>
+/// <param name="South">Southern latitude bound in decimal degrees.</param>
+/// <param name="East">Eastern longitude bound in decimal degrees.</param>
+/// <param name="North">Northern latitude bound in decimal degrees.</param>
+public record CacheBounds(double West, double South, double East, double North);

Alidade.Osm/Models/OsmCacheData.cs

@@ -0,0 +1,11 @@
+namespace Alidade.Osm.Models;
+
+/// <summary>
+///   The three typed OSM element collections stored in and returned by
+///   <see cref="IOsmCacheService"/>. Contains only data fetched
+///   from the OSM API this session — never locally-edited elements.
+/// </summary>
+/// <param name="Nodes">OSM nodes included in the cached area.</param>
+/// <param name="Ways">OSM ways included in the cached area.</param>
+/// <param name="Relations">OSM relations included in the cached area.</param>
+public record OsmCacheData(IReadOnlyList<OsmNode> Nodes, IReadOnlyList<OsmWay> Ways, IReadOnlyList<OsmRelation> Relations);

Alidade.Osm/Services/IOsmCacheService.cs

@@ -0,0 +1,48 @@
+namespace Alidade.Osm.Services;
+
+/// <summary>
+///   Session-scoped cache for OSM data fetched from the API.
+///
+///   Tracks the geographic area that has already been fetched so that
+///   viewport changes only trigger API calls for the uncached portions.
+/// </summary>
+public interface IOsmCacheService
+{
+    /// <summary>
+    ///   Returns the sub-bboxes of <paramref name="request"/> whose data is not yet in
+    ///   the cache, decomposed into axis-aligned rectangles. Returns an empty list when
+    ///   the entire requested area is already cached.
+    /// </summary>
+    /// <param name="request">The geographic bounding box to test against the cache.</param>
+    /// <returns>
+    ///   A list of bboxes whose union covers the uncached portion of <paramref name="request"/>,
+    ///   or an empty list if the full area is already cached.
+    /// </returns>
+    public List<CacheBounds> GetGeometryMissBboxes(CacheBounds request);
+
+    /// <summary>
+    ///   Unions <paramref name="bounds"/> into the cached area geometry and merges the
+    ///   supplied OSM elements into the cache store.
+    /// </summary>
+    /// <param name="bounds">The geographic bounding box that was just fetched.</param>
+    /// <param name="data">The OSM elements returned for that bbox.</param>
+    public void AddToCache(CacheBounds bounds, OsmCacheData data);
+
+    /// <summary>
+    ///   Returns all cached OSM elements that fall within <paramref name="bounds"/>.
+    ///   Ways whose nodes extend outside <paramref name="bounds"/> are included along
+    ///   with their out-of-bbox member nodes, matching the OSM API's full-way behaviour.
+    /// </summary>
+    /// <param name="bounds">The geographic bounding box to retrieve data for.</param>
+    /// <returns>The cached OSM elements within <paramref name="bounds"/>.</returns>
+    /// <exception cref="InvalidOperationException">
+    ///   Thrown when any part of <paramref name="bounds"/> lies outside the cached area.
+    ///   This is intentional during development to surface missing-cache bugs early.
+    /// </exception>
+    public OsmCacheData GetGeometryFromBbox(CacheBounds bounds);
+
+    /// <summary>
+    ///   Resets the cache to its initial empty state, discarding all cached geometry and elements.
+    /// </summary>
+    public void Clear();
+}

Alidade.Osm/Services/OsmCacheService.cs

@@ -0,0 +1,178 @@
+using NetTopologySuite.Geometries;
+
+namespace Alidade.Osm.Services;
+
+/// <inheritdoc />
+internal sealed class OsmCacheService : IOsmCacheService
+{
+    // TODO: Replace the O(n) linear scans in GetGeometryFromBbox with three
+    //       NTS Quadtree<long> spatial indexes (one per element type) if profiling
+    //       shows the scan becoming a bottleneck during long panning sessions.
+    //       Quadtree supports incremental inserts; STRtree is bulk-load only.
+    private Geometry? _cachedArea;
+    private readonly Dictionary<long, OsmNode> _nodes = [];
+    private readonly Dictionary<long, OsmWay> _ways = [];
+    private readonly Dictionary<long, OsmRelation> _relations = [];
+
+    private static readonly GeometryFactory _geomFactory = new(new PrecisionModel(), 4326);
+
+    /// <inheritdoc />
+    public List<CacheBounds> GetGeometryMissBboxes(CacheBounds request)
+    {
+        if (_cachedArea is null)
+        {
+            return [request];
+        }
+
+        Geometry requestGeom = BoundsToGeometry(request);
+        Geometry diff = requestGeom.Difference(_cachedArea);
+
+        if (diff.IsEmpty)
+        {
+            return [];
+        }
+
+        return DecomposeToBboxes(diff);
+    }
+
+    /// <inheritdoc />
+    public void AddToCache(CacheBounds bounds, OsmCacheData data)
+    {
+        Geometry newGeom = BoundsToGeometry(bounds);
+        _cachedArea = _cachedArea is null
+            ? newGeom
+            : _cachedArea.Union(newGeom);
+
+        foreach (OsmNode n in data.Nodes)
+        {
+            _nodes[n.Id] = n;
+        }
+
+        foreach (OsmWay w in data.Ways)
+        {
+            _ways[w.Id] = w;
+        }
+
+        foreach (OsmRelation r in data.Relations)
+        {
+            _relations[r.Id] = r;
+        }
+    }
+
+    /// <inheritdoc />
+    public OsmCacheData GetGeometryFromBbox(CacheBounds bounds)
+    {
+        Geometry requestGeom = BoundsToGeometry(bounds);
+
+        if (_cachedArea is null || !_cachedArea.Covers(requestGeom))
+        {
+            throw new InvalidOperationException(
+                $"Requested bbox ({bounds}) includes area outside the OSM cache.");
+        }
+
+        List<OsmNode> nodesInBbox = [.. _nodes.Values
+            .Where(n => n.Lat <= bounds.North
+                        && n.Lon <= bounds.East
+                        && n.Lat >= bounds.South
+                        && n.Lon >= bounds.West)];
+
+        HashSet<long> nodeIdsInBbox = nodesInBbox.Select(n => n.Id).ToHashSet();
+
+        List<OsmWay> ways = [.. _ways.Values.Where(w => w.NodeIds.Any(id => nodeIdsInBbox.Contains(id)))];
+
+        // Include out-of-bbox nodes referenced by included ways so that rendering
+        // doesn't break for ways that cross the viewport boundary — the OSM API
+        // always returns full way geometry including nodes outside the requested bbox.
+        HashSet<long> allNodeIds = [..nodeIdsInBbox];
+        List<OsmNode> allNodes = [..nodesInBbox];
+
+        foreach (OsmWay way in ways)
+        {
+            foreach (long nodeId in way.NodeIds)
+            {
+                if (allNodeIds.Add(nodeId) && _nodes.TryGetValue(nodeId, out OsmNode? extraNode))
+                {
+                    allNodes.Add(extraNode);
+                }
+            }
+        }
+
+        HashSet<long> wayIds = [.. ways.Select(w => w.Id)];
+
+        List<OsmRelation> relations = [.. _relations.Values
+            .Where(r => r.Members.Any(m =>
+                (m.Type == OsmElementTypes.Node && allNodeIds.Contains(m.Ref))
+                || (m.Type == OsmElementTypes.Way && wayIds.Contains(m.Ref)))
+            )];
+
+        return new OsmCacheData(allNodes, ways, relations);
+    }
+
+    /// <inheritdoc />
+    public void Clear()
+    {
+        _cachedArea = null;
+        _nodes.Clear();
+        _ways.Clear();
+        _relations.Clear();
+    }
+
+    private static Geometry BoundsToGeometry(CacheBounds b)
+        => _geomFactory.ToGeometry(new Envelope(b.West, b.East, b.South, b.North));
+
+    private static CacheBounds EnvelopeToCacheBounds(Envelope env)
+        => new(env.MinX, env.MinY, env.MaxX, env.MaxY);
+
+    /// <summary>
+    ///   Decomposes an orthogonal difference polygon (or multipolygon) into a minimal
+    ///   set of axis-aligned bboxes using horizontal strip decomposition. Each consecutive
+    ///   pair of unique latitude values in the geometry defines a horizontal band; the
+    ///   intersection of the diff with that band yields one or more bboxes for that strip.
+    ///   An L-shaped diff (typical single-pan case) produces exactly two bboxes.
+    /// </summary>
+    private static List<CacheBounds> DecomposeToBboxes(Geometry diff)
+    {
+        double[] ys = [.. diff.Coordinates
+            .Select(c => c.Y)
+            .Distinct()
+            .OrderBy(y => y)];
+
+        List<CacheBounds> result = [];
+        Envelope diffEnv = diff.EnvelopeInternal;
+
+        for (int i = 0; i < ys.Length - 1; i++)
+        {
+            double yLow  = ys[i];
+            double yHigh = ys[i + 1];
+
+            // Horizontal slab spanning the band, extended past diff's X extent so the
+            // intersection clips cleanly against the diff's actual X boundary.
+            Envelope slabEnv = new(diffEnv.MinX - 1.0, diffEnv.MaxX + 1.0, yLow, yHigh);
+            Geometry slab = _geomFactory.ToGeometry(slabEnv);
+            Geometry band = diff.Intersection(slab);
+
+            if (band.IsEmpty)
+            {
+                continue;
+            }
+
+            if (band is GeometryCollection gc)
+            {
+                for (int j = 0; j < gc.NumGeometries; j++)
+                {
+                    Geometry part = gc.GetGeometryN(j);
+                    if (!part.IsEmpty)
+                    {
+                        result.Add(EnvelopeToCacheBounds(part.EnvelopeInternal));
+                    }
+                }
+            }
+            else
+            {
+                result.Add(EnvelopeToCacheBounds(band.EnvelopeInternal));
+            }
+        }
+
+        return result;
+    }
+}

Alidade/Services/EditBufferService.cs

@@ -1,7 +1,5 @@
 using System.Text.Json;
-using Alidade.Handlers.EditBuffer;
 using Alidade.Map.Handlers;
-using Alidade.Osm.Handlers.Editing;
 using Alidade.Osm.Models.Editing;
 using NetTopologySuite.Features;
 
@@ -24,6 +22,7 @@ public class EditBufferService : IDisposable
     private readonly EditBufferStateService _editState;
     private readonly MapStateService _mapState;
     private readonly SelectionStateService _selectionState;
+    private readonly IOsmCacheService _osmCache;
     private readonly ValidationService? _validation;
     private readonly ILogger<EditBufferService> _log;
 
@@ -50,6 +49,7 @@ public EditBufferService(
         EditBufferStateService editState,
         MapStateService mapState,
         SelectionStateService selectionState,
+        IOsmCacheService osmCache,
         ILogger<EditBufferService> log,
         ValidationService? validation = null)
     {
@@ -60,6 +60,7 @@ public EditBufferService(
         _editState = editState;
         _mapState = mapState;
         _selectionState = selectionState;
+        _osmCache = osmCache;
         _validation = validation;
         _log = log;
 
@@ -201,6 +202,7 @@ public void Clear()
         _fetchCts.Cancel();
         _fetchCts.Dispose();
         _fetchCts = new CancellationTokenSource();
+        _osmCache.Clear();
         _editState.SetState(new EditBufferState());
 
         MapBounds? bounds = _mapState.State.CurrentBounds;
@@ -421,20 +423,40 @@ internal async Task RunFetchBboxAsync(MapBounds bounds, IMediator mediator, Canc
 
         try
         {
-            FetchBboxResult? fetched = await mediator.Send(
-                new FetchBbox.Query(bounds.West, bounds.South, bounds.East, bounds.North), ct);
+            CacheBounds cacheBounds = new(bounds.West, bounds.South, bounds.East, bounds.North);
+            List<CacheBounds> missBboxes = _osmCache.GetGeometryMissBboxes(cacheBounds);
+            bool allSucceeded = true;
 
-            if (fetched is not null)
+            foreach (CacheBounds miss in missBboxes)
             {
-                MergeFetchedData(
-                    (IReadOnlyList<OsmNode>)fetched.Nodes,
-                    (IReadOnlyList<OsmWay>)fetched.Ways,
-                    (IReadOnlyList<OsmRelation>)fetched.Relations);
+                FetchBboxResult? fetched = await mediator.Send(
+                    new FetchBbox.Query(miss.West, miss.South, miss.East, miss.North), ct);
+
+                if (fetched is not null)
+                {
+                    _osmCache.AddToCache(miss, new OsmCacheData(
+                        (IReadOnlyList<OsmNode>)fetched.Nodes,
+                        (IReadOnlyList<OsmWay>)fetched.Ways,
+                        (IReadOnlyList<OsmRelation>)fetched.Relations));
+                }
+                else
+                {
+                    allSucceeded = false;
+                }
+            }
+
+            // Merge from cache when the full viewport is available.
+            // allSucceeded remains true when missBboxes is empty (full cache hit),
+            // covering the case where the user navigates back to a previously visited area.
+            if (allSucceeded)
+            {
+                OsmCacheData viewportData = _osmCache.GetGeometryFromBbox(cacheBounds);
+                MergeFetchedData(viewportData.Nodes, viewportData.Ways, viewportData.Relations);
             }
         }
         catch (OperationCanceledException)
         {
-            // Fetch cancelled by Clear() during an endpoint switch
+            // Fetch cancelled by Clear() during an endpoint switch.
         }
     }