@math.gl/dggs 5.0.0-alpha.10

package/src/quadkey-decoder.ts

@@ -0,0 +1,103 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {type Bounds2D} from '@math.gl/types';
+import {
+  withDGGSBoundaryOptions,
+  type DGGSCell,
+  type DGGSDecoder,
+  getDGGSCellToken
+} from './dggs-decoder';
+
+const TILE_SIZE = 512;
+
+/** Decoder for the quadkey DGGS */
+export const QuadkeyDecoder = withDGGSBoundaryOptions({
+  name: 'quadkey',
+  hasNumericRepresentation: false,
+  cellColumnNames: ['quadkey', 'quadkeyId', 'quadkey_id'],
+  cellToLngLat: (cell: DGGSCell): [number, number] =>
+    getQuadkeyLngLat(getDGGSCellToken(cell, 'Quadkey')),
+  cellToBoundary: (cell: DGGSCell): [number, number][] =>
+    getQuadkeyBoundary(getDGGSCellToken(cell, 'Quadkey')),
+  cellToBoundaryFlat: (cell: DGGSCell): number[] =>
+    getQuadkeyBoundaryFlat(getDGGSCellToken(cell, 'Quadkey')),
+  cellToBounds: (cell: DGGSCell): Bounds2D => getQuadkeyBounds(getDGGSCellToken(cell, 'Quadkey'))
+} as const satisfies DGGSDecoder);
+
+function getQuadkeyLngLat(quadkey: string): [number, number] {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [(e + w) / 2, (s + n) / 2];
+}
+
+function getQuadkeyBoundary(quadkey: string): [number, number][] {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [
+    [e, n],
+    [e, s],
+    [w, s],
+    [w, n],
+    [e, n]
+  ];
+}
+
+function getQuadkeyBoundaryFlat(quadkey: string): number[] {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [e, n, e, s, w, s, w, n, e, n];
+}
+
+function getQuadkeyBounds(quadkey: string): Bounds2D {
+  const [topLeft, bottomRight] = quadkeyToWorldBounds(quadkey);
+  const [w, n] = worldToLngLat(topLeft);
+  const [e, s] = worldToLngLat(bottomRight);
+  return [
+    [w, s],
+    [e, n]
+  ];
+}
+
+export function quadkeyToWorldBounds(quadkey: string): [[number, number], [number, number]] {
+  let x = 0;
+  let y = 0;
+  let mask = 1 << quadkey.length;
+  const scale = mask / TILE_SIZE;
+
+  for (let i = 0; i < quadkey.length; i++) {
+    mask >>= 1;
+    const q = parseInt(quadkey[i], 10);
+    if (q % 2) x |= mask;
+    if (q > 1) y |= mask;
+  }
+  return [
+    [x / scale, TILE_SIZE - y / scale],
+    [(x + 0.99) / scale, TILE_SIZE - (y + 0.99) / scale]
+  ];
+}
+
+// CONSTANTS
+const PI = Math.PI;
+const PI_4 = PI / 4;
+const RADIANS_TO_DEGREES = 180 / PI;
+
+/**
+ * Unproject world point [x,y] on map onto {lat, lon} on sphere
+ *
+ * @param xy - array with [x,y] members
+ *  representing point on projected map plane
+ * @return - array with [x,y] of point on sphere.
+ *   Has toArray method if you need a GeoJSON Array.
+ *   Per cartographic tradition, lat and lon are specified as degrees.
+ */
+function worldToLngLat(xy: number[]): [number, number] {
+  const [x, y] = xy;
+  const lambda2 = (x / TILE_SIZE) * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp((y / TILE_SIZE) * (2 * PI) - PI)) - PI_4);
+  return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
+}

package/src/quadkey.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export {QuadkeyDecoder, quadkeyToWorldBounds} from './quadkey-decoder';

package/src/s2-decoder.ts

