More refactoring: using a decent, configurable datapipeline now

Logic/FeatureSource/FeatureSource.ts

@@ -0,0 +1,5 @@
+import {UIEventSource} from "../UIEventSource";
+
+export default interface FeatureSource {
+    features: UIEventSource<{feature: any, freshness: Date}[]>;
+}

Logic/FeatureSource/FeatureSourceMerger.ts

@@ -0,0 +1,40 @@
+import FeatureSource from "./FeatureSource";
+import {UIEventSource} from "../UIEventSource";
+
+export default class FeatureSourceMerger implements FeatureSource {
+
+    public features: UIEventSource<{ feature: any; freshness: Date }[]> = new UIEventSource<{feature: any; freshness: Date}[]>([]);
+    private readonly _sources: FeatureSource[];
+
+    constructor(sources: FeatureSource[]) {
+        this._sources = sources;
+        const self = this;
+        for (const source of sources) {
+            source.features.addCallback(() => self.Update());
+        }
+    }
+
+    private Update() {
+        let all = {}; // Mapping 'id' -> {feature, freshness}
+        for (const source of this._sources) {
+            for (const f of source.features.data) {
+                const id = f.feature.properties.id+f.feature.geometry.type;
+                const oldV = all[id];
+                if(oldV === undefined){
+                    all[id] = f;
+                }else{
+                    if(oldV.freshness < f.freshness){
+                        all[id]=f;
+                    }
+                }
+            }
+        }
+        const newList = [];
+        for (const id in all) {
+            newList.push(all[id]);
+        }
+        this.features.setData(newList);
+    }
+
+
+}

Logic/FeatureSource/FilteringFeatureSource.ts

@@ -0,0 +1,52 @@
+import FeatureSource from "./FeatureSource";
+import {UIEventSource} from "../UIEventSource";
+import LayerConfig from "../../Customizations/JSON/LayerConfig";
+import Loc from "../../Models/Loc";
+
+export default class FilteringFeatureSource implements FeatureSource {
+    public features: UIEventSource<{ feature: any; freshness: Date }[]> = new UIEventSource<{ feature: any; freshness: Date }[]>([]);
+
+    constructor(layers: {
+                    isDisplayed: UIEventSource<boolean>,
+                    layerDef: LayerConfig
+                }[],
+                location: UIEventSource<Loc>,
+                upstream: FeatureSource) {
+
+        const layerDict = {};
+       
+        const self = this;
+        
+        function update() {
+            console.log("UPdating...")
+            const features: { feature: any, freshness: Date }[] = upstream.features.data;
+            const newFeatures = features.filter(f => {
+                const layerId = f.feature.properties._matching_layer_id;
+                if (layerId === undefined) {
+                    console.error(f)
+                    throw "feature._matching_layer_id is undefined"
+                }
+                const layer: {
+                    isDisplayed: UIEventSource<boolean>,
+                    layerDef: LayerConfig
+                } = layerDict[layerId];
+                if (layer === undefined) {
+                    throw "No layer found with id " + layerId;
+                }
+                return layer.isDisplayed.data && (layer.layerDef.minzoom <= location.data.zoom);
+            });
+            self.features.setData(newFeatures);
+        }
+        for (const layer of layers) {
+            layerDict[layer.layerDef.id] = layer;
+            layer.isDisplayed.addCallback(update)
+        }
+        upstream.features.addCallback(update);
+        location.map(l => l.zoom).addCallback(update);
+
+
+    }
+
+
+
+}

Logic/FeatureSource/NoOverlapSource.ts

