gridviz 3.0.32 → 3.0.34

package/package.json

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

package/src/core/Drawable.js

@@ -30,7 +30,7 @@ export class Drawable {
          * The function parameter is the zoom level.
          * (see CanvasRenderingContext2D: globalCompositeOperation property)
          * @type {function(number):GlobalCompositeOperation} */
-        this.blendOperation = opts.blendOperation || ((z) => 'source-over')
+        this.blendOperation = opts.blendOperation //|| ((z) => 'source-over')
 
         /** @type {(function(number):string)|undefined} */
         this.filterColor = opts.filterColor // (z) => "#eee7"
@@ -39,7 +39,7 @@ export class Drawable {
     }
 
     /**
-     * Draw layer filter.
+     * Draw filter.
      *
      * @param {import("./GeoCanvas.js").GeoCanvas} geoCanvas The canvas where to draw the layer.
      * @returns {void}

package/src/core/Map.js

@@ -182,14 +182,19 @@ export class Map {
         const z = this.geoCanvas.view.z
         this.updateExtentGeo()
 
+        const ctx = this.geoCanvas.offscreenCtx
+
         //go through the layers
         for (const layer of this.layers) {
             //check if layer is visible
             if (layer.visible && !layer.visible(z)) continue
 
             //set layer alpha and blend mode
-            this.geoCanvas.offscreenCtx.globalAlpha = layer.alpha ? layer.alpha(z) : 1.0
-            if (layer.blendOperation) this.geoCanvas.offscreenCtx.globalCompositeOperation = layer.blendOperation(z)
+            if (layer.alpha || layer.blendOperation) {
+                ctx.save()
+                if (layer.alpha) ctx.globalAlpha = layer.alpha(z)
+                if (layer.blendOperation) ctx.globalCompositeOperation = layer.blendOperation(z)
+            }
 
             //set affin transform to draw with geographical coordinates
             this.geoCanvas.setCanvasTransform()
@@ -201,8 +206,7 @@ export class Map {
             if (layer.filterColor) layer.drawFilter(this.geoCanvas)
 
             //restore default alpha and blend operation
-            this.geoCanvas.offscreenCtx.globalAlpha = 1.0
-            this.geoCanvas.offscreenCtx.globalCompositeOperation = this.defaultGlobalCompositeOperation
+            if (layer.alpha || layer.blendOperation) ctx.restore()
         }
 
         // one drawImage call: draw the offscreen canvas to the main canvas

package/src/index.js

@@ -23,6 +23,7 @@ export { SegmentStyle } from './style/SegmentStyle.js'
 export { TextStyle } from './style/TextStyle.js'
 export { PillarStyle } from './style/PillarStyle.js'
 export { SideStyle } from './style/SideStyle.js'
+export { ShadingRayStyle } from './style/ShadingRayStyle.js'
 export { ShadingStyle } from './style/ShadingStyle.js'
 export { SideCategoryStyle } from './style/SideCategoryStyle.js'
 export { DotDensityStyle } from './style/DotDensityStyle.js'
@@ -35,6 +36,7 @@ export { NinjaStarStyle } from './style/NinjaStarStyle.js'
 export { TimeSeriesStyle } from './style/TimeSeriesStyle.js'
 export { IsoFenceStyle } from './style/IsoFenceStyle.js'
 export { ImageStyle } from './style/ImageStyle.js'
+export { Interpolator } from './style/Interpolator.js'
 
 // export additional layers
 export { GridLayer } from './layer/GridLayer.js'
@@ -62,7 +64,7 @@ export { TernaryLegend } from './legend/TernaryLegend.js'
 export * from './utils/stretching.js'
 export * from './utils/scale.js'
 export * from './utils/ternary.js'
-export { nice } from './utils/utils.js'
+export { nice, cellsToMatrix } from './utils/utils.js'
 
 import { GeoCanvas } from './core/GeoCanvas.js'
 export const getParameterByName = GeoCanvas.getParameterByName

package/src/layer/GeoJSONLayer.js

@@ -30,6 +30,7 @@ export class GeoJSONLayer extends Layer {
         this.preprocess = opts.preprocess
 
         //for points
+
         /**
          * @private
          * @type {function(object,number):string} */
@@ -39,36 +40,32 @@ export class GeoJSONLayer extends Layer {
          * @private
          * @type {function(object,number):number} */
         this.size = opts.size || ((f, z) => 10)
-        /**
-         * @private
-         * @type {function(object,number):string} */
-        this.strokeStyle = opts.strokeStyle || ((f, z) => 'red')
-        /**
-         * @private
-         * @type {function(object,number):string} */
-        this.fillStyle = opts.fillStyle || ((f, z) => 'black')
-        /**
-         * In pixel
-         * @private
-         * @type {function(object,number):number} */
-        this.lineWidth = opts.lineWidth || ((f, z) => 2)
 
-        //for lines
+        // for lines and polygon outlines
 
         /**
          * @private
          * @type {function(object,number):string} */
-        this.color = opts.color || ((f, z) => 'gray')
+        this.strokeStyle = opts.strokeStyle || opts.color || ((f, z) => 'gray')
         /**
          * In pixel
          * @private
          * @type {function(object,number):number} */
-        this.width = opts.width || ((f, z) => 2)
+        this.lineWidth = opts.lineWidth || opts.width || ((f, z) => 2)
         /**
          * @private
          * @type {function(object,number):Array.<number>|undefined} */
         this.lineDash = opts.lineDash || ((f, z) => undefined)
 
+
+        // for polygon filling and point symbol filling
+        /**
+         * @private
+         * @type {function(object,number):string} */
+        this.fillStyle = opts.fillStyle || ((f, z) => 'black')
+
+
+
         /**
          * @private
          * @type {Array.<object> | undefined} */
@@ -96,81 +93,136 @@ export class GeoJSONLayer extends Layer {
         const z = geoCanvas.view.z
         const ctx = geoCanvas.offscreenCtx
 
-        for (const f of this.fs) {
-            const gt = f.geometry.type
-
-            if (gt == 'Point' || gt == 'MultiPoint') {
-
-                //get style parameters for the point feature
-                const shape = this.shape(f, z)
-                if (!shape || shape == 'none') continue
-                const size = this.size(f, z) * z
-                if (!size) continue
-                const strokeStyle = this.strokeStyle(f, z)
-                const fillStyle = this.fillStyle(f, z)
-                const lineWidth = this.lineWidth(f, z) * z
-
-                //set canvas drawing parameters
-                if (strokeStyle) ctx.strokeStyle = strokeStyle
-                if (fillStyle) ctx.fillStyle = fillStyle
-                if (lineWidth) ctx.lineWidth = lineWidth
-
-                let cs = f.geometry.coordinates
-                if (gt == 'Point') cs = [cs]
-
-                if (shape == 'circle') {
-                    //draw circle - fill and stroke
-                    for (const c of cs) {
-                        ctx.beginPath()
-                        ctx.arc(c[0], c[1], size / 2, 0, 2 * Math.PI, false)
-                        if (fillStyle) ctx.fill()
-                        if (strokeStyle && lineWidth) ctx.stroke()
-                    }
-                } else if (shape == 'square') {
-                    //draw square - fill and stroke
-                    for (const c of cs) {
-                        ctx.beginPath()
-                        ctx.rect(c[0] - size / 2, c[1] - size / 2, size, size)
-                        if (fillStyle) ctx.fill()
-                        if (strokeStyle && lineWidth) ctx.stroke()
-                    }
-                } else {
-                    console.error('Unexpected shape for point geojson: ' + shape)
+        // draw each feature
+        for (const f of this.fs)
+            this.drawGeometry(f, f.geometry, f.geometry.type, z, ctx)
+
+    }
+
+    /**
+     * @private
+     * Draw a geometry on the canvas, according to its type and the layer style.
+     * @param {object} f The feature to draw
+     * @param {object} geom The geometry of the feature to draw
+     * @param {string} gt The geometry type (e.g. 'Point', 'LineString', etc.)
+     * @param {number} z The current zoom level of the map
+     * @param {CanvasRenderingContext2D} ctx The canvas context to draw on
+     * @returns {void}
+     */
+    drawGeometry(f, geom, gt, z, ctx) {
+        if (gt == 'Point' || gt == 'MultiPoint') {
+
+            //get style parameters for the point feature
+            const shape = this.shape(f, z)
+            if (!shape || shape == 'none') return
+            const size = this.size(f, z) * z
+            if (!size) return
+
+            const strokeStyle = this.strokeStyle(f, z)
+            const fillStyle = this.fillStyle(f, z)
+            const lineWidth = this.lineWidth(f, z) * z
+
+            //set canvas drawing parameters
+            ctx.save()
+            if (strokeStyle) ctx.strokeStyle = strokeStyle
+            if (fillStyle) ctx.fillStyle = fillStyle
+            if (lineWidth) ctx.lineWidth = lineWidth
+
+            let cs = geom.coordinates
+            if (gt == 'Point') cs = [cs]
+
+            if (shape == 'circle') {
+                //draw circle - fill and stroke
+                for (const c of cs) {
+                    ctx.beginPath()
+                    ctx.arc(c[0], c[1], size / 2, 0, 2 * Math.PI, false)
+                    if (fillStyle) ctx.fill()
+                    if (strokeStyle && lineWidth) ctx.stroke()
+                }
+            } else if (shape == 'square') {
+                //draw square - fill and stroke
+                for (const c of cs) {
+                    ctx.beginPath()
+                    ctx.rect(c[0] - size / 2, c[1] - size / 2, size, size)
+                    if (fillStyle) ctx.fill()
+                    if (strokeStyle && lineWidth) ctx.stroke()
                 }
-            } else if (gt == 'LineString' || gt == 'MultiLineString') {
+            } else {
+                console.error('Unexpected shape for point GeoJSON: ' + shape)
+            }
+            ctx.restore()
+
+        } else if (gt == 'LineString' || gt == 'MultiLineString') {
 
-                //set color
-                const col = this.color(f, z)
-                if (!col || col == 'none') continue
-                ctx.strokeStyle = col
+            const col = this.strokeStyle(f, z)
+            if (!col || col === 'none') return
 
-                //set linewidth
-                const wP = this.width(f, z)
-                if (!wP || wP < 0) continue
-                ctx.lineWidth = wP * z
+            const wP = this.lineWidth(f, z)
+            if (!wP || wP < 0) return
 
-                //set line dash
-                const ldP = this.lineDash(f, z)
-                if (ldP) ctx.setLineDash(ldP)
+            ctx.save()
+            ctx.strokeStyle = col
+            ctx.lineWidth = wP * z
+            ctx.setLineDash(this.lineDash(f, z) || [])
+
+            //
+            const css = gt === 'LineString' ? [geom.coordinates] : geom.coordinates
+
+            for (const cs of css) {
+                if (cs.length < 2) continue
+                ctx.beginPath()
+                ctx.moveTo(cs[0][0], cs[0][1])
+                for (let i = 1; i < cs.length; i++) ctx.lineTo(cs[i][0], cs[i][1])
+                ctx.stroke()
+            }
 
-                let css = f.geometry.coordinates
-                if (gt == 'LineString') css = [css]
+            ctx.restore()
 
-                //draw lines
-                for (const cs of css) {
+        } else if (gt == 'Polygon' || gt == 'MultiPolygon') {
+            ctx.save()
+
+            // A Polygon is [ outerRing, ...holes ]. A MultiPolygon is [ [ outerRing, ...holes ], ... ]
+            const polygons = gt === 'Polygon' ? [geom.coordinates] : geom.coordinates
+
+            ctx.beginPath()
+
+            for (const rings of polygons) {
+                for (const cs of rings) {
                     if (cs.length < 2) continue
-                    ctx.beginPath()
                     ctx.moveTo(cs[0][0], cs[0][1])
                     for (let i = 1; i < cs.length; i++) ctx.lineTo(cs[i][0], cs[i][1])
+                    ctx.closePath()
+                }
+            }
+
+            // Fill
+            const fillStyle = this.fillStyle(f, z)
+            if (fillStyle && fillStyle !== 'none') {
+                ctx.fillStyle = fillStyle
+                ctx.fill('evenodd')         // even-odd punches holes correctly regardless of ring winding order
+            }
+
+            // Stroke (optional, only if style provides a width)
+            const wP = this.lineWidth(f, z)
+            if (wP && wP > 0) {
+                const strokeStyle = this.strokeStyle?.(f, z) ?? fillStyle
+                if (strokeStyle && strokeStyle !== 'none') {
+                    ctx.strokeStyle = strokeStyle
+                    ctx.lineWidth = wP * z
+                    ctx.setLineDash(this.lineDash?.(f, z) || [])
                     ctx.stroke()
                 }
-            } else {
-                console.log('Unsupported geometry type in GeoJSONLayer: ' + gt)
             }
-        }
+            ctx.restore()
+
+        } else if (gt == 'GeometryCollection') {
+            //recursive call for each geometry in the collection
+            for (const g of geom.geometries)
+                this.drawGeometry(f, g, g.type, z, ctx)
 
-        //...
-        ctx.setLineDash([])
+        } else {
+            console.log('Unexpected geometry type in GeoJSONLayer: ' + gt)
+        }
     }
 
     /**
@@ -180,7 +232,7 @@ export class GeoJSONLayer extends Layer {
      */
     async load(callback) {
         if (!this.url) {
-            console.log('Failed loading boundaries: No URL specified. ' + this.url)
+            console.log('Failed loading GeoJSON data: No URL specified. ' + this.url)
             this.loadingStatus = 'failed'
             this.labels = []
             return
@@ -216,7 +268,7 @@ export class GeoJSONLayer extends Layer {
             //redraw
             if (callback) callback()
         } catch (error) {
-            console.log('Failed loading boundaries from ' + this.url)
+            console.log('Failed loading GeoJSON from ' + this.url)
             this.fs = []
             this.loadingStatus = 'failed'
         }

package/src/layer/GridLayer.js

@@ -60,15 +60,26 @@ export class GridLayer extends Layer {
         //update dataset view cache
         dsc.updateViewCache(geoCanvas.extGeo)
 
+
+        //set layer alpha and blend mode
+        if (this.alpha || this.blendOperation) {
+            ctx.save()
+            if (this.alpha) ctx.globalAlpha = this.alpha(z)
+            if (this.blendOperation) ctx.globalCompositeOperation = this.blendOperation(z)
+        }
+
         //draw cells, style by style
         for (const s of this.styles) {
             //check if style is visible
             if (s.visible && !s.visible(z)) continue
 
-            //set style alpha and blend mode
-            //TODO: multiply by layer alpha ?
-            ctx.globalAlpha = s.alpha ? s.alpha(z) : 1.0
-            if (s.blendOperation) ctx.globalCompositeOperation = s.blendOperation(z)
+            // set style alpha and blend mode
+            //TODO: multiply style alpha by layer alpha ?
+            if (s.alpha || s.blendOperation) {
+                ctx.save()
+                if (s.alpha) ctx.globalAlpha = s.alpha(z)
+                if (s.blendOperation) ctx.globalCompositeOperation = s.blendOperation(z)
+            }
 
             //set affin transform to draw with geographical coordinates
             geoCanvas.setCanvasTransform()
@@ -78,8 +89,14 @@ export class GridLayer extends Layer {
 
             //draw style filter
             if (s.filterColor) s.drawFilter(geoCanvas)
+
+            //restore default alpha and blend operation - before style change
+            if (s.alpha || s.blendOperation) ctx.restore()
         }
 
+        //restore default alpha and blend operation - before layer change
+        if (this.alpha || this.blendOperation) ctx.restore()
+
         //add legend element
         if (legend) {
             for (const s of this.styles) {

package/src/legend/TernaryLegend.js

@@ -19,7 +19,7 @@ export class TernaryLegend extends Legend {
         this.classifier = opts.classifier
 
         this.width = opts.width || 150
-        this.selectionColor = this.selectionColor || 'red'
+        this.selectionColor = opts.selectionColor || 'red'
         this.tooltip = opts.tooltip
         this.texts = opts.texts
 

package/src/style/Interpolator.js

@@ -0,0 +1,258 @@
+//@ts-check
+'use strict'
+
+import { Style } from '../core/Style.js'
+import { cellsToMatrix } from '../utils/utils.js'
+
+/**
+ * @module style
+ * @author Julien Gaffuri
+ */
+export class Interpolator extends Style {
+    /** @param {object} opts */
+    constructor(opts) {
+        super(opts)
+        opts = opts || {}
+
+        /** The cell value to interpolate
+         * @type { function } } */
+        this.value = opts.value //(c) => elevation
+
+        /** The target resolution. As a function (resolution, z) => targetResolution
+         * NB: Try to make sure that resolution/targetResolution is an integer.
+         * @type { function } } */
+        this.targetResolution = opts.targetResolution || ((r, z) => r / 5)
+
+        /** the property name to store the interpolated value in the cell
+         * @type { string } } */
+        this.interpolatedProperty = opts.interpolatedProperty || 'value'
+
+        // the interpolation method: currently only 'bilinear' is supported
+        //this.method = opts.method || 'bilinear' // 'nearest', 'bilinear'
+
+        /** when a neighbor cell has no value, take zero value or average of surrounding cells
+         * @type { string } } */
+        this.nodataHandling = opts.nodataHandling || "zero" // 'zero', 'average'
+
+        /** The styles to represent the interpolated grid.
+         * @type {Array.<Style>} */
+        this.styles = opts.styles || []
+    }
+
+
+    /**
+     *
+     * @param {Array.<import("../core/Dataset.js").Cell>} cells
+     * @param {import("../core/GeoCanvas.js").GeoCanvas} geoCanvas
+     * @param {number} resolution
+     */
+    draw(cells, geoCanvas, resolution) {
+
+        //filter cells
+        if (this.filter) cells = cells.filter(this.filter)
+        if (cells.length == 0) return;
+
+        //
+        const z = geoCanvas.view.z
+
+        //get view scale
+        //const viewScale = this.viewScale ? this.viewScale(cells, resolution, z) : undefined
+
+        //index cells by y and x
+        let m = cellsToMatrix(cells, resolution, c => this.value(c))
+        const x0 = m.x0, y0 = m.y0
+
+        //get target resolution and scale factor
+        let targetResolution = this.targetResolution(resolution, z)
+        const scaleFactor = Math.round(resolution / targetResolution)
+        targetResolution = resolution / scaleFactor
+
+        // compute ray casting shadow
+        m = bilinearInterpolator(m, scaleFactor, this.nodataHandling);
+
+        // make cells
+        cells = []
+        const ra = (resolution - targetResolution) / 2
+        for (let i = 0; i < m.length; i++) {
+            const row = m[i]
+            const y = y0 - i * targetResolution + ra
+            for (let j = 0; j < row.length; j++) {
+                const v = row[j]
+                if (!v) continue
+                const c = { x: x0 + j * targetResolution + ra, y: y }
+                c[this.interpolatedProperty] = v
+                cells.push(c)
+            }
+        }
+
+        //draw smoothed cells from styles
+        const ctx = geoCanvas.offscreenCtx
+        for (let s of this.styles) {
+
+            //check if style is visible
+            if (s.visible && !s.visible(z)) continue
+
+            //set style alpha and blend mode
+            //TODO: multiply by layer alpha ?
+            if (s.alpha || s.blendOperation) {
+                ctx.save()
+                if (s.alpha) ctx.globalAlpha = s.alpha(z)
+                if (s.blendOperation) ctx.globalCompositeOperation = s.blendOperation(z)
+            }
+
+            //set affin transform to draw with geographical coordinates
+            geoCanvas.setCanvasTransform()
+
+            //draw with style
+            s.draw(cells, geoCanvas, targetResolution)
+
+            //draw style filter
+            if (s.filterColor) s.drawFilter(geoCanvas)
+
+            //restore ctx
+            if (s.alpha || s.blendOperation) ctx.restore()
+        }
+
+    }
+}
+
+
+const interp = (topLeft, topRight, bottomLeft, bottomRight, xRatio, yRatio) => {
+    const top = topLeft + (topRight - topLeft) * xRatio;
+    const bottom = bottomLeft + (bottomRight - bottomLeft) * xRatio;
+    return top + (bottom - top) * yRatio;
+}
+
+
+function bilinearInterpolator(grid, scaleFactor = 5, nodataHandling = "zero") {
+
+    if (scaleFactor === 1) return grid;
+
+    // input grid dimensions
+    const rows = grid.length;
+    if (rows === 0) return [];
+    const cols = grid[0].length;
+
+    // output grid dimensions
+    const fineRows = rows * scaleFactor;
+    const fineCols = cols * scaleFactor;
+    const fineGrid = Array(fineRows).fill().map(() => Array(fineCols).fill(undefined));
+
+    // check if scale factor is even
+    const sfIsEven = scaleFactor % 2 === 0
+
+    //compute output grid values
+    for (let i = 0; i < fineRows; i++) {
+
+        const coarseI = Math.min(Math.floor(i / scaleFactor), rows - 2);
+        const yRatio = (i % scaleFactor) / scaleFactor;
+        const i_ = coarseI * scaleFactor + (scaleFactor / 2)
+
+        for (let j = 0; j < fineCols; j++) {
+            const coarseJ = Math.min(Math.floor(j / scaleFactor), cols - 2);
+            const xRatio = (j % scaleFactor) / scaleFactor;
+            const j_ = coarseJ * scaleFactor + (scaleFactor / 2)
+
+            // get four corner values
+            const topLeft = grid[coarseI][coarseJ];
+            const topRight = grid[coarseI][coarseJ + 1];
+            const bottomLeft = grid[coarseI + 1][coarseJ];
+            const bottomRight = grid[coarseI + 1][coarseJ + 1];
+
+
+            if (sfIsEven) {
+                if (topLeft === undefined && i <= i_ && j <= j_) continue
+                if (topRight === undefined && i <= i_ && j >= j_) continue
+                if (bottomLeft === undefined && i >= i_ && j <= j_) continue
+                if (bottomRight === undefined && i >= i_ && j >= j_) continue
+            } else {
+                if (topLeft === undefined && i < i_ && j < j_) continue
+                if (topRight === undefined && i < i_ && j > j_) continue
+                if (bottomLeft === undefined && i > i_ && j < j_) continue
+                if (bottomRight === undefined && i > i_ && j > j_) continue
+            }
+
+            if(nodataHandling === "zero") {
+                // replace undefined values by zero
+                fineGrid[i][j] = interp(topLeft || 0, topRight || 0, bottomLeft || 0, bottomRight || 0, xRatio, yRatio)
+                continue
+            }
+
+            // general case: bilinear interpolation
+            // If all four are defined, interpolate normally
+            if (topLeft !== undefined && topRight !== undefined && bottomLeft !== undefined && bottomRight !== undefined) {
+                fineGrid[i][j] = interp(topLeft, topRight, bottomLeft, bottomRight, xRatio, yRatio)
+                continue
+            }
+
+            // If only one is not defined, use average value of 2 adjacents and interpolate
+            if (topLeft === undefined && topRight !== undefined && bottomLeft !== undefined && bottomRight !== undefined) {
+                const v = topRight + bottomLeft
+                fineGrid[i][j] = interp(v / 2, topRight, bottomLeft, bottomRight, xRatio, yRatio)
+                continue
+            }
+            if (topLeft !== undefined && topRight === undefined && bottomLeft !== undefined && bottomRight !== undefined) {
+                const v = topLeft + bottomRight
+                fineGrid[i][j] = interp(topLeft, v / 2, bottomLeft, bottomRight, xRatio, yRatio)
+                continue
+            }
+            if (topLeft !== undefined && topRight !== undefined && bottomLeft === undefined && bottomRight !== undefined) {
+                const v = topLeft + bottomRight
+                fineGrid[i][j] = interp(topLeft, topRight, v / 2, bottomRight, xRatio, yRatio)
+                continue
+            }
+            if (topLeft !== undefined && topRight !== undefined && bottomLeft !== undefined && bottomRight === undefined) {
+                const v = topRight + bottomLeft
+                fineGrid[i][j] = interp(topLeft, topRight, bottomLeft, v / 2, xRatio, yRatio)
+                continue
+            }
+
+            // If only two diagonally opposite points are defined, interpolate along diagonal
+            if (topLeft !== undefined && bottomRight !== undefined) {
+                const t = (xRatio + yRatio) * Math.SQRT1_2
+                fineGrid[i][j] = topLeft * (1 - t) + bottomRight * t;
+                continue
+            }
+            if (topRight !== undefined && bottomLeft !== undefined) {
+                const t = (1 - xRatio + yRatio) * Math.SQRT1_2
+                fineGrid[i][j] = topRight * (1 - t) + bottomLeft * t;
+                continue
+            }
+
+            // If only two adjacent points are defined, interpolate between them
+            if (topLeft !== undefined && bottomLeft !== undefined) {
+                fineGrid[i][j] = bottomLeft * yRatio + topLeft * (1 - yRatio);
+                continue
+            }
+            if (topRight !== undefined && bottomRight !== undefined) {
+                fineGrid[i][j] = bottomRight * yRatio + topRight * (1 - yRatio);
+                continue
+            }
+            if (topLeft !== undefined && topRight !== undefined) {
+                fineGrid[i][j] = topRight * xRatio + topLeft * (1 - xRatio);
+            }
+            if (bottomLeft !== undefined && bottomRight !== undefined) {
+                fineGrid[i][j] = bottomRight * xRatio + bottomLeft * (1 - xRatio);
+                continue
+            }
+
+            // If only one point is defined, use that value
+            if (topLeft !== undefined) {
+                fineGrid[i][j] = topLeft;
+                continue
+            }
+            if (topRight !== undefined) {
+                fineGrid[i][j] = topRight;
+                continue
+            }
+            if (bottomLeft !== undefined) {
+                fineGrid[i][j] = bottomLeft;
+                continue
+            }
+            if (bottomRight !== undefined) {
+                fineGrid[i][j] = bottomRight;
+            }
+        }
+    }
+    return fineGrid;
+}