gridviz 3.0.34 → 3.0.36

package/src/utils/utils.js

@@ -1,125 +1,125 @@
-//@ts-check
-'use strict'
-
-import { min, max, extent } from 'd3-array'
-
-/**
- * Get the class id from a value and class break values
- *
- * @param {number} v the value
- * @param {Array.<number>} breaks the breaks
- * @returns The class id, from 0 to breaks.length
- * @deprecated use getClassifier instead.
- */
-export function getClass(v, breaks) {
-    if (!breaks) return
-    if (breaks.length == 0) return 0
-    if (v <= breaks[0]) return 0
-    for (let i = 1; i < breaks.length; i++) if (breaks[i - 1] < v && v <= breaks[i]) return i
-    return breaks.length
-}
-
-//take 'nice' value (power of ten, or multiple)
-export function nice(v, multiples = [8, 6, 5, 4, 2.5, 2]) {
-    //compute bigger power of ten below
-    const v_ = Math.pow(10, Math.floor(Math.log10(v)))
-    for (let multiple of multiples) if (v_ * multiple <= v) return v_ * multiple
-    return v_
-}
-
-/**
- * A grid cell.
- * @typedef {{x: number, y: number}} Cell */
-
-/**
- * Index cells by y and x
- * @param {Array.<Cell>} cells
- * @param {Function} [fun]
- * @returns {Object}
- */
-export function cellsToGrid(cells, fun) {
-    /** @type {Object} */
-    const ind = {}
-    for (const cell of cells) {
-        let row = ind[cell.y]
-        if (!row) {
-            row = {}
-            ind[cell.y] = row
-        }
-        row[cell.x] = fun ? fun(cell) : cell
-    }
-    return ind
-}
-
-
-
-/**
- * Cells to grid.
- * 
- * @param {Array.<Cell>} cells
- * @param {number} resolution
- * @param {Function} [fun]
- * @returns {Object}
- * Grid[i][j] is the value for line i and column j.
- * Numbered from top to bottom, from left to right.
- * Properties x0 and y0 are the geo coordinates of the lower left corner of the top left cell.
- * Properties minI, maxI, minJ, maxJ are the extent of the grid.
- */
-export function cellsToMatrix(cells, resolution, fun) {
-
-    // get cells extent
-    const [minx, maxx] = extent(cells, c => c.x)
-    const [miny, maxy] = extent(cells, c => c.y)
-
-    // get grid dimension
-    const rows = Math.ceil((maxy - miny) / resolution) + 1
-    const cols = Math.ceil((maxx - minx) / resolution) + 1
-
-    // make empty grid
-    const grid = Array.from({ length: rows }, () => new Array(cols).fill(undefined));
-    grid.x0 = minx
-    grid.y0 = maxy
-    grid.resolution = resolution
-
-    for (const c of cells) {
-        const i = Math.floor((maxy - c.y) / resolution)
-        const j = Math.floor((c.x - minx) / resolution)
-        const v = fun ? fun(c) : c
-        grid[i][j] = v
-    }
-    return grid
-}
-
-
-
-/*
-//no longer used
-export function loadImage(src) {
-    return new Promise((resolve, reject) => {
-        const img = new Image();
-        img.onload = function () { resolve(img); };
-        img.onerror = function () { reject(new Error('Error loading image')); };
-        img.src = src;
-    });
-}
-*/
-
-/*
-export let monitor = false
-
-let previousDate
-export function monitorDuration(message) {
-    const nowDate = Date.now()
-
-    //first call
-    if (!previousDate) {
-        previousDate = nowDate
-        console.log(previousDate, message)
-        return
-    }
-
-    const d = nowDate - previousDate
-    previousDate = nowDate
-    console.log(d, message)
-}
-*/
+//@ts-check
+'use strict'
+
+import { min, max, extent } from 'd3-array'
+
+/**
+ * Get the class id from a value and class break values
+ *
+ * @param {number} v the value
+ * @param {Array.<number>} breaks the breaks
+ * @returns The class id, from 0 to breaks.length
+ * @deprecated use getClassifier instead.
+ */
+export function getClass(v, breaks) {
+    if (!breaks) return
+    if (breaks.length == 0) return 0
+    if (v <= breaks[0]) return 0
+    for (let i = 1; i < breaks.length; i++) if (breaks[i - 1] < v && v <= breaks[i]) return i
+    return breaks.length
+}
+
+//take 'nice' value (power of ten, or multiple)
+export function nice(v, multiples = [8, 6, 5, 4, 2.5, 2]) {
+    //compute bigger power of ten below
+    const v_ = Math.pow(10, Math.floor(Math.log10(v)))
+    for (let multiple of multiples) if (v_ * multiple <= v) return v_ * multiple
+    return v_
+}
+
+/**
+ * A grid cell.
+ * @typedef {{x: number, y: number}} Cell */
+
+/**
+ * Index cells by y and x
+ * @param {Array.<Cell>} cells
+ * @param {Function} [fun]
+ * @returns {Object}
+ */
+export function cellsToGrid(cells, fun) {
+    /** @type {Object} */
+    const ind = {}
+    for (const cell of cells) {
+        let row = ind[cell.y]
+        if (!row) {
+            row = {}
+            ind[cell.y] = row
+        }
+        row[cell.x] = fun ? fun(cell) : cell
+    }
+    return ind
+}
+
+
+
+/**
+ * Cells to grid.
+ * 
+ * @param {Array.<Cell>} cells
+ * @param {number} resolution
+ * @param {Function} [fun]
+ * @returns {Object}
+ * Grid[i][j] is the value for line i and column j.
+ * Numbered from top to bottom, from left to right.
+ * Properties x0 and y0 are the geo coordinates of the lower left corner of the top left cell.
+ * Properties minI, maxI, minJ, maxJ are the extent of the grid.
+ */
+export function cellsToMatrix(cells, resolution, fun) {
+
+    // get cells extent
+    const [minx, maxx] = extent(cells, c => c.x)
+    const [miny, maxy] = extent(cells, c => c.y)
+
+    // get grid dimension
+    const rows = Math.ceil((maxy - miny) / resolution) + 1
+    const cols = Math.ceil((maxx - minx) / resolution) + 1
+
+    // make empty grid
+    const grid = Array.from({ length: rows }, () => new Array(cols).fill(undefined));
+    grid.x0 = minx
+    grid.y0 = maxy
+    grid.resolution = resolution
+
+    for (const c of cells) {
+        const i = Math.floor((maxy - c.y) / resolution)
+        const j = Math.floor((c.x - minx) / resolution)
+        const v = fun ? fun(c) : c
+        grid[i][j] = v
+    }
+    return grid
+}
+
+
+
+/*
+//no longer used
+export function loadImage(src) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = function () { resolve(img); };
+        img.onerror = function () { reject(new Error('Error loading image')); };
+        img.src = src;
+    });
+}
+*/
+
+/*
+export let monitor = false
+
+let previousDate
+export function monitorDuration(message) {
+    const nowDate = Date.now()
+
+    //first call
+    if (!previousDate) {
+        previousDate = nowDate
+        console.log(previousDate, message)
+        return
+    }
+
+    const d = nowDate - previousDate
+    previousDate = nowDate
+    console.log(d, message)
+}
+*/

