gridviz 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gridviz",
-    "version": "3.0.0",
+    "version": "3.0.1",
     "description": "Visualization tool for gridded statistics",
     "keywords": [
         "statistics",

package/src/core/Dataset.js

@@ -20,7 +20,6 @@ export class Dataset {
      * @abstract
      */
     constructor(map, url, resolution, opts = {}) {
-        opts = opts || {}
 
         /**
          * The map.

package/src/core/Map.js

@@ -135,6 +135,20 @@ export class Map {
         //.style("visibility", "hidden")
     }
 
+    /**
+     * Set/get layer stack.
+     * 
+     * @param {undefined|import("./Layer.js").Layer|import("./Layer.js").Layer[]} layers 
+     * @returns { this | import("./Layer.js").Layer[] }
+     */
+    layers_(layers) {
+        if (arguments.length === 0) return this.layers
+        if (arguments.length === 1)
+            if (Array.isArray(layers)) this.layers = layers
+            else this.layers = [layers]
+        else this.layers = arguments
+        return this
+    }
 
     /** @returns {this} */
     redraw() {

package/src/dataset/JSGrid.js

@@ -1,8 +1,6 @@
 //@ts-check
 'use strict'
 
-/** @typedef {{ dims: object, crs: string, tileSizeCell: number, originPoint: {x:number,y:number}, resolutionGeo: number, tilingBounds:import("../core/GeoCanvas.js").Envelope }} GridInfo */
-
 import { Dataset } from '../core/Dataset.js'
 
 /**
@@ -11,6 +9,7 @@ import { Dataset } from '../core/Dataset.js'
  * @author Joseph Davies, Julien Gaffuri
  */
 export class JSGrid extends Dataset {
+
     /**
      * @param {number} resolution The dataset resolution in geographical unit.
      * @param {Array.<Object>} cells The cells.
@@ -20,7 +19,7 @@ export class JSGrid extends Dataset {
 
         /**
          * @private
-         * @type {Array.<import("../core/MultiResolutionDataset.js").Cell>} */
+         * @type {Array.<import('../core/Dataset.js').Cell>} */
         this.cells = cells || []
     }
 

package/src/index.js

@@ -3,7 +3,7 @@
 
 // the application
 export { Map } from './core/Map.js'
-//export { GeoCanvas } from './GeoCanvas.js'
+export { GeoCanvas } from './core/GeoCanvas.js'
 export { Style } from './core/Style.js'
 export { Layer } from './core/Layer.js'
 export { MultiResolutionDataset } from './core/MultiResolutionDataset.js'

package/src/layer/GridLayer.js

@@ -20,6 +20,7 @@ export class GridLayer extends Layer {
 
         /** @type {import("../core/Dataset").Dataset|import("../core/MultiResolutionDataset").MultiResolutionDataset} */
         this.dataset = dataset
+
         /** @type {Array.<import("../core/Style").Style>} */
         this.styles = styles
 
@@ -121,6 +122,25 @@ export class GridLayer extends Layer {
         return this.dataset.getDataset(z, this.minPixelsPerCell);
     }
 
+
+
+    /**
+     * Set/get style stack.
+     * 
+     * @param {undefined|import("../core/Style").Style|Array.<import("../core/Style").Style>} styles 
+     * @returns { this | Array.<import("../core/Style").Style> }
+     */
+    styles_(styles) {
+        if (arguments.length === 0) return this.styles
+        if (arguments.length === 1)
+            if (Array.isArray(styles)) this.styles = styles
+            else this.styles = [styles]
+        else this.styles = arguments
+        return this
+    }
+
+
+
     /**
      * The default function returning cell information as HTML.
      * This is typically used for tooltip information.

package/src/utils/scale.js

@@ -15,9 +15,9 @@ import { scaleQuantile } from "d3-scale"
 
 
 /**
- * Generic function for view scale - continuous
+ * Generic function for view scale - continuous or discrete
  * 
- * @param {{ valueFunction:function(import("../core/Dataset").Cell):number, minValue?:number, minSizePix?:number, maxSizeFactor?:number, range?:[number, number], domain?:[number, number], stretching?:function(number):number }} opts 
+ * @param {{ valueFunction:function(import("../core/Dataset").Cell):number, minValue?:number, minSizePix?:number, maxSizeFactor?:number, range?:[number, number], domain?:[number, number], stretching?:function(number):number, classNumber?:number}} opts 
  * @returns {function(Array.<import("../core/Dataset").Cell>):Scale}
  */
 export const viewScale = (opts) => {
@@ -28,21 +28,27 @@ export const viewScale = (opts) => {
     const stretching = opts.stretching
     const range_ = opts.range
     const domain_ = opts.domain
+    const classNumber = opts.classNumber
     return (cells, r, z) => {
         const domain = domain_ || [minValue, max(cells, valueFunction)]
         const range = range_ || [minSizePix * z, r * maxSizeFactor]
+        const domainSize = domain[1] - domain[0], domainMin = domain[0]
+        const rangeSize = range[1] - range[0], rangeMin = range[0]
         return t => {
             //scale to [0,1]
-            t = (t - domain[0]) / (domain[1] - domain[0])
+            t = (t - domainMin) / domainSize
             //stretch
             if (stretching) t = stretching(t)
+            //classify
+            if (classNumber) t = t == 1 ? 1 : Math.floor(t * (classNumber)) / (classNumber - 1)
             //scale to range
-            return range[0] + t * (range[1] - range[0])
+            return rangeMin + t * rangeSize
         }
     }
 }
 
 
+
 /**
  * Generic function for view scale - quantile
  * 
@@ -71,24 +77,29 @@ export const viewScaleQuantile = (opts) => {
 
 
 /**
- * Generic function for color view scale - continuous
+ * Generic function for color view scale - continuous or discrete
  * 
- * @param {{ valueFunction:function(import("../core/Dataset").Cell):number, colorScale?:function(number):string, stretching?:function(number):number }} opts 
+ * @param {{ valueFunction:function(import("../core/Dataset").Cell):number, colorScale?:function(number):string, colors?:Array.<string>, stretching?:function(number):number }} opts 
  * @returns {function(Array.<import("../core/Dataset").Cell>):ColorScale}
  */
 export const viewScaleColor = (opts) => {
     const valueFunction = opts.valueFunction
-    const colorScale = opts.colorScale || (() => "purple")
     const stretching = opts.stretching
+    let colorScale = opts.colorScale || (() => "purple")
+
+    //case of discrete colors
+    if (opts.colors)
+        colorScale = t => opts.colors[t == 1 ? opts.colors.length - 1 : Math.floor(t * opts.colors.length)]
+
     return (cells) => {
         if (cells.length == 0 || !cells) return
         /** @type {[undefined, undefined] | [number, number]} */
         const domain = extent(cells, valueFunction)
         if (domain[0] == undefined) return
-        const amplitude = domain[1] - domain[0]
+        const domainSize = domain[1] - domain[0]
         const scale = t => {
             //scale to [0,1]
-            t = (t - domain[0]) / amplitude
+            t = (t - domain[0]) / domainSize
             //stretch
             if (stretching) t = stretching(t)
             return colorScale(t)
@@ -96,13 +107,17 @@ export const viewScaleColor = (opts) => {
         //function that return the domain value from the [0,1] range.
         scale.invert = t => {
             if (stretching) t = stretching.invert(t)
-            return domain[0] + t * amplitude
+            return domain[0] + t * domainSize
         }
 
         return scale;
     }
 }
 
+
+
+
+
 /**
  * Generic function for color view scale - quantile
  *