"use strict"; import path from 'path'; import L from 'leaflet'; import chroma from 'chroma-js'; import WorkerWrapper from './WorkerWrapper.mjs'; import GetFromUrl from './Helpers/GetFromUrl.mjs'; import Config from './ClientConfig.mjs'; import promise_unwind from './Helpers/PromiseUnwind.mjs'; class LayerAI { /** * Computes a bounding box that exactly encompasses all the gateways in * the index. * @return {{north:number,south:number,east:number,west:number}} The computed bounding box */ get gateway_bounds() { let result = { east: Infinity, west: -Infinity, north: Infinity, south: -Infinity }; for(let gateway of this.index.index) { result.east = Math.min(gateway.longitude, result.east); result.west = Math.max(gateway.longitude, result.west); result.north = Math.min(gateway.latitude, result.north); result.south = Math.max(gateway.latitude, result.south); } return result; } /** * Initialises a new Leaflet AI layer instance. * @param {[type]} map [description] */ constructor(map) { // The Leaflet map instance to attach to this.map = map; // The array of web workers that do the computation this.workers = []; // The array the GeoJSON is stored in as it's generated this.geojson = []; this.stats = { rssi_min: Infinity, rssi_max: -Infinity }; // The bounding box of the map we're generating this.map_bounds = null; } /** * Sets up the Leaflet AI visualisation layer. * @return {Promise} A promise that resolves when setup is complete. */ async setup() { // Download the index file that tells us where the gateways and their // trained models are located this.index = JSON.parse( await GetFromUrl(Config.ai_index_file) ); console.log(this.index); for(let gateway of this.index.index) { gateway.frozen_net = JSON.parse(await GetFromUrl(`${window.location.href}/${path.dirname(Config.ai_index_file)}/${gateway.filename}`)) } // Figure out the bounds of the map we're going to generate this.map_bounds = this.gateway_bounds; this.map_bounds.north += Config.border.lat; this.map_bounds.south -= Config.border.lat; this.map_bounds.east += Config.border.lng; this.map_bounds.west -= Config.border.lng; // Setup the colour scale this.colour_scale = chroma.scale([ Config.colour_scale.min, Config.colour_scale.max ]).domain([ this.index.properties.rssi_min, this.index.properties.rssi_max ]); // Setup the web worker army for(let i = 0; i < (navigator.hardwareConcurrency || 4); i++) { console.info(`Starting worker ${i}`); let next_worker = new WorkerWrapper(); await next_worker.setup(this.map_bounds, this.index); this.workers.push(next_worker); } // Generate the Leaflet layer this.layer = await this.generate_layer(); this.layer.addTo(this.map); console.log("[Layer/AI] Complete"); } /** * Generates and returns the Leaflet layer containing the AI-predicted * values. * @return {Promise} A Promise that resolves to the generated Leaflet layer. */ async generate_layer() { console.log("[Layer/AI] Rendering map"); let map = await this.render_map(); console.log("[Layer/AI] Passing to Leaflet"); return L.geoJSON(map, { style: (feature) => { return { stroke: true, color: feature.properties.colour, weight: 1, fillColor: feature.properties.colour, fillOpacity: 0.4 } } }); } /** * Uses a Web Worker and pre-trained AIs to generate a GeoJSON map of * signal strength for a bounding box around the known gateways. * @return {Promise} A Promise that resolves to a GeoJSON array representing the map. */ async render_map() { let work_generator = (function*() { for(let lat = this.map_bounds.south; lat < this.map_bounds.north; lat += Config.step.lat) { yield lat; } }).bind(this)(); let unwinders = []; for(let i = 0; i < this.workers.length; i++) { let next_latitude = work_generator.next().value; let next_promise = this.workers[i].predict_row(next_latitude) .then(this.process_result_row.bind(this, next_latitude, i, work_generator)); unwinders.push(promise_unwind(next_promise)); } // Wait for all the workers to finish await Promise.all(unwinders); this.workers.length = 0; // Empty the array of workers console.log("Statistics:", this.stats); return this.geojson; } /** * Processes a single row of results from a web worker. * @param {number} lat The latitude value that was processed by the web worker. * @param {number} worker_index The index of the worker that returned the results. * @param {Generator} work_generator The work generator to use to queue the next work item. * @param {Object} next_result The result object returned by the web worker. * @return {Promise|null} Returns a Promise that resolves to the next work item that need processing, or null if allt he work hass been completed. */ process_result_row(lat, worker_index, work_generator, next_result) { let lng = this.map_bounds.west; // Keep up with the statistics if(next_result.stats.rssi_max > this.stats.rssi_max) this.stats.rssi_max = next_result.stats.rssi_max; if(next_result.stats.rssi_min < this.stats.rssi_min) this.stats.rssi_min = next_result.stats.rssi_min; for(let value of next_result.result) { // Generate the GeoJSON feature for this cell of the map this.geojson.push({ type: "Feature", geometry: { type: "Polygon", coordinates: [ [ // Outer shape [lng, lat], [lng, lat + Config.step.lat], [lng + Config.step.lng, lat + Config.step.lat], [lng + Config.step.lng, lat] ] // If there were any holes in the shape, we'd put them here ] }, properties: { colour: this.colour_scale(value).toString() } }); lng += Config.step.lng; } let next_work_item = work_generator.next(); if(!next_work_item.done) { return this.workers[worker_index].predict_row(next_work_item.value) .then(this.process_result_row.bind(this, next_work_item.value, worker_index, work_generator)); } else { console.log(`Ending worker ${worker_index}`); // Shut down the worker - we're done! this.workers[worker_index].end(); return null; } } } export default LayerAI;