@vcmap/ui 5.0.0-rc.18 → 5.0.0-rc.21

package/dist/assets/cesium/Workers/WebMercatorProjection-13a90d41.js

@@ -0,0 +1,151 @@
+define(['exports', './Matrix3-315394f6', './defaultValue-0a909f67', './Check-666ab1a0', './Math-2dbd6b93'], (function (exports, Matrix3, defaultValue, Check, Math$1) { 'use strict';
+
+  /**
+   * The map projection used by Google Maps, Bing Maps, and most of ArcGIS Online, EPSG:3857.  This
+   * projection use longitude and latitude expressed with the WGS84 and transforms them to Mercator using
+   * the spherical (rather than ellipsoidal) equations.
+   *
+   * @alias WebMercatorProjection
+   * @constructor
+   *
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
+   *
+   * @see GeographicProjection
+   */
+  function WebMercatorProjection(ellipsoid) {
+    this._ellipsoid = defaultValue.defaultValue(ellipsoid, Matrix3.Ellipsoid.WGS84);
+    this._semimajorAxis = this._ellipsoid.maximumRadius;
+    this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
+  }
+
+  Object.defineProperties(WebMercatorProjection.prototype, {
+    /**
+     * Gets the {@link Ellipsoid}.
+     *
+     * @memberof WebMercatorProjection.prototype
+     *
+     * @type {Ellipsoid}
+     * @readonly
+     */
+    ellipsoid: {
+      get: function () {
+        return this._ellipsoid;
+      },
+    },
+  });
+
+  /**
+   * Converts a Mercator angle, in the range -PI to PI, to a geodetic latitude
+   * in the range -PI/2 to PI/2.
+   *
+   * @param {Number} mercatorAngle The angle to convert.
+   * @returns {Number} The geodetic latitude in radians.
+   */
+  WebMercatorProjection.mercatorAngleToGeodeticLatitude = function (
+    mercatorAngle
+  ) {
+    return Math$1.CesiumMath.PI_OVER_TWO - 2.0 * Math.atan(Math.exp(-mercatorAngle));
+  };
+
+  /**
+   * Converts a geodetic latitude in radians, in the range -PI/2 to PI/2, to a Mercator
+   * angle in the range -PI to PI.
+   *
+   * @param {Number} latitude The geodetic latitude in radians.
+   * @returns {Number} The Mercator angle.
+   */
+  WebMercatorProjection.geodeticLatitudeToMercatorAngle = function (latitude) {
+    // Clamp the latitude coordinate to the valid Mercator bounds.
+    if (latitude > WebMercatorProjection.MaximumLatitude) {
+      latitude = WebMercatorProjection.MaximumLatitude;
+    } else if (latitude < -WebMercatorProjection.MaximumLatitude) {
+      latitude = -WebMercatorProjection.MaximumLatitude;
+    }
+    const sinLatitude = Math.sin(latitude);
+    return 0.5 * Math.log((1.0 + sinLatitude) / (1.0 - sinLatitude));
+  };
+
+  /**
+   * The maximum latitude (both North and South) supported by a Web Mercator
+   * (EPSG:3857) projection.  Technically, the Mercator projection is defined
+   * for any latitude up to (but not including) 90 degrees, but it makes sense
+   * to cut it off sooner because it grows exponentially with increasing latitude.
+   * The logic behind this particular cutoff value, which is the one used by
+   * Google Maps, Bing Maps, and Esri, is that it makes the projection
+   * square.  That is, the rectangle is equal in the X and Y directions.
+   *
+   * The constant value is computed by calling:
+   *    WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI)
+   *
+   * @type {Number}
+   */
+  WebMercatorProjection.MaximumLatitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(
+    Math.PI
+  );
+
+  /**
+   * Converts geodetic ellipsoid coordinates, in radians, to the equivalent Web Mercator
+   * X, Y, Z coordinates expressed in meters and returned in a {@link Cartesian3}.  The height
+   * is copied unmodified to the Z coordinate.
+   *
+   * @param {Cartographic} cartographic The cartographic coordinates in radians.
+   * @param {Cartesian3} [result] The instance to which to copy the result, or undefined if a
+   *        new instance should be created.
+   * @returns {Cartesian3} The equivalent web mercator X, Y, Z coordinates, in meters.
+   */
+  WebMercatorProjection.prototype.project = function (cartographic, result) {
+    const semimajorAxis = this._semimajorAxis;
+    const x = cartographic.longitude * semimajorAxis;
+    const y =
+      WebMercatorProjection.geodeticLatitudeToMercatorAngle(
+        cartographic.latitude
+      ) * semimajorAxis;
+    const z = cartographic.height;
+
+    if (!defaultValue.defined(result)) {
+      return new Matrix3.Cartesian3(x, y, z);
+    }
+
+    result.x = x;
+    result.y = y;
+    result.z = z;
+    return result;
+  };
+
+  /**
+   * Converts Web Mercator X, Y coordinates, expressed in meters, to a {@link Cartographic}
+   * containing geodetic ellipsoid coordinates.  The Z coordinate is copied unmodified to the
+   * height.
+   *
+   * @param {Cartesian3} cartesian The web mercator Cartesian position to unrproject with height (z) in meters.
+   * @param {Cartographic} [result] The instance to which to copy the result, or undefined if a
+   *        new instance should be created.
+   * @returns {Cartographic} The equivalent cartographic coordinates.
+   */
+  WebMercatorProjection.prototype.unproject = function (cartesian, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(cartesian)) {
+      throw new Check.DeveloperError("cartesian is required");
+    }
+    //>>includeEnd('debug');
+
+    const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
+    const longitude = cartesian.x * oneOverEarthSemimajorAxis;
+    const latitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(
+      cartesian.y * oneOverEarthSemimajorAxis
+    );
+    const height = cartesian.z;
+
+    if (!defaultValue.defined(result)) {
+      return new Matrix3.Cartographic(longitude, latitude, height);
+    }
+
+    result.longitude = longitude;
+    result.latitude = latitude;
+    result.height = height;
+    return result;
+  };
+
+  exports.WebMercatorProjection = WebMercatorProjection;
+
+}));

