@vcmap/ui 5.0.0-rc.17 → 5.0.0-rc.20

package/dist/assets/cesium/Workers/AxisAlignedBoundingBox-ff186ccc.js

@@ -0,0 +1,258 @@
+define(['exports', './Matrix3-315394f6', './Check-666ab1a0', './defaultValue-0a909f67', './Transforms-40229881'], (function (exports, Matrix3, Check, defaultValue, Transforms) { 'use strict';
+
+  /**
+   * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
+   * @alias AxisAlignedBoundingBox
+   * @constructor
+   *
+   * @param {Cartesian3} [minimum=Cartesian3.ZERO] The minimum point along the x, y, and z axes.
+   * @param {Cartesian3} [maximum=Cartesian3.ZERO] The maximum point along the x, y, and z axes.
+   * @param {Cartesian3} [center] The center of the box; automatically computed if not supplied.
+   *
+   * @see BoundingSphere
+   * @see BoundingRectangle
+   */
+  function AxisAlignedBoundingBox(minimum, maximum, center) {
+    /**
+     * The minimum point defining the bounding box.
+     * @type {Cartesian3}
+     * @default {@link Cartesian3.ZERO}
+     */
+    this.minimum = Matrix3.Cartesian3.clone(defaultValue.defaultValue(minimum, Matrix3.Cartesian3.ZERO));
+
+    /**
+     * The maximum point defining the bounding box.
+     * @type {Cartesian3}
+     * @default {@link Cartesian3.ZERO}
+     */
+    this.maximum = Matrix3.Cartesian3.clone(defaultValue.defaultValue(maximum, Matrix3.Cartesian3.ZERO));
+
+    // If center was not defined, compute it.
+    if (!defaultValue.defined(center)) {
+      center = Matrix3.Cartesian3.midpoint(this.minimum, this.maximum, new Matrix3.Cartesian3());
+    } else {
+      center = Matrix3.Cartesian3.clone(center);
+    }
+
+    /**
+     * The center point of the bounding box.
+     * @type {Cartesian3}
+     */
+    this.center = center;
+  }
+
+  /**
+   * Creates an instance of an AxisAlignedBoundingBox from its corners.
+   *
+   * @param {Cartesian3} minimum The minimum point along the x, y, and z axes.
+   * @param {Cartesian3} maximum The maximum point along the x, y, and z axes.
+   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
+   *
+   * @example
+   * // Compute an axis aligned bounding box from the two corners.
+   * const box = Cesium.AxisAlignedBoundingBox.fromCorners(new Cesium.Cartesian3(-1, -1, -1), new Cesium.Cartesian3(1, 1, 1));
+   */
+  AxisAlignedBoundingBox.fromCorners = function (minimum, maximum, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("minimum", minimum);
+    Check.Check.defined("maximum", maximum);
+    //>>includeEnd('debug');
+
+    if (!defaultValue.defined(result)) {
+      result = new AxisAlignedBoundingBox();
+    }
+
+    result.minimum = Matrix3.Cartesian3.clone(minimum, result.minimum);
+    result.maximum = Matrix3.Cartesian3.clone(maximum, result.maximum);
+    result.center = Matrix3.Cartesian3.midpoint(minimum, maximum, result.center);
+
+    return result;
+  };
+
+  /**
+   * Computes an instance of an AxisAlignedBoundingBox. The box is determined by
+   * finding the points spaced the farthest apart on the x, y, and z axes.
+   *
+   * @param {Cartesian3[]} positions List of points that the bounding box will enclose.  Each point must have a <code>x</code>, <code>y</code>, and <code>z</code> properties.
+   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
+   *
+   * @example
+   * // Compute an axis aligned bounding box enclosing two points.
+   * const box = Cesium.AxisAlignedBoundingBox.fromPoints([new Cesium.Cartesian3(2, 0, 0), new Cesium.Cartesian3(-2, 0, 0)]);
+   */
+  AxisAlignedBoundingBox.fromPoints = function (positions, result) {
+    if (!defaultValue.defined(result)) {
+      result = new AxisAlignedBoundingBox();
+    }
+
+    if (!defaultValue.defined(positions) || positions.length === 0) {
+      result.minimum = Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, result.minimum);
+      result.maximum = Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, result.maximum);
+      result.center = Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, result.center);
+      return result;
+    }
+
+    let minimumX = positions[0].x;
+    let minimumY = positions[0].y;
+    let minimumZ = positions[0].z;
+
+    let maximumX = positions[0].x;
+    let maximumY = positions[0].y;
+    let maximumZ = positions[0].z;
+
+    const length = positions.length;
+    for (let i = 1; i < length; i++) {
+      const p = positions[i];
+      const x = p.x;
+      const y = p.y;
+      const z = p.z;
+
+      minimumX = Math.min(x, minimumX);
+      maximumX = Math.max(x, maximumX);
+      minimumY = Math.min(y, minimumY);
+      maximumY = Math.max(y, maximumY);
+      minimumZ = Math.min(z, minimumZ);
+      maximumZ = Math.max(z, maximumZ);
+    }
+
+    const minimum = result.minimum;
+    minimum.x = minimumX;
+    minimum.y = minimumY;
+    minimum.z = minimumZ;
+
+    const maximum = result.maximum;
+    maximum.x = maximumX;
+    maximum.y = maximumY;
+    maximum.z = maximumZ;
+
+    result.center = Matrix3.Cartesian3.midpoint(minimum, maximum, result.center);
+
+    return result;
+  };
+
+  /**
+   * Duplicates a AxisAlignedBoundingBox instance.
+   *
+   * @param {AxisAlignedBoundingBox} box The bounding box to duplicate.
+   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if none was provided. (Returns undefined if box is undefined)
+   */
+  AxisAlignedBoundingBox.clone = function (box, result) {
+    if (!defaultValue.defined(box)) {
+      return undefined;
+    }
+
+    if (!defaultValue.defined(result)) {
+      return new AxisAlignedBoundingBox(box.minimum, box.maximum, box.center);
+    }
+
+    result.minimum = Matrix3.Cartesian3.clone(box.minimum, result.minimum);
+    result.maximum = Matrix3.Cartesian3.clone(box.maximum, result.maximum);
+    result.center = Matrix3.Cartesian3.clone(box.center, result.center);
+    return result;
+  };
+
+  /**
+   * Compares the provided AxisAlignedBoundingBox componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {AxisAlignedBoundingBox} [left] The first AxisAlignedBoundingBox.
+   * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox.
+   * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  AxisAlignedBoundingBox.equals = function (left, right) {
+    return (
+      left === right ||
+      (defaultValue.defined(left) &&
+        defaultValue.defined(right) &&
+        Matrix3.Cartesian3.equals(left.center, right.center) &&
+        Matrix3.Cartesian3.equals(left.minimum, right.minimum) &&
+        Matrix3.Cartesian3.equals(left.maximum, right.maximum))
+    );
+  };
+
+  let intersectScratch = new Matrix3.Cartesian3();
+  /**
+   * Determines which side of a plane a box is located.
+   *
+   * @param {AxisAlignedBoundingBox} box The bounding box to test.
+   * @param {Plane} plane The plane to test against.
+   * @returns {Intersect} {@link Intersect.INSIDE} if the entire box is on the side of the plane
+   *                      the normal is pointing, {@link Intersect.OUTSIDE} if the entire box is
+   *                      on the opposite side, and {@link Intersect.INTERSECTING} if the box
+   *                      intersects the plane.
+   */
+  AxisAlignedBoundingBox.intersectPlane = function (box, plane) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("box", box);
+    Check.Check.defined("plane", plane);
+    //>>includeEnd('debug');
+
+    intersectScratch = Matrix3.Cartesian3.subtract(
+      box.maximum,
+      box.minimum,
+      intersectScratch
+    );
+    const h = Matrix3.Cartesian3.multiplyByScalar(
+      intersectScratch,
+      0.5,
+      intersectScratch
+    ); //The positive half diagonal
+    const normal = plane.normal;
+    const e =
+      h.x * Math.abs(normal.x) +
+      h.y * Math.abs(normal.y) +
+      h.z * Math.abs(normal.z);
+    const s = Matrix3.Cartesian3.dot(box.center, normal) + plane.distance; //signed distance from center
+
+    if (s - e > 0) {
+      return Transforms.Intersect.INSIDE;
+    }
+
+    if (s + e < 0) {
+      //Not in front because normals point inward
+      return Transforms.Intersect.OUTSIDE;
+    }
+
+    return Transforms.Intersect.INTERSECTING;
+  };
+
+  /**
+   * Duplicates this AxisAlignedBoundingBox instance.
+   *
+   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
+   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
+   */
+  AxisAlignedBoundingBox.prototype.clone = function (result) {
+    return AxisAlignedBoundingBox.clone(this, result);
+  };
+
+  /**
+   * Determines which side of a plane this box is located.
+   *
+   * @param {Plane} plane The plane to test against.
+   * @returns {Intersect} {@link Intersect.INSIDE} if the entire box is on the side of the plane
+   *                      the normal is pointing, {@link Intersect.OUTSIDE} if the entire box is
+   *                      on the opposite side, and {@link Intersect.INTERSECTING} if the box
+   *                      intersects the plane.
+   */
+  AxisAlignedBoundingBox.prototype.intersectPlane = function (plane) {
+    return AxisAlignedBoundingBox.intersectPlane(this, plane);
+  };
+
+  /**
+   * Compares this AxisAlignedBoundingBox against the provided AxisAlignedBoundingBox componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {AxisAlignedBoundingBox} [right] The right hand side AxisAlignedBoundingBox.
+   * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+   */
+  AxisAlignedBoundingBox.prototype.equals = function (right) {
+    return AxisAlignedBoundingBox.equals(this, right);
+  };
+
+  exports.AxisAlignedBoundingBox = AxisAlignedBoundingBox;
+
+}));