@@ -0,0 +1,157 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {type Bounds2D} from '@math.gl/types';
+import {withDGGSBoundaryOptions, type DGGSCell, type DGGSDecoder} from './dggs-decoder';
+
+import {getS2IndexFromToken, getS2TokenFromIndex} from './s2-geometry/s2-token';
+import {getS2GeoBounds} from './s2-geometry/s2-to-boundary';
+import {getS2Cell, IJToST, STToUV, FaceUVToXYZ, XYZToLngLat} from './s2-geometry/s2-geometry';
+
+/** Decoder for the S2 DGGS */
+export const S2Decoder = withDGGSBoundaryOptions({
+  name: 's2',
+  hasNumericRepresentation: true,
+  cellColumnNames: ['s2', 's2Token', 's2_token', 's2Cell', 's2_cell', 's2CellId', 's2_cell_id'],
+  tokenToCell: (s2Token: string): bigint => getS2IndexFromToken(s2Token),
+  cellToToken: (cell: DGGSCell): string => getS2TokenFromIndex(getS2CellIndex(cell)),
+  cellToLngLat: (cell: DGGSCell): [number, number] => getS2LngLat(cell),
+  cellToBoundary: (cell: DGGSCell): [number, number][] => getS2Boundary(cell),
+  cellToBoundaryFlat: (cell: DGGSCell): number[] => getS2BoundaryFlat(cell),
+  cellToBounds: (cell: DGGSCell): Bounds2D => getS2Bounds(cell)
+} as const satisfies DGGSDecoder);
+
+/**
+ * Retrieve S2 geometry center
+ */
+export function getS2LngLat(cell: DGGSCell): [number, number] {
+  const s2Index = getS2CellIndex(cell);
+  const s2Cell = getS2Cell(s2Index);
+
+  const st = IJToST(s2Cell.ij, s2Cell.level, [0.5, 0.5]);
+  const uv = STToUV(st);
+  const xyz = FaceUVToXYZ(s2Cell.face, uv);
+  const lngLat = XYZToLngLat(xyz);
+
+  return lngLat as [number, number];
+}
+
+/**
+ * Get a polygon with corner coordinates for an s2 cell
+ * @param - This can be an S2 key or token
+ * @return {Float64Array} - a simple polygon in flat array format: [lng0, lat0, lng1, lat1, ...]
+ *   - the polygon is closed, i.e. last coordinate is a copy of the first coordinate
+ */
+export function getS2BoundaryFlat(cell: DGGSCell): number[] {
+  const s2Index = getS2CellIndex(cell);
+  const float64Array = getS2GeoBounds(s2Index);
+  // TODO - inefficient
+  return Array.from(float64Array);
+}
+
+function getS2Boundary(cell: DGGSCell): [number, number][] {
+  const flatBoundary = getS2BoundaryFlat(cell);
+  const boundary: [number, number][] = [];
+  for (let i = 0; i < flatBoundary.length; i += 2) {
+    boundary.push([flatBoundary[i], flatBoundary[i + 1]]);
+  }
+  return boundary;
+}
+
+/**
+ * Returns conservative longitude/latitude bounds for an S2 cell.
+ *
+ * Longitudes are unwrapped so `east >= west`; either endpoint may lie outside `[-180, 180]` for
+ * antimeridian cells. The two level-zero polar faces span a complete 360-degree longitude range.
+ *
+ * @param cell - S2 token or 64-bit cell index.
+ * @returns Bounds in `[[west, south], [east, north]]` order and degrees.
+ */
+export function getS2Bounds(cell: DGGSCell): Bounds2D {
+  const s2Cell = getS2Cell(getS2CellIndex(cell));
+  if (s2Cell.level === 0) {
+    return getS2RootBounds(s2Cell.face);
+  }
+
+  // For non-root S2 cells, latitude and longitude extrema occur at vertices. Root cells require
+  // the special cases above because their curved edges or interiors contain the extrema.
+  // https://github.com/google/s2geometry/blob/master/src/s2/s2cell.cc
+  const offsets: readonly [number, number][] = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0]
+  ];
+  let west = Infinity;
+  let south = Infinity;
+  let east = -Infinity;
+  let north = -Infinity;
+  let previousLongitude: number | undefined;
+  for (const offset of offsets) {
+    const st = IJToST(s2Cell.ij, s2Cell.level, offset);
+    const uv = STToUV(st);
+    const [x, y, z] = FaceUVToXYZ(s2Cell.face, uv);
+    let [longitude, latitude] = XYZToLngLat([x, y, z]);
+    if (x === 0 && y === 0 && previousLongitude !== undefined) {
+      longitude = previousLongitude;
+    }
+    if (previousLongitude !== undefined) {
+      const longitudeDelta = longitude - previousLongitude;
+      longitude += longitudeDelta > 180 ? -360 : longitudeDelta < -180 ? 360 : 0;
+    }
+    previousLongitude = longitude;
+    west = Math.min(west, longitude);
+    south = Math.min(south, latitude);
+    east = Math.max(east, longitude);
+    north = Math.max(north, latitude);
+  }
+
+  const angularEpsilon = (2 * Number.EPSILON * 180) / Math.PI;
+  return [
+    [west - angularEpsilon, Math.max(-90, south - angularEpsilon)],
+    [east + angularEpsilon, Math.min(90, north + angularEpsilon)]
+  ];
+}
+
+function getS2CellIndex(cell: DGGSCell): bigint {
+  return typeof cell === 'bigint' ? cell : getS2IndexFromToken(cell);
+}
+
+function getS2RootBounds(face: number): Bounds2D {
+  const polarLatitude = (Math.asin(Math.sqrt(1 / 3)) * 180) / Math.PI;
+  switch (face) {
+    case 0:
+      return [
+        [-45, -45],
+        [45, 45]
+      ];
+    case 1:
+      return [
+        [45, -45],
+        [135, 45]
+      ];
+    case 2:
+      return [
+        [-180, polarLatitude],
+        [180, 90]
+      ];
+    case 3:
+      return [
+        [135, -45],
+        [225, 45]
+      ];
+    case 4:
+      return [
+        [-135, -45],
+        [-45, 45]
+      ];
+    case 5:
+      return [
+        [-180, -90],
+        [180, -polarLatitude]
+      ];
+    default:
+      throw new Error(`Invalid S2 face: ${face}`);
+  }
+}

