@loaders.gl/terrain 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/esm/lib/decode-quantized-mesh.js

@@ -0,0 +1,231 @@
+const QUANTIZED_MESH_HEADER = new Map([['centerX', Float64Array.BYTES_PER_ELEMENT], ['centerY', Float64Array.BYTES_PER_ELEMENT], ['centerZ', Float64Array.BYTES_PER_ELEMENT], ['minHeight', Float32Array.BYTES_PER_ELEMENT], ['maxHeight', Float32Array.BYTES_PER_ELEMENT], ['boundingSphereCenterX', Float64Array.BYTES_PER_ELEMENT], ['boundingSphereCenterY', Float64Array.BYTES_PER_ELEMENT], ['boundingSphereCenterZ', Float64Array.BYTES_PER_ELEMENT], ['boundingSphereRadius', Float64Array.BYTES_PER_ELEMENT], ['horizonOcclusionPointX', Float64Array.BYTES_PER_ELEMENT], ['horizonOcclusionPointY', Float64Array.BYTES_PER_ELEMENT], ['horizonOcclusionPointZ', Float64Array.BYTES_PER_ELEMENT]]);
+function decodeZigZag(value) {
+  return value >> 1 ^ -(value & 1);
+}
+function decodeHeader(dataView) {
+  let position = 0;
+  const header = {};
+  for (const [key, bytesCount] of QUANTIZED_MESH_HEADER) {
+    const getter = bytesCount === 8 ? dataView.getFloat64 : dataView.getFloat32;
+    header[key] = getter.call(dataView, position, true);
+    position += bytesCount;
+  }
+  return {
+    header,
+    headerEndPosition: position
+  };
+}
+function decodeVertexData(dataView, headerEndPosition) {
+  let position = headerEndPosition;
+  const elementsPerVertex = 3;
+  const vertexCount = dataView.getUint32(position, true);
+  const vertexData = new Uint16Array(vertexCount * elementsPerVertex);
+  position += Uint32Array.BYTES_PER_ELEMENT;
+  const bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
+  const elementArrayLength = vertexCount * bytesPerArrayElement;
+  const uArrayStartPosition = position;
+  const vArrayStartPosition = uArrayStartPosition + elementArrayLength;
+  const heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
+  let u = 0;
+  let v = 0;
+  let height = 0;
+  for (let i = 0; i < vertexCount; i++) {
+    u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));
+    v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));
+    height += decodeZigZag(dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true));
+    vertexData[i] = u;
+    vertexData[i + vertexCount] = v;
+    vertexData[i + vertexCount * 2] = height;
+  }
+  position += elementArrayLength * 3;
+  return {
+    vertexData,
+    vertexDataEndPosition: position
+  };
+}
+function decodeIndex(buffer, position, indicesCount, bytesPerIndex) {
+  let encoded = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  let indices;
+  if (bytesPerIndex === 2) {
+    indices = new Uint16Array(buffer, position, indicesCount);
+  } else {
+    indices = new Uint32Array(buffer, position, indicesCount);
+  }
+  if (!encoded) {
+    return indices;
+  }
+  let highest = 0;
+  for (let i = 0; i < indices.length; ++i) {
+    const code = indices[i];
+    indices[i] = highest - code;
+    if (code === 0) {
+      ++highest;
+    }
+  }
+  return indices;
+}
+function decodeTriangleIndices(dataView, vertexData, vertexDataEndPosition) {
+  let position = vertexDataEndPosition;
+  const elementsPerVertex = 3;
+  const vertexCount = vertexData.length / elementsPerVertex;
+  const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
+  if (position % bytesPerIndex !== 0) {
+    position += bytesPerIndex - position % bytesPerIndex;
+  }
+  const triangleCount = dataView.getUint32(position, true);
+  position += Uint32Array.BYTES_PER_ELEMENT;
+  const triangleIndicesCount = triangleCount * 3;
+  const triangleIndices = decodeIndex(dataView.buffer, position, triangleIndicesCount, bytesPerIndex);
+  position += triangleIndicesCount * bytesPerIndex;
+  return {
+    triangleIndicesEndPosition: position,
+    triangleIndices
+  };
+}
+function decodeEdgeIndices(dataView, vertexData, triangleIndicesEndPosition) {
+  let position = triangleIndicesEndPosition;
+  const elementsPerVertex = 3;
+  const vertexCount = vertexData.length / elementsPerVertex;
+  const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
+  const westVertexCount = dataView.getUint32(position, true);
+  position += Uint32Array.BYTES_PER_ELEMENT;
+  const westIndices = decodeIndex(dataView.buffer, position, westVertexCount, bytesPerIndex, false);
+  position += westVertexCount * bytesPerIndex;
+  const southVertexCount = dataView.getUint32(position, true);
+  position += Uint32Array.BYTES_PER_ELEMENT;
+  const southIndices = decodeIndex(dataView.buffer, position, southVertexCount, bytesPerIndex, false);
+  position += southVertexCount * bytesPerIndex;
+  const eastVertexCount = dataView.getUint32(position, true);
+  position += Uint32Array.BYTES_PER_ELEMENT;
+  const eastIndices = decodeIndex(dataView.buffer, position, eastVertexCount, bytesPerIndex, false);
+  position += eastVertexCount * bytesPerIndex;
+  const northVertexCount = dataView.getUint32(position, true);
+  position += Uint32Array.BYTES_PER_ELEMENT;
+  const northIndices = decodeIndex(dataView.buffer, position, northVertexCount, bytesPerIndex, false);
+  position += northVertexCount * bytesPerIndex;
+  return {
+    edgeIndicesEndPosition: position,
+    westIndices,
+    southIndices,
+    eastIndices,
+    northIndices
+  };
+}
+function decodeVertexNormalsExtension(extensionDataView) {
+  return new Uint8Array(extensionDataView.buffer, extensionDataView.byteOffset, extensionDataView.byteLength);
+}
+function decodeWaterMaskExtension(extensionDataView) {
+  return extensionDataView.buffer.slice(extensionDataView.byteOffset, extensionDataView.byteOffset + extensionDataView.byteLength);
+}
+function decodeExtensions(dataView, indicesEndPosition) {
+  const extensions = {};
+  if (dataView.byteLength <= indicesEndPosition) {
+    return {
+      extensions,
+      extensionsEndPosition: indicesEndPosition
+    };
+  }
+  let position = indicesEndPosition;
+  while (position < dataView.byteLength) {
+    const extensionId = dataView.getUint8(position, true);
+    position += Uint8Array.BYTES_PER_ELEMENT;
+    const extensionLength = dataView.getUint32(position, true);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    const extensionView = new DataView(dataView.buffer, position, extensionLength);
+    switch (extensionId) {
+      case 1:
+        {
+          extensions.vertexNormals = decodeVertexNormalsExtension(extensionView);
+          break;
+        }
+      case 2:
+        {
+          extensions.waterMask = decodeWaterMaskExtension(extensionView);
+          break;
+        }
+      default:
+        {}
+    }
+    position += extensionLength;
+  }
+  return {
+    extensions,
+    extensionsEndPosition: position
+  };
+}
+export const DECODING_STEPS = {
+  header: 0,
+  vertices: 1,
+  triangleIndices: 2,
+  edgeIndices: 3,
+  extensions: 4
+};
+const DEFAULT_OPTIONS = {
+  maxDecodingStep: DECODING_STEPS.extensions
+};
+export default function decode(data, userOptions) {
+  const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);
+  const view = new DataView(data);
+  const {
+    header,
+    headerEndPosition
+  } = decodeHeader(view);
+  if (options.maxDecodingStep < DECODING_STEPS.vertices) {
+    return {
+      header
+    };
+  }
+  const {
+    vertexData,
+    vertexDataEndPosition
+  } = decodeVertexData(view, headerEndPosition);
+  if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {
+    return {
+      header,
+      vertexData
+    };
+  }
+  const {
+    triangleIndices,
+    triangleIndicesEndPosition
+  } = decodeTriangleIndices(view, vertexData, vertexDataEndPosition);
+  if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {
+    return {
+      header,
+      vertexData,
+      triangleIndices
+    };
+  }
+  const {
+    westIndices,
+    southIndices,
+    eastIndices,
+    northIndices,
+    edgeIndicesEndPosition
+  } = decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
+  if (options.maxDecodingStep < DECODING_STEPS.extensions) {
+    return {
+      header,
+      vertexData,
+      triangleIndices,
+      westIndices,
+      northIndices,
+      eastIndices,
+      southIndices
+    };
+  }
+  const {
+    extensions
+  } = decodeExtensions(view, edgeIndicesEndPosition);
+  return {
+    header,
+    vertexData,
+    triangleIndices,
+    westIndices,
+    northIndices,
+    eastIndices,
+    southIndices,
+    extensions
+  };
+}
+//# sourceMappingURL=decode-quantized-mesh.js.map

