@pggis/pg-sdk 3.3.10 → 3.5.0

package/dist/resources/Workers/chunk-KKCR2YOP.js

@@ -1,421 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.115
- *
- * Copyright 2011-2022 Cesium Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Columbus View (Pat. Pend.)
- *
- * Portions licensed separately.
- * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
- */
-
-import {
-  EllipsoidGeodesic_default
-} from "./chunk-F4HFJMGM.js";
-import {
-  EllipsoidRhumbLine_default
-} from "./chunk-SH5USDPI.js";
-import {
-  IntersectionTests_default
-} from "./chunk-2FRVPMCS.js";
-import {
-  Plane_default
-} from "./chunk-Y5UQJLYE.js";
-import {
-  Matrix4_default
-} from "./chunk-YJEBABKH.js";
-import {
-  Cartesian3_default,
-  Cartographic_default,
-  Ellipsoid_default
-} from "./chunk-OGXZVPPM.js";
-import {
-  Math_default
-} from "./chunk-5QULIR53.js";
-import {
-  defaultValue_default
-} from "./chunk-BBWDMCVU.js";
-import {
-  DeveloperError_default
-} from "./chunk-XGI5BXZY.js";
-import {
-  defined_default
-} from "./chunk-YWTJ2B4B.js";
-
-// packages/engine/Source/Core/PolylinePipeline.js
-var PolylinePipeline = {};
-PolylinePipeline.numberOfPoints = function(p0, p1, minDistance) {
-  const distance = Cartesian3_default.distance(p0, p1);
-  return Math.ceil(distance / minDistance);
-};
-PolylinePipeline.numberOfPointsRhumbLine = function(p0, p1, granularity) {
-  const radiansDistanceSquared = Math.pow(p0.longitude - p1.longitude, 2) + Math.pow(p0.latitude - p1.latitude, 2);
-  return Math.max(
-    1,
-    Math.ceil(Math.sqrt(radiansDistanceSquared / (granularity * granularity)))
-  );
-};
-var cartoScratch = new Cartographic_default();
-PolylinePipeline.extractHeights = function(positions, ellipsoid) {
-  const length = positions.length;
-  const heights = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const p = positions[i];
-    heights[i] = ellipsoid.cartesianToCartographic(p, cartoScratch).height;
-  }
-  return heights;
-};
-var wrapLongitudeInversMatrix = new Matrix4_default();
-var wrapLongitudeOrigin = new Cartesian3_default();
-var wrapLongitudeXZNormal = new Cartesian3_default();
-var wrapLongitudeXZPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
-var wrapLongitudeYZNormal = new Cartesian3_default();
-var wrapLongitudeYZPlane = new Plane_default(Cartesian3_default.UNIT_X, 0);
-var wrapLongitudeIntersection = new Cartesian3_default();
-var wrapLongitudeOffset = new Cartesian3_default();
-var subdivideHeightsScratchArray = [];
-function subdivideHeights(numPoints, h0, h1) {
-  const heights = subdivideHeightsScratchArray;
-  heights.length = numPoints;
-  let i;
-  if (h0 === h1) {
-    for (i = 0; i < numPoints; i++) {
-      heights[i] = h0;
-    }
-    return heights;
-  }
-  const dHeight = h1 - h0;
-  const heightPerVertex = dHeight / numPoints;
-  for (i = 0; i < numPoints; i++) {
-    const h = h0 + i * heightPerVertex;
-    heights[i] = h;
-  }
-  return heights;
-}
-var carto1 = new Cartographic_default();
-var carto2 = new Cartographic_default();
-var cartesian = new Cartesian3_default();
-var scaleFirst = new Cartesian3_default();
-var scaleLast = new Cartesian3_default();
-var ellipsoidGeodesic = new EllipsoidGeodesic_default();
-var ellipsoidRhumb = new EllipsoidRhumbLine_default();
-function generateCartesianArc(p0, p1, minDistance, ellipsoid, h0, h1, array, offset) {
-  const first = ellipsoid.scaleToGeodeticSurface(p0, scaleFirst);
-  const last = ellipsoid.scaleToGeodeticSurface(p1, scaleLast);
-  const numPoints = PolylinePipeline.numberOfPoints(p0, p1, minDistance);
-  const start = ellipsoid.cartesianToCartographic(first, carto1);
-  const end = ellipsoid.cartesianToCartographic(last, carto2);
-  const heights = subdivideHeights(numPoints, h0, h1);
-  ellipsoidGeodesic.setEndPoints(start, end);
-  const surfaceDistanceBetweenPoints = ellipsoidGeodesic.surfaceDistance / numPoints;
-  let index = offset;
-  start.height = h0;
-  let cart = ellipsoid.cartographicToCartesian(start, cartesian);
-  Cartesian3_default.pack(cart, array, index);
-  index += 3;
-  for (let i = 1; i < numPoints; i++) {
-    const carto = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
-      i * surfaceDistanceBetweenPoints,
-      carto2
-    );
-    carto.height = heights[i];
-    cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-    Cartesian3_default.pack(cart, array, index);
-    index += 3;
-  }
-  return index;
-}
-function generateCartesianRhumbArc(p0, p1, granularity, ellipsoid, h0, h1, array, offset) {
-  const start = ellipsoid.cartesianToCartographic(p0, carto1);
-  const end = ellipsoid.cartesianToCartographic(p1, carto2);
-  const numPoints = PolylinePipeline.numberOfPointsRhumbLine(
-    start,
-    end,
-    granularity
-  );
-  start.height = 0;
-  end.height = 0;
-  const heights = subdivideHeights(numPoints, h0, h1);
-  if (!ellipsoidRhumb.ellipsoid.equals(ellipsoid)) {
-    ellipsoidRhumb = new EllipsoidRhumbLine_default(void 0, void 0, ellipsoid);
-  }
-  ellipsoidRhumb.setEndPoints(start, end);
-  const surfaceDistanceBetweenPoints = ellipsoidRhumb.surfaceDistance / numPoints;
-  let index = offset;
-  start.height = h0;
-  let cart = ellipsoid.cartographicToCartesian(start, cartesian);
-  Cartesian3_default.pack(cart, array, index);
-  index += 3;
-  for (let i = 1; i < numPoints; i++) {
-    const carto = ellipsoidRhumb.interpolateUsingSurfaceDistance(
-      i * surfaceDistanceBetweenPoints,
-      carto2
-    );
-    carto.height = heights[i];
-    cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-    Cartesian3_default.pack(cart, array, index);
-    index += 3;
-  }
-  return index;
-}
-PolylinePipeline.wrapLongitude = function(positions, modelMatrix) {
-  const cartesians = [];
-  const segments = [];
-  if (defined_default(positions) && positions.length > 0) {
-    modelMatrix = defaultValue_default(modelMatrix, Matrix4_default.IDENTITY);
-    const inverseModelMatrix = Matrix4_default.inverseTransformation(
-      modelMatrix,
-      wrapLongitudeInversMatrix
-    );
-    const origin = Matrix4_default.multiplyByPoint(
-      inverseModelMatrix,
-      Cartesian3_default.ZERO,
-      wrapLongitudeOrigin
-    );
-    const xzNormal = Cartesian3_default.normalize(
-      Matrix4_default.multiplyByPointAsVector(
-        inverseModelMatrix,
-        Cartesian3_default.UNIT_Y,
-        wrapLongitudeXZNormal
-      ),
-      wrapLongitudeXZNormal
-    );
-    const xzPlane = Plane_default.fromPointNormal(
-      origin,
-      xzNormal,
-      wrapLongitudeXZPlane
-    );
-    const yzNormal = Cartesian3_default.normalize(
-      Matrix4_default.multiplyByPointAsVector(
-        inverseModelMatrix,
-        Cartesian3_default.UNIT_X,
-        wrapLongitudeYZNormal
-      ),
-      wrapLongitudeYZNormal
-    );
-    const yzPlane = Plane_default.fromPointNormal(
-      origin,
-      yzNormal,
-      wrapLongitudeYZPlane
-    );
-    let count = 1;
-    cartesians.push(Cartesian3_default.clone(positions[0]));
-    let prev = cartesians[0];
-    const length = positions.length;
-    for (let i = 1; i < length; ++i) {
-      const cur = positions[i];
-      if (Plane_default.getPointDistance(yzPlane, prev) < 0 || Plane_default.getPointDistance(yzPlane, cur) < 0) {
-        const intersection = IntersectionTests_default.lineSegmentPlane(
-          prev,
-          cur,
-          xzPlane,
-          wrapLongitudeIntersection
-        );
-        if (defined_default(intersection)) {
-          const offset = Cartesian3_default.multiplyByScalar(
-            xzNormal,
-            5e-9,
-            wrapLongitudeOffset
-          );
-          if (Plane_default.getPointDistance(xzPlane, prev) < 0) {
-            Cartesian3_default.negate(offset, offset);
-          }
-          cartesians.push(
-            Cartesian3_default.add(intersection, offset, new Cartesian3_default())
-          );
-          segments.push(count + 1);
-          Cartesian3_default.negate(offset, offset);
-          cartesians.push(
-            Cartesian3_default.add(intersection, offset, new Cartesian3_default())
-          );
-          count = 1;
-        }
-      }
-      cartesians.push(Cartesian3_default.clone(positions[i]));
-      count++;
-      prev = cur;
-    }
-    segments.push(count);
-  }
-  return {
-    positions: cartesians,
-    lengths: segments
-  };
-};
-PolylinePipeline.generateArc = function(options) {
-  if (!defined_default(options)) {
-    options = {};
-  }
-  const positions = options.positions;
-  if (!defined_default(positions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  const length = positions.length;
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
-  let height = defaultValue_default(options.height, 0);
-  const hasHeightArray = Array.isArray(height);
-  if (length < 1) {
-    return [];
-  } else if (length === 1) {
-    const p = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
-    height = hasHeightArray ? height[0] : height;
-    if (height !== 0) {
-      const n = ellipsoid.geodeticSurfaceNormal(p, cartesian);
-      Cartesian3_default.multiplyByScalar(n, height, n);
-      Cartesian3_default.add(p, n, p);
-    }
-    return [p.x, p.y, p.z];
-  }
-  let minDistance = options.minDistance;
-  if (!defined_default(minDistance)) {
-    const granularity = defaultValue_default(
-      options.granularity,
-      Math_default.RADIANS_PER_DEGREE
-    );
-    minDistance = Math_default.chordLength(granularity, ellipsoid.maximumRadius);
-  }
-  let numPoints = 0;
-  let i;
-  for (i = 0; i < length - 1; i++) {
-    numPoints += PolylinePipeline.numberOfPoints(
-      positions[i],
-      positions[i + 1],
-      minDistance
-    );
-  }
-  const arrayLength = (numPoints + 1) * 3;
-  const newPositions = new Array(arrayLength);
-  let offset = 0;
-  for (i = 0; i < length - 1; i++) {
-    const p0 = positions[i];
-    const p1 = positions[i + 1];
-    const h0 = hasHeightArray ? height[i] : height;
-    const h1 = hasHeightArray ? height[i + 1] : height;
-    offset = generateCartesianArc(
-      p0,
-      p1,
-      minDistance,
-      ellipsoid,
-      h0,
-      h1,
-      newPositions,
-      offset
-    );
-  }
-  subdivideHeightsScratchArray.length = 0;
-  const lastPoint = positions[length - 1];
-  const carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
-  carto.height = hasHeightArray ? height[length - 1] : height;
-  const cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-  Cartesian3_default.pack(cart, newPositions, arrayLength - 3);
-  return newPositions;
-};
-var scratchCartographic0 = new Cartographic_default();
-var scratchCartographic1 = new Cartographic_default();
-PolylinePipeline.generateRhumbArc = function(options) {
-  if (!defined_default(options)) {
-    options = {};
-  }
-  const positions = options.positions;
-  if (!defined_default(positions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  const length = positions.length;
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
-  let height = defaultValue_default(options.height, 0);
-  const hasHeightArray = Array.isArray(height);
-  if (length < 1) {
-    return [];
-  } else if (length === 1) {
-    const p = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
-    height = hasHeightArray ? height[0] : height;
-    if (height !== 0) {
-      const n = ellipsoid.geodeticSurfaceNormal(p, cartesian);
-      Cartesian3_default.multiplyByScalar(n, height, n);
-      Cartesian3_default.add(p, n, p);
-    }
-    return [p.x, p.y, p.z];
-  }
-  const granularity = defaultValue_default(
-    options.granularity,
-    Math_default.RADIANS_PER_DEGREE
-  );
-  let numPoints = 0;
-  let i;
-  let c0 = ellipsoid.cartesianToCartographic(
-    positions[0],
-    scratchCartographic0
-  );
-  let c1;
-  for (i = 0; i < length - 1; i++) {
-    c1 = ellipsoid.cartesianToCartographic(
-      positions[i + 1],
-      scratchCartographic1
-    );
-    numPoints += PolylinePipeline.numberOfPointsRhumbLine(c0, c1, granularity);
-    c0 = Cartographic_default.clone(c1, scratchCartographic0);
-  }
-  const arrayLength = (numPoints + 1) * 3;
-  const newPositions = new Array(arrayLength);
-  let offset = 0;
-  for (i = 0; i < length - 1; i++) {
-    const p0 = positions[i];
-    const p1 = positions[i + 1];
-    const h0 = hasHeightArray ? height[i] : height;
-    const h1 = hasHeightArray ? height[i + 1] : height;
-    offset = generateCartesianRhumbArc(
-      p0,
-      p1,
-      granularity,
-      ellipsoid,
-      h0,
-      h1,
-      newPositions,
-      offset
-    );
-  }
-  subdivideHeightsScratchArray.length = 0;
-  const lastPoint = positions[length - 1];
-  const carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
-  carto.height = hasHeightArray ? height[length - 1] : height;
-  const cart = ellipsoid.cartographicToCartesian(carto, cartesian);
-  Cartesian3_default.pack(cart, newPositions, arrayLength - 3);
-  return newPositions;
-};
-PolylinePipeline.generateCartesianArc = function(options) {
-  const numberArray = PolylinePipeline.generateArc(options);
-  const size = numberArray.length / 3;
-  const newPositions = new Array(size);
-  for (let i = 0; i < size; i++) {
-    newPositions[i] = Cartesian3_default.unpack(numberArray, i * 3);
-  }
-  return newPositions;
-};
-PolylinePipeline.generateCartesianRhumbArc = function(options) {
-  const numberArray = PolylinePipeline.generateRhumbArc(options);
-  const size = numberArray.length / 3;
-  const newPositions = new Array(size);
-  for (let i = 0; i < size; i++) {
-    newPositions[i] = Cartesian3_default.unpack(numberArray, i * 3);
-  }
-  return newPositions;
-};
-var PolylinePipeline_default = PolylinePipeline;
-
-export {
-  PolylinePipeline_default
-};

package/dist/resources/Workers/chunk-LPR3YNP2.js

@@ -1,138 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.115
- *
- * Copyright 2011-2022 Cesium Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Columbus View (Pat. Pend.)
- *
- * Portions licensed separately.
- * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
- */
-
-import {
-  Math_default
-} from "./chunk-5QULIR53.js";
-import {
-  WebGLConstants_default
-} from "./chunk-SOWMRMWA.js";
-import {
-  DeveloperError_default
-} from "./chunk-XGI5BXZY.js";
-import {
-  defined_default
-} from "./chunk-YWTJ2B4B.js";
-
-// packages/engine/Source/Core/IndexDatatype.js
-var IndexDatatype = {
-  /**
-   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
-   * of an element in <code>Uint8Array</code>.
-   *
-   * @type {number}
-   * @constant
-   */
-  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
-  /**
-   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
-   * of an element in <code>Uint16Array</code>.
-   *
-   * @type {number}
-   * @constant
-   */
-  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
-  /**
-   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
-   * of an element in <code>Uint32Array</code>.
-   *
-   * @type {number}
-   * @constant
-   */
-  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT
-};
-IndexDatatype.getSizeInBytes = function(indexDatatype) {
-  switch (indexDatatype) {
-    case IndexDatatype.UNSIGNED_BYTE:
-      return Uint8Array.BYTES_PER_ELEMENT;
-    case IndexDatatype.UNSIGNED_SHORT:
-      return Uint16Array.BYTES_PER_ELEMENT;
-    case IndexDatatype.UNSIGNED_INT:
-      return Uint32Array.BYTES_PER_ELEMENT;
-  }
-  throw new DeveloperError_default(
-    "indexDatatype is required and must be a valid IndexDatatype constant."
-  );
-};
-IndexDatatype.fromSizeInBytes = function(sizeInBytes) {
-  switch (sizeInBytes) {
-    case 2:
-      return IndexDatatype.UNSIGNED_SHORT;
-    case 4:
-      return IndexDatatype.UNSIGNED_INT;
-    case 1:
-      return IndexDatatype.UNSIGNED_BYTE;
-    default:
-      throw new DeveloperError_default(
-        "Size in bytes cannot be mapped to an IndexDatatype"
-      );
-  }
-};
-IndexDatatype.validate = function(indexDatatype) {
-  return defined_default(indexDatatype) && (indexDatatype === IndexDatatype.UNSIGNED_BYTE || indexDatatype === IndexDatatype.UNSIGNED_SHORT || indexDatatype === IndexDatatype.UNSIGNED_INT);
-};
-IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
-  if (!defined_default(numberOfVertices)) {
-    throw new DeveloperError_default("numberOfVertices is required.");
-  }
-  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
-    return new Uint32Array(indicesLengthOrArray);
-  }
-  return new Uint16Array(indicesLengthOrArray);
-};
-IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
-  if (!defined_default(numberOfVertices)) {
-    throw new DeveloperError_default("numberOfVertices is required.");
-  }
-  if (!defined_default(sourceArray)) {
-    throw new DeveloperError_default("sourceArray is required.");
-  }
-  if (!defined_default(byteOffset)) {
-    throw new DeveloperError_default("byteOffset is required.");
-  }
-  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
-    return new Uint32Array(sourceArray, byteOffset, length);
-  }
-  return new Uint16Array(sourceArray, byteOffset, length);
-};
-IndexDatatype.fromTypedArray = function(array) {
-  if (array instanceof Uint8Array) {
-    return IndexDatatype.UNSIGNED_BYTE;
-  }
-  if (array instanceof Uint16Array) {
-    return IndexDatatype.UNSIGNED_SHORT;
-  }
-  if (array instanceof Uint32Array) {
-    return IndexDatatype.UNSIGNED_INT;
-  }
-  throw new DeveloperError_default(
-    "array must be a Uint8Array, Uint16Array, or Uint32Array."
-  );
-};
-var IndexDatatype_default = Object.freeze(IndexDatatype);
-
-export {
-  IndexDatatype_default
-};