package/src/utils/webGLUtils.js

@@ -1,73 +1,73 @@
-//@ts-check
-'use strict'
-
-/**
- * @param {string} width
- * @param {string} height
- * @param {object} opts
- * @returns {{canvas:HTMLCanvasElement, gl:WebGLRenderingContext, width:number, height:number }}
- */
-export function makeWebGLCanvas(width, height, opts = {}) {
-    const canvas = document.createElement('canvas')
-    canvas.setAttribute('width', width)
-    canvas.setAttribute('height', height)
-    const version2 = (opts && +opts.version==2)? "2" : ""
-    /** @type {WebGLRenderingContext} */
-    const gl = canvas.getContext('webgl' + version2, opts)
-    if (!gl) {
-        throw new Error('Unable to initialize WebGL'+version2+'. Your browser or machine may not support it.')
-    }
-    return { canvas: canvas, gl: gl, width: width, height: height }
-}
-
-/**
- * Initialize a shader program, so WebGL knows how to draw our data
- *
- * @param {WebGLRenderingContext} gl
- * @param  {...WebGLShader} shaders
- * @returns {WebGLProgram}
- */
-export function initShaderProgram(gl, ...shaders) {
-    /** @type {WebGLProgram|null} */
-    const program = gl.createProgram()
-    if (program == null) throw new Error('Cannot create webGL program')
-    for (const shader of shaders) gl.attachShader(program, shader)
-    gl.linkProgram(program)
-    if (gl.getProgramParameter(program, gl.LINK_STATUS)) return program
-    throw new Error(gl.getProgramInfoLog(program) || 'Cannot create webGL program (2)')
-}
-
-/**
- * Creates a shader of the given type, uploads the source and compiles it.
- *
- * @param {WebGLRenderingContext} gl
- * @param {number} type
- * @param  {...string} sources
- * @returns {WebGLShader}
- */
-export function createShader(gl, type, ...sources) {
-    /** @type {WebGLShader|null} */
-    const shader = gl.createShader(type)
-    if (shader == null) throw new Error('Cannot create webGL shader')
-    gl.shaderSource(shader, sources.join('\n'))
-    gl.compileShader(shader)
-    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS)) return shader
-    throw new Error(gl.getShaderInfoLog(shader) || 'Cannot create webGL shader (2)')
-}
-
-/**
- * Check if webGL is supported
- *
- * @returns {boolean}
- */
-export function checkWebGLSupport() {
-    try {
-        const canvas = document.createElement('canvas')
-        return !!(
-            !!window.WebGLRenderingContext &&
-            (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
-        )
-    } catch (err) {
-        return false
-    }
-}
+//@ts-check
+'use strict'
+
+/**
+ * @param {string} width
+ * @param {string} height
+ * @param {object} opts
+ * @returns {{canvas:HTMLCanvasElement, gl:WebGLRenderingContext, width:number, height:number }}
+ */
+export function makeWebGLCanvas(width, height, opts = {}) {
+    const canvas = document.createElement('canvas')
+    canvas.setAttribute('width', width)
+    canvas.setAttribute('height', height)
+    const version2 = (opts && +opts.version==2)? "2" : ""
+    /** @type {WebGLRenderingContext} */
+    const gl = canvas.getContext('webgl' + version2, opts)
+    if (!gl) {
+        throw new Error('Unable to initialize WebGL'+version2+'. Your browser or machine may not support it.')
+    }
+    return { canvas: canvas, gl: gl, width: width, height: height }
+}
+
+/**
+ * Initialize a shader program, so WebGL knows how to draw our data
+ *
+ * @param {WebGLRenderingContext} gl
+ * @param  {...WebGLShader} shaders
+ * @returns {WebGLProgram}
+ */
+export function initShaderProgram(gl, ...shaders) {
+    /** @type {WebGLProgram|null} */
+    const program = gl.createProgram()
+    if (program == null) throw new Error('Cannot create webGL program')
+    for (const shader of shaders) gl.attachShader(program, shader)
+    gl.linkProgram(program)
+    if (gl.getProgramParameter(program, gl.LINK_STATUS)) return program
+    throw new Error(gl.getProgramInfoLog(program) || 'Cannot create webGL program (2)')
+}
+
+/**
+ * Creates a shader of the given type, uploads the source and compiles it.
+ *
+ * @param {WebGLRenderingContext} gl
+ * @param {number} type
+ * @param  {...string} sources
+ * @returns {WebGLShader}
+ */
+export function createShader(gl, type, ...sources) {
+    /** @type {WebGLShader|null} */
+    const shader = gl.createShader(type)
+    if (shader == null) throw new Error('Cannot create webGL shader')
+    gl.shaderSource(shader, sources.join('\n'))
+    gl.compileShader(shader)
+    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS)) return shader
+    throw new Error(gl.getShaderInfoLog(shader) || 'Cannot create webGL shader (2)')
+}
+
+/**
+ * Check if webGL is supported
+ *
+ * @returns {boolean}
+ */
+export function checkWebGLSupport() {
+    try {
+        const canvas = document.createElement('canvas')
+        return !!(
+            !!window.WebGLRenderingContext &&
+            (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
+        )
+    } catch (err) {
+        return false
+    }
+}

package/src/utils/zoomUtils.js

@@ -1,142 +1,142 @@
-//@ts-check
-'use strict'
-
-/**
- *
- * @param {import("../App").App} app
- * @param {number} zTarget
- * @param {number} factor
- * @param {number} delayMs
- * @param {function|undefined} callback
- * @param {number} delayBeforeCallBackMs
- * @returns
- */
-export function zoomTo(
-    app,
-    zTarget,
-    factor = 1.01,
-    delayMs = 0,
-    callback = undefined,
-    delayBeforeCallBackMs = 0
-) {
-    //ensure good factor value: >1
-    factor = factor || 1.01
-    if (factor < 1) {
-        console.error('Unexpected value for factor: ' + factor + '. Set to default value 1.01')
-        factor = 1.01
-    }
-
-    const zIni = map.getZoom()
-    if (zTarget == zIni) return
-    if (zTarget < zIni) factor = 1 / factor
-    let z = zIni
-    let timer = setInterval(() => {
-        //compute new zoom level
-        z = map.getZoom() * factor
-        if (zTarget > zIni && z > zTarget) z = zTarget
-        if (zTarget < zIni && z < zTarget) z = zTarget
-
-        //set new zoom level
-        map.setZoom(z)
-        map.redraw()
-
-        //target reached
-        if (z == zTarget) {
-            clearInterval(timer)
-            //trigger callback, if any
-            if (callback)
-                setTimeout(() => {
-                    callback()
-                }, delayBeforeCallBackMs)
-        }
-    }, delayMs)
-    return timer
-}
-
-/**
- *
- * @param {import("../App").App} app
- * @param {number} xTarget
- * @param {number} yTarget
- * @param {number} zTarget
- * @param {number} progressFactorPix
- * @param {number} delayMs
- * @param {function|undefined} callback
- * @param {number} delayBeforeCallBackMs
- * @returns
- */
-export function goToStraight(
-    app,
-    xTarget = NaN,
-    yTarget = NaN,
-    zTarget = NaN,
-    progressFactorPix = 5,
-    delayMs = 0,
-    callback = undefined,
-    delayBeforeCallBackMs = 0
-) {
-    //store initial position/zoom
-    const zIni = map.getZoom()
-    const cIni = map.getView()
-
-    //default
-    xTarget = isNaN(xTarget) ? cIni.x : xTarget
-    yTarget = isNaN(yTarget) ? cIni.y : yTarget
-    zTarget = isNaN(zTarget) ? zIni : zTarget
-
-    //prepare for pan
-    const dx = xTarget - cIni.x
-    const dy = yTarget - cIni.y
-    let d = Math.hypot(dx, dy)
-    const ddx = (progressFactorPix * zIni * dx) / d
-    const ddy = (progressFactorPix * zIni * dy) / d
-
-    //prepare for zoom
-    let r = zTarget / zIni
-    const n = d / (progressFactorPix * zIni)
-    const zoomFactor = d > 0 ? Math.pow(r, 1 / n) : Math.pow(r, 1 / 10) //TODO not 10 ?
-
-    //timer
-    let timer = setInterval(() => {
-        //compute and set new position
-        if (d > 0) {
-            const c = map.getView()
-            let nx = c.x + ddx
-            let ny = c.y + ddy
-            //if went too far, stop at target values
-            if (nx < xTarget && xTarget < c.x) nx = xTarget
-            if (c.x < xTarget && xTarget < nx) nx = xTarget
-            if (ny < yTarget && yTarget < c.y) ny = yTarget
-            if (c.y < yTarget && yTarget < ny) ny = yTarget
-            map.setGeoCenter({ x: nx, y: ny })
-            if (nx == xTarget && ny == yTarget) d = 0
-        }
-
-        //compute and set new zoom
-        if (r != 1) {
-            const z = map.getZoom()
-            let nz = zoomFactor * z
-            //if went too far, stop at target values
-            if (nz < zTarget && zTarget < z) nz = zTarget
-            if (z < zTarget && zTarget < nz) nz = zTarget
-            map.setZoom(nz)
-            if (nz == zTarget) r = 1
-        }
-
-        //redraw
-        map.redraw()
-
-        //if target reached, stop
-        if (d == 0 && r == 1) {
-            //console.log("OK !")
-            clearInterval(timer)
-            //trigger callback, if any
-            if (callback)
-                setTimeout(() => {
-                    callback()
-                }, delayBeforeCallBackMs)
-        }
-    }, delayMs)
-
-    return timer
-}
+//@ts-check
+'use strict'
+
+/**
+ *
+ * @param {import("../App").App} app
+ * @param {number} zTarget
+ * @param {number} factor
+ * @param {number} delayMs
+ * @param {function|undefined} callback
+ * @param {number} delayBeforeCallBackMs
+ * @returns
+ */
+export function zoomTo(
+    app,
+    zTarget,
+    factor = 1.01,
+    delayMs = 0,
+    callback = undefined,
+    delayBeforeCallBackMs = 0
+) {
+    //ensure good factor value: >1
+    factor = factor || 1.01
+    if (factor < 1) {
+        console.error('Unexpected value for factor: ' + factor + '. Set to default value 1.01')
+        factor = 1.01
+    }
+
+    const zIni = map.getZoom()
+    if (zTarget == zIni) return
+    if (zTarget < zIni) factor = 1 / factor
+    let z = zIni
+    let timer = setInterval(() => {
+        //compute new zoom level
+        z = map.getZoom() * factor
+        if (zTarget > zIni && z > zTarget) z = zTarget
+        if (zTarget < zIni && z < zTarget) z = zTarget
+
+        //set new zoom level
+        map.setZoom(z)
+        map.redraw()
+
+        //target reached
+        if (z == zTarget) {
+            clearInterval(timer)
+            //trigger callback, if any
+            if (callback)
+                setTimeout(() => {
+                    callback()
+                }, delayBeforeCallBackMs)
+        }
+    }, delayMs)
+    return timer
+}
+
+/**
+ *
+ * @param {import("../App").App} app
+ * @param {number} xTarget
+ * @param {number} yTarget
+ * @param {number} zTarget
+ * @param {number} progressFactorPix
+ * @param {number} delayMs
+ * @param {function|undefined} callback
+ * @param {number} delayBeforeCallBackMs
+ * @returns
+ */
+export function goToStraight(
+    app,
+    xTarget = NaN,
+    yTarget = NaN,
+    zTarget = NaN,
+    progressFactorPix = 5,
+    delayMs = 0,
+    callback = undefined,
+    delayBeforeCallBackMs = 0
+) {
+    //store initial position/zoom
+    const zIni = map.getZoom()
+    const cIni = map.getView()
+
+    //default
+    xTarget = isNaN(xTarget) ? cIni.x : xTarget
+    yTarget = isNaN(yTarget) ? cIni.y : yTarget
+    zTarget = isNaN(zTarget) ? zIni : zTarget
+
+    //prepare for pan
+    const dx = xTarget - cIni.x
+    const dy = yTarget - cIni.y
+    let d = Math.hypot(dx, dy)
+    const ddx = (progressFactorPix * zIni * dx) / d
+    const ddy = (progressFactorPix * zIni * dy) / d
+
+    //prepare for zoom
+    let r = zTarget / zIni
+    const n = d / (progressFactorPix * zIni)
+    const zoomFactor = d > 0 ? Math.pow(r, 1 / n) : Math.pow(r, 1 / 10) //TODO not 10 ?
+
+    //timer
+    let timer = setInterval(() => {
+        //compute and set new position
+        if (d > 0) {
+            const c = map.getView()
+            let nx = c.x + ddx
+            let ny = c.y + ddy
+            //if went too far, stop at target values
+            if (nx < xTarget && xTarget < c.x) nx = xTarget
+            if (c.x < xTarget && xTarget < nx) nx = xTarget
+            if (ny < yTarget && yTarget < c.y) ny = yTarget
+            if (c.y < yTarget && yTarget < ny) ny = yTarget
+            map.setGeoCenter({ x: nx, y: ny })
+            if (nx == xTarget && ny == yTarget) d = 0
+        }
+
+        //compute and set new zoom
+        if (r != 1) {
+            const z = map.getZoom()
+            let nz = zoomFactor * z
+            //if went too far, stop at target values
+            if (nz < zTarget && zTarget < z) nz = zTarget
+            if (z < zTarget && zTarget < nz) nz = zTarget
+            map.setZoom(nz)
+            if (nz == zTarget) r = 1
+        }
+
+        //redraw
+        map.redraw()
+
+        //if target reached, stop
+        if (d == 0 && r == 1) {
+            //console.log("OK !")
+            clearInterval(timer)
+            //trigger callback, if any
+            if (callback)
+                setTimeout(() => {
+                    callback()
+                }, delayBeforeCallBackMs)
+        }
+    }, delayMs)
+
+    return timer
+}