@deck.gl/geo-layers 9.3.0-alpha.6 → 9.3.0-beta.1

package/dist/dist.dev.js

@@ -2878,6 +2878,8 @@ var __exports__ = (() => {
   var distanceToVertex = 3 - Math.sqrt(5);
   var Rmidedge = Math.sqrt(3 - \u03C6);
   var Rcircumscribed = Math.sqrt(3) * Rmidedge / \u03C6;
+  var AUTHALIC_RADIUS_EARTH = 63710072e-1;
+  var AUTHALIC_AREA_EARTH = 4 * Math.PI * AUTHALIC_RADIUS_EARTH * AUTHALIC_RADIUS_EARTH;
   common_exports.setMatrixArrayType(Float64Array);
   var PentagonShape = class _PentagonShape {
     constructor(vertices) {
@@ -3579,12 +3581,13 @@ var __exports__ = (() => {
       }
     }
   };
-  common_exports.setMatrixArrayType(Float64Array);
   var YES = -1;
   var NO = 1;
+  common_exports.setMatrixArrayType(Float64Array);
   var KJToIJ = ([k, j]) => {
     return vec2_exports.fromValues(k - j, j);
   };
+  common_exports.setMatrixArrayType(Float64Array);
   var kPos = vec2_exports.fromValues(1, 0);
   var jPos = vec2_exports.fromValues(0, 1);
   var kNeg = vec2_exports.negate(vec2_exports.create(), kPos);
@@ -3622,7 +3625,6 @@ var __exports__ = (() => {
   var quaternaryToFlips = (n) => {
     return [[NO, NO], [NO, YES], [NO, NO], [YES, NO]][n];
   };
-  var FLIP_SHIFT = vec2_exports.fromValues(-1, 1);
   function reversePattern(pattern) {
     return Array.from({ length: pattern.length }, (_, i) => pattern.indexOf(i));
   }
@@ -3630,7 +3632,7 @@ var __exports__ = (() => {
   var PATTERN_FLIPPED = [0, 1, 2, 7, 3, 4, 5, 6];
   var PATTERN_REVERSED = reversePattern(PATTERN);
   var PATTERN_FLIPPED_REVERSED = reversePattern(PATTERN_FLIPPED);
-  var _shiftDigits = (digits, i, flips, invertJ, pattern) => {
+  var shiftDigits = (digits, i, flips, invertJ, pattern) => {
     if (i <= 0)
       return;
     const parentK = digits[i] || 0;
@@ -3652,7 +3654,10 @@ var __exports__ = (() => {
     digits[i - 1] = dst % 4;
     digits[i] = (parentK + 4 + Math.floor(dst / 4) - Math.floor(src / 4)) % 4;
   };
-  var sToAnchor = (s, resolution, orientation) => {
+  common_exports.setMatrixArrayType(Float64Array);
+  var FLIP_SHIFT = vec2_exports.fromValues(-1, 1);
+  var SHIFTDIGITS = true;
+  var sToAnchor = (s, resolution, orientation, doShiftDigits = SHIFTDIGITS) => {
     let input = BigInt(s);
     const reverse = orientation === "vu" || orientation === "wu" || orientation === "vw";
     const invertJ = orientation === "wv" || orientation === "vw";
@@ -3660,7 +3665,7 @@ var __exports__ = (() => {
     if (reverse) {
       input = (1n << BigInt(2 * resolution)) - input - 1n;
     }
-    const anchor = _sToAnchor(input, resolution, invertJ, flipIJ);
+    const anchor = _sToAnchor(input, resolution, invertJ, flipIJ, doShiftDigits);
     if (flipIJ) {
       const { offset: [_i, _j], flips: [flipX, flipY] } = anchor;
       anchor.offset = [_j, _i];
@@ -3678,7 +3683,7 @@ var __exports__ = (() => {
     }
     return anchor;
   };
-  var _sToAnchor = (s, resolution, invertJ, flipIJ) => {
+  var _sToAnchor = (s, resolution, invertJ, flipIJ, doShiftDigits = SHIFTDIGITS) => {
     const offset = vec2_exports.create();
     const flips = [NO, NO];
     let input = BigInt(s);
@@ -3689,7 +3694,9 @@ var __exports__ = (() => {
     }
     const pattern = flipIJ ? PATTERN_FLIPPED : PATTERN;
     for (let i = digits.length - 1; i >= 0; i--) {
-      _shiftDigits(digits, i, flips, invertJ, pattern);
+      if (doShiftDigits) {
+        shiftDigits(digits, i, flips, invertJ, pattern);
+      }
       vec2_exports.multiply(flips, flips, quaternaryToFlips(digits[i]));
     }
     flips[0] = NO;
@@ -3700,9 +3707,16 @@ var __exports__ = (() => {
       vec2_exports.add(offset, offset, childOffset);
       vec2_exports.multiply(flips, flips, quaternaryToFlips(digits[i]));
     }
-    const k = digits[0] || 0;
-    return { flips, k, offset: KJToIJ(offset) };
+    const q = digits[0] || 0;
+    return { q, offset: KJToIJ(offset), flips };
   };
+  var PROBE_R = 0.1;
+  var PROBE_OFFSETS = [
+    [PROBE_R * Math.cos(45 * Math.PI / 180), PROBE_R * Math.sin(45 * Math.PI / 180)],
+    [PROBE_R * Math.cos(113 * Math.PI / 180), PROBE_R * Math.sin(113 * Math.PI / 180)],
+    [PROBE_R * Math.cos(293 * Math.PI / 180), PROBE_R * Math.sin(293 * Math.PI / 180)],
+    [PROBE_R * Math.cos(225 * Math.PI / 180), PROBE_R * Math.sin(225 * Math.PI / 180)]
+  ];
   common_exports.setMatrixArrayType(Float64Array);
   var TRIANGLE_MODE = false;
   var shiftRight = vec2_exports.clone(w);
@@ -3719,12 +3733,12 @@ var __exports__ = (() => {
     if (anchor.flips[0] === NO && anchor.flips[1] === YES) {
       pentagon.rotate180();
     }
-    const { k } = anchor;
+    const { q } = anchor;
     const F2 = anchor.flips[0] + anchor.flips[1];
     if (
       // Orient last two pentagons when both or neither flips are YES
-      (F2 === -2 || F2 === 2) && k > 1 || // Orient first & last pentagons when only one of flips is YES
-      F2 === 0 && (k === 0 || k === 3)
+      (F2 === -2 || F2 === 2) && q > 1 || // Orient first & last pentagons when only one of flips is YES
+      F2 === 0 && (q === 0 || q === 3)
     ) {
       pentagon.reflectY();
     }
@@ -3958,13 +3972,40 @@ var __exports__ = (() => {
   var FIRST_HILBERT_RESOLUTION = 2;
   var MAX_RESOLUTION = 30;
   var HILBERT_START_BIT = 58n;
-  var REMOVAL_MASK = 0x3ffffffffffffffn;
+  var WORLD_CELL = 0n;
   function getResolution(index) {
+    if (index === 0n)
+      return -1;
+    if (index & 1n || (index & 0b111n) === 0b100n || (index & 0b11111n) === 0b10000n)
+      return MAX_RESOLUTION;
     let resolution = MAX_RESOLUTION - 1;
     let shifted = index >> 1n;
-    while (resolution > -1 && (shifted & 0b1n) === 0n) {
+    if (shifted === 0n)
+      return -1;
+    let low32 = Number(shifted & 0xFFFFFFFFn);
+    let remaining;
+    if (low32 === 0) {
+      shifted >>= 32n;
+      resolution -= 16;
+      remaining = Number(shifted);
+    } else {
+      remaining = low32;
+    }
+    if ((remaining & 65535) === 0) {
+      remaining >>= 16;
+      resolution -= 8;
+    }
+    if (resolution >= 6 && (remaining & 255) === 0) {
+      remaining >>= 8;
+      resolution -= 4;
+    }
+    if (resolution >= 4 && (remaining & 15) === 0) {
+      remaining >>= 4;
+      resolution -= 2;
+    }
+    while (resolution > -1 && (remaining & 1) === 0) {
       resolution -= 1;
-      shifted = shifted >> (resolution < FIRST_HILBERT_RESOLUTION ? 1n : 2n);
+      remaining = remaining >> (resolution < FIRST_HILBERT_RESOLUTION ? 1 : 2);
     }
     return resolution;
   }
@@ -3973,27 +4014,33 @@ var __exports__ = (() => {
     if (resolution === -1) {
       return { origin: origins[0], segment: 0, S: 0n, resolution };
     }
-    const top6Bits = Number(index >> 58n);
+    let quintantShift = HILBERT_START_BIT;
+    let quintantOffset = 0;
+    if (resolution === MAX_RESOLUTION) {
+      const markerBits = index & 1n ? 1n : index & 0b100n ? 3n : 5n;
+      quintantShift = HILBERT_START_BIT + markerBits;
+      quintantOffset = markerBits === 1n ? 0 : markerBits === 3n ? 32 : 40;
+    }
+    const topBits = Number(index >> quintantShift) + quintantOffset;
     let origin, segment;
     if (resolution === 0) {
-      const originId2 = top6Bits;
-      origin = origins[originId2];
+      origin = origins[topBits];
       segment = 0;
     } else {
-      const originId2 = Math.floor(top6Bits / 5);
+      const originId2 = Math.floor(topBits / 5);
       origin = origins[originId2];
-      segment = (top6Bits + origin.firstQuintant) % 5;
+      segment = (topBits + origin.firstQuintant) % 5;
     }
     if (!origin) {
-      throw new Error(`Could not parse origin: ${top6Bits}`);
+      throw new Error(`Could not parse origin: ${topBits}`);
     }
     if (resolution < FIRST_HILBERT_RESOLUTION) {
       return { origin, segment, S: 0n, resolution };
     }
     const hilbertLevels = resolution - FIRST_HILBERT_RESOLUTION + 1;
     const hilbertBits = BigInt(2 * hilbertLevels);
-    const shift = HILBERT_START_BIT - hilbertBits;
-    const S = (index & REMOVAL_MASK) >> shift;
+    const removalMask = (1n << quintantShift) - 1n;
+    const S = (index & removalMask) >> quintantShift - hilbertBits;
     return { origin, segment, S, resolution };
   }
   common_exports.setMatrixArrayType(Float64Array);
@@ -4012,6 +4059,9 @@ var __exports__ = (() => {
     return getPentagonVertices(hilbertResolution, quintant, anchor);
   }
   function cellToBoundary(cellId, { closedRing = true, segments = "auto" } = { closedRing: true, segments: "auto" }) {
+    if (cellId === WORLD_CELL) {
+      return [];
+    }
     const { S, segment, origin, resolution } = deserialize(cellId);
     if (segments === "auto") {
       segments = Math.max(1, Math.pow(2, 6 - resolution));
@@ -4031,8 +4081,13 @@ var __exports__ = (() => {
   function hexToU64(hex) {
     return BigInt(`0x${hex}`);
   }
-  var AUTHALIC_RADIUS = 63710072e-1;
-  var AUTHALIC_AREA = 4 * Math.PI * AUTHALIC_RADIUS * AUTHALIC_RADIUS;
+  var CELL_RADIUS_SAFETY_FACTOR = 2;
+  var BASE_CELL_RADIUS = CELL_RADIUS_SAFETY_FACTOR * AUTHALIC_RADIUS_EARTH / Math.sqrt(15);
+  var _cellRadius = new Array(31);
+  _cellRadius[0] = CELL_RADIUS_SAFETY_FACTOR * AUTHALIC_RADIUS_EARTH / Math.sqrt(3);
+  for (let r = 1; r <= 30; r++) {
+    _cellRadius[r] = BASE_CELL_RADIUS / (1 << r - 1);
+  }
   common_exports.setMatrixArrayType(Float64Array);
 
   // src/h3-layers/h3-utils.ts
@@ -14503,7 +14558,7 @@ var __exports__ = (() => {
     visibleMinZoom,
     visibleMaxZoom
   }) {
-    let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE4 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset;
+    let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE4 / tileSize) + zoomOffset) : Math.ceil(viewport.zoom + zoomOffset);
     if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
       if (!extent) {
         return [];

package/dist/index.cjs

@@ -1068,7 +1068,7 @@ function getIdentityTileIndices(viewport, z, tileSize, extent, modelMatrixInvers
   return indices;
 }
 function getTileIndices({ viewport, maxZoom, minZoom, zRange, extent, tileSize = TILE_SIZE3, modelMatrix, modelMatrixInverse, zoomOffset = 0, visibleMinZoom, visibleMaxZoom }) {
-  let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE3 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset;
+  let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE3 / tileSize) + zoomOffset) : Math.ceil(viewport.zoom + zoomOffset);
   if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
     if (!extent) {
       return [];