@@ -0,0 +1,86 @@
+import LayerConfig from "../../Customizations/JSON/LayerConfig";
+import FeatureSource from "./FeatureSource";
+import {UIEventSource} from "../UIEventSource";
+import {GeoOperations} from "../GeoOperations";
+
+/**
+ * The no overlap source takes a featureSource and applies a filter on it.
+ * First, it'll figure out for each feature to which layer it belongs
+ * Then, it'll check any feature of any 'lower' layer
+ */
+export default class NoOverlapSource {
+
+    features: UIEventSource<{ feature: any, freshness: Date }[]> = new UIEventSource<{ feature: any, freshness: Date }[]>([]);
+
+    constructor(layers: {
+                    layerDef: LayerConfig
+                }[],
+                upstream: FeatureSource) {
+        const layerDict = {};
+        let noOverlapRemoval = true;
+        const layerIds = []
+        for (const layer of layers) {
+            layerDict[layer.layerDef.id] = layer;
+            layerIds.push(layer.layerDef.id);
+            if ((layer.layerDef.hideUnderlayingFeaturesMinPercentage ?? 0) !== 0) {
+                noOverlapRemoval = false;
+            }
+        }
+        if (noOverlapRemoval) {
+            this.features = upstream.features;
+            return;
+        }
+
+
+        this.features = upstream.features.map(
+            features => {
+                if (features === undefined) {
+                    return;
+                }
+               
+                // There is overlap removal active
+                // We partition all the features with their respective layerIDs
+                const partitions = {};
+                for (const layerId of layerIds) {
+                    partitions[layerId] = []
+                }
+                for (const feature of features) {
+                    partitions[feature.feature.properties._matching_layer_id].push(feature);
+                }
+
+                // With this partitioning in hand, we run over every layer and remove every underlying feature if needed
+                for (let i = 0; i < layerIds.length; i++) {
+                    let layerId = layerIds[i];
+                    const percentage = layerDict[layerId].layerDef.hideUnderlayingFeaturesMinPercentage ?? 0;
+                    if (percentage === 0) {
+                        // We don't have to remove underlying features!
+                        continue;
+                    }
+                    const guardPartition = partitions[layerId];
+                    for (let j = i + 1; j < layerIds.length; j++) {
+                        let layerJd = layerIds[j];
+                        let partitionToShrink: { feature: any, freshness: Date }[] = partitions[layerJd];
+                        let newPartition = [];
+                        for (const mightBeDeleted of partitionToShrink) {
+                            const doesOverlap = GeoOperations.featureIsContainedInAny(
+                                mightBeDeleted.feature,
+                                guardPartition.map(f => f.feature),
+                                percentage
+                            );
+                            if(!doesOverlap){
+                                newPartition.push(mightBeDeleted);
+                            }
+                        }
+                        partitions[layerJd] = newPartition;
+                    }
+                }
+
+                // At last, we create the actual new features
+                let newFeatures: { feature: any, freshness: Date }[] = [];
+                for (const layerId of layerIds) {
+                    newFeatures = newFeatures.concat(partitions[layerId]);
+                }
+                return newFeatures;
+            });
+    }
+}

Logic/FeatureSource/RememberingSource.ts

@@ -0,0 +1,24 @@
+/**
+ * Every previously added point is remembered, but new points are added
+ */
+import FeatureSource from "./FeatureSource";
+import {UIEventSource} from "../UIEventSource";
+
+export default class RememberingSource implements FeatureSource{
+    features: UIEventSource<{feature: any, freshness: Date}[]> = new UIEventSource<{feature: any, freshness: Date}[]>([]);
+    
+    constructor(source: FeatureSource) {
+        const self = this;
+        source.features.addCallbackAndRun(features => {
+            if(features === undefined){
+                return;
+            }
+            const ids = new Set<string>( features.map(f => f.feature.properties.id+f.feature.geometry.type));
+            const newList = features.concat(
+                self.features.data.filter(old => !ids.has(old.feature.properties.id+old.feature.geometry.type))
+            )
+            self.features.setData(newList);
+        })
+    }
+    
+}

Logic/FeatureSource/WayHandlingApplyingFeatureSource.ts

@@ -0,0 +1,66 @@
+import FeatureSource from "./FeatureSource";
+import {UIEventSource} from "../UIEventSource";
+import LayerConfig from "../../Customizations/JSON/LayerConfig";
+import {GeoOperations} from "../GeoOperations";
+
+export default class WayHandlingApplyingFeatureSource implements FeatureSource {
+    features: UIEventSource<{ feature: any; freshness: Date }[]>;
+
+    constructor(layers: {
+                    layerDef: LayerConfig
+                }[],
+                upstream: FeatureSource) {
+        const layerDict = {};
+        let allDefaultWayHandling = true;
+        for (const layer of layers) {
+            layerDict[layer.layerDef.id] = layer;
+            if (layer.layerDef.wayHandling !== LayerConfig.WAYHANDLING_DEFAULT) {
+                allDefaultWayHandling = false;
+            }
+        }
+        if (allDefaultWayHandling) {
+            this.features = upstream.features;
+            return;
+        }
+
+
+        this.features = upstream.features.map(
+            features => {
+                if(features === undefined){
+                    return;
+                }
+                const newFeatures: { feature: any, freshness: Date }[] = [];
+                for (const f of features) {
+                    const feat = f.feature;
+                    const layerId = feat.properties._matching_layer_id;
+                    const layer: LayerConfig = layerDict[layerId].layerDef;
+                    if (layer === undefined) {
+                        throw "No layer found with id " + layerId;
+                    }
+                    
+                    if(layer.wayHandling === LayerConfig.WAYHANDLING_DEFAULT){
+                        newFeatures.push(f);
+                        continue;
+                    }
+
+                    if (feat.geometry.type === "Point") {
+                        newFeatures.push(f);
+                        // it is a point, nothing to do here
+                        continue;
+                    }
+
+                    const centerPoint = GeoOperations.centerpoint(feat);
+                    newFeatures.push({feature: centerPoint, freshness: f.freshness});
+                    
+                    if(layer.wayHandling === LayerConfig.WAYHANDLING_CENTER_AND_WAY){
+                        newFeatures.push(f);
+                    }
+                    
+                }
+                return newFeatures;
+            }
+        );
+
+    }
+
+}