package/dist/esm/lib/decode-quantized-mesh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-quantized-mesh.js","names":["QUANTIZED_MESH_HEADER","Map","Float64Array","BYTES_PER_ELEMENT","Float32Array","decodeZigZag","value","decodeHeader","dataView","position","header","key","bytesCount","getter","getFloat64","getFloat32","call","headerEndPosition","decodeVertexData","elementsPerVertex","vertexCount","getUint32","vertexData","Uint16Array","Uint32Array","bytesPerArrayElement","elementArrayLength","uArrayStartPosition","vArrayStartPosition","heightArrayStartPosition","u","v","height","i","getUint16","vertexDataEndPosition","decodeIndex","buffer","indicesCount","bytesPerIndex","encoded","arguments","length","undefined","indices","highest","code","decodeTriangleIndices","triangleCount","triangleIndicesCount","triangleIndices","triangleIndicesEndPosition","decodeEdgeIndices","westVertexCount","westIndices","southVertexCount","southIndices","eastVertexCount","eastIndices","northVertexCount","northIndices","edgeIndicesEndPosition","decodeVertexNormalsExtension","extensionDataView","Uint8Array","byteOffset","byteLength","decodeWaterMaskExtension","slice","decodeExtensions","indicesEndPosition","extensions","extensionsEndPosition","extensionId","getUint8","extensionLength","extensionView","DataView","vertexNormals","waterMask","DECODING_STEPS","vertices","edgeIndices","DEFAULT_OPTIONS","maxDecodingStep","decode","data","userOptions","options","Object","assign","view"],"sources":["../../../src/lib/decode-quantized-mesh.ts"],"sourcesContent":["// Copyright (C) 2018-2019 HERE Europe B.V.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nconst QUANTIZED_MESH_HEADER = new Map([\n  ['centerX', Float64Array.BYTES_PER_ELEMENT],\n  ['centerY', Float64Array.BYTES_PER_ELEMENT],\n  ['centerZ', Float64Array.BYTES_PER_ELEMENT],\n\n  ['minHeight', Float32Array.BYTES_PER_ELEMENT],\n  ['maxHeight', Float32Array.BYTES_PER_ELEMENT],\n\n  ['boundingSphereCenterX', Float64Array.BYTES_PER_ELEMENT],\n  ['boundingSphereCenterY', Float64Array.BYTES_PER_ELEMENT],\n  ['boundingSphereCenterZ', Float64Array.BYTES_PER_ELEMENT],\n  ['boundingSphereRadius', Float64Array.BYTES_PER_ELEMENT],\n\n  ['horizonOcclusionPointX', Float64Array.BYTES_PER_ELEMENT],\n  ['horizonOcclusionPointY', Float64Array.BYTES_PER_ELEMENT],\n  ['horizonOcclusionPointZ', Float64Array.BYTES_PER_ELEMENT]\n]);\n\nfunction decodeZigZag(value) {\n  return (value >> 1) ^ -(value & 1);\n}\n\nfunction decodeHeader(dataView) {\n  let position = 0;\n  const header = {};\n\n  for (const [key, bytesCount] of QUANTIZED_MESH_HEADER) {\n    const getter = bytesCount === 8 ? dataView.getFloat64 : dataView.getFloat32;\n\n    header[key] = getter.call(dataView, position, true);\n    position += bytesCount;\n  }\n\n  return {header, headerEndPosition: position};\n}\n\nfunction decodeVertexData(dataView, headerEndPosition) {\n  let position = headerEndPosition;\n  const elementsPerVertex = 3;\n  const vertexCount = dataView.getUint32(position, true);\n  const vertexData = new Uint16Array(vertexCount * elementsPerVertex);\n\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;\n  const elementArrayLength = vertexCount * bytesPerArrayElement;\n  const uArrayStartPosition = position;\n  const vArrayStartPosition = uArrayStartPosition + elementArrayLength;\n  const heightArrayStartPosition = vArrayStartPosition + elementArrayLength;\n\n  let u = 0;\n  let v = 0;\n  let height = 0;\n\n  for (let i = 0; i < vertexCount; i++) {\n    u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));\n    v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));\n    height += decodeZigZag(\n      dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true)\n    );\n\n    vertexData[i] = u;\n    vertexData[i + vertexCount] = v;\n    vertexData[i + vertexCount * 2] = height;\n  }\n\n  position += elementArrayLength * 3;\n\n  return {vertexData, vertexDataEndPosition: position};\n}\n\nfunction decodeIndex(buffer, position, indicesCount, bytesPerIndex, encoded = true) {\n  let indices;\n\n  if (bytesPerIndex === 2) {\n    indices = new Uint16Array(buffer, position, indicesCount);\n  } else {\n    indices = new Uint32Array(buffer, position, indicesCount);\n  }\n\n  if (!encoded) {\n    return indices;\n  }\n\n  let highest = 0;\n\n  for (let i = 0; i < indices.length; ++i) {\n    const code = indices[i];\n\n    indices[i] = highest - code;\n\n    if (code === 0) {\n      ++highest;\n    }\n  }\n\n  return indices;\n}\n\nfunction decodeTriangleIndices(dataView, vertexData, vertexDataEndPosition) {\n  let position = vertexDataEndPosition;\n  const elementsPerVertex = 3;\n  const vertexCount = vertexData.length / elementsPerVertex;\n  const bytesPerIndex =\n    vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;\n\n  if (position % bytesPerIndex !== 0) {\n    position += bytesPerIndex - (position % bytesPerIndex);\n  }\n\n  const triangleCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const triangleIndicesCount = triangleCount * 3;\n  const triangleIndices = decodeIndex(\n    dataView.buffer,\n    position,\n    triangleIndicesCount,\n    bytesPerIndex\n  );\n  position += triangleIndicesCount * bytesPerIndex;\n\n  return {\n    triangleIndicesEndPosition: position,\n    triangleIndices\n  };\n}\n\nfunction decodeEdgeIndices(dataView, vertexData, triangleIndicesEndPosition) {\n  let position = triangleIndicesEndPosition;\n  const elementsPerVertex = 3;\n  const vertexCount = vertexData.length / elementsPerVertex;\n  const bytesPerIndex =\n    vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;\n\n  const westVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const westIndices = decodeIndex(dataView.buffer, position, westVertexCount, bytesPerIndex, false);\n  position += westVertexCount * bytesPerIndex;\n\n  const southVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const southIndices = decodeIndex(\n    dataView.buffer,\n    position,\n    southVertexCount,\n    bytesPerIndex,\n    false\n  );\n  position += southVertexCount * bytesPerIndex;\n\n  const eastVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const eastIndices = decodeIndex(dataView.buffer, position, eastVertexCount, bytesPerIndex, false);\n  position += eastVertexCount * bytesPerIndex;\n\n  const northVertexCount = dataView.getUint32(position, true);\n  position += Uint32Array.BYTES_PER_ELEMENT;\n\n  const northIndices = decodeIndex(\n    dataView.buffer,\n    position,\n    northVertexCount,\n    bytesPerIndex,\n    false\n  );\n  position += northVertexCount * bytesPerIndex;\n\n  return {\n    edgeIndicesEndPosition: position,\n    westIndices,\n    southIndices,\n    eastIndices,\n    northIndices\n  };\n}\n\nfunction decodeVertexNormalsExtension(extensionDataView) {\n  return new Uint8Array(\n    extensionDataView.buffer,\n    extensionDataView.byteOffset,\n    extensionDataView.byteLength\n  );\n}\n\nfunction decodeWaterMaskExtension(extensionDataView) {\n  return extensionDataView.buffer.slice(\n    extensionDataView.byteOffset,\n    extensionDataView.byteOffset + extensionDataView.byteLength\n  );\n}\n\ntype Extensions = {\n  vertexNormals?: any;\n  waterMask?: any;\n};\n\nfunction decodeExtensions(dataView, indicesEndPosition) {\n  const extensions: Extensions = {};\n\n  if (dataView.byteLength <= indicesEndPosition) {\n    return {extensions, extensionsEndPosition: indicesEndPosition};\n  }\n\n  let position = indicesEndPosition;\n\n  while (position < dataView.byteLength) {\n    const extensionId = dataView.getUint8(position, true);\n    position += Uint8Array.BYTES_PER_ELEMENT;\n\n    const extensionLength = dataView.getUint32(position, true);\n    position += Uint32Array.BYTES_PER_ELEMENT;\n\n    const extensionView = new DataView(dataView.buffer, position, extensionLength);\n\n    switch (extensionId) {\n      case 1: {\n        extensions.vertexNormals = decodeVertexNormalsExtension(extensionView);\n\n        break;\n      }\n      case 2: {\n        extensions.waterMask = decodeWaterMaskExtension(extensionView);\n\n        break;\n      }\n      default: {\n        // console.warn(`Unknown extension with id ${extensionId}`)\n      }\n    }\n\n    position += extensionLength;\n  }\n\n  return {extensions, extensionsEndPosition: position};\n}\n\nexport const DECODING_STEPS = {\n  header: 0,\n  vertices: 1,\n  triangleIndices: 2,\n  edgeIndices: 3,\n  extensions: 4\n};\n\nconst DEFAULT_OPTIONS = {\n  maxDecodingStep: DECODING_STEPS.extensions\n};\n\nexport default function decode(data, userOptions) {\n  const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);\n  const view = new DataView(data);\n  const {header, headerEndPosition} = decodeHeader(view);\n\n  if (options.maxDecodingStep < DECODING_STEPS.vertices) {\n    return {header};\n  }\n\n  const {vertexData, vertexDataEndPosition} = decodeVertexData(view, headerEndPosition);\n\n  if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {\n    return {header, vertexData};\n  }\n\n  const {triangleIndices, triangleIndicesEndPosition} = decodeTriangleIndices(\n    view,\n    vertexData,\n    vertexDataEndPosition\n  );\n\n  if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {\n    return {header, vertexData, triangleIndices};\n  }\n\n  const {westIndices, southIndices, eastIndices, northIndices, edgeIndicesEndPosition} =\n    decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);\n\n  if (options.maxDecodingStep < DECODING_STEPS.extensions) {\n    return {\n      header,\n      vertexData,\n      triangleIndices,\n      westIndices,\n      northIndices,\n      eastIndices,\n      southIndices\n    };\n  }\n\n  const {extensions} = decodeExtensions(view, edgeIndicesEndPosition);\n\n  return {\n    header,\n    vertexData,\n    triangleIndices,\n    westIndices,\n    northIndices,\n    eastIndices,\n    southIndices,\n    extensions\n  };\n}\n"],"mappings":"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"}

