mapcomplete/Logic/Actors/UpdateFromOverpass.ts

211 lines
7.5 KiB
TypeScript
Raw Normal View History

import {UIEventSource} from "../UIEventSource";
import Loc from "../../Models/Loc";
import {Or} from "../Tags/Or";
import LayoutConfig from "../../Customizations/JSON/LayoutConfig";
import {Overpass} from "../Osm/Overpass";
import Bounds from "../../Models/Bounds";
import FeatureSource from "../FeatureSource/FeatureSource";
import {Utils} from "../../Utils";
import {TagsFilter} from "../Tags/TagsFilter";
2020-06-24 00:35:19 +02:00
export default class UpdateFromOverpass implements FeatureSource {
2021-01-03 00:19:42 +01:00
public readonly name = "UpdateFromOverpass"
2021-01-03 00:19:42 +01:00
/**
* The last loaded features of the geojson
*/
public readonly features: UIEventSource<{ feature: any, freshness: Date }[]> = new UIEventSource<any[]>(undefined);
2021-01-03 00:19:42 +01:00
2020-06-24 00:35:19 +02:00
public readonly sufficientlyZoomed: UIEventSource<boolean>;
2020-06-24 00:35:19 +02:00
public readonly runningQuery: UIEventSource<boolean> = new UIEventSource<boolean>(false);
public readonly timeout: UIEventSource<number> = new UIEventSource<number>(0);
private readonly retries: UIEventSource<number> = new UIEventSource<number>(0);
/**
* The previous bounds for which the query has been run at the given zoom level
*
* Note that some layers only activate on a certain zoom level.
* If the map location changes, we check for each layer if it is loaded:
* we start checking the bounds at the first zoom level the layer might operate. If in bounds - no reload needed, otherwise we continue walking down
2020-06-24 00:35:19 +02:00
*/
2021-01-03 00:19:42 +01:00
private readonly _previousBounds: Map<number, Bounds[]> = new Map<number, Bounds[]>();
private readonly _location: UIEventSource<Loc>;
private readonly _layoutToUse: UIEventSource<LayoutConfig>;
private readonly _leafletMap: UIEventSource<L.Map>;
2020-06-24 00:35:19 +02:00
/**
* The most important layer should go first, as that one gets first pick for the questions
*/
2021-01-03 00:19:42 +01:00
constructor(
location: UIEventSource<Loc>,
layoutToUse: UIEventSource<LayoutConfig>,
leafletMap: UIEventSource<L.Map>) {
this._location = location;
this._layoutToUse = layoutToUse;
this._leafletMap = leafletMap;
2020-06-24 00:35:19 +02:00
const self = this;
2021-01-03 00:19:42 +01:00
this.sufficientlyZoomed = location.map(location => {
if (location?.zoom === undefined) {
return false;
}
2021-01-03 00:19:42 +01:00
let minzoom = Math.min(...layoutToUse.data.layers.map(layer => layer.minzoom ?? 18));
return location.zoom >= minzoom;
2021-01-03 00:19:42 +01:00
}, [layoutToUse]
);
for (let i = 0; i < 25; i++) {
// This update removes all data on all layers -> erase the map on lower levels too
2021-01-03 00:19:42 +01:00
this._previousBounds.set(i, []);
}
2021-01-03 00:19:42 +01:00
layoutToUse.addCallback(() => {
self.update()
2020-06-24 00:35:19 +02:00
});
location.addCallback(() => {
2021-01-03 00:19:42 +01:00
self.update()
2020-07-31 16:17:16 +02:00
});
}
public ForceRefresh() {
for (let i = 0; i < 25; i++) {
2021-01-03 00:19:42 +01:00
this._previousBounds.set(i, []);
}
2021-01-03 00:19:42 +01:00
this.update();
}
2020-06-24 00:35:19 +02:00
private GetFilter(): Overpass {
let filters: TagsFilter[] = [];
let extraScripts: string[] = [];
2021-01-03 00:19:42 +01:00
for (const layer of this._layoutToUse.data.layers) {
if (typeof (layer) === "string") {
throw "A layer was not expanded!"
2020-09-02 11:37:34 +02:00
}
2021-01-03 00:19:42 +01:00
if (this._location.data.zoom < layer.minzoom) {
continue;
}
if (layer.doNotDownload) {
2020-11-17 02:22:48 +01:00
continue;
}
if (layer.source.geojsonSource !== undefined) {
// Not our responsibility to download this layer!
continue;
}
// Check if data for this layer has already been loaded
let previouslyLoaded = false;
for (let z = layer.minzoom; z < 25 && !previouslyLoaded; z++) {
2021-01-03 00:19:42 +01:00
const previousLoadedBounds = this._previousBounds.get(z);
if (previousLoadedBounds === undefined) {
continue;
}
for (const previousLoadedBound of previousLoadedBounds) {
2021-01-03 00:19:42 +01:00
previouslyLoaded = previouslyLoaded || this.IsInBounds(previousLoadedBound);
if (previouslyLoaded) {
break;
}
}
}
if (previouslyLoaded) {
continue;
2020-07-31 16:17:16 +02:00
}
if (layer.source.overpassScript !== undefined) {
extraScripts.push(layer.source.overpassScript)
} else {
filters.push(layer.source.osmTags);
}
2020-07-31 16:17:16 +02:00
}
filters = Utils.NoNull(filters)
extraScripts = Utils.NoNull(extraScripts)
if (filters.length + extraScripts.length === 0) {
2020-07-31 16:17:16 +02:00
return undefined;
}
return new Overpass(new Or(filters), extraScripts);
2020-06-24 00:35:19 +02:00
}
2021-01-03 00:19:42 +01:00
private update(): void {
2020-06-24 00:35:19 +02:00
if (this.runningQuery.data) {
console.log("Still running a query, not updating");
return;
}
if (this.timeout.data > 0) {
console.log("Still in timeout - not updating")
2020-07-31 16:17:16 +02:00
return;
2020-06-24 00:35:19 +02:00
}
2020-07-30 00:59:08 +02:00
2021-01-03 00:19:42 +01:00
const bounds = this._leafletMap.data.getBounds();
2020-07-31 16:17:16 +02:00
2021-01-03 00:19:42 +01:00
const diff = this._layoutToUse.data.widenFactor;
2020-07-30 00:59:08 +02:00
const n = Math.min(90, bounds.getNorth() + diff);
const e = Math.min(180, bounds.getEast() + diff);
const s = Math.max(-90, bounds.getSouth() - diff);
const w = Math.max(-180, bounds.getWest() - diff);
const queryBounds = {north: n, east: e, south: s, west: w};
2020-07-30 00:59:08 +02:00
const z = Math.floor(this._location.data.zoom ?? 0);
2020-07-31 16:17:16 +02:00
2020-06-24 00:35:19 +02:00
const self = this;
const overpass = this.GetFilter();
if (overpass === undefined) {
return;
}
this.runningQuery.setData(true);
overpass.queryGeoJson(queryBounds,
2021-01-03 00:19:42 +01:00
function (data, date) {
self._previousBounds.get(z).push(queryBounds);
self.retries.setData(0);
self.features.setData(data.features.map(f => ({feature: f, freshness: date})));
2021-01-03 00:19:42 +01:00
self.runningQuery.setData(false);
2020-06-24 00:35:19 +02:00
},
function (reason) {
2021-01-03 00:19:42 +01:00
self.retries.data++;
self.ForceRefresh();
self.timeout.setData(self.retries.data * 5);
console.log(`QUERY FAILED (retrying in ${5 * self.retries.data} sec)`);
2021-01-03 00:19:42 +01:00
self.retries.ping();
self.runningQuery.setData(false);
function countDown() {
window?.setTimeout(
function () {
console.log("Countdown: ", self.timeout.data)
if (self.timeout.data > 1) {
self.timeout.setData(self.timeout.data - 1);
window.setTimeout(
countDown,
1000
)
} else {
self.timeout.setData(0);
self.update()
}
}, 1000
)
}
countDown();
2020-06-24 00:35:19 +02:00
}
);
2020-06-24 00:35:19 +02:00
}
2021-01-03 00:19:42 +01:00
private IsInBounds(bounds: Bounds): boolean {
if (this._previousBounds === undefined) {
2020-06-24 00:35:19 +02:00
return false;
}
2021-01-03 00:19:42 +01:00
const b = this._leafletMap.data.getBounds();
return b.getSouth() >= bounds.south &&
b.getNorth() <= bounds.north &&
b.getEast() <= bounds.east &&
b.getWest() >= bounds.west;
2020-06-24 00:35:19 +02:00
}
2020-06-24 00:35:19 +02:00
}