@npm9912/v-map 0.1.0

package/dist/cjs/index-BIL4VsgP.js

@@ -0,0 +1,310 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-B83fTs8d.js');
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var wellknown = {exports: {}};
+
+/*eslint-disable no-cond-assign */
+
+var hasRequiredWellknown;
+
+function requireWellknown () {
+	if (hasRequiredWellknown) return wellknown.exports;
+	hasRequiredWellknown = 1;
+	wellknown.exports = parse;
+	wellknown.exports.parse = parse;
+	wellknown.exports.stringify = stringify;
+
+	var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+	// Matches sequences like '100 100' or '100 100 100'.
+	var tuples = new RegExp('^' + numberRegexp.source + '(\\s' + numberRegexp.source + '){1,}');
+
+	/*
+	 * Parse WKT and return GeoJSON.
+	 *
+	 * @param {string} _ A WKT geometry
+	 * @return {?Object} A GeoJSON geometry object
+	 */
+	function parse (input) {
+	  var parts = input.split(';');
+	  var _ = parts.pop();
+	  var srid = (parts.shift() || '').split('=').pop();
+
+	  var i = 0;
+
+	  function $ (re) {
+	    var match = _.substring(i).match(re);
+	    if (!match) return null;
+	    else {
+	      i += match[0].length;
+	      return match[0];
+	    }
+	  }
+
+	  function crs (obj) {
+	    if (obj && srid.match(/\d+/)) {
+	      obj.crs = {
+	        type: 'name',
+	        properties: {
+	          name: 'urn:ogc:def:crs:EPSG::' + srid
+	        }
+	      };
+	    }
+
+	    return obj;
+	  }
+
+	  function white () { $(/^\s*/); }
+
+	  function multicoords () {
+	    white();
+	    var depth = 0;
+	    var rings = [];
+	    var stack = [rings];
+	    var pointer = rings;
+	    var elem;
+
+	    while (elem =
+	           $(/^(\()/) ||
+	             $(/^(\))/) ||
+	               $(/^(,)/) ||
+	                 $(tuples)) {
+	      if (elem === '(') {
+	        stack.push(pointer);
+	        pointer = [];
+	        stack[stack.length - 1].push(pointer);
+	        depth++;
+	      } else if (elem === ')') {
+	        // For the case: Polygon(), ...
+	        if (pointer.length === 0) return null;
+
+	        pointer = stack.pop();
+	        // the stack was empty, input was malformed
+	        if (!pointer) return null;
+	        depth--;
+	        if (depth === 0) break;
+	      } else if (elem === ',') {
+	        pointer = [];
+	        stack[stack.length - 1].push(pointer);
+	      } else if (!elem.split(/\s/g).some(isNaN)) {
+	        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+	      } else {
+	        return null;
+	      }
+	      white();
+	    }
+
+	    if (depth !== 0) return null;
+
+	    return rings;
+	  }
+
+	  function coords () {
+	    var list = [];
+	    var item;
+	    var pt;
+	    while (pt =
+	           $(tuples) ||
+	             $(/^(,)/)) {
+	      if (pt === ',') {
+	        list.push(item);
+	        item = [];
+	      } else if (!pt.split(/\s/g).some(isNaN)) {
+	        if (!item) item = [];
+	        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+	      }
+	      white();
+	    }
+
+	    if (item) list.push(item);
+	    else return null;
+
+	    return list.length ? list : null;
+	  }
+
+	  function point () {
+	    if (!$(/^(point(\sz)?)/i)) return null;
+	    white();
+	    if (!$(/^(\()/)) return null;
+	    var c = coords();
+	    if (!c) return null;
+	    white();
+	    if (!$(/^(\))/)) return null;
+	    return {
+	      type: 'Point',
+	      coordinates: c[0]
+	    };
+	  }
+
+	  function multipoint () {
+	    if (!$(/^(multipoint)/i)) return null;
+	    white();
+	    var newCoordsFormat = _
+	      .substring(_.indexOf('(') + 1, _.length - 1)
+	      .replace(/\(/g, '')
+	      .replace(/\)/g, '');
+	    _ = 'MULTIPOINT (' + newCoordsFormat + ')';
+	    var c = multicoords();
+	    if (!c) return null;
+	    white();
+	    return {
+	      type: 'MultiPoint',
+	      coordinates: c
+	    };
+	  }
+
+	  function multilinestring () {
+	    if (!$(/^(multilinestring)/i)) return null;
+	    white();
+	    var c = multicoords();
+	    if (!c) return null;
+	    white();
+	    return {
+	      type: 'MultiLineString',
+	      coordinates: c
+	    };
+	  }
+
+	  function linestring () {
+	    if (!$(/^(linestring(\sz)?)/i)) return null;
+	    white();
+	    if (!$(/^(\()/)) return null;
+	    var c = coords();
+	    if (!c) return null;
+	    if (!$(/^(\))/)) return null;
+	    return {
+	      type: 'LineString',
+	      coordinates: c
+	    };
+	  }
+
+	  function polygon () {
+	    if (!$(/^(polygon(\sz)?)/i)) return null;
+	    white();
+	    var c = multicoords();
+	    if (!c) return null;
+	    return {
+	      type: 'Polygon',
+	      coordinates: c
+	    };
+	  }
+
+	  function multipolygon () {
+	    if (!$(/^(multipolygon)/i)) return null;
+	    white();
+	    var c = multicoords();
+	    if (!c) return null;
+	    return {
+	      type: 'MultiPolygon',
+	      coordinates: c
+	    };
+	  }
+
+	  function geometrycollection () {
+	    var geometries = [];
+	    var geometry;
+
+	    if (!$(/^(geometrycollection)/i)) return null;
+	    white();
+
+	    if (!$(/^(\()/)) return null;
+	    while (geometry = root()) {
+	      geometries.push(geometry);
+	      white();
+	      $(/^(,)/);
+	      white();
+	    }
+	    if (!$(/^(\))/)) return null;
+
+	    return {
+	      type: 'GeometryCollection',
+	      geometries: geometries
+	    };
+	  }
+
+	  function root () {
+	    return point() ||
+	      linestring() ||
+	      polygon() ||
+	      multipoint() ||
+	      multilinestring() ||
+	      multipolygon() ||
+	      geometrycollection();
+	  }
+
+	  return crs(root());
+	}
+
+	/**
+	 * Stringifies a GeoJSON object into WKT
+	 */
+	function stringify (gj) {
+	  if (gj.type === 'Feature') {
+	    gj = gj.geometry;
+	  }
+
+	  function pairWKT (c) {
+	    return c.join(' ');
+	  }
+
+	  function ringWKT (r) {
+	    return r.map(pairWKT).join(', ');
+	  }
+
+	  function ringsWKT (r) {
+	    return r.map(ringWKT).map(wrapParens).join(', ');
+	  }
+
+	  function multiRingsWKT (r) {
+	    return r.map(ringsWKT).map(wrapParens).join(', ');
+	  }
+
+	  function wrapParens (s) { return '(' + s + ')'; }
+
+	  switch (gj.type) {
+	    case 'Point':
+	      return 'POINT (' + pairWKT(gj.coordinates) + ')';
+	    case 'LineString':
+	      return 'LINESTRING (' + ringWKT(gj.coordinates) + ')';
+	    case 'Polygon':
+	      return 'POLYGON (' + ringsWKT(gj.coordinates) + ')';
+	    case 'MultiPoint':
+	      return 'MULTIPOINT (' + ringWKT(gj.coordinates) + ')';
+	    case 'MultiPolygon':
+	      return 'MULTIPOLYGON (' + multiRingsWKT(gj.coordinates) + ')';
+	    case 'MultiLineString':
+	      return 'MULTILINESTRING (' + ringsWKT(gj.coordinates) + ')';
+	    case 'GeometryCollection':
+	      return 'GEOMETRYCOLLECTION (' + gj.geometries.map(stringify).join(', ') + ')';
+	    default:
+	      throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');
+	  }
+	}
+	return wellknown.exports;
+}
+
+var wellknownExports = requireWellknown();
+var index = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(wellknownExports);
+
+var index$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: index
+}, [wellknownExports]);
+
+exports.index = index$1;
+exports.wellknownExports = wellknownExports;

package/dist/cjs/index-Blku2QY8.js

@@ -0,0 +1,167 @@
+'use strict';
+
+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};
+    }
+}
+
+exports.default = Martini;

package/dist/cjs/index-CJvvX4yx.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var deckProvider = require('./deck-provider-Ctq3Q8a1.js');
+var scenegraphLayer = require('./scenegraph-layer-DwNoxQdi.js');
+require('./styleconfig-CVRqArk-.js');
+require('./index.browser-DQhD8Jwl.js');
+require('./index-BIL4VsgP.js');
+require('./_commonjsHelpers-B83fTs8d.js');
+require('./messages-D7h4m8Tx.js');
+require('./geotiff-source-RaNzzWkC.js');
+require('@loaders.gl/core');
+require('@loaders.gl/images');
+require('@loaders.gl/loader-utils');
+require('@loaders.gl/terrain');
+require('@loaders.gl/schema');
+require('@loaders.gl/gltf');
+
+
+
+exports.SimpleMeshLayer = deckProvider.SimpleMeshLayer;
+exports.ScenegraphLayer = scenegraphLayer.ScenegraphLayer;