@gisatcz/deckgl-geolib 1.10.1-dev.0 → 1.10.1-dev.1

package/dist/cjs/index.js

@@ -14987,7 +14987,750 @@ async function fromArrayBuffer(arrayBuffer, signal) {
   return GeoTIFF.fromSource(makeBufferSource(arrayBuffer), signal);
 }
 
+class Martini {
+    constructor(gridSize = 257) {
+        this.gridSize = gridSize;
+        const tileSize = gridSize - 1;
+        if (tileSize & (tileSize - 1)) throw new Error(
+            `Expected grid size to be 2^n+1, got ${gridSize}.`);
+
+        this.numTriangles = tileSize * tileSize * 2 - 2;
+        this.numParentTriangles = this.numTriangles - tileSize * tileSize;
+
+        this.indices = new Uint32Array(this.gridSize * this.gridSize);
+
+        // coordinates for all possible triangles in an RTIN tile
+        this.coords = new Uint16Array(this.numTriangles * 4);
+
+        // get triangle coordinates from its index in an implicit binary tree
+        for (let i = 0; i < this.numTriangles; i++) {
+            let id = i + 2;
+            let ax = 0, ay = 0, bx = 0, by = 0, cx = 0, cy = 0;
+            if (id & 1) {
+                bx = by = cx = tileSize; // bottom-left triangle
+            } else {
+                ax = ay = cy = tileSize; // top-right triangle
+            }
+            while ((id >>= 1) > 1) {
+                const mx = (ax + bx) >> 1;
+                const my = (ay + by) >> 1;
+
+                if (id & 1) { // left half
+                    bx = ax; by = ay;
+                    ax = cx; ay = cy;
+                } else { // right half
+                    ax = bx; ay = by;
+                    bx = cx; by = cy;
+                }
+                cx = mx; cy = my;
+            }
+            const k = i * 4;
+            this.coords[k + 0] = ax;
+            this.coords[k + 1] = ay;
+            this.coords[k + 2] = bx;
+            this.coords[k + 3] = by;
+        }
+    }
+
+    createTile(terrain) {
+        return new Tile(terrain, this);
+    }
+}
+
+class Tile {
+    constructor(terrain, martini) {
+        const size = martini.gridSize;
+        if (terrain.length !== size * size) throw new Error(
+            `Expected terrain data of length ${size * size} (${size} x ${size}), got ${terrain.length}.`);
+
+        this.terrain = terrain;
+        this.martini = martini;
+        this.errors = new Float32Array(terrain.length);
+        this.update();
+    }
+
+    update() {
+        const {numTriangles, numParentTriangles, coords, gridSize: size} = this.martini;
+        const {terrain, errors} = this;
+
+        // iterate over all possible triangles, starting from the smallest level
+        for (let i = numTriangles - 1; i >= 0; i--) {
+            const k = i * 4;
+            const ax = coords[k + 0];
+            const ay = coords[k + 1];
+            const bx = coords[k + 2];
+            const by = coords[k + 3];
+            const mx = (ax + bx) >> 1;
+            const my = (ay + by) >> 1;
+            const cx = mx + my - ay;
+            const cy = my + ax - mx;
+
+            // calculate error in the middle of the long edge of the triangle
+            const interpolatedHeight = (terrain[ay * size + ax] + terrain[by * size + bx]) / 2;
+            const middleIndex = my * size + mx;
+            const middleError = Math.abs(interpolatedHeight - terrain[middleIndex]);
+
+            errors[middleIndex] = Math.max(errors[middleIndex], middleError);
+
+            if (i < numParentTriangles) { // bigger triangles; accumulate error with children
+                const leftChildIndex = ((ay + cy) >> 1) * size + ((ax + cx) >> 1);
+                const rightChildIndex = ((by + cy) >> 1) * size + ((bx + cx) >> 1);
+                errors[middleIndex] = Math.max(errors[middleIndex], errors[leftChildIndex], errors[rightChildIndex]);
+            }
+        }
+    }
+
+    getMesh(maxError = 0) {
+        const {gridSize: size, indices} = this.martini;
+        const {errors} = this;
+        let numVertices = 0;
+        let numTriangles = 0;
+        const max = size - 1;
+
+        // use an index grid to keep track of vertices that were already used to avoid duplication
+        indices.fill(0);
+
+        // retrieve mesh in two stages that both traverse the error map:
+        // - countElements: find used vertices (and assign each an index), and count triangles (for minimum allocation)
+        // - processTriangle: fill the allocated vertices & triangles typed arrays
+
+        function countElements(ax, ay, bx, by, cx, cy) {
+            const mx = (ax + bx) >> 1;
+            const my = (ay + by) >> 1;
+
+            if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
+                countElements(cx, cy, ax, ay, mx, my);
+                countElements(bx, by, cx, cy, mx, my);
+            } else {
+                indices[ay * size + ax] = indices[ay * size + ax] || ++numVertices;
+                indices[by * size + bx] = indices[by * size + bx] || ++numVertices;
+                indices[cy * size + cx] = indices[cy * size + cx] || ++numVertices;
+                numTriangles++;
+            }
+        }
+        countElements(0, 0, max, max, max, 0);
+        countElements(max, max, 0, 0, 0, max);
+
+        const vertices = new Uint16Array(numVertices * 2);
+        const triangles = new Uint32Array(numTriangles * 3);
+        let triIndex = 0;
+
+        function processTriangle(ax, ay, bx, by, cx, cy) {
+            const mx = (ax + bx) >> 1;
+            const my = (ay + by) >> 1;
+
+            if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
+                // triangle doesn't approximate the surface well enough; drill down further
+                processTriangle(cx, cy, ax, ay, mx, my);
+                processTriangle(bx, by, cx, cy, mx, my);
+
+            } else {
+                // add a triangle
+                const a = indices[ay * size + ax] - 1;
+                const b = indices[by * size + bx] - 1;
+                const c = indices[cy * size + cx] - 1;
+
+                vertices[2 * a] = ax;
+                vertices[2 * a + 1] = ay;
+
+                vertices[2 * b] = bx;
+                vertices[2 * b + 1] = by;
+
+                vertices[2 * c] = cx;
+                vertices[2 * c + 1] = cy;
+
+                triangles[triIndex++] = a;
+                triangles[triIndex++] = b;
+                triangles[triIndex++] = c;
+            }
+        }
+        processTriangle(0, 0, max, max, max, 0);
+        processTriangle(max, max, 0, 0, 0, max);
+
+        return {vertices, triangles};
+    }
+}
+
+function getMeshBoundingBox(attributes) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  const positions = attributes.POSITION ? attributes.POSITION.value : [];
+  const len = positions && positions.length;
+  for (let i = 0; i < len; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    minX = x < minX ? x : minX;
+    minY = y < minY ? y : minY;
+    minZ = z < minZ ? z : minZ;
+    maxX = x > maxX ? x : maxX;
+    maxY = y > maxY ? y : maxY;
+    maxZ = z > maxZ ? z : maxZ;
+  }
+  return [[minX, minY, minZ], [maxX, maxY, maxZ]];
+}
+
+function concatenateTypedArrays() {
+  for (var _len2 = arguments.length, typedArrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    typedArrays[_key2] = arguments[_key2];
+  }
+  const arrays = typedArrays;
+  const TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
+  if (!TypedArrayConstructor) {
+    throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
+  }
+  const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
+  const result = new TypedArrayConstructor(sumLength);
+  let offset = 0;
+  for (const array of arrays) {
+    result.set(array, offset);
+    offset += array.length;
+  }
+  return result;
+}
+
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Add skirt to existing mesh
+ * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
+ * @param {any} triangles - indices array of the mesh geometry
+ * @param skirtHeight - height of the skirt geometry
+ * @param outsideIndices - edge indices from quantized mesh data
+ * @returns - geometry data with added skirt
+ */
+function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
+    const outsideEdges = outsideIndices
+        ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value)
+        : getOutsideEdgesFromTriangles(triangles);
+    // 2 new vertices for each outside edge
+    const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);
+    const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);
+    // 2 new triangles for each outside edge
+    const newTriangles = new triangles.constructor(outsideEdges.length * 6);
+    for (let i = 0; i < outsideEdges.length; i++) {
+        const edge = outsideEdges[i];
+        updateAttributesForNewEdge({
+            edge,
+            edgeIndex: i,
+            attributes,
+            skirtHeight,
+            newPosition,
+            newTexcoord0,
+            newTriangles,
+        });
+    }
+    attributes.POSITION.value = concatenateTypedArrays(attributes.POSITION.value, newPosition);
+    attributes.TEXCOORD_0.value = concatenateTypedArrays(attributes.TEXCOORD_0.value, newTexcoord0);
+    const resultTriangles = triangles instanceof Array
+        ? triangles.concat(newTriangles)
+        : concatenateTypedArrays(triangles, newTriangles);
+    return {
+        attributes,
+        triangles: resultTriangles,
+    };
+}
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {any} triangles - indices array of the mesh geometry
+ * @returns {number[][]} - outside edges data
+ */
+function getOutsideEdgesFromTriangles(triangles) {
+    var _a, _b;
+    const edges = [];
+    for (let i = 0; i < triangles.length; i += 3) {
+        edges.push([triangles[i], triangles[i + 1]]);
+        edges.push([triangles[i + 1], triangles[i + 2]]);
+        edges.push([triangles[i + 2], triangles[i]]);
+    }
+    edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
+    const outsideEdges = [];
+    let index = 0;
+    while (index < edges.length) {
+        if (edges[index][0] === ((_a = edges[index + 1]) === null || _a === void 0 ? void 0 : _a[1]) && edges[index][1] === ((_b = edges[index + 1]) === null || _b === void 0 ? void 0 : _b[0])) {
+            index += 2;
+        }
+        else {
+            outsideEdges.push(edges[index]);
+            index++;
+        }
+    }
+    return outsideEdges;
+}
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {object} indices - edge indices from quantized mesh data
+ * @param {TypedArray} position - position attribute geometry data
+ * @returns {number[][]} - outside edges data
+ */
+function getOutsideEdgesFromIndices(indices, position) {
+    // Sort skirt indices to create adjacent triangles
+    indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
+    // Reverse (b - a) to match triangle winding
+    indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
+    indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
+    // Reverse (b - a) to match triangle winding
+    indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
+    const edges = [];
+    for (const index in indices) {
+        const indexGroup = indices[index];
+        for (let i = 0; i < indexGroup.length - 1; i++) {
+            edges.push([indexGroup[i], indexGroup[i + 1]]);
+        }
+    }
+    return edges;
+}
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {object} args
+ * @param {number[]} args.edge - edge indices in geometry
+ * @param {number} args.edgeIndex - edge index in outsideEdges array
+ * @param {object} args.attributes - POSITION and TEXCOORD_0 attributes
+ * @param {number} args.skirtHeight - height of the skirt geometry
+ * @param {TypedArray} args.newPosition - POSITION array for skirt data
+ * @param {TypedArray} args.newTexcoord0 - TEXCOORD_0 array for skirt data
+ * @param {TypedArray | Array} args.newTriangles - trinagle indices array for skirt data
+ * @returns {void}
+ */
+function updateAttributesForNewEdge({ edge, edgeIndex, attributes, skirtHeight, newPosition, newTexcoord0, newTriangles, }) {
+    const positionsLength = attributes.POSITION.value.length;
+    const vertex1Offset = edgeIndex * 2;
+    const vertex2Offset = edgeIndex * 2 + 1;
+    // Define POSITION for new 1st vertex
+    newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
+    newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
+    // Define POSITION for new 2nd vertex
+    newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
+    newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
+    // Use same TEXCOORDS for skirt vertices
+    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2), vertex1Offset * 2);
+    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2), vertex2Offset * 2);
+    // Define new triangles
+    const triangle1Offset = edgeIndex * 2 * 3;
+    newTriangles[triangle1Offset] = edge[0];
+    newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 2] = edge[1];
+    newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 4] = edge[0];
+    newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
+}
+
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// ISC License
+// Copyright(c) 2019, Michael Fogleman, Vladimir Agafonkin
+// @ts-nocheck
+/* eslint-disable complexity, max-params, max-statements, max-depth, no-constant-condition */
+class Delatin {
+    constructor(data, width, height = width) {
+        this.data = data; // height data
+        this.width = width;
+        this.height = height;
+        this.coords = []; // vertex coordinates (x, y)
+        this.triangles = []; // mesh triangle indices
+        // additional triangle data
+        this._halfedges = [];
+        this._candidates = [];
+        this._queueIndices = [];
+        this._queue = []; // queue of added triangles
+        this._errors = [];
+        this._rms = [];
+        this._pending = []; // triangles pending addition to queue
+        this._pendingLen = 0;
+        this._rmsSum = 0;
+        const x1 = width - 1;
+        const y1 = height - 1;
+        const p0 = this._addPoint(0, 0);
+        const p1 = this._addPoint(x1, 0);
+        const p2 = this._addPoint(0, y1);
+        const p3 = this._addPoint(x1, y1);
+        // add initial two triangles
+        const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
+        this._addTriangle(p0, p3, p1, t0, -1, -1);
+        this._flush();
+    }
+    // refine the mesh until its maximum error gets below the given one
+    run(maxError = 1) {
+        while (this.getMaxError() > maxError) {
+            this.refine();
+        }
+    }
+    // refine the mesh with a single point
+    refine() {
+        this._step();
+        this._flush();
+    }
+    // max error of the current mesh
+    getMaxError() {
+        return this._errors[0];
+    }
+    // root-mean-square deviation of the current mesh
+    getRMSD() {
+        return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
+    }
+    // height value at a given position
+    heightAt(x, y) {
+        return this.data[this.width * y + x];
+    }
+    // rasterize and queue all triangles that got added or updated in _step
+    _flush() {
+        const { coords } = this;
+        for (let i = 0; i < this._pendingLen; i++) {
+            const t = this._pending[i];
+            // rasterize triangle to find maximum pixel error
+            const a = 2 * this.triangles[t * 3 + 0];
+            const b = 2 * this.triangles[t * 3 + 1];
+            const c = 2 * this.triangles[t * 3 + 2];
+            this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
+        }
+        this._pendingLen = 0;
+    }
+    // rasterize a triangle, find its max error, and queue it for processing
+    _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
+        // triangle bounding box
+        const minX = Math.min(p0x, p1x, p2x);
+        const minY = Math.min(p0y, p1y, p2y);
+        const maxX = Math.max(p0x, p1x, p2x);
+        const maxY = Math.max(p0y, p1y, p2y);
+        // forward differencing variables
+        let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
+        let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
+        let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
+        const a01 = p1y - p0y;
+        const b01 = p0x - p1x;
+        const a12 = p2y - p1y;
+        const b12 = p1x - p2x;
+        const a20 = p0y - p2y;
+        const b20 = p2x - p0x;
+        // pre-multiplied z values at vertices
+        const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
+        const z0 = this.heightAt(p0x, p0y) / a;
+        const z1 = this.heightAt(p1x, p1y) / a;
+        const z2 = this.heightAt(p2x, p2y) / a;
+        // iterate over pixels in bounding box
+        let maxError = 0;
+        let mx = 0;
+        let my = 0;
+        let rms = 0;
+        for (let y = minY; y <= maxY; y++) {
+            // compute starting offset
+            let dx = 0;
+            if (w00 < 0 && a12 !== 0) {
+                dx = Math.max(dx, Math.floor(-w00 / a12));
+            }
+            if (w01 < 0 && a20 !== 0) {
+                dx = Math.max(dx, Math.floor(-w01 / a20));
+            }
+            if (w02 < 0 && a01 !== 0) {
+                dx = Math.max(dx, Math.floor(-w02 / a01));
+            }
+            let w0 = w00 + a12 * dx;
+            let w1 = w01 + a20 * dx;
+            let w2 = w02 + a01 * dx;
+            let wasInside = false;
+            for (let x = minX + dx; x <= maxX; x++) {
+                // check if inside triangle
+                if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
+                    wasInside = true;
+                    // compute z using barycentric coordinates
+                    const z = z0 * w0 + z1 * w1 + z2 * w2;
+                    const dz = Math.abs(z - this.heightAt(x, y));
+                    rms += dz * dz;
+                    if (dz > maxError) {
+                        maxError = dz;
+                        mx = x;
+                        my = y;
+                    }
+                }
+                else if (wasInside) {
+                    break;
+                }
+                w0 += a12;
+                w1 += a20;
+                w2 += a01;
+            }
+            w00 += b12;
+            w01 += b20;
+            w02 += b01;
+        }
+        if ((mx === p0x && my === p0y) || (mx === p1x && my === p1y) || (mx === p2x && my === p2y)) {
+            maxError = 0;
+        }
+        // update triangle metadata
+        this._candidates[2 * t] = mx;
+        this._candidates[2 * t + 1] = my;
+        this._rms[t] = rms;
+        // add triangle to priority queue
+        this._queuePush(t, maxError, rms);
+    }
+    // process the next triangle in the queue, splitting it with a new point
+    _step() {
+        // pop triangle with highest error from priority queue
+        const t = this._queuePop();
+        const e0 = t * 3 + 0;
+        const e1 = t * 3 + 1;
+        const e2 = t * 3 + 2;
+        const p0 = this.triangles[e0];
+        const p1 = this.triangles[e1];
+        const p2 = this.triangles[e2];
+        const ax = this.coords[2 * p0];
+        const ay = this.coords[2 * p0 + 1];
+        const bx = this.coords[2 * p1];
+        const by = this.coords[2 * p1 + 1];
+        const cx = this.coords[2 * p2];
+        const cy = this.coords[2 * p2 + 1];
+        const px = this._candidates[2 * t];
+        const py = this._candidates[2 * t + 1];
+        const pn = this._addPoint(px, py);
+        if (orient(ax, ay, bx, by, px, py) === 0) {
+            this._handleCollinear(pn, e0);
+        }
+        else if (orient(bx, by, cx, cy, px, py) === 0) {
+            this._handleCollinear(pn, e1);
+        }
+        else if (orient(cx, cy, ax, ay, px, py) === 0) {
+            this._handleCollinear(pn, e2);
+        }
+        else {
+            const h0 = this._halfedges[e0];
+            const h1 = this._halfedges[e1];
+            const h2 = this._halfedges[e2];
+            const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
+            const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
+            const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
+            this._legalize(t0);
+            this._legalize(t1);
+            this._legalize(t2);
+        }
+    }
+    // add coordinates for a new vertex
+    _addPoint(x, y) {
+        const i = this.coords.length >> 1;
+        this.coords.push(x, y);
+        return i;
+    }
+    // add or update a triangle in the mesh
+    _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
+        const t = e / 3; // new triangle index
+        // add triangle vertices
+        this.triangles[e + 0] = a;
+        this.triangles[e + 1] = b;
+        this.triangles[e + 2] = c;
+        // add triangle halfedges
+        this._halfedges[e + 0] = ab;
+        this._halfedges[e + 1] = bc;
+        this._halfedges[e + 2] = ca;
+        // link neighboring halfedges
+        if (ab >= 0) {
+            this._halfedges[ab] = e + 0;
+        }
+        if (bc >= 0) {
+            this._halfedges[bc] = e + 1;
+        }
+        if (ca >= 0) {
+            this._halfedges[ca] = e + 2;
+        }
+        // init triangle metadata
+        this._candidates[2 * t + 0] = 0;
+        this._candidates[2 * t + 1] = 0;
+        this._queueIndices[t] = -1;
+        this._rms[t] = 0;
+        // add triangle to pending queue for later rasterization
+        this._pending[this._pendingLen++] = t;
+        // return first halfedge index
+        return e;
+    }
+    _legalize(a) {
+        // if the pair of triangles doesn't satisfy the Delaunay condition
+        // (p1 is inside the circumcircle of [p0, pl, pr]), flip them,
+        // then do the same check/flip recursively for the new pair of triangles
+        //
+        //           pl                    pl
+        //          /||\                  /  \
+        //       al/ || \bl            al/    \a
+        //        /  ||  \              /      \
+        //       /  a||b  \    flip    /___ar___\
+        //     p0\   ||   /p1   =>   p0\---bl---/p1
+        //        \  ||  /              \      /
+        //       ar\ || /br             b\    /br
+        //          \||/                  \  /
+        //           pr                    pr
+        const b = this._halfedges[a];
+        if (b < 0) {
+            return;
+        }
+        const a0 = a - (a % 3);
+        const b0 = b - (b % 3);
+        const al = a0 + ((a + 1) % 3);
+        const ar = a0 + ((a + 2) % 3);
+        const bl = b0 + ((b + 2) % 3);
+        const br = b0 + ((b + 1) % 3);
+        const p0 = this.triangles[ar];
+        const pr = this.triangles[a];
+        const pl = this.triangles[al];
+        const p1 = this.triangles[bl];
+        const { coords } = this;
+        if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
+            return;
+        }
+        const hal = this._halfedges[al];
+        const har = this._halfedges[ar];
+        const hbl = this._halfedges[bl];
+        const hbr = this._halfedges[br];
+        this._queueRemove(a0 / 3);
+        this._queueRemove(b0 / 3);
+        const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
+        const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
+        this._legalize(t0 + 1);
+        this._legalize(t1 + 2);
+    }
+    // handle a case where new vertex is on the edge of a triangle
+    _handleCollinear(pn, a) {
+        const a0 = a - (a % 3);
+        const al = a0 + ((a + 1) % 3);
+        const ar = a0 + ((a + 2) % 3);
+        const p0 = this.triangles[ar];
+        const pr = this.triangles[a];
+        const pl = this.triangles[al];
+        const hal = this._halfedges[al];
+        const har = this._halfedges[ar];
+        const b = this._halfedges[a];
+        if (b < 0) {
+            const t0 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
+            const t1 = this._addTriangle(p0, pn, pl, t0, -1, hal);
+            this._legalize(t0 + 1);
+            this._legalize(t1 + 2);
+            return;
+        }
+        const b0 = b - (b % 3);
+        const bl = b0 + ((b + 2) % 3);
+        const br = b0 + ((b + 1) % 3);
+        const p1 = this.triangles[bl];
+        const hbl = this._halfedges[bl];
+        const hbr = this._halfedges[br];
+        this._queueRemove(b0 / 3);
+        const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
+        const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
+        const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
+        const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
+        this._legalize(t0);
+        this._legalize(t1);
+        this._legalize(t2);
+        this._legalize(t3);
+    }
+    // priority queue methods
+    _queuePush(t, error, rms) {
+        const i = this._queue.length;
+        this._queueIndices[t] = i;
+        this._queue.push(t);
+        this._errors.push(error);
+        this._rmsSum += rms;
+        this._queueUp(i);
+    }
+    _queuePop() {
+        const n = this._queue.length - 1;
+        this._queueSwap(0, n);
+        this._queueDown(0, n);
+        return this._queuePopBack();
+    }
+    _queuePopBack() {
+        const t = this._queue.pop();
+        this._errors.pop();
+        this._rmsSum -= this._rms[t];
+        this._queueIndices[t] = -1;
+        return t;
+    }
+    _queueRemove(t) {
+        const i = this._queueIndices[t];
+        if (i < 0) {
+            const it = this._pending.indexOf(t);
+            if (it !== -1) {
+                this._pending[it] = this._pending[--this._pendingLen];
+            }
+            else {
+                throw new Error('Broken triangulation (something went wrong).');
+            }
+            return;
+        }
+        const n = this._queue.length - 1;
+        if (n !== i) {
+            this._queueSwap(i, n);
+            if (!this._queueDown(i, n)) {
+                this._queueUp(i);
+            }
+        }
+        this._queuePopBack();
+    }
+    _queueLess(i, j) {
+        return this._errors[i] > this._errors[j];
+    }
+    _queueSwap(i, j) {
+        const pi = this._queue[i];
+        const pj = this._queue[j];
+        this._queue[i] = pj;
+        this._queue[j] = pi;
+        this._queueIndices[pi] = j;
+        this._queueIndices[pj] = i;
+        const e = this._errors[i];
+        this._errors[i] = this._errors[j];
+        this._errors[j] = e;
+    }
+    _queueUp(j0) {
+        let j = j0;
+        while (true) {
+            const i = (j - 1) >> 1;
+            if (i === j || !this._queueLess(j, i)) {
+                break;
+            }
+            this._queueSwap(i, j);
+            j = i;
+        }
+    }
+    _queueDown(i0, n) {
+        let i = i0;
+        while (true) {
+            const j1 = 2 * i + 1;
+            if (j1 >= n || j1 < 0) {
+                break;
+            }
+            const j2 = j1 + 1;
+            let j = j1;
+            if (j2 < n && this._queueLess(j2, j1)) {
+                j = j2;
+            }
+            if (!this._queueLess(j, i)) {
+                break;
+            }
+            this._queueSwap(i, j);
+            i = j;
+        }
+        return i > i0;
+    }
+}
+function orient(ax, ay, bx, by, cx, cy) {
+    return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
+}
+function inCircle(ax, ay, bx, by, cx, cy, px, py) {
+    const dx = ax - px;
+    const dy = ay - py;
+    const ex = bx - px;
+    const ey = by - py;
+    const fx = cx - px;
+    const fy = cy - py;
+    const ap = dx * dx + dy * dy;
+    const bp = ex * ex + ey * ey;
+    const cp = fx * fx + fy * fy;
+    return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
+}
+
 /* eslint 'max-len': [1, { code: 105, comments: 999, ignoreStrings: true, ignoreUrls: true }] */