package/dist/esm/lib/delatin/index.js

@@ -0,0 +1,355 @@
+export default class Delatin {
+  constructor(data, width) {
+    let height = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : width;
+    this.data = data;
+    this.width = width;
+    this.height = height;
+    this.coords = [];
+    this.triangles = [];
+    this._halfedges = [];
+    this._candidates = [];
+    this._queueIndices = [];
+    this._queue = [];
+    this._errors = [];
+    this._rms = [];
+    this._pending = [];
+    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);
+    const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
+    this._addTriangle(p0, p3, p1, t0, -1, -1);
+    this._flush();
+  }
+  run() {
+    let maxError = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    while (this.getMaxError() > maxError) {
+      this.refine();
+    }
+  }
+  refine() {
+    this._step();
+    this._flush();
+  }
+  getMaxError() {
+    return this._errors[0];
+  }
+  getRMSD() {
+    return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
+  }
+  heightAt(x, y) {
+    return this.data[this.width * y + x];
+  }
+  _flush() {
+    const coords = this.coords;
+    for (let i = 0; i < this._pendingLen; i++) {
+      const t = this._pending[i];
+      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;
+  }
+  _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
+    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);
+    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;
+    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;
+    let maxError = 0;
+    let mx = 0;
+    let my = 0;
+    let rms = 0;
+    for (let y = minY; y <= maxY; y++) {
+      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++) {
+        if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
+          wasInside = true;
+          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;
+    }
+    this._candidates[2 * t] = mx;
+    this._candidates[2 * t + 1] = my;
+    this._rms[t] = rms;
+    this._queuePush(t, maxError, rms);
+  }
+  _step() {
+    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);
+    }
+  }
+  _addPoint(x, y) {
+    const i = this.coords.length >> 1;
+    this.coords.push(x, y);
+    return i;
+  }
+  _addTriangle(a, b, c, ab, bc, ca) {
+    let e = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : this.triangles.length;
+    const t = e / 3;
+    this.triangles[e + 0] = a;
+    this.triangles[e + 1] = b;
+    this.triangles[e + 2] = c;
+    this._halfedges[e + 0] = ab;
+    this._halfedges[e + 1] = bc;
+    this._halfedges[e + 2] = ca;
+    if (ab >= 0) {
+      this._halfedges[ab] = e + 0;
+    }
+    if (bc >= 0) {
+      this._halfedges[bc] = e + 1;
+    }
+    if (ca >= 0) {
+      this._halfedges[ca] = e + 2;
+    }
+    this._candidates[2 * t + 0] = 0;
+    this._candidates[2 * t + 1] = 0;
+    this._queueIndices[t] = -1;
+    this._rms[t] = 0;
+    this._pending[this._pendingLen++] = t;
+    return e;
+  }
+  _legalize(a) {
+    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.coords;
+    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);
+  }
+  _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);
+  }
+  _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;
+}
+//# sourceMappingURL=index.js.map