imerss-bioinfo 1.0.0

package/src/client/js/leafletMap.js

@@ -0,0 +1,357 @@
+/* global L */
+
+"use strict";
+
+// noinspection ES6ConvertVarToLetConst // otherwise this is a duplicate on minifying
+var hortis = fluid.registerNamespace("hortis");
+
+// Workaround taken from https://github.com/Leaflet/Leaflet/issues/4745 to prevent coordinates being rounded to
+// integers during rendering
+L.Map.include({
+    latLngToLayerPoint: function (latlng) {
+        const projectedPoint = this.project(L.latLng(latlng));
+        const togo = projectedPoint._subtract(this.getPixelOrigin());
+        togo.x = fluid.roundToDecimal(togo.x, 3);
+        togo.y = fluid.roundToDecimal(togo.y, 3);
+        return togo;
+    }
+});
+
+fluid.defaults("hortis.leafletMap", {
+    gradeNames: ["fluid.viewComponent", "{sunburstLoader}.options.mapFlavourGrade"], // Not a distribution because of FLUID-5836
+    selectors: {
+        map: ".fld-imerss-map",
+        tooltip: ".fld-imerss-map-tooltip"
+    },
+    members: {
+        toPlot: {}, // General contract from grid map - indexed by "mapBlockId" to "bucket" - contains byTaxonId, count, Lpolygon (colours only used in drawGrid)
+        // byTaxonId is hash of rowId to array of obsId as built in hortis.quantiser.indexObs - so count is equal to # of keys
+        map: "@expand:L.map({that}.dom.map.0, {that}.options.mapOptions)"
+    },
+    datasets: {},
+    // Needs to be parameterised since leafletMapWithRegions and leafletMapWithGrid have different update semantics -
+    // regions is prone to an update cycle when clearing the selection and grid is not. Need to review this semantic
+    // carefully between the two variants
+    selectionTransactionSource: null,
+    model: {
+        mapInitialised: "@expand:{that}.events.buildMap.fire()",
+        // zoom: Number (0 - whole world -> 18 - maximal zoom)
+        datasetEnabled: "@expand:hortis.datasetEnabledModel({that}.options.datasets)",
+        // Terrible name which needs to be reviewed - common between map variants indicating "selected region"
+        mapBlockTooltipId: null
+    },
+    events: {
+        buildMap: null,
+        clearMapSelection: null
+    },
+    markup: {
+        tooltip: "<div class=\"fld-imerss-map-tooltip\"></div>",
+        grid: "<div class=\"fld-imerss-map-grid\"></div>",
+        tooltipHeader: "<table>",
+        tooltipRow: "<tr><td class=\"fl-taxonDisplay-key\">%key: </td><td class=\"fl-taxonDisplay-value\">%value</td>",
+        tooltipFooter: "</table>"
+    },
+    // fitBounds: [[48.855,-123.65],[49.005,-123.25]],
+    listeners: {
+        "buildMap.bindZoom": "hortis.leafletMap.bindZoom({that})",
+        "buildMap.fitBounds": "hortis.leafletMap.fitBounds({that}, {that}.options.fitBounds)",
+        "buildMap.createTooltip": "hortis.leafletMap.createTooltip({that}, {that}.options.markup)",
+        "buildMap.addTiles": "hortis.leafletMap.addTileLayer({that}.map, {that}.options.tileOptions)",
+        "clearMapSelection.mapBlock": {
+            changePath: "mapBlockTooltipId",
+            value: null
+        }
+    },
+    invokers: {
+        // Perhaps this will one day be a "materialiser registration" and we will instead call applier.pullModel("zoom")
+        acquireZoom: "hortis.leafletMap.acquireZoom({that})",
+        fitBounds: "hortis.leafletMap.fitBounds({that}, {arguments}.0, {arguments}.1)"
+    },
+    dynamicComponents: {
+        geoJSONLayers: { // Dumb, "global" geoJSON layers that are not interactive. Only historical example is json_Galiano_map_0, as per qgis2web exports
+            sources: "{that}.options.geoJSONMapLayers",
+            type: "hortis.geoJSONMapLayer",
+            options: {
+                layer: "{source}"
+            }
+        }
+    },
+    mapOptions: {
+        zoomSnap: 0.1
+    },
+    heatLow: "#ffffff"
+    // heatHigh: "#ff0000",
+});
+
+fluid.defaults("hortis.leafletMapWithWE", {
+    selectors: {
+        WEOverlay: ".fld-imerss-we-overlay"
+    },
+    listeners: {
+        "buildMap.bindWEClick": "hortis.leafletMap.bindWEClick({that})"
+    }
+});
+
+hortis.leafletMap.bindWEClick = function (map) {
+    const overlay = map.locate("WEOverlay");
+    overlay.click(function () {
+        map.map.flyToBounds(hortis.projectBounds.Pepiowelh, {duration: 2});
+        overlay.css("opacity", 0);
+        overlay.css("pointer-events", "none");
+    });
+};
+
+hortis.leafletMap.acquireZoom = function (map) {
+    map.applier.change("zoom", map.map.getZoom());
+};
+
+hortis.leafletMap.bindZoom = function (map) {
+    const leafletMap = map.map;
+    // Note that we can't apply the change at startup because of FLUID-5498
+    leafletMap.on("zoomend", function () {
+        map.acquireZoom();
+    });
+    leafletMap.on("moveend", function () {
+        console.log("Bounds now ", leafletMap.getBounds());
+    });
+};
+
+// Mixin grades for leafletMap selecting different tile layers
+fluid.defaults("hortis.streetmapTiles", {
+    tileOptions: {
+        tileUrl: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+        tileAttribution: "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors"
+    }
+});
+
+fluid.defaults("hortis.GBIFTiles", {
+    tileOptions: {
+        tileUrl: "https://tile.gbif.org/3857/omt/{z}/{x}/{y}@1x.png?style=gbif-classic",
+        tileAttribution: "&copy <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors, © <a href=\"https://openmaptiles.org/\">OpenMapTiles</a>, <a href=\"/citation-guidelines\">GBIF</a>"
+    }
+});
+
+fluid.defaults("hortis.MtbTiles", {
+    tileOptions: {
+        tileUrl: "http://tile.mtbmap.cz/mtbmap_tiles/{z}/{x}/{y}.png",
+        tileAttribution: "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors &amp; USGS"
+    }
+});
+
+hortis.leafletMap.addTileLayer = function (map, tileOptions) {
+    if (tileOptions && tileOptions.tileUrl) {
+        L.tileLayer(tileOptions.tileUrl, {
+            attribution: tileOptions.tileAttribution
+        }).addTo(map);
+    }
+};
+
+hortis.datasetEnabledModel = function (datasets) {
+    return fluid.transform(datasets, function () {
+        return true;
+    });
+};
+
+fluid.defaults("hortis.geoJSONMapLayer", {
+    gradeNames: "fluid.component",
+    style: {
+        color: "black",
+        weight: 1.0
+    },
+    listeners: {
+        "onCreate.applyLayer": "hortis.applyGeoJSONMapLayer({that}, {hortis.leafletMap})"
+    }
+});
+
+hortis.applyGeoJSONMapLayer = function (mapLayer, map) {
+    L.geoJSON(mapLayer.options.layer, {
+        style: mapLayer.options.style
+    }).addTo(map.map);
+};
+
+hortis.leafletMap.fitBounds = function (map, fitBounds) {
+    if (fitBounds) {
+        map.map.fitBounds(fitBounds);
+        map.acquireZoom();
+    }
+};
+
+hortis.leafletMap.createTooltip = function (that, markup) {
+    const tooltip = $(markup.tooltip).appendTo(that.locate("map"));
+    tooltip.hide();
+    that.map.createPane("hortis-tooltip", tooltip[0]);
+    const container = that.map.getContainer();
+    $(container).on("click", function (event) {
+        if (event.target === container) {
+            that.events.clearMapSelection.fire();
+        }
+    });
+    $(document).on("click", function (event) {
+        const closest = event.target.closest(".fld-imerss-nodismiss-map");
+        // Mysteriously SVG paths are not in the document
+        if (!closest && event.target.closest("body")) {
+            that.events.clearMapSelection.fire();
+        }
+    });
+};
+
+
+hortis.projectBounds = {
+    Galiano: [[48.855, -123.65], [49.005, -123.25]],
+    Valdes: [[49.000, -123.798], [49.144, -123.504]],
+    Xetthecum: [[48.93713, -123.5110], [48.9511, -123.4980]],
+    Pepiowelh: [[48.5650, -123.1575], [48.5980, -123.1266]],
+    HoweSound: [[49.160, -124.281], [50.170, -122.050]],
+    SalishSea: [[47.568, -124.200], [49.134, -122.059]]
+};
+
+fluid.defaults("hortis.sunburstLoaderWithMap", {
+    gradeNames: "hortis.sunburstLoader",
+    selectors: {
+        mapHolder: ".fld-imerss-map-holder"
+    },
+    events: {
+        sunburstLoaded: null
+    },
+    mapBounds: hortis.projectBounds.Galiano,
+    mapGrades: [],
+    mapFlavourGrade: "hortis.leafletMap.withGrid", // swap out for "withRegions" for Xetthecum style map
+    markupTemplate: "%resourceBase/html/imerss-viz-map.html",
+    distributeOptions: {
+        sunburstLoaded: {
+            target: "{that sunburst}.options.listeners.onCreate",
+            record: "{hortis.sunburstLoaderWithMap}.events.sunburstLoaded.fire"
+        },
+        flatTree: {
+            target: "{that quantiser}.options.members.flatTree",
+            record: "@expand:fluid.identity({sunburst}.flatTree)"
+        },
+        mapGrades: {
+            target: "{that map}.options.gradeNames",
+            source: "{that}.options.mapGrades"
+        }
+    },
+    components: {
+        map: {
+            type: "hortis.leafletMap",
+            container: "{sunburstLoaderWithMap}.dom.mapHolder",
+            createOnEvent: "sunburstLoaded",
+            options: {
+                gradeNames: "hortis.mapWithSunburst",
+                fitBounds: "{hortis.configHolder}.options.mapBounds",
+                showObsListInTooltip: "{hortis.configHolder}.options.showObsListInTooltip"
+            }
+        }
+    }
+});
+
+// Mixin grade for sunburstLoader, currently used in Xetthecum driver
+fluid.defaults("hortis.svgPatternLoader", {
+    svgPatterns: "%resourceBase/html/xetthecum-patterns.html",
+    resources: {
+        svgPatterns: {
+            url: "{that}.options.svgPatterns",
+            dataType: "text"
+        }
+    },
+    listeners: {
+        "onResourcesLoaded.injectPatterns": {
+            funcName: "hortis.injectSvgPatterns",
+            args: ["{svgPatternLoader}.resources.svgPatterns.resourceText", "{that}.options.resourceBase", "{that}.container"]
+        }
+    }
+});
+
+hortis.injectSvgPatterns = function (patternText, resourceBase, container) {
+    const expanded = patternText.replace(/%resourceBase/g, resourceBase);
+    const patterns = $(expanded);
+    container.append(patterns);
+};
+
+fluid.defaults("hortis.mapLoaderWithoutSunburst", {
+    // TODO: Refactor this obvious insanity
+    gradeNames: "hortis.sunburstLoaderWithMap",
+    markupTemplate: "%resourceBase/html/imerss-viz-map-only.html",
+    components: {
+        sunburst: {
+            options: {
+                model: {
+                    visible: false
+                },
+                components: {
+                    autocomplete: {
+                        type: "fluid.emptySubcomponent"
+                    },
+                    tabs: {
+                        type: "fluid.emptySubcomponent"
+                    },
+                    checklist: {
+                        type: "fluid.emptySubcomponent"
+                    }
+                }
+            }
+        }
+    }
+});
+
+fluid.defaults("hortis.mapWithSunburst", {
+    modelListeners: {
+        mapFocusedTooltipToSunburst: {
+            path: "{map}.model.mapBlockTooltipId",
+            func: "hortis.mapBlockToFocusedTaxa",
+            args: ["{change}.value", "{map}", "{sunburst}"]
+        }
+    },
+    datasets: "{sunburst}.viz.datasets",
+    geoJSONMapLayers: "{sunburstLoaderWithMap}.options.geoJSONMapLayers"
+});
+
+// Can't use modelRelay because of https://issues.fluidproject.org/browse/FLUID-6208
+hortis.mapBlockToFocusedTaxa = function (mapBlockTooltipId, map, sunburst) {
+    const togo = {};
+    if (mapBlockTooltipId) {
+        const bucket = map.toPlot[mapBlockTooltipId];
+        if (bucket) {
+            fluid.each(bucket.byTaxonId, function (obs, taxonId) {
+                togo[taxonId] = true;
+            });
+        }
+    }
+    const source = map.options.selectionTransactionSource;
+    // As transaction to avoid triggering hortis.updateRowFocus twice which then invokes beginZoom
+    const trans = sunburst.applier.initiate(source);
+    trans.change("rowFocus", null, "DELETE", source);
+    trans.change("rowFocus", togo, null, source);
+    trans.commit();
+};
+
+// From https://en.wikipedia.org/wiki/Longitude#Length_of_a_degree_of_longitude
+hortis.WGS84a = 6378137;
+hortis.WGS84b = 6356752.3142;
+hortis.WGS84e2 = (hortis.WGS84a * hortis.WGS84a - hortis.WGS84b * hortis.WGS84b) / (hortis.WGS84a * hortis.WGS84a);
+
+/** Length in metres for a degree of longitude at given latitude **/
+
+hortis.longitudeLength = function (latitude) {
+    const latrad = Math.PI * latitude / 180;
+    const sinrad = Math.sin(latrad);
+    return Math.PI * hortis.WGS84a * Math.cos(latrad) / (180 * Math.sqrt(1 - hortis.WGS84e2 * sinrad * sinrad));
+};
+
+/** Length in metres for a degree of latitude at given latitude **/
+
+hortis.latitudeLength = function (latitude) {
+    const latrad = Math.PI * latitude / 180;
+    const sinrad = Math.sin(latrad);
+    return Math.PI * hortis.WGS84a * (1 - hortis.WGS84e2) / (180 * Math.pow(1 - hortis.WGS84e2 * sinrad * sinrad, 1.5));
+};
+
+hortis.longToLat = function (lng, lat) {
+    const longLength = hortis.longitudeLength(lat);
+    const latLength = hortis.latitudeLength(lat);
+    return lng * longLength / latLength;
+};
+
+hortis.quantiserDataset = function () {
+    return {maxCount: 0, totalCount: 0, buckets: {}, byTaxonId: {}};
+};

