Merge branch 'develop' into feature/maproulette

Logic/FeatureSource/FeaturePipeline.ts

@@ -23,8 +23,11 @@ import TileFreshnessCalculator from "./TileFreshnessCalculator";
 import FullNodeDatabaseSource from "./TiledFeatureSource/FullNodeDatabaseSource";
 import MapState from "../State/MapState";
 import {ElementStorage} from "../ElementStorage";
-import {Feature, Geometry} from "@turf/turf";
 import {OsmFeature} from "../../Models/OsmFeature";
+import LayerConfig from "../../Models/ThemeConfig/LayerConfig";
+import {FilterState} from "../../Models/FilteredLayer";
+import {GeoOperations} from "../GeoOperations";
+import {Utils} from "../../Utils";
 
 
 /**
@@ -514,6 +517,62 @@ export default class FeaturePipeline {
         return updater;
     }
 
+    /**
+     * Builds upon 'GetAllFeaturesAndMetaWithin', but does stricter BBOX-checking and applies the filters
+     */
+    public getAllVisibleElementsWithmeta(bbox: BBox): { center: [number, number], element: OsmFeature, layer: LayerConfig }[] {
+        if (bbox === undefined) {
+            console.warn("No bbox")
+            return []
+        }
+
+        const layers = Utils.toIdRecord(this.state.layoutToUse.layers)
+        const elementsWithMeta: { features: OsmFeature[], layer: string }[] = this.GetAllFeaturesAndMetaWithin(bbox)
+
+        let elements: {center: [number, number], element: OsmFeature, layer: LayerConfig }[] = []
+        let seenElements = new Set<string>()
+        for (const elementsWithMetaElement of elementsWithMeta) {
+            const layer = layers[elementsWithMetaElement.layer]
+            if(layer.title === undefined){
+                continue
+            }
+            const filtered = this.state.filteredLayers.data.find(fl => fl.layerDef == layer);
+            for (let i = 0; i < elementsWithMetaElement.features.length; i++) {
+                const element = elementsWithMetaElement.features[i];
+                if (!filtered.isDisplayed.data) {
+                    continue
+                }
+                if (seenElements.has(element.properties.id)) {
+                    continue
+                }
+                seenElements.add(element.properties.id)
+                if (!bbox.overlapsWith(BBox.get(element))) {
+                    continue
+                }
+                if (layer?.isShown !== undefined && !layer.isShown.matchesProperties(element)) {
+                    continue
+                }
+                const activeFilters: FilterState[] = Array.from(filtered.appliedFilters.data.values());
+                if (!activeFilters.every(filter => filter?.currentFilter === undefined || filter?.currentFilter?.matchesProperties(element.properties))) {
+                    continue
+                }
+                const center = GeoOperations.centerpointCoordinates(element);
+                elements.push({
+                    element,
+                    center,
+                    layer: layers[elementsWithMetaElement.layer],
+                })
+
+            }
+        }
+
+
+     
+
+        return elements;
+    }
+
+
     /**
     * Inject a new point
      */

Logic/FeatureSource/Sources/FilteringFeatureSource.ts

@@ -1,10 +1,9 @@
-import {UIEventSource} from "../../UIEventSource";
-import FilteredLayer from "../../../Models/FilteredLayer";
+import {Store, UIEventSource} from "../../UIEventSource";
+import FilteredLayer, {FilterState} from "../../../Models/FilteredLayer";
 import {FeatureSourceForLayer, Tiled} from "../FeatureSource";
 import {BBox} from "../../BBox";
 import {ElementStorage} from "../../ElementStorage";
 import {TagsFilter} from "../../Tags/TagsFilter";
-import {tag} from "@turf/turf";
 import {OsmFeature} from "../../../Models/OsmFeature";
 
 export default class FilteringFeatureSource implements FeatureSourceForLayer, Tiled {
@@ -16,7 +15,9 @@ export default class FilteringFeatureSource implements FeatureSourceForLayer, Ti
     public readonly bbox: BBox
     private readonly upstream: FeatureSourceForLayer;
     private readonly state: {
-        locationControl: UIEventSource<{ zoom: number }>; selectedElement: UIEventSource<any>,
+        locationControl: Store<{ zoom: number }>; 
+        selectedElement: Store<any>,
+        globalFilters: Store<{ filter: FilterState }[]>,
         allElements: ElementStorage
     };
     private readonly _alreadyRegistered = new Set<UIEventSource<any>>();
@@ -25,9 +26,10 @@ export default class FilteringFeatureSource implements FeatureSourceForLayer, Ti
 
     constructor(
         state: {
-            locationControl: UIEventSource<{ zoom: number }>,
-            selectedElement: UIEventSource<any>,
-            allElements: ElementStorage
+            locationControl: Store<{ zoom: number }>,
+            selectedElement: Store<any>,
+            allElements: ElementStorage,
+            globalFilters: Store<{ filter: FilterState }[]>
         },
         tileIndex,
         upstream: FeatureSourceForLayer,
@@ -60,6 +62,10 @@ export default class FilteringFeatureSource implements FeatureSourceForLayer, Ti
         metataggingUpdated?.addCallback(_ => {
             self._is_dirty.setData(true)
         })
+        
+        state.globalFilters.addCallback(_ => {
+            self.update()
+        })
 
         this.update();
     }
@@ -69,6 +75,7 @@ export default class FilteringFeatureSource implements FeatureSourceForLayer, Ti
         const layer = this.upstream.layer;
         const features: { feature: OsmFeature; freshness: Date }[] = (this.upstream.features.data ?? []);
         const includedFeatureIds = new Set<string>();
+        const globalFilters = self.state.globalFilters.data.map(f => f.filter);
         const newFeatures = (features ?? []).filter((f) => {
 
             self.registerCallback(f.feature)
@@ -88,6 +95,14 @@ export default class FilteringFeatureSource implements FeatureSourceForLayer, Ti
                 }
             }
 
+            for (const filter of globalFilters) {
+                const neededTags: TagsFilter = filter?.currentFilter
+                if (neededTags !== undefined && !neededTags.matchesProperties(f.feature.properties)) {
+                    // Hidden by the filter on the layer itself - we want to hide it no matter what
+                    return false;
+                }
+            }
+
             includedFeatureIds.add(f.feature.properties.id)
             return true;
         });