package/dist/assets/cesium/Workers/arrayRemoveDuplicates-c2038105.js

@@ -0,0 +1,129 @@
+define(['exports', './Check-666ab1a0', './defaultValue-0a909f67', './Math-2dbd6b93'], (function (exports, Check, defaultValue, Math) { 'use strict';
+
+  const removeDuplicatesEpsilon = Math.CesiumMath.EPSILON10;
+
+  /**
+   * Removes adjacent duplicate values in an array of values.
+   *
+   * @param {Array.<*>} [values] The array of values.
+   * @param {Function} equalsEpsilon Function to compare values with an epsilon. Boolean equalsEpsilon(left, right, epsilon).
+   * @param {Boolean} [wrapAround=false] Compare the last value in the array against the first value. If they are equal, the last value is removed.
+   * @param {Array.<Number>} [removedIndices=undefined] Store the indices that correspond to the duplicate items removed from the array, if there were any.
+   * @returns {Array.<*>|undefined} A new array of values with no adjacent duplicate values or the input array if no duplicates were found.
+   *
+   * @example
+   * // Returns [(1.0, 1.0, 1.0), (2.0, 2.0, 2.0), (3.0, 3.0, 3.0), (1.0, 1.0, 1.0)]
+   * const values = [
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0),
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0),
+   *     new Cesium.Cartesian3(2.0, 2.0, 2.0),
+   *     new Cesium.Cartesian3(3.0, 3.0, 3.0),
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0)];
+   * const nonDuplicatevalues = Cesium.PolylinePipeline.removeDuplicates(values, Cartesian3.equalsEpsilon);
+   *
+   * @example
+   * // Returns [(1.0, 1.0, 1.0), (2.0, 2.0, 2.0), (3.0, 3.0, 3.0)]
+   * const values = [
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0),
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0),
+   *     new Cesium.Cartesian3(2.0, 2.0, 2.0),
+   *     new Cesium.Cartesian3(3.0, 3.0, 3.0),
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0)];
+   * const nonDuplicatevalues = Cesium.PolylinePipeline.removeDuplicates(values, Cartesian3.equalsEpsilon, true);
+   *
+   * @example
+   * // Returns [(1.0, 1.0, 1.0), (2.0, 2.0, 2.0), (3.0, 3.0, 3.0)]
+   * // removedIndices will be equal to [1, 3, 5]
+   * const values = [
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0),
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0),
+   *     new Cesium.Cartesian3(2.0, 2.0, 2.0),
+   *     new Cesium.Cartesian3(2.0, 2.0, 2.0),
+   *     new Cesium.Cartesian3(3.0, 3.0, 3.0),
+   *     new Cesium.Cartesian3(1.0, 1.0, 1.0)];
+   * const nonDuplicatevalues = Cesium.PolylinePipeline.removeDuplicates(values, Cartesian3.equalsEpsilon, true);
+   * @private
+   */
+  function arrayRemoveDuplicates(
+    values,
+    equalsEpsilon,
+    wrapAround,
+    removedIndices
+  ) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("equalsEpsilon", equalsEpsilon);
+    //>>includeEnd('debug');
+
+    if (!defaultValue.defined(values)) {
+      return undefined;
+    }
+
+    wrapAround = defaultValue.defaultValue(wrapAround, false);
+    const storeRemovedIndices = defaultValue.defined(removedIndices);
+
+    const length = values.length;
+    if (length < 2) {
+      return values;
+    }
+
+    let i;
+    let v0 = values[0];
+    let v1;
+
+    // We only want to create a new array if there are duplicates in the array.
+    // As such, cleanedValues is undefined until it encounters the first duplicate, if it exists.
+    let cleanedValues;
+    let lastCleanIndex = 0;
+
+    // removedIndexLCI keeps track of where lastCleanIndex would be if it were sorted into the removedIndices array.
+    // In case of arrays such as [A, B, C, ..., A, A, A], removedIndices will not be sorted properly without this.
+    let removedIndexLCI = -1;
+
+    for (i = 1; i < length; ++i) {
+      v1 = values[i];
+      if (equalsEpsilon(v0, v1, removeDuplicatesEpsilon)) {
+        if (!defaultValue.defined(cleanedValues)) {
+          cleanedValues = values.slice(0, i);
+          lastCleanIndex = i - 1;
+          removedIndexLCI = 0;
+        }
+        if (storeRemovedIndices) {
+          removedIndices.push(i);
+        }
+      } else {
+        if (defaultValue.defined(cleanedValues)) {
+          cleanedValues.push(v1);
+          lastCleanIndex = i;
+          if (storeRemovedIndices) {
+            removedIndexLCI = removedIndices.length;
+          }
+        }
+        v0 = v1;
+      }
+    }
+
+    if (
+      wrapAround &&
+      equalsEpsilon(values[0], values[length - 1], removeDuplicatesEpsilon)
+    ) {
+      if (storeRemovedIndices) {
+        if (defaultValue.defined(cleanedValues)) {
+          removedIndices.splice(removedIndexLCI, 0, lastCleanIndex);
+        } else {
+          removedIndices.push(length - 1);
+        }
+      }
+
+      if (defaultValue.defined(cleanedValues)) {
+        cleanedValues.length -= 1;
+      } else {
+        cleanedValues = values.slice(0, -1);
+      }
+    }
+
+    return defaultValue.defined(cleanedValues) ? cleanedValues : values;
+  }
+
+  exports.arrayRemoveDuplicates = arrayRemoveDuplicates;
+
+}));