package/src/client/js/leafletMapWithGrid.js

@@ -0,0 +1,337 @@
+/* global L */
+
+"use strict";
+
+// noinspection ES6ConvertVarToLetConst // otherwise this is a duplicate on minifying
+var hortis = fluid.registerNamespace("hortis");
+
+fluid.defaults("hortis.leafletMap.withGrid", {
+    selectors: {
+        grid: ".fld-imerss-map-grid",
+        datasetControls: ".fld-imerss-dataset-controls",
+        datasetsLabel: ".fld-imerss-datasets-label"
+    },
+    baseZoomForOutline: 11.9,
+    model: {
+        datasetsLabel: "Data Sources:"
+    },
+    modelListeners: {
+        drawGrid: {
+            path: ["indexVersion", "datasetEnabled"],
+            func: "{that}.drawGrid"
+        },
+        zoomToOutline: {
+            path: "zoom",
+            listener: "hortis.leafletMap.updateOutlineWidth",
+            args: ["{change}.value", "{that}.options.baseZoomForOutline", "{that}.container.0"]
+        },
+        drawScale: {
+            path: "{quantiser}.model.squareSide",
+            func: "hortis.leafletMap.drawScale",
+            args: ["{that}", "{change}.value"]
+        },
+        updateTooltip: {
+            path: ["mapBlockTooltipId", "indexVersion", "datasetEnabled"],
+            priority: "after:drawGrid",
+            excludeSource: "init",
+            func: "hortis.leafletMap.withGrid.updateTooltip",
+            args: ["{that}", "{that}.model.mapBlockTooltipId"]
+        },
+        updateTooltipHighlight: {
+            path: "mapBlockTooltipId",
+            excludeSource: "init",
+            func: "hortis.leafletMap.withGrid.updateTooltipHighlight",
+            args: ["{that}", "{change}.oldValue"]
+        }
+    },
+    invokers: {
+        drawGrid: "hortis.leafletMap.drawGrid({that}, {that}.quantiser, {that}.model.datasetEnabled)"
+    },
+    gridStyle: {
+        className: "fld-imerss-map-region"
+    },
+    listeners: {
+        "buildMap.addGrid": "hortis.leafletMap.withGrid.addGrid({that})"
+    },
+    modelRelay: {
+        renderDatasetControls: { // This could be refined someday if we are ever required to produce dataset controls with non-square map regions
+            target: "datasetControls",
+            func: "hortis.renderDatasetControls",
+            args: ["{that}.model.datasetEnabled", "{that}.quantiser.model.squareSide", "{that}.options.datasets", "{that}.quantiser", "{that}.model.indexVersion"]
+        },
+        datasetsLabel: {
+            source: "datasetsLabel",
+            target: "dom.datasetsLabel.text"
+        }
+    },
+    components: {
+        quantiser: {
+            type: "hortis.quantiser",
+            options: {
+                baseLatitude: "{leafletMap}.options.fitBounds.0.0",
+                datasets: "{leafletMap}.options.datasets",
+                model: {
+                    indexVersion: "{leafletMap}.model.indexVersion"
+                }
+            }
+        }
+    },
+    dynamicComponents: {
+        datasetControls: {
+            sources: "{that}.model.datasetControls",
+            type: "{source}.type",
+            options: {
+                model: {
+                    datasetControl: "{source}"
+                }
+            }
+        }
+    }
+});
+
+hortis.leafletMap.updateOutlineWidth = function (zoom, baseZoom, container) {
+    const relativeZoom = Math.min(1, Math.pow(2, 2 * (zoom - baseZoom)));
+    container.style.setProperty("--imerss-stroke-width", 2 * relativeZoom);
+};
+
+hortis.leafletMap.withGrid.addGrid = function (that) {
+    that.map.createPane("hortis-grid");
+    that.gridGroup = L.layerGroup({pane: "hortis-grid"}).addTo(that.map);
+};
+
+hortis.leafletMap.drawScale = function (map, squareSide) {
+    const dimText = squareSide.toFixed(0) + "m";
+    map.container.find(".leaflet-bottom.leaflet-left").text("Block size: " + dimText + " x " + dimText);
+};
+
+hortis.rectFromCorner = function (tl, latres, longres) {
+    return [
+        [tl[0], tl[1]],
+        [tl[0], tl[1] + longres],
+        [tl[0] + latres, tl[1] + longres],
+        [tl[0] + latres, tl[1]]
+    ];
+};
+
+hortis.leafletMap.drawGrid = function (map, quantiser, datasetEnabled) {
+    map.gridGroup.clearLayers();
+
+    const latres = quantiser.model.latResolution, longres = quantiser.model.longResolution;
+    const heatLow = fluid.colour.hexToArray(map.options.heatLow);
+    const toPlot = map.toPlot = {};
+    fluid.each(quantiser.datasets, function (dataset, datasetId) {
+        if (datasetEnabled[datasetId]) {
+            const mapDataset = map.options.datasets[datasetId];
+            const heatHigh = fluid.colour.hexToArray(mapDataset.colour);
+            fluid.each(dataset.buckets, function (bucket, key) {
+                const prop = Math.pow(bucket.count / dataset.maxCount, 0.25);
+                const fillColour = fluid.colour.interpolate(prop, heatLow, heatHigh);
+                fluid.model.setSimple(toPlot, [key, "colours", datasetId], fillColour);
+                const plotBucket = toPlot[key];
+                plotBucket.count = plotBucket.count || 0;
+                plotBucket.count += bucket.count;
+                plotBucket.byTaxonId = fluid.extend({}, plotBucket.byTaxonId, bucket.byTaxonId);
+            });
+        }
+    });
+    fluid.each(toPlot, function (bucket, key) {
+        const colours = fluid.values(bucket.colours);
+        const colour = fluid.colour.average(colours);
+        const topLeft = hortis.quantiser.indexToCoord(key, latres, longres);
+        bucket.polygon = hortis.rectFromCorner(topLeft, latres, longres);
+        bucket.Lpolygon = L.polygon(bucket.polygon, fluid.extend({}, map.options.gridStyle, {
+            fillColor: fluid.colour.arrayToString(colour),
+            pane: "hortis-grid"
+        }));
+        map.gridGroup.addLayer(bucket.Lpolygon);
+        bucket.Lpolygon.on("click", function () {
+            console.log("Map clicked on key ", key);
+            map.applier.change("mapBlockTooltipId", key);
+        });
+    });
+    // Deal with overall loss of a block through not appearing in dataset selection
+    if (!toPlot[map.model.mapBlockTooltipId]) {
+        map.applier.change("mapBlockTooltipId", null);
+    }
+};
+
+hortis.leafletMap.tooltipRow = function (map, key, value) {
+    return fluid.stringTemplate(map.options.markup.tooltipRow, {key: key, value: value});
+};
+
+// TODO: Design fault, only responsible for REMOVING highlight, adding of highlight occurs in updateTooltip
+hortis.leafletMap.withGrid.updateTooltipHighlight = function (map, oldKey) {
+    if (oldKey) {
+        const oldBucket = map.toPlot[oldKey];
+        if (oldBucket) {
+            const element = oldBucket.Lpolygon.getElement();
+            element.classList.remove("fl-imerss-highlightBlock");
+        }
+    }
+};
+
+// It is called "tooltip" but actually it is a popup panel activated on click
+hortis.leafletMap.withGrid.updateTooltip = function (map, key) {
+    const tooltip = map.locate("tooltip");
+    const bucket = map.toPlot[key];
+    if (bucket) {
+        let text = map.options.markup.tooltipHeader;
+        const dumpRow = function (key, value) {
+            text += hortis.leafletMap.tooltipRow(map, key, value);
+        };
+        const resolution = map.quantiser.model.longResolution;
+        const dp = Math.max(3, 1 - Math.log10(resolution));
+        const c = function (value) {
+            return value.toFixed(dp);
+        };
+        dumpRow("Observation Count", bucket.count);
+        dumpRow("Species Richness", Object.values(bucket.byTaxonId).length);
+        const p = bucket.polygon;
+        const lat0 = p[0][0], lat1 = p[2][0];
+        const lng0 = p[0][1], lng1 = p[1][1];
+        dumpRow("Latitude", c(lat0) + " to " + c(lat1));
+        dumpRow("Longitude", c(lng0) + " to " + c(lng1));
+        if (bucket.count < 5 && map.options.showObsListInTooltip) {
+            const obs = fluid.flatten(Object.values(bucket.byTaxonId));
+            const obsString = fluid.transform(obs, hortis.renderObsId).map(s => "iNaturalist: " + s).join("<br/>");
+            dumpRow("Observations", obsString);
+        }
+        text += map.options.markup.tooltipFooter;
+        tooltip[0].innerHTML = text;
+        tooltip.show();
+        const element = bucket.Lpolygon.getElement();
+        element.classList.add("fl-imerss-highlightBlock");
+        const parent = element.parentNode;
+        parent.insertBefore(element, null);
+    } else {
+        tooltip.hide();
+    }
+};
+
+
+fluid.defaults("hortis.quantiser", {
+    gradeNames: "fluid.modelComponent",
+    baseLatitude: 51,
+    model: {
+        longResolution: 0.005,
+        indexVersion: 0
+    },
+    modelRelay: {
+        latResolution: {
+            target: "latResolution",
+            singleTransform: {
+                type: "fluid.transforms.free",
+                args: ["{that}.model.longResolution", "{that}.options.baseLatitude"],
+                func: "hortis.longToLat"
+            }
+        },
+        squareSide: {
+            target: "squareSide",
+            singleTransform: {
+                type: "fluid.transforms.free",
+                func: "hortis.quantiser.squareSide",
+                args: ["{that}.options.baseLatitude", "{that}.model.latResolution"]
+            }
+        },
+        index: {
+            target: "indexVersion",
+            singleTransform: {
+                type: "fluid.transforms.free",
+                args: ["{that}", "{that}.options.datasets", "{that}.model.latResolution", "{that}.model.longResolution", "{that}.model.squareSide", "{that}.model.indexVersion"],
+                func: "hortis.quantiser.indexTree"
+            }
+        }
+    },
+    members: {
+        datasets: {
+            // hash of datasetId to {maxCount, buckets}
+            // where buckets is hash of id to {count, byId}
+        }
+    },
+    events: {
+        indexUpdated: null
+    },
+    invokers: {
+        datasetToSummary: "hortis.quantiser.datasetToSummary({arguments}.0, {arguments}.1)", // bucket - will be modified
+        indexObs: "hortis.quantiser.indexObs({that}, {arguments}.0, {arguments}.1, {arguments}.2, {arguments}.3, {arguments}.4)" // coord, obsId, id, latRes, longRes
+    }
+});
+
+hortis.quantiser.squareSide = function (baseLatitude, latResolution) {
+    return hortis.latitudeLength(baseLatitude) * latResolution;
+};
+
+hortis.quantiser.indexToCoord = function (index, latres, longres) {
+    const coords = index.split("|");
+    return [coords[0] * latres, coords[1] * longres];
+};
+
+hortis.quantiser.coordToIndex = function (coord, latres, longres) {
+    if (coord) {
+        const lat = Math.floor(coord[0] / latres);
+        const lng = Math.floor(coord[1] / longres);
+        return lat + "|" + lng;
+    } else {
+        return "null";
+    }
+};
+
+hortis.datasetIdFromObs = function (obsId) {
+    const colpos = obsId.indexOf(":");
+    return obsId.substring(0, colpos);
+};
+
+hortis.localIdFromObs = function (obsId) {
+    const colpos = obsId.indexOf(":");
+    return obsId.substring(colpos + 1);
+};
+
+hortis.quantiser.indexObs = function (that, coord, obsId, rowId, latResolution, longResolution) {
+    const coordIndex = hortis.quantiser.coordToIndex(coord, latResolution, longResolution);
+    const datasetId = hortis.datasetIdFromObs(obsId);
+    const dataset = that.datasets[datasetId];
+    if (!dataset) {
+        fluid.fail("Found observation with unknown dataset " + datasetId);
+    }
+
+    dataset.byTaxonId[rowId] = true;
+    dataset.totalCount++;
+    if (coordIndex !== "null") {
+        let bucket = dataset.buckets[coordIndex];
+        if (!bucket) {
+            bucket = dataset.buckets[coordIndex] = {count: 0, byTaxonId: {}};
+        }
+        bucket.count++;
+        dataset.maxCount = Math.max(dataset.maxCount, bucket.count);
+        let bucketTaxa = bucket.byTaxonId[rowId]; // TODO: use fluid.pushArray?
+        if (!bucketTaxa) {
+            bucketTaxa = bucket.byTaxonId[rowId] = [];
+        }
+        bucketTaxa.push(obsId);
+    }
+};
+
+hortis.quantiser.datasetToSummary = function (dataset, squareSide) {
+    const squareArea = squareSide * squareSide / (1000 * 1000);
+    dataset.taxaCount = Object.keys(dataset.byTaxonId).length;
+    dataset.area = (Object.keys(dataset.buckets).length * squareArea).toFixed(2);
+};
+
+hortis.quantiser.indexTree = function (that, datasets, latResolution, longResolution, squareSide, indexVersion) {
+    that.datasets = fluid.transform(datasets, hortis.quantiserDataset);
+    for (let i = that.flatTree.length - 1; i >= 0; --i) {
+        const row = that.flatTree[i];
+        if (row.coords) {
+            const coords = JSON.parse(row.coords);
+            fluid.each(coords, function (coord, obsId) {
+                that.indexObs(coord, obsId, row.id, latResolution, longResolution);
+            });
+        }
+    };
+
+    fluid.each(that.datasets, function (dataset) {
+        that.datasetToSummary(dataset, squareSide);
+    });
+
+    return indexVersion + 1;
+};