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

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

@@ -1,25 +1,301 @@
-/**
- * @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","./arrayRemoveDuplicates-f13aceb1","./BoundingRectangle-201b1a81","./Transforms-d2e5867e","./ComponentDatatype-0200bf8c","./PolylineVolumeGeometryLibrary-2d903430","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./IndexDatatype-e713bfd2","./PolygonPipeline-eb527514","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./EllipsoidTangentPlane-c080fd1b","./AxisAlignedBoundingBox-d0c22774","./IntersectionTests-eb4db8e0","./Plane-b0299683","./PolylinePipeline-0f23dd84","./EllipsoidGeodesic-8bfefbff","./EllipsoidRhumbLine-03528f73"],(function(e,t,n,i,o,a,l,r,s,p,c,d,u,y,f,g,h,m,b,E,_,P){"use strict";function k(n){const i=(n=e.defaultValue(n,e.defaultValue.EMPTY_OBJECT)).polylinePositions,o=n.shapePositions;this._positions=i,this._shape=o,this._ellipsoid=t.Ellipsoid.clone(e.defaultValue(n.ellipsoid,t.Ellipsoid.WGS84)),this._cornerType=e.defaultValue(n.cornerType,l.CornerType.ROUNDED),this._granularity=e.defaultValue(n.granularity,a.CesiumMath.RADIANS_PER_DEGREE),this._workerName="createPolylineVolumeOutlineGeometry";let r=1+i.length*t.Cartesian3.packedLength;r+=1+o.length*t.Cartesian2.packedLength,this.packedLength=r+t.Ellipsoid.packedLength+2}k.pack=function(n,i,o){let a;o=e.defaultValue(o,0);const l=n._positions;let r=l.length;for(i[o++]=r,a=0;a<r;++a,o+=t.Cartesian3.packedLength)t.Cartesian3.pack(l[a],i,o);const s=n._shape;for(r=s.length,i[o++]=r,a=0;a<r;++a,o+=t.Cartesian2.packedLength)t.Cartesian2.pack(s[a],i,o);return t.Ellipsoid.pack(n._ellipsoid,i,o),o+=t.Ellipsoid.packedLength,i[o++]=n._cornerType,i[o]=n._granularity,i};const C=t.Ellipsoid.clone(t.Ellipsoid.UNIT_SPHERE),L={polylinePositions:void 0,shapePositions:void 0,ellipsoid:C,height:void 0,cornerType:void 0,granularity:void 0};k.unpack=function(n,i,o){let a;i=e.defaultValue(i,0);let l=n[i++];const r=new Array(l);for(a=0;a<l;++a,i+=t.Cartesian3.packedLength)r[a]=t.Cartesian3.unpack(n,i);l=n[i++];const s=new Array(l);for(a=0;a<l;++a,i+=t.Cartesian2.packedLength)s[a]=t.Cartesian2.unpack(n,i);const p=t.Ellipsoid.unpack(n,i,C);i+=t.Ellipsoid.packedLength;const c=n[i++],d=n[i];return e.defined(o)?(o._positions=r,o._shape=s,o._ellipsoid=t.Ellipsoid.clone(p,o._ellipsoid),o._cornerType=c,o._granularity=d,o):(L.polylinePositions=r,L.shapePositions=s,L.cornerType=c,L.granularity=d,new k(L))};const T=new i.BoundingRectangle;return k.createGeometry=function(e){const d=e._positions,u=n.arrayRemoveDuplicates(d,t.Cartesian3.equalsEpsilon);let y=e._shape;if(y=l.PolylineVolumeGeometryLibrary.removeDuplicatesFromShape(y),u.length<2||y.length<3)return;c.PolygonPipeline.computeWindingOrder2D(y)===c.WindingOrder.CLOCKWISE&&y.reverse();const f=i.BoundingRectangle.fromPoints(y,T);return function(e,t){const n=new s.GeometryAttributes;n.position=new r.GeometryAttribute({componentDatatype:a.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:e});const i=t.length,l=n.position.values.length/3,c=e.length/3/i,d=p.IndexDatatype.createTypedArray(l,2*i*(c+1));let u,y,f=0;u=0;let g=u*i;for(y=0;y<i-1;y++)d[f++]=y+g,d[f++]=y+g+1;for(d[f++]=i-1+g,d[f++]=g,u=c-1,g=u*i,y=0;y<i-1;y++)d[f++]=y+g,d[f++]=y+g+1;for(d[f++]=i-1+g,d[f++]=g,u=0;u<c-1;u++){const e=i*u,t=e+i;for(y=0;y<i;y++)d[f++]=y+e,d[f++]=y+t}return new r.Geometry({attributes:n,indices:p.IndexDatatype.createTypedArray(l,d),boundingSphere:o.BoundingSphere.fromVertices(e),primitiveType:r.PrimitiveType.LINES})}(l.PolylineVolumeGeometryLibrary.computePositions(u,y,f,e,!1),y)},function(n,i){return e.defined(i)&&(n=k.unpack(n,i)),n._ellipsoid=t.Ellipsoid.clone(n._ellipsoid),k.createGeometry(n)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './arrayRemoveDuplicates-c2038105', './BoundingRectangle-be5924f4', './Transforms-40229881', './Matrix2-13178034', './ComponentDatatype-f7b11d02', './PolylineVolumeGeometryLibrary-a510d657', './Check-666ab1a0', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './PolygonPipeline-844aab0a', './combine-ca22a614', './RuntimeError-06c93819', './WebGLConstants-a8cc3e8c', './EllipsoidTangentPlane-214683dc', './AxisAlignedBoundingBox-ff186ccc', './IntersectionTests-f6e6bd8a', './Plane-900aa728', './PolylinePipeline-32f36d2a', './EllipsoidGeodesic-98c62a56', './EllipsoidRhumbLine-19756602'], (function (defaultValue, Matrix3, arrayRemoveDuplicates, BoundingRectangle, Transforms, Matrix2, ComponentDatatype, PolylineVolumeGeometryLibrary, Check, GeometryAttribute, GeometryAttributes, IndexDatatype, Math, PolygonPipeline, combine, RuntimeError, WebGLConstants, EllipsoidTangentPlane, AxisAlignedBoundingBox, IntersectionTests, Plane, PolylinePipeline, EllipsoidGeodesic, EllipsoidRhumbLine) { 'use strict';
+
+  function computeAttributes(positions, shape) {
+    const attributes = new GeometryAttributes.GeometryAttributes();
+    attributes.position = new GeometryAttribute.GeometryAttribute({
+      componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions,
+    });
+
+    const shapeLength = shape.length;
+    const vertexCount = attributes.position.values.length / 3;
+    const positionLength = positions.length / 3;
+    const shapeCount = positionLength / shapeLength;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(
+      vertexCount,
+      2 * shapeLength * (shapeCount + 1)
+    );
+    let i, j;
+    let index = 0;
+    i = 0;
+    let offset = i * shapeLength;
+    for (j = 0; j < shapeLength - 1; j++) {
+      indices[index++] = j + offset;
+      indices[index++] = j + offset + 1;
+    }
+    indices[index++] = shapeLength - 1 + offset;
+    indices[index++] = offset;
+
+    i = shapeCount - 1;
+    offset = i * shapeLength;
+    for (j = 0; j < shapeLength - 1; j++) {
+      indices[index++] = j + offset;
+      indices[index++] = j + offset + 1;
+    }
+    indices[index++] = shapeLength - 1 + offset;
+    indices[index++] = offset;
+
+    for (i = 0; i < shapeCount - 1; i++) {
+      const firstOffset = shapeLength * i;
+      const secondOffset = firstOffset + shapeLength;
+      for (j = 0; j < shapeLength; j++) {
+        indices[index++] = j + firstOffset;
+        indices[index++] = j + secondOffset;
+      }
+    }
+
+    const geometry = new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: IndexDatatype.IndexDatatype.createTypedArray(vertexCount, indices),
+      boundingSphere: Transforms.BoundingSphere.fromVertices(positions),
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+    });
+
+    return geometry;
+  }
+
+  /**
+   * A description of a polyline with a volume (a 2D shape extruded along a polyline).
+   *
+   * @alias PolylineVolumeOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.polylinePositions An array of positions that define the center of the polyline volume.
+   * @param {Cartesian2[]} options.shapePositions An array of positions that define the shape to be extruded along the polyline
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
+   * @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 {CornerType} [options.cornerType=CornerType.ROUNDED] Determines the style of the corners.
+   *
+   * @see PolylineVolumeOutlineGeometry#createGeometry
+   *
+   * @example
+   * function computeCircle(radius) {
+   *   const positions = [];
+   *   for (let i = 0; i < 360; i++) {
+   *     const radians = Cesium.Math.toRadians(i);
+   *     positions.push(new Cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
+   *   }
+   *   return positions;
+   * }
+   *
+   * const volumeOutline = new Cesium.PolylineVolumeOutlineGeometry({
+   *   polylinePositions : Cesium.Cartesian3.fromDegreesArray([
+   *     -72.0, 40.0,
+   *     -70.0, 35.0
+   *   ]),
+   *   shapePositions : computeCircle(100000.0)
+   * });
+   */
+  function PolylineVolumeOutlineGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+    const positions = options.polylinePositions;
+    const shape = options.shapePositions;
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(positions)) {
+      throw new Check.DeveloperError("options.polylinePositions is required.");
+    }
+    if (!defaultValue.defined(shape)) {
+      throw new Check.DeveloperError("options.shapePositions is required.");
+    }
+    //>>includeEnd('debug');
+
+    this._positions = positions;
+    this._shape = shape;
+    this._ellipsoid = Matrix3.Ellipsoid.clone(
+      defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84)
+    );
+    this._cornerType = defaultValue.defaultValue(options.cornerType, PolylineVolumeGeometryLibrary.CornerType.ROUNDED);
+    this._granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math.CesiumMath.RADIANS_PER_DEGREE
+    );
+    this._workerName = "createPolylineVolumeOutlineGeometry";
+
+    let numComponents = 1 + positions.length * Matrix3.Cartesian3.packedLength;
+    numComponents += 1 + shape.length * Matrix2.Cartesian2.packedLength;
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength = numComponents + Matrix3.Ellipsoid.packedLength + 2;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {PolylineVolumeOutlineGeometry} 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
+   */
+  PolylineVolumeOutlineGeometry.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 shape = value._shape;
+    length = shape.length;
+    array[startingIndex++] = length;
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix2.Cartesian2.packedLength) {
+      Matrix2.Cartesian2.pack(shape[i], array, startingIndex);
+    }
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    array[startingIndex++] = value._cornerType;
+    array[startingIndex] = value._granularity;
+
+    return array;
+  };
+
+  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
+  const scratchOptions = {
+    polylinePositions: undefined,
+    shapePositions: undefined,
+    ellipsoid: scratchEllipsoid,
+    height: undefined,
+    cornerType: undefined,
+    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 {PolylineVolumeOutlineGeometry} [result] The object into which to store the result.
+   * @returns {PolylineVolumeOutlineGeometry} The modified result parameter or a new PolylineVolumeOutlineGeometry instance if one was not provided.
+   */
+  PolylineVolumeOutlineGeometry.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++];
+    const shape = new Array(length);
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix2.Cartesian2.packedLength) {
+      shape[i] = Matrix2.Cartesian2.unpack(array, startingIndex);
+    }
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const cornerType = array[startingIndex++];
+    const granularity = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.polylinePositions = positions;
+      scratchOptions.shapePositions = shape;
+      scratchOptions.cornerType = cornerType;
+      scratchOptions.granularity = granularity;
+      return new PolylineVolumeOutlineGeometry(scratchOptions);
+    }
+
+    result._positions = positions;
+    result._shape = shape;
+    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
+    result._cornerType = cornerType;
+    result._granularity = granularity;
+
+    return result;
+  };
+
+  const brScratch = new BoundingRectangle.BoundingRectangle();
+
+  /**
+   * Computes the geometric representation of the outline of a polyline with a volume, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {PolylineVolumeOutlineGeometry} polylineVolumeOutlineGeometry A description of the polyline volume outline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  PolylineVolumeOutlineGeometry.createGeometry = function (
+    polylineVolumeOutlineGeometry
+  ) {
+    const positions = polylineVolumeOutlineGeometry._positions;
+    const cleanPositions = arrayRemoveDuplicates.arrayRemoveDuplicates(
+      positions,
+      Matrix3.Cartesian3.equalsEpsilon
+    );
+    let shape2D = polylineVolumeOutlineGeometry._shape;
+    shape2D = PolylineVolumeGeometryLibrary.PolylineVolumeGeometryLibrary.removeDuplicatesFromShape(shape2D);
+
+    if (cleanPositions.length < 2 || shape2D.length < 3) {
+      return undefined;
+    }
+
+    if (
+      PolygonPipeline.PolygonPipeline.computeWindingOrder2D(shape2D) === PolygonPipeline.WindingOrder.CLOCKWISE
+    ) {
+      shape2D.reverse();
+    }
+    const boundingRectangle = BoundingRectangle.BoundingRectangle.fromPoints(shape2D, brScratch);
+
+    const computedPositions = PolylineVolumeGeometryLibrary.PolylineVolumeGeometryLibrary.computePositions(
+      cleanPositions,
+      shape2D,
+      boundingRectangle,
+      polylineVolumeOutlineGeometry,
+      false
+    );
+    return computeAttributes(computedPositions, shape2D);
+  };
+
+  function createPolylineVolumeOutlineGeometry(
+    polylineVolumeOutlineGeometry,
+    offset
+  ) {
+    if (defaultValue.defined(offset)) {
+      polylineVolumeOutlineGeometry = PolylineVolumeOutlineGeometry.unpack(
+        polylineVolumeOutlineGeometry,
+        offset
+      );
+    }
+    polylineVolumeOutlineGeometry._ellipsoid = Matrix3.Ellipsoid.clone(
+      polylineVolumeOutlineGeometry._ellipsoid
+    );
+    return PolylineVolumeOutlineGeometry.createGeometry(
+      polylineVolumeOutlineGeometry
+    );
+  }
+
+  return createPolylineVolumeOutlineGeometry;
+
+}));