package/src/s2-geometry/s2-geometry.ts

@@ -0,0 +1,303 @@
+// math.gl
+// SPDX-License-Identifier: MIT and ISC
+// Copyright (c) vis.gl contributors
+
+// math.gl, MIT license
+/*
+Adapted from s2-geometry under ISC License (ISC)
+Copyright (c) 2012-2016, Jon Atkins <github@jonatkins.com>
+Copyright (c) 2016, AJ ONeal <aj@daplie.com>
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+import {isS2IndexValid} from './s2-token';
+
+export type S2Cell = {
+  face: number;
+  ij: [number, number];
+  level: number;
+};
+
+export function getS2Cell(s2Index: bigint): S2Cell {
+  if (!isS2IndexValid(s2Index)) {
+    throw new Error(`Invalid S2 index: ${s2Index}`);
+  }
+  const key = toHilbertQuadkey(s2Index);
+  const s2cell = fromHilbertQuadKey(key);
+  return s2cell;
+}
+
+//
+// Functional Style
+//
+const FACE_BITS = 3;
+const MAX_LEVEL = 30;
+const POS_BITS = 2 * MAX_LEVEL + 1; // 61 (60 bits of data, 1 bit lsb marker)
+const RADIAN_TO_DEGREE = 180 / Math.PI;
+
+type HilbertOrientation = 'a' | 'b' | 'c' | 'd';
+
+const HILBERT_MAP: Record<
+  HilbertOrientation,
+  readonly (readonly [position: number, orientation: HilbertOrientation])[]
+> = {
+  a: [
+    [0, 'd'],
+    [1, 'a'],
+    [3, 'b'],
+    [2, 'a']
+  ],
+  b: [
+    [2, 'b'],
+    [1, 'b'],
+    [3, 'a'],
+    [0, 'c']
+  ],
+  c: [
+    [2, 'c'],
+    [3, 'd'],
+    [1, 'c'],
+    [0, 'b']
+  ],
+  d: [
+    [0, 'a'],
+    [3, 'c'],
+    [1, 'd'],
+    [2, 'd']
+  ]
+};
+
+/*
+  Original function taken from deck.gl doesn't support the case of (face <= 5)
+  It's fixed here.
+*/
+export function fromHilbertQuadKey(hilbertQuadkey: string): S2Cell {
+  if (!/^[0-5]\/[0-3]{0,30}$/.test(hilbertQuadkey)) {
+    throw new Error(`Invalid S2 Hilbert quadkey: ${hilbertQuadkey}`);
+  }
+  const parts = hilbertQuadkey.split('/');
+  const face = parseInt(parts[0], 10);
+  const position = parts[1] || '';
+  const maxLevel = position.length;
+  let level = 0;
+
+  const point = [0, 0] as [number, number];
+
+  for (let i = maxLevel - 1; i >= 0; i--) {
+    level = maxLevel - i;
+    const bit = position[i];
+    let rx = 0;
+    let ry = 0;
+    if (bit === '1') {
+      ry = 1;
+    } else if (bit === '2') {
+      rx = 1;
+      ry = 1;
+    } else if (bit === '3') {
+      rx = 1;
+    }
+
+    const val = Math.pow(2, level - 1);
+    rotateAndFlipQuadrant(val, point, rx, ry);
+
+    point[0] += val * rx;
+    point[1] += val * ry;
+  }
+
+  if (face % 2 === 1) {
+    const t = point[0];
+    point[0] = point[1];
+    point[1] = t;
+  }
+
+  return {face, ij: point, level};
+}
+
+export function toHilbertQuadkey(id: bigint): string {
+  if (!isS2IndexValid(id)) {
+    throw new Error(`Invalid S2 index: ${id}`);
+  }
+  let bin = id.toString(2);
+
+  while (bin.length < FACE_BITS + POS_BITS) {
+    // eslint-disable-next-line prefer-template
+    bin = '0' + bin;
+  }
+
+  // MUST come AFTER binstr has been left-padded with '0's
+  const lsbIndex = bin.lastIndexOf('1');
+  // substr(start, len)
+  // substring(start, end) // includes start, does not include end
+  const faceB = bin.substring(0, 3);
+  // posB will always be a multiple of 2 (or it's invalid)
+  const posB = bin.substring(3, lsbIndex);
+  const levelN = posB.length / 2;
+
+  const faceS = BigInt(`0b${faceB}`).toString(10);
+
+  let posS = '';
+  if (levelN !== 0) {
+    posS = BigInt(`0b${posB}`).toString(4);
+
+    while (posS.length < levelN) {
+      // eslint-disable-next-line prefer-template
+      posS = '0' + posS;
+    }
+  }
+  return `${faceS}/${posS}`;
+}
+
+/**
+ * Converts face-local integer coordinates into an S2 cell index.
+ *
+ * @param s2Cell - Face, `(i, j)` coordinates, and level of an S2 cell.
+ * @returns The corresponding 64-bit S2 cell index.
+ */
+export function getS2IndexFromCell(s2Cell: S2Cell): bigint {
+  const {face, ij, level} = s2Cell;
+  if (!Number.isInteger(face) || face < 0 || face > 5) {
+    throw new Error(`Invalid S2 face: ${face}`);
+  }
+  if (!Number.isInteger(level) || level < 0 || level > MAX_LEVEL) {
+    throw new Error(`Invalid S2 level: ${level}`);
+  }
+  const maximumCoordinate = 2 ** level;
+  if (
+    !Number.isInteger(ij[0]) ||
+    !Number.isInteger(ij[1]) ||
+    ij[0] < 0 ||
+    ij[1] < 0 ||
+    ij[0] >= maximumCoordinate ||
+    ij[1] >= maximumCoordinate
+  ) {
+    throw new Error(`Invalid S2 IJ coordinates: ${ij[0]}, ${ij[1]}`);
+  }
+
+  const positions = getHilbertQuadList(ij[0], ij[1], level, face);
+  let s2Index = BigInt(face) << 61n;
+  for (let positionIndex = 0; positionIndex < positions.length; positionIndex++) {
+    const bitOffset = 59 - positionIndex * 2;
+    s2Index |= BigInt(positions[positionIndex]) << BigInt(bitOffset);
+  }
+  s2Index |= 1n << BigInt(60 - level * 2);
+  return s2Index;
+}
+
+/**
+ * Returns a spatially addressed descendant of an S2 cell.
+ *
+ * Unlike {@link getS2ChildIndex}, `x` and `y` address the descendant along increasing face-local
+ * `i` and `j` axes. This accounts for Hilbert orientation changes across faces and levels.
+ *
+ * @param rootIndex - Valid S2 cell index at the root of the relative grid.
+ * @param relativeLevel - Number of subdivision levels below the root.
+ * @param x - Descendant coordinate along the root cell's increasing `i` axis.
+ * @param y - Descendant coordinate along the root cell's increasing `j` axis.
+ * @returns The descendant S2 cell index.
+ */
+export function getS2DescendantIndex(
+  rootIndex: bigint,
+  relativeLevel: number,
+  x: number,
+  y: number
+): bigint {
+  const rootCell = getS2Cell(rootIndex);
+  if (
+    !Number.isInteger(relativeLevel) ||
+    relativeLevel < 0 ||
+    rootCell.level + relativeLevel > MAX_LEVEL
+  ) {
+    throw new Error(`Invalid S2 relative level: ${relativeLevel}`);
+  }
+  const divisionCount = 2 ** relativeLevel;
+  if (
+    !Number.isInteger(x) ||
+    !Number.isInteger(y) ||
+    x < 0 ||
+    y < 0 ||
+    x >= divisionCount ||
+    y >= divisionCount
+  ) {
+    throw new Error(`Invalid S2 descendant coordinates: ${x}, ${y}`);
+  }
+  return getS2IndexFromCell({
+    face: rootCell.face,
+    ij: [rootCell.ij[0] * divisionCount + x, rootCell.ij[1] * divisionCount + y],
+    level: rootCell.level + relativeLevel
+  });
+}
+
+export function IJToST(
+  ij: [number, number],
+  order: number,
+  offsets: [number, number]
+): [number, number] {
+  const maxSize = 1 << order;
+
+  return [(ij[0] + offsets[0]) / maxSize, (ij[1] + offsets[1]) / maxSize];
+}
+
+function singleSTtoUV(st: number): number {
+  if (st >= 0.5) {
+    return (1 / 3.0) * (4 * st * st - 1);
+  }
+  return (1 / 3.0) * (1 - 4 * (1 - st) * (1 - st));
+}
+
+export function STToUV(st: [number, number]): [number, number] {
+  return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
+}
+
+export function FaceUVToXYZ(face: number, [u, v]: [number, number]): [number, number, number] {
+  switch (face) {
+    case 0:
+      return [1, u, v];
+    case 1:
+      return [-u, 1, v];
+    case 2:
+      return [-u, -v, 1];
+    case 3:
+      return [-1, -v, -u];
+    case 4:
+      return [v, -1, -u];
+    case 5:
+      return [v, u, -1];
+    default:
+      throw new Error('Invalid face');
+  }
+}
+
+export function XYZToLngLat([x, y, z]: [number, number, number]): [number, number] {
+  const lat = Math.atan2(z, Math.sqrt(x * x + y * y));
+  const lng = Math.atan2(y, x);
+
+  return [lng * RADIAN_TO_DEGREE, lat * RADIAN_TO_DEGREE];
+}
+
+function rotateAndFlipQuadrant(n: number, point: [number, number], rx: number, ry: number): void {
+  if (ry === 0) {
+    if (rx === 1) {
+      point[0] = n - 1 - point[0];
+      point[1] = n - 1 - point[1];
+    }
+
+    const x = point[0];
+    point[0] = point[1];
+    point[1] = x;
+  }
+}
+
+function getHilbertQuadList(x: number, y: number, level: number, face: number): number[] {
+  let orientation: HilbertOrientation = face % 2 === 1 ? 'd' : 'a';
+  const positions: number[] = [];
+  for (let bit = level - 1; bit >= 0; bit--) {
+    const mask = 1 << bit;
+    const quadrantX = (x & mask) !== 0 ? 1 : 0;
+    const quadrantY = (y & mask) !== 0 ? 1 : 0;
+    const [position, nextOrientation] = HILBERT_MAP[orientation][quadrantX * 2 + quadrantY];
+    positions.push(position);
+    orientation = nextOrientation;
+  }
+  return positions;
+}