package/dist/assets/cesium/Workers/BoundingRectangle-be5924f4.js

@@ -0,0 +1,369 @@
+define(['exports', './Matrix2-13178034', './Matrix3-315394f6', './Check-666ab1a0', './defaultValue-0a909f67', './Transforms-40229881'], (function (exports, Matrix2, Matrix3, Check, defaultValue, Transforms) { 'use strict';
+
+  /**
+   * A bounding rectangle given by a corner, width and height.
+   * @alias BoundingRectangle
+   * @constructor
+   *
+   * @param {Number} [x=0.0] The x coordinate of the rectangle.
+   * @param {Number} [y=0.0] The y coordinate of the rectangle.
+   * @param {Number} [width=0.0] The width of the rectangle.
+   * @param {Number} [height=0.0] The height of the rectangle.
+   *
+   * @see BoundingSphere
+   * @see Packable
+   */
+  function BoundingRectangle(x, y, width, height) {
+    /**
+     * The x coordinate of the rectangle.
+     * @type {Number}
+     * @default 0.0
+     */
+    this.x = defaultValue.defaultValue(x, 0.0);
+
+    /**
+     * The y coordinate of the rectangle.
+     * @type {Number}
+     * @default 0.0
+     */
+    this.y = defaultValue.defaultValue(y, 0.0);
+
+    /**
+     * The width of the rectangle.
+     * @type {Number}
+     * @default 0.0
+     */
+    this.width = defaultValue.defaultValue(width, 0.0);
+
+    /**
+     * The height of the rectangle.
+     * @type {Number}
+     * @default 0.0
+     */
+    this.height = defaultValue.defaultValue(height, 0.0);
+  }
+
+  /**
+   * The number of elements used to pack the object into an array.
+   * @type {Number}
+   */
+  BoundingRectangle.packedLength = 4;
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {BoundingRectangle} value The value to pack.
+   * @param {Number[]} array The array to pack into.
+   * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
+   *
+   * @returns {Number[]} The array that was packed into
+   */
+  BoundingRectangle.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("value", value);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    array[startingIndex++] = value.x;
+    array[startingIndex++] = value.y;
+    array[startingIndex++] = value.width;
+    array[startingIndex] = value.height;
+
+    return array;
+  };
+
+  /**
+   * Retrieves an instance from a packed array.
+   *
+   * @param {Number[]} array The packed array.
+   * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
+   * @param {BoundingRectangle} [result] The object into which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+   */
+  BoundingRectangle.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    if (!defaultValue.defined(result)) {
+      result = new BoundingRectangle();
+    }
+    result.x = array[startingIndex++];
+    result.y = array[startingIndex++];
+    result.width = array[startingIndex++];
+    result.height = array[startingIndex];
+    return result;
+  };
+
+  /**
+   * Computes a bounding rectangle enclosing the list of 2D points.
+   * The rectangle is oriented with the corner at the bottom left.
+   *
+   * @param {Cartesian2[]} positions List of points that the bounding rectangle will enclose.  Each point must have <code>x</code> and <code>y</code> properties.
+   * @param {BoundingRectangle} [result] The object onto which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+   */
+  BoundingRectangle.fromPoints = function (positions, result) {
+    if (!defaultValue.defined(result)) {
+      result = new BoundingRectangle();
+    }
+
+    if (!defaultValue.defined(positions) || positions.length === 0) {
+      result.x = 0;
+      result.y = 0;
+      result.width = 0;
+      result.height = 0;
+      return result;
+    }
+
+    const length = positions.length;
+
+    let minimumX = positions[0].x;
+    let minimumY = positions[0].y;
+
+    let maximumX = positions[0].x;
+    let maximumY = positions[0].y;
+
+    for (let i = 1; i < length; i++) {
+      const p = positions[i];
+      const x = p.x;
+      const y = p.y;
+
+      minimumX = Math.min(x, minimumX);
+      maximumX = Math.max(x, maximumX);
+      minimumY = Math.min(y, minimumY);
+      maximumY = Math.max(y, maximumY);
+    }
+
+    result.x = minimumX;
+    result.y = minimumY;
+    result.width = maximumX - minimumX;
+    result.height = maximumY - minimumY;
+    return result;
+  };
+
+  const defaultProjection = new Transforms.GeographicProjection();
+  const fromRectangleLowerLeft = new Matrix3.Cartographic();
+  const fromRectangleUpperRight = new Matrix3.Cartographic();
+  /**
+   * Computes a bounding rectangle from a rectangle.
+   *
+   * @param {Rectangle} rectangle The valid rectangle used to create a bounding rectangle.
+   * @param {Object} [projection=GeographicProjection] The projection used to project the rectangle into 2D.
+   * @param {BoundingRectangle} [result] The object onto which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+   */
+  BoundingRectangle.fromRectangle = function (rectangle, projection, result) {
+    if (!defaultValue.defined(result)) {
+      result = new BoundingRectangle();
+    }
+
+    if (!defaultValue.defined(rectangle)) {
+      result.x = 0;
+      result.y = 0;
+      result.width = 0;
+      result.height = 0;
+      return result;
+    }
+
+    projection = defaultValue.defaultValue(projection, defaultProjection);
+
+    const lowerLeft = projection.project(
+      Matrix2.Rectangle.southwest(rectangle, fromRectangleLowerLeft)
+    );
+    const upperRight = projection.project(
+      Matrix2.Rectangle.northeast(rectangle, fromRectangleUpperRight)
+    );
+
+    Matrix2.Cartesian2.subtract(upperRight, lowerLeft, upperRight);
+
+    result.x = lowerLeft.x;
+    result.y = lowerLeft.y;
+    result.width = upperRight.x;
+    result.height = upperRight.y;
+    return result;
+  };
+
+  /**
+   * Duplicates a BoundingRectangle instance.
+   *
+   * @param {BoundingRectangle} rectangle The bounding rectangle to duplicate.
+   * @param {BoundingRectangle} [result] The object onto which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided. (Returns undefined if rectangle is undefined)
+   */
+  BoundingRectangle.clone = function (rectangle, result) {
+    if (!defaultValue.defined(rectangle)) {
+      return undefined;
+    }
+
+    if (!defaultValue.defined(result)) {
+      return new BoundingRectangle(
+        rectangle.x,
+        rectangle.y,
+        rectangle.width,
+        rectangle.height
+      );
+    }
+
+    result.x = rectangle.x;
+    result.y = rectangle.y;
+    result.width = rectangle.width;
+    result.height = rectangle.height;
+    return result;
+  };
+
+  /**
+   * Computes a bounding rectangle that is the union of the left and right bounding rectangles.
+   *
+   * @param {BoundingRectangle} left A rectangle to enclose in bounding rectangle.
+   * @param {BoundingRectangle} right A rectangle to enclose in a bounding rectangle.
+   * @param {BoundingRectangle} [result] The object onto which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+   */
+  BoundingRectangle.union = function (left, right, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("left", left);
+    Check.Check.typeOf.object("right", right);
+    //>>includeEnd('debug');
+
+    if (!defaultValue.defined(result)) {
+      result = new BoundingRectangle();
+    }
+
+    const lowerLeftX = Math.min(left.x, right.x);
+    const lowerLeftY = Math.min(left.y, right.y);
+    const upperRightX = Math.max(left.x + left.width, right.x + right.width);
+    const upperRightY = Math.max(left.y + left.height, right.y + right.height);
+
+    result.x = lowerLeftX;
+    result.y = lowerLeftY;
+    result.width = upperRightX - lowerLeftX;
+    result.height = upperRightY - lowerLeftY;
+    return result;
+  };
+
+  /**
+   * Computes a bounding rectangle by enlarging the provided rectangle until it contains the provided point.
+   *
+   * @param {BoundingRectangle} rectangle A rectangle to expand.
+   * @param {Cartesian2} point A point to enclose in a bounding rectangle.
+   * @param {BoundingRectangle} [result] The object onto which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+   */
+  BoundingRectangle.expand = function (rectangle, point, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("rectangle", rectangle);
+    Check.Check.typeOf.object("point", point);
+    //>>includeEnd('debug');
+
+    result = BoundingRectangle.clone(rectangle, result);
+
+    const width = point.x - result.x;
+    const height = point.y - result.y;
+
+    if (width > result.width) {
+      result.width = width;
+    } else if (width < 0) {
+      result.width -= width;
+      result.x = point.x;
+    }
+
+    if (height > result.height) {
+      result.height = height;
+    } else if (height < 0) {
+      result.height -= height;
+      result.y = point.y;
+    }
+
+    return result;
+  };
+
+  /**
+   * Determines if two rectangles intersect.
+   *
+   * @param {BoundingRectangle} left A rectangle to check for intersection.
+   * @param {BoundingRectangle} right The other rectangle to check for intersection.
+   * @returns {Intersect} <code>Intersect.INTERSECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
+   */
+  BoundingRectangle.intersect = function (left, right) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("left", left);
+    Check.Check.typeOf.object("right", right);
+    //>>includeEnd('debug');
+
+    const leftX = left.x;
+    const leftY = left.y;
+    const rightX = right.x;
+    const rightY = right.y;
+    if (
+      !(
+        leftX > rightX + right.width ||
+        leftX + left.width < rightX ||
+        leftY + left.height < rightY ||
+        leftY > rightY + right.height
+      )
+    ) {
+      return Transforms.Intersect.INTERSECTING;
+    }
+
+    return Transforms.Intersect.OUTSIDE;
+  };
+
+  /**
+   * Compares the provided BoundingRectangles componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {BoundingRectangle} [left] The first BoundingRectangle.
+   * @param {BoundingRectangle} [right] The second BoundingRectangle.
+   * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  BoundingRectangle.equals = function (left, right) {
+    return (
+      left === right ||
+      (defaultValue.defined(left) &&
+        defaultValue.defined(right) &&
+        left.x === right.x &&
+        left.y === right.y &&
+        left.width === right.width &&
+        left.height === right.height)
+    );
+  };
+
+  /**
+   * Duplicates this BoundingRectangle instance.
+   *
+   * @param {BoundingRectangle} [result] The object onto which to store the result.
+   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
+   */
+  BoundingRectangle.prototype.clone = function (result) {
+    return BoundingRectangle.clone(this, result);
+  };
+
+  /**
+   * Determines if this rectangle intersects with another.
+   *
+   * @param {BoundingRectangle} right A rectangle to check for intersection.
+   * @returns {Intersect} <code>Intersect.INTERSECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
+   */
+  BoundingRectangle.prototype.intersect = function (right) {
+    return BoundingRectangle.intersect(this, right);
+  };
+
+  /**
+   * Compares this BoundingRectangle against the provided BoundingRectangle componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {BoundingRectangle} [right] The right hand side BoundingRectangle.
+   * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+   */
+  BoundingRectangle.prototype.equals = function (right) {
+    return BoundingRectangle.equals(this, right);
+  };
+
+  exports.BoundingRectangle = BoundingRectangle;
+
+}));