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

package/dist/assets/cesium/Workers/createWallOutlineGeometry.js

@@ -1,25 +1,432 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./defaultValue-0c475b81","./Matrix2-eefef8eb","./Transforms-d2e5867e","./ComponentDatatype-0200bf8c","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./IndexDatatype-e713bfd2","./WallGeometryLibrary-1a33e416","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./arrayRemoveDuplicates-f13aceb1","./PolylinePipeline-0f23dd84","./EllipsoidGeodesic-8bfefbff","./EllipsoidRhumbLine-03528f73","./IntersectionTests-eb4db8e0","./Plane-b0299683"],(function(e,i,t,n,o,a,s,r,l,m,d,u,p,c,f,h,g,y){"use strict";const _=new i.Cartesian3,b=new i.Cartesian3;function E(t){const o=(t=e.defaultValue(t,e.defaultValue.EMPTY_OBJECT)).positions,a=t.maximumHeights,s=t.minimumHeights,r=e.defaultValue(t.granularity,n.CesiumMath.RADIANS_PER_DEGREE),l=e.defaultValue(t.ellipsoid,i.Ellipsoid.WGS84);this._positions=o,this._minimumHeights=s,this._maximumHeights=a,this._granularity=r,this._ellipsoid=i.Ellipsoid.clone(l),this._workerName="createWallOutlineGeometry";let m=1+o.length*i.Cartesian3.packedLength+2;e.defined(s)&&(m+=s.length),e.defined(a)&&(m+=a.length),this.packedLength=m+i.Ellipsoid.packedLength+1}E.pack=function(t,n,o){let a;o=e.defaultValue(o,0);const s=t._positions;let r=s.length;for(n[o++]=r,a=0;a<r;++a,o+=i.Cartesian3.packedLength)i.Cartesian3.pack(s[a],n,o);const l=t._minimumHeights;if(r=e.defined(l)?l.length:0,n[o++]=r,e.defined(l))for(a=0;a<r;++a)n[o++]=l[a];const m=t._maximumHeights;if(r=e.defined(m)?m.length:0,n[o++]=r,e.defined(m))for(a=0;a<r;++a)n[o++]=m[a];return i.Ellipsoid.pack(t._ellipsoid,n,o),n[o+=i.Ellipsoid.packedLength]=t._granularity,n};const H=i.Ellipsoid.clone(i.Ellipsoid.UNIT_SPHERE),C={positions:void 0,minimumHeights:void 0,maximumHeights:void 0,ellipsoid:H,granularity:void 0};return E.unpack=function(t,n,o){let a;n=e.defaultValue(n,0);let s=t[n++];const r=new Array(s);for(a=0;a<s;++a,n+=i.Cartesian3.packedLength)r[a]=i.Cartesian3.unpack(t,n);let l,m;if(s=t[n++],s>0)for(l=new Array(s),a=0;a<s;++a)l[a]=t[n++];if(s=t[n++],s>0)for(m=new Array(s),a=0;a<s;++a)m[a]=t[n++];const d=i.Ellipsoid.unpack(t,n,H),u=t[n+=i.Ellipsoid.packedLength];return e.defined(o)?(o._positions=r,o._minimumHeights=l,o._maximumHeights=m,o._ellipsoid=i.Ellipsoid.clone(d,o._ellipsoid),o._granularity=u,o):(C.positions=r,C.minimumHeights=l,C.maximumHeights=m,C.granularity=u,new E(C))},E.fromConstantHeights=function(i){const t=(i=e.defaultValue(i,e.defaultValue.EMPTY_OBJECT)).positions;let n,o;const a=i.minimumHeight,s=i.maximumHeight,r=e.defined(a),l=e.defined(s);if(r||l){const e=t.length;n=r?new Array(e):void 0,o=l?new Array(e):void 0;for(let i=0;i<e;++i)r&&(n[i]=a),l&&(o[i]=s)}return new E({positions:t,maximumHeights:o,minimumHeights:n,ellipsoid:i.ellipsoid})},E.createGeometry=function(l){const m=l._positions,d=l._minimumHeights,u=l._maximumHeights,p=l._granularity,c=l._ellipsoid,f=r.WallGeometryLibrary.computePositions(c,m,u,d,p,!1);if(!e.defined(f))return;const h=f.bottomPositions,g=f.topPositions;let y=g.length,E=2*y;const H=new Float64Array(E);let C,A=0;for(y/=3,C=0;C<y;++C){const e=3*C,t=i.Cartesian3.fromArray(g,e,_),n=i.Cartesian3.fromArray(h,e,b);H[A++]=n.x,H[A++]=n.y,H[A++]=n.z,H[A++]=t.x,H[A++]=t.y,H[A++]=t.z}const k=new a.GeometryAttributes({position:new o.GeometryAttribute({componentDatatype:n.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:H})}),w=E/3;E=2*w-4+w;const x=s.IndexDatatype.createTypedArray(w,E);let G=0;for(C=0;C<w-2;C+=2){const e=C,t=C+2,o=i.Cartesian3.fromArray(H,3*e,_),a=i.Cartesian3.fromArray(H,3*t,b);if(i.Cartesian3.equalsEpsilon(o,a,n.CesiumMath.EPSILON10))continue;const s=C+1,r=C+3;x[G++]=s,x[G++]=e,x[G++]=s,x[G++]=r,x[G++]=e,x[G++]=t}return x[G++]=w-2,x[G++]=w-1,new o.Geometry({attributes:k,indices:x,primitiveType:o.PrimitiveType.LINES,boundingSphere:new t.BoundingSphere.fromVertices(H)})},function(t,n){return e.defined(n)&&(t=E.unpack(t,n)),t._ellipsoid=i.Ellipsoid.clone(t._ellipsoid),E.createGeometry(t)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './Transforms-40229881', './ComponentDatatype-f7b11d02', './Check-666ab1a0', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './WallGeometryLibrary-919eed92', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './arrayRemoveDuplicates-c2038105', './PolylinePipeline-32f36d2a', './EllipsoidGeodesic-98c62a56', './EllipsoidRhumbLine-19756602', './IntersectionTests-f6e6bd8a', './Plane-900aa728'], (function (defaultValue, Matrix3, Transforms, ComponentDatatype, Check, GeometryAttribute, GeometryAttributes, IndexDatatype, Math, WallGeometryLibrary, Matrix2, RuntimeError, combine, WebGLConstants, arrayRemoveDuplicates, PolylinePipeline, EllipsoidGeodesic, EllipsoidRhumbLine, IntersectionTests, Plane) { 'use strict';
+
+  const scratchCartesian3Position1 = new Matrix3.Cartesian3();
+  const scratchCartesian3Position2 = new Matrix3.Cartesian3();
+
+  /**
+   * A description of a wall outline. A wall is defined by a series of points,
+   * which extrude down to the ground. Optionally, they can extrude downwards to a specified height.
+   *
+   * @alias WallOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of Cartesian objects, which are the points of the wall.
+   * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+   * @param {Number[]} [options.maximumHeights] An array parallel to <code>positions</code> that give the maximum height of the
+   *        wall at <code>positions</code>. If undefined, the height of each position in used.
+   * @param {Number[]} [options.minimumHeights] An array parallel to <code>positions</code> that give the minimum height of the
+   *        wall at <code>positions</code>. If undefined, the height at each position is 0.0.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid for coordinate manipulation
+   *
+   * @exception {DeveloperError} positions length must be greater than or equal to 2.
+   * @exception {DeveloperError} positions and maximumHeights must have the same length.
+   * @exception {DeveloperError} positions and minimumHeights must have the same length.
+   *
+   * @see WallGeometry#createGeometry
+   * @see WallGeometry#fromConstantHeight
+   *
+   * @example
+   * // create a wall outline that spans from ground level to 10000 meters
+   * const wall = new Cesium.WallOutlineGeometry({
+   *   positions : Cesium.Cartesian3.fromDegreesArrayHeights([
+   *     19.0, 47.0, 10000.0,
+   *     19.0, 48.0, 10000.0,
+   *     20.0, 48.0, 10000.0,
+   *     20.0, 47.0, 10000.0,
+   *     19.0, 47.0, 10000.0
+   *   ])
+   * });
+   * const geometry = Cesium.WallOutlineGeometry.createGeometry(wall);
+   */
+  function WallOutlineGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+
+    const wallPositions = options.positions;
+    const maximumHeights = options.maximumHeights;
+    const minimumHeights = options.minimumHeights;
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(wallPositions)) {
+      throw new Check.DeveloperError("options.positions is required.");
+    }
+    if (
+      defaultValue.defined(maximumHeights) &&
+      maximumHeights.length !== wallPositions.length
+    ) {
+      throw new Check.DeveloperError(
+        "options.positions and options.maximumHeights must have the same length."
+      );
+    }
+    if (
+      defaultValue.defined(minimumHeights) &&
+      minimumHeights.length !== wallPositions.length
+    ) {
+      throw new Check.DeveloperError(
+        "options.positions and options.minimumHeights must have the same length."
+      );
+    }
+    //>>includeEnd('debug');
+
+    const granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math.CesiumMath.RADIANS_PER_DEGREE
+    );
+    const ellipsoid = defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84);
+
+    this._positions = wallPositions;
+    this._minimumHeights = minimumHeights;
+    this._maximumHeights = maximumHeights;
+    this._granularity = granularity;
+    this._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid);
+    this._workerName = "createWallOutlineGeometry";
+
+    let numComponents = 1 + wallPositions.length * Matrix3.Cartesian3.packedLength + 2;
+    if (defaultValue.defined(minimumHeights)) {
+      numComponents += minimumHeights.length;
+    }
+    if (defaultValue.defined(maximumHeights)) {
+      numComponents += maximumHeights.length;
+    }
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength = numComponents + Matrix3.Ellipsoid.packedLength + 1;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {WallOutlineGeometry} 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
+   */
+  WallOutlineGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(value)) {
+      throw new Check.DeveloperError("value is required");
+    }
+    if (!defaultValue.defined(array)) {
+      throw new Check.DeveloperError("array is required");
+    }
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    let i;
+
+    const positions = value._positions;
+    let length = positions.length;
+    array[startingIndex++] = length;
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      Matrix3.Cartesian3.pack(positions[i], array, startingIndex);
+    }
+
+    const minimumHeights = value._minimumHeights;
+    length = defaultValue.defined(minimumHeights) ? minimumHeights.length : 0;
+    array[startingIndex++] = length;
+
+    if (defaultValue.defined(minimumHeights)) {
+      for (i = 0; i < length; ++i) {
+        array[startingIndex++] = minimumHeights[i];
+      }
+    }
+
+    const maximumHeights = value._maximumHeights;
+    length = defaultValue.defined(maximumHeights) ? maximumHeights.length : 0;
+    array[startingIndex++] = length;
+
+    if (defaultValue.defined(maximumHeights)) {
+      for (i = 0; i < length; ++i) {
+        array[startingIndex++] = maximumHeights[i];
+      }
+    }
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    array[startingIndex] = value._granularity;
+
+    return array;
+  };
+
+  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
+  const scratchOptions = {
+    positions: undefined,
+    minimumHeights: undefined,
+    maximumHeights: undefined,
+    ellipsoid: scratchEllipsoid,
+    granularity: undefined,
+  };
+
+  /**
+   * 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 {WallOutlineGeometry} [result] The object into which to store the result.
+   * @returns {WallOutlineGeometry} The modified result parameter or a new WallOutlineGeometry instance if one was not provided.
+   */
+  WallOutlineGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(array)) {
+      throw new Check.DeveloperError("array is required");
+    }
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    let i;
+
+    let length = array[startingIndex++];
+    const positions = new Array(length);
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      positions[i] = Matrix3.Cartesian3.unpack(array, startingIndex);
+    }
+
+    length = array[startingIndex++];
+    let minimumHeights;
+
+    if (length > 0) {
+      minimumHeights = new Array(length);
+      for (i = 0; i < length; ++i) {
+        minimumHeights[i] = array[startingIndex++];
+      }
+    }
+
+    length = array[startingIndex++];
+    let maximumHeights;
+
+    if (length > 0) {
+      maximumHeights = new Array(length);
+      for (i = 0; i < length; ++i) {
+        maximumHeights[i] = array[startingIndex++];
+      }
+    }
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const granularity = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.positions = positions;
+      scratchOptions.minimumHeights = minimumHeights;
+      scratchOptions.maximumHeights = maximumHeights;
+      scratchOptions.granularity = granularity;
+      return new WallOutlineGeometry(scratchOptions);
+    }
+
+    result._positions = positions;
+    result._minimumHeights = minimumHeights;
+    result._maximumHeights = maximumHeights;
+    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
+    result._granularity = granularity;
+
+    return result;
+  };
+
+  /**
+   * A description of a walloutline. A wall is defined by a series of points,
+   * which extrude down to the ground. Optionally, they can extrude downwards to a specified height.
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of Cartesian objects, which are the points of the wall.
+   * @param {Number} [options.maximumHeight] A constant that defines the maximum height of the
+   *        wall at <code>positions</code>. If undefined, the height of each position in used.
+   * @param {Number} [options.minimumHeight] A constant that defines the minimum height of the
+   *        wall at <code>positions</code>. If undefined, the height at each position is 0.0.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid for coordinate manipulation
+   * @returns {WallOutlineGeometry}
+   *
+   *
+   * @example
+   * // create a wall that spans from 10000 meters to 20000 meters
+   * const wall = Cesium.WallOutlineGeometry.fromConstantHeights({
+   *   positions : Cesium.Cartesian3.fromDegreesArray([
+   *     19.0, 47.0,
+   *     19.0, 48.0,
+   *     20.0, 48.0,
+   *     20.0, 47.0,
+   *     19.0, 47.0,
+   *   ]),
+   *   minimumHeight : 20000.0,
+   *   maximumHeight : 10000.0
+   * });
+   * const geometry = Cesium.WallOutlineGeometry.createGeometry(wall);
+   *
+   * @see WallOutlineGeometry#createGeometry
+   */
+  WallOutlineGeometry.fromConstantHeights = function (options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+    const positions = options.positions;
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(positions)) {
+      throw new Check.DeveloperError("options.positions is required.");
+    }
+    //>>includeEnd('debug');
+
+    let minHeights;
+    let maxHeights;
+
+    const min = options.minimumHeight;
+    const max = options.maximumHeight;
+
+    const doMin = defaultValue.defined(min);
+    const doMax = defaultValue.defined(max);
+    if (doMin || doMax) {
+      const length = positions.length;
+      minHeights = doMin ? new Array(length) : undefined;
+      maxHeights = doMax ? new Array(length) : undefined;
+
+      for (let i = 0; i < length; ++i) {
+        if (doMin) {
+          minHeights[i] = min;
+        }
+
+        if (doMax) {
+          maxHeights[i] = max;
+        }
+      }
+    }
+
+    const newOptions = {
+      positions: positions,
+      maximumHeights: maxHeights,
+      minimumHeights: minHeights,
+      ellipsoid: options.ellipsoid,
+    };
+    return new WallOutlineGeometry(newOptions);
+  };
+
+  /**
+   * Computes the geometric representation of a wall outline, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {WallOutlineGeometry} wallGeometry A description of the wall outline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  WallOutlineGeometry.createGeometry = function (wallGeometry) {
+    const wallPositions = wallGeometry._positions;
+    const minimumHeights = wallGeometry._minimumHeights;
+    const maximumHeights = wallGeometry._maximumHeights;
+    const granularity = wallGeometry._granularity;
+    const ellipsoid = wallGeometry._ellipsoid;
+
+    const pos = WallGeometryLibrary.WallGeometryLibrary.computePositions(
+      ellipsoid,
+      wallPositions,
+      maximumHeights,
+      minimumHeights,
+      granularity,
+      false
+    );
+    if (!defaultValue.defined(pos)) {
+      return;
+    }
+
+    const bottomPositions = pos.bottomPositions;
+    const topPositions = pos.topPositions;
+
+    let length = topPositions.length;
+    let size = length * 2;
+
+    const positions = new Float64Array(size);
+    let positionIndex = 0;
+
+    // add lower and upper points one after the other, lower
+    // points being even and upper points being odd
+    length /= 3;
+    let i;
+    for (i = 0; i < length; ++i) {
+      const i3 = i * 3;
+      const topPosition = Matrix3.Cartesian3.fromArray(
+        topPositions,
+        i3,
+        scratchCartesian3Position1
+      );
+      const bottomPosition = Matrix3.Cartesian3.fromArray(
+        bottomPositions,
+        i3,
+        scratchCartesian3Position2
+      );
+
+      // insert the lower point
+      positions[positionIndex++] = bottomPosition.x;
+      positions[positionIndex++] = bottomPosition.y;
+      positions[positionIndex++] = bottomPosition.z;
+
+      // insert the upper point
+      positions[positionIndex++] = topPosition.x;
+      positions[positionIndex++] = topPosition.y;
+      positions[positionIndex++] = topPosition.z;
+    }
+
+    const attributes = new GeometryAttributes.GeometryAttributes({
+      position: new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+        componentsPerAttribute: 3,
+        values: positions,
+      }),
+    });
+
+    const numVertices = size / 3;
+    size = 2 * numVertices - 4 + numVertices;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(numVertices, size);
+
+    let edgeIndex = 0;
+    for (i = 0; i < numVertices - 2; i += 2) {
+      const LL = i;
+      const LR = i + 2;
+      const pl = Matrix3.Cartesian3.fromArray(
+        positions,
+        LL * 3,
+        scratchCartesian3Position1
+      );
+      const pr = Matrix3.Cartesian3.fromArray(
+        positions,
+        LR * 3,
+        scratchCartesian3Position2
+      );
+      if (Matrix3.Cartesian3.equalsEpsilon(pl, pr, Math.CesiumMath.EPSILON10)) {
+        continue;
+      }
+      const UL = i + 1;
+      const UR = i + 3;
+
+      indices[edgeIndex++] = UL;
+      indices[edgeIndex++] = LL;
+      indices[edgeIndex++] = UL;
+      indices[edgeIndex++] = UR;
+      indices[edgeIndex++] = LL;
+      indices[edgeIndex++] = LR;
+    }
+
+    indices[edgeIndex++] = numVertices - 2;
+    indices[edgeIndex++] = numVertices - 1;
+
+    return new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: indices,
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      boundingSphere: new Transforms.BoundingSphere.fromVertices(positions),
+    });
+  };
+
+  function createWallOutlineGeometry(wallGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      wallGeometry = WallOutlineGeometry.unpack(wallGeometry, offset);
+    }
+    wallGeometry._ellipsoid = Matrix3.Ellipsoid.clone(wallGeometry._ellipsoid);
+    return WallOutlineGeometry.createGeometry(wallGeometry);
+  }
+
+  return createWallOutlineGeometry;
+
+}));