package/src/s2-geometry/s2-to-boundary.ts

@@ -0,0 +1,76 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {IJToST, STToUV, FaceUVToXYZ, XYZToLngLat, getS2Cell} from './s2-geometry';
+
+const MAX_RESOLUTION = 100;
+
+export function getS2GeoBounds(s2Index: bigint): Float64Array {
+  const s2Cell = getS2Cell(s2Index);
+  return getS2GeoBoundsFromCell(s2Cell);
+}
+
+/**
+ * The S2 cell edge is curved: http://s2geometry.io/
+ * This is more prominent at lower levels
+ * resolution is the number of segments to generate per edge.
+ * We exponentially reduce resolution as level increases so it doesn't affect perf
+ * when there are a large number of cells
+ */
+// eslint-disable-next-line max-statements
+export function getS2GeoBoundsFromCell({
+  face,
+  ij,
+  level
+}: {
+  face: number;
+  ij: [number, number];
+  level: number;
+}): Float64Array {
+  const offsets = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0],
+    [0, 0]
+  ];
+
+  const resolution = Math.max(1, Math.ceil(MAX_RESOLUTION * Math.pow(2, -level)));
+  const result = new Float64Array(4 * resolution * 2 + 2);
+  let ptIndex = 0;
+  let prevLng = 0;
+
+  for (let i = 0; i < 4; i++) {
+    const offset = offsets[i].slice(0) as [number, number];
+    const nextOffset = offsets[i + 1];
+    const stepI = (nextOffset[0] - offset[0]) / resolution;
+    const stepJ = (nextOffset[1] - offset[1]) / resolution;
+
+    for (let j = 0; j < resolution; j++) {
+      offset[0] += stepI;
+      offset[1] += stepJ;
+      // Cell can be represented by coordinates IJ, ST, UV, XYZ
+      // http://s2geometry.io/devguide/s2cell_hierarchy#coordinate-systems
+      const st = IJToST(ij, level, offset);
+      const uv = STToUV(st);
+      const xyz = FaceUVToXYZ(face, uv);
+      const lngLat = XYZToLngLat(xyz);
+
+      // Adjust longitude for Web Mercator projection
+      if (Math.abs(lngLat[1]) > 89.999) {
+        lngLat[0] = prevLng;
+      }
+      const deltaLng = lngLat[0] - prevLng;
+      lngLat[0] += deltaLng > 180 ? -360 : deltaLng < -180 ? 360 : 0;
+
+      result[ptIndex++] = lngLat[0];
+      result[ptIndex++] = lngLat[1];
+      prevLng = lngLat[0];
+    }
+  }
+  // close the loop
+  result[ptIndex++] = result[0];
+  result[ptIndex++] = result[1];
+  return result;
+}