+const tesselator = 'martini';
 const DefaultGeoImageOptions = {
     type: 'image',
     format: 'uint8',
@@ -15034,6 +15777,7 @@ class GeoImage {
     getMap(input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const mergedOptions = Object.assign(Object.assign({}, DefaultGeoImageOptions), options);
+            console.log('xxx_mergedOptions', mergedOptions);
             switch (mergedOptions.type) {
                 case 'image':
                     return this.getBitmap(input, mergedOptions);
@@ -15066,32 +15810,111 @@ class GeoImage {
             let channel = rasters[0];
             if (options.useChannel != null) {
                 if (rasters[options.useChannel]) {
-                    channel = rasters[options.useChannel];
+                    channel = rasters[options.useChannel]; // length = 65536
                 }
             }
-            const canvas = document.createElement('canvas');
-            canvas.width = width;
-            canvas.height = height;
-            const c = canvas.getContext('2d');
-            const imageData = c.createImageData(width, height);
+            // const canvas = document.createElement('canvas');
+            // canvas.width = width;
+            // canvas.height = height;
+            // // const c = canvas.getContext('2d');
+            // // const imageData = c!.createImageData(width, height);
+            // const terrain = new Float32Array((width + 1) * (height + 1));
+            const terrain = new Float32Array((width + 1) * (height + 1)); // length = 66049
             const numOfChannels = channel.length / (width * height);
-            const size = width * height * 4;
+            // return mesh data
+            // const size: number = width * height * 4;
+            const size = width * height;
+            console.log('xxx_size', size);
             let pixel = options.useChannel === null ? 0 : options.useChannel;
-            for (let i = 0; i < size; i += 4) {
-                //  height image calculation based on:
-                //  https://deck.gl/docs/api-reference/geo-layers/terrain-layer
-                const elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier;
-                const colorValue = Math.floor((elevationValue + 10000) / 0.1);
-                imageData.data[i] = Math.floor(colorValue / (256 * 256));
-                imageData.data[i + 1] = Math.floor((colorValue / 256) % 256);
-                imageData.data[i + 2] = colorValue % 256;
-                imageData.data[i + 3] = 255;
-                pixel += numOfChannels;
+            for (let i = 0, y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++, i++) {
+                    const elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier;
+                    terrain[i + y] = elevationValue;
+                    pixel += numOfChannels;
+                }
             }
-            c.putImageData(imageData, 0, 0);
-            const imageUrl = canvas.toDataURL('image/png');
+            // for (let i = 0; i < size; i++) {
+            //   //  height image calculation based on:
+            //   //  https://deck.gl/docs/api-reference/geo-layers/terrain-layer
+            //   const elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier!;
+            //   terrain[i] = elevationValue;
+            //   // const colorValue = Math.floor((elevationValue + 10000) / 0.1);
+            //   // imageData.data[i] = Math.floor(colorValue / (256 * 256));
+            //   // imageData.data[i + 1] = Math.floor((colorValue / 256) % 256);
+            //   // imageData.data[i + 2] = colorValue % 256;
+            //   // imageData.data[i + 3] = 255;
+            //   pixel += numOfChannels;
+            // }
+            // c!.putImageData(imageData, 0, 0);
+            // const imageUrl = canvas.toDataURL('image/png');
             // console.log('Heightmap generated.');
-            return imageUrl;
+            console.log('xxx_terrain', terrain);
+            if (terrain[0] > 0) {
+                debugger;
+            }
+            {
+                // backfill bottom border
+                for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
+                    terrain[i] = terrain[i - width - 1];
+                }
+                // backfill right border
+                for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
+                    terrain[i] = terrain[i - 1];
+                }
+            }
+            // getMesh
+            const { terrainSkirtHeight } = options;
+            console.log('xxx_bounds_0', input.bounds);
+            let mesh;
+            switch (tesselator) {
+                case 'martini':
+                    mesh = getMartiniTileMesh(terrainSkirtHeight, width, terrain);
+                    break;
+                case 'delatin':
+                    mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
+                    break;
+                default:
+                    if (width === height && !(height && (width - 1))) {
+                        // fixme get terrain to separate method
+                        // terrain = getTerrain(data, width, height, elevationDecoder, 'martini');
+                        mesh = getMartiniTileMesh(terrainSkirtHeight, width, terrain);
+                    }
+                    else {
+                        // fixme get terrain to separate method
+                        // terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');
+                        mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
+                    }
+                    break;
+            }
+            // Martini
+            // Martini
+            // Delatin
+            // Delatin
+            const { vertices } = mesh;
+            let { triangles } = mesh;
+            let attributes = getMeshAttributes(vertices, terrain, width, height, input.bounds);
+            // Compute bounding box before adding skirt so that z values are not skewed
+            const boundingBox = getMeshBoundingBox(attributes);
+            // FIXME uncomment and add skirt
+            console.log('xxx_skirtHeight', terrainSkirtHeight);
+            if (terrainSkirtHeight) {
+                const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, terrainSkirtHeight);
+                attributes = newAttributes;
+                triangles = newTriangles;
+            }
+            return {
+                // Data return by this loader implementation
+                loaderData: {
+                    header: {},
+                },
+                header: {
+                    vertexCount: triangles.length,
+                    boundingBox,
+                },
+                mode: 4,
+                indices: { value: Uint32Array.from(triangles), size: 1 },
+                attributes,
+            };
         });
     }
     getBitmap(input, options) {
@@ -15128,6 +15951,7 @@ class GeoImage {
             let b;
             let a;
             const size = width * height * 4;
+            // const size = width * height;
             if (!options.noDataValue) {
                 console.log('Missing noData value. Raster might be displayed incorrectly.');
             }
@@ -15348,6 +16172,68 @@ class GeoImage {
         return noDataValue !== undefined && pixels.every((pixel) => pixel === noDataValue);
     }
 }
+//
+//
+//
+/**
+ * Get Martini generated vertices and triangles
+ *
+ * @param {number} meshMaxError threshold for simplifying mesh
+ * @param {number} width width of the input data
+ * @param {number[] | Float32Array} terrain elevation data
+ * @returns {{vertices: Uint16Array, triangles: Uint32Array}} vertices and triangles data
+ */
+function getMartiniTileMesh(meshMaxError, width, terrain) {
+    const gridSize = width + 1;
+    const martini = new Martini(gridSize);
+    const tile = martini.createTile(terrain);
+    const { vertices, triangles } = tile.getMesh(meshMaxError);
+    return { vertices, triangles };
+}
+function getMeshAttributes(vertices, terrain, width, height, bounds) {
+    const gridSize = width + 1;
+    const numOfVerticies = vertices.length / 2;
+    // vec3. x, y in pixels, z in meters
+    const positions = new Float32Array(numOfVerticies * 3);
+    // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
+    const texCoords = new Float32Array(numOfVerticies * 2);
+    console.log('xxx_bounds', bounds);
+    const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
+    const xScale = (maxX - minX) / width;
+    const yScale = (maxY - minY) / height;
+    for (let i = 0; i < numOfVerticies; i++) {
+        const x = vertices[i * 2];
+        const y = vertices[i * 2 + 1];
+        const pixelIdx = y * gridSize + x;
+        positions[3 * i + 0] = x * xScale + minX;
+        positions[3 * i + 1] = -y * yScale + maxY;
+        positions[3 * i + 2] = terrain[pixelIdx];
+        texCoords[2 * i + 0] = x / width;
+        texCoords[2 * i + 1] = y / height;
+    }
+    return {
+        POSITION: { value: positions, size: 3 },
+        TEXCOORD_0: { value: texCoords, size: 2 },
+        // NORMAL: {}, - optional, but creates the high poly look with lighting
+    };
+}
+/**
+ * Get Delatin generated vertices and triangles
+ *
+ * @param {number} meshMaxError threshold for simplifying mesh
+ * @param {number} width width of the input data array
+ * @param {number} height height of the input data array
+ * @param {number[] | Float32Array} terrain elevation data
+ * @returns {{vertices: number[], triangles: number[]}} vertices and triangles data
+ */
+function getDelatinTileMesh(meshMaxError, width, height, terrain) {
+    const tin = new Delatin(terrain, width + 1, height + 1);
+    tin.run(meshMaxError);
+    // @ts-expect-error
+    const { coords, triangles } = tin;
+    const vertices = coords;
+    return { vertices, triangles };
+}
 
 const EARTH_CIRCUMFERENCE = 40075000.0;
 const EARTH_HALF_CIRCUMFERENCE = 20037500.0;
@@ -15441,7 +16327,7 @@ class CogTiles {
         const cartographicPositionAdjusted = [cartographicPosition[0], -cartographicPosition[1]];
         return cartographicPositionAdjusted;
     }
-    getTile(x, y, z) {
+    getTile(x, y, z, bounds) {
         return __awaiter(this, void 0, void 0, function* () {
             const wantedMpp = this.getResolutionFromZoomLevel(this.tileSize, z);
             const img = this.cog.getImageByResolution(wantedMpp);
@@ -15487,7 +16373,7 @@ class CogTiles {
             // console.log("Bits per sample: " + bitsPerSample)
             // console.log("Single channel pixel format: " + bitsPerSample/)
             if (x - ox >= 0 && y - oy >= 0 && x - ox < tilesX && y - oy < tilesY) {
-                // console.log("getting tile: " + [x - ox, y - oy]);
+                // console.log(`getting tile: ${[x - ox, y - oy]}`);
                 const tile = yield img.getTile((x - ox), (y - oy));
                 // console.time("Request to data time: ")
                 switch (img.compression) {
@@ -15533,10 +16419,12 @@ class CogTiles {
                     default: decompressedFormatted = null;
                 }
                 // console.log(decompressedFormatted)
+                // const { meshMaxError, bounds, elevationDecoder } = this.options;
                 decompressed = yield this.geo.getMap({
                     rasters: [decompressedFormatted],
                     width: this.tileSize,
                     height: this.tileSize,
+                    bounds,
                 }, this.options);
                 // console.log(decompressed.length)
                 return decompressed;
@@ -15778,7 +16666,7 @@ class CogTerrainLayer extends core.CompositeLayer {
             const cog = yield this.terrainCogTiles.initializeCog(terrainUrl);
             this.tileSize = this.terrainCogTiles.getTileSize(cog);
             const zoomRange = this.terrainCogTiles.getZoomRange(cog);
-            [this.minZoom, this.maxZoom] = zoomRange;
+            [this.props.minZoom, this.props.maxZoom] = zoomRange;
             this.setState({ initialized: true });
         });
     }