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

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

@@ -1,25 +1,683 @@
-/**
- * @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","./ArcType-c9b2b290","./Transforms-d2e5867e","./ComponentDatatype-0200bf8c","./EllipsoidTangentPlane-c080fd1b","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryInstance-ee3aa3ba","./GeometryOffsetAttribute-08ae0c50","./GeometryPipeline-33ca229c","./IndexDatatype-e713bfd2","./PolygonGeometryLibrary-b61295f3","./PolygonPipeline-eb527514","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./AxisAlignedBoundingBox-d0c22774","./IntersectionTests-eb4db8e0","./Plane-b0299683","./AttributeCompression-7b0f288d","./EncodedCartesian3-ea0e408f","./arrayRemoveDuplicates-f13aceb1","./EllipsoidRhumbLine-03528f73"],(function(e,t,i,o,r,n,a,s,l,y,u,p,c,d,f,g,m,h,b,P,E,A,_,G,L){"use strict";const H=[],T=[];function v(e,t,o,y,u){const f=n.EllipsoidTangentPlane.fromPoints(t,e).projectPointsOntoPlane(t,H);let g,m;d.PolygonPipeline.computeWindingOrder2D(f)===d.WindingOrder.CLOCKWISE&&(f.reverse(),t=t.slice().reverse());let h=t.length,b=0;if(y)for(g=new Float64Array(2*h*3),m=0;m<h;m++){const e=t[m],i=t[(m+1)%h];g[b++]=e.x,g[b++]=e.y,g[b++]=e.z,g[b++]=i.x,g[b++]=i.y,g[b++]=i.z}else{let r=0;if(u===i.ArcType.GEODESIC)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideLineCount(t[m],t[(m+1)%h],o);else if(u===i.ArcType.RHUMB)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideRhumbLineCount(e,t[m],t[(m+1)%h],o);for(g=new Float64Array(3*r),m=0;m<h;m++){let r;u===i.ArcType.GEODESIC?r=c.PolygonGeometryLibrary.subdivideLine(t[m],t[(m+1)%h],o,T):u===i.ArcType.RHUMB&&(r=c.PolygonGeometryLibrary.subdivideRhumbLine(e,t[m],t[(m+1)%h],o,T));const n=r.length;for(let e=0;e<n;++e)g[b++]=r[e]}}h=g.length/3;const P=2*h,E=p.IndexDatatype.createTypedArray(h,P);for(b=0,m=0;m<h-1;m++)E[b++]=m,E[b++]=m+1;return E[b++]=h-1,E[b++]=0,new l.GeometryInstance({geometry:new a.Geometry({attributes:new s.GeometryAttributes({position:new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:g})}),indices:E,primitiveType:a.PrimitiveType.LINES})})}function C(e,t,o,y,u){const f=n.EllipsoidTangentPlane.fromPoints(t,e).projectPointsOntoPlane(t,H);let g,m;d.PolygonPipeline.computeWindingOrder2D(f)===d.WindingOrder.CLOCKWISE&&(f.reverse(),t=t.slice().reverse());let h=t.length;const b=new Array(h);let P=0;if(y)for(g=new Float64Array(2*h*3*2),m=0;m<h;++m){b[m]=P/3;const e=t[m],i=t[(m+1)%h];g[P++]=e.x,g[P++]=e.y,g[P++]=e.z,g[P++]=i.x,g[P++]=i.y,g[P++]=i.z}else{let r=0;if(u===i.ArcType.GEODESIC)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideLineCount(t[m],t[(m+1)%h],o);else if(u===i.ArcType.RHUMB)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideRhumbLineCount(e,t[m],t[(m+1)%h],o);for(g=new Float64Array(3*r*2),m=0;m<h;++m){let r;b[m]=P/3,u===i.ArcType.GEODESIC?r=c.PolygonGeometryLibrary.subdivideLine(t[m],t[(m+1)%h],o,T):u===i.ArcType.RHUMB&&(r=c.PolygonGeometryLibrary.subdivideRhumbLine(e,t[m],t[(m+1)%h],o,T));const n=r.length;for(let e=0;e<n;++e)g[P++]=r[e]}}h=g.length/6;const E=b.length,A=2*(2*h+E),_=p.IndexDatatype.createTypedArray(h+E,A);for(P=0,m=0;m<h;++m)_[P++]=m,_[P++]=(m+1)%h,_[P++]=m+h,_[P++]=(m+1)%h+h;for(m=0;m<E;m++){const e=b[m];_[P++]=e,_[P++]=e+h}return new l.GeometryInstance({geometry:new a.Geometry({attributes:new s.GeometryAttributes({position:new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:g})}),indices:_,primitiveType:a.PrimitiveType.LINES})})}function O(o){const n=o.polygonHierarchy,a=e.defaultValue(o.ellipsoid,t.Ellipsoid.WGS84),s=e.defaultValue(o.granularity,r.CesiumMath.RADIANS_PER_DEGREE),l=e.defaultValue(o.perPositionHeight,!1),y=l&&e.defined(o.extrudedHeight),u=e.defaultValue(o.arcType,i.ArcType.GEODESIC);let p=e.defaultValue(o.height,0),d=e.defaultValue(o.extrudedHeight,p);if(!y){const e=Math.max(p,d);d=Math.min(p,d),p=e}this._ellipsoid=t.Ellipsoid.clone(a),this._granularity=s,this._height=p,this._extrudedHeight=d,this._arcType=u,this._polygonHierarchy=n,this._perPositionHeight=l,this._perPositionHeightExtrude=y,this._offsetAttribute=o.offsetAttribute,this._workerName="createPolygonOutlineGeometry",this.packedLength=c.PolygonGeometryLibrary.computeHierarchyPackedLength(n,t.Cartesian3)+t.Ellipsoid.packedLength+8}O.pack=function(i,o,r){return r=e.defaultValue(r,0),r=c.PolygonGeometryLibrary.packPolygonHierarchy(i._polygonHierarchy,o,r,t.Cartesian3),t.Ellipsoid.pack(i._ellipsoid,o,r),r+=t.Ellipsoid.packedLength,o[r++]=i._height,o[r++]=i._extrudedHeight,o[r++]=i._granularity,o[r++]=i._perPositionHeightExtrude?1:0,o[r++]=i._perPositionHeight?1:0,o[r++]=i._arcType,o[r++]=e.defaultValue(i._offsetAttribute,-1),o[r]=i.packedLength,o};const x=t.Ellipsoid.clone(t.Ellipsoid.UNIT_SPHERE),D={polygonHierarchy:{}};return O.unpack=function(i,o,r){o=e.defaultValue(o,0);const n=c.PolygonGeometryLibrary.unpackPolygonHierarchy(i,o,t.Cartesian3);o=n.startingIndex,delete n.startingIndex;const a=t.Ellipsoid.unpack(i,o,x);o+=t.Ellipsoid.packedLength;const s=i[o++],l=i[o++],y=i[o++],u=1===i[o++],p=1===i[o++],d=i[o++],f=i[o++],g=i[o];return e.defined(r)||(r=new O(D)),r._polygonHierarchy=n,r._ellipsoid=t.Ellipsoid.clone(a,r._ellipsoid),r._height=s,r._extrudedHeight=l,r._granularity=y,r._perPositionHeight=p,r._perPositionHeightExtrude=u,r._arcType=d,r._offsetAttribute=-1===f?void 0:f,r.packedLength=g,r},O.fromPositions=function(t){return new O({polygonHierarchy:{positions:(t=e.defaultValue(t,e.defaultValue.EMPTY_OBJECT)).positions},height:t.height,extrudedHeight:t.extrudedHeight,ellipsoid:t.ellipsoid,granularity:t.granularity,perPositionHeight:t.perPositionHeight,arcType:t.arcType,offsetAttribute:t.offsetAttribute})},O.createGeometry=function(t){const i=t._ellipsoid,n=t._granularity,s=t._polygonHierarchy,l=t._perPositionHeight,p=t._arcType,f=c.PolygonGeometryLibrary.polygonOutlinesFromHierarchy(s,!l,i);if(0===f.length)return;let g;const m=[],h=r.CesiumMath.chordLength(n,i.maximumRadius),b=t._height,P=t._extrudedHeight;let E,A;if(t._perPositionHeightExtrude||!r.CesiumMath.equalsEpsilon(b,P,0,r.CesiumMath.EPSILON2))for(A=0;A<f.length;A++){if(g=C(i,f[A],h,l,p),g.geometry=c.PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(g.geometry,b,P,i,l),e.defined(t._offsetAttribute)){const e=g.geometry.attributes.position.values.length/3;let i=new Uint8Array(e);t._offsetAttribute===y.GeometryOffsetAttribute.TOP?i=i.fill(1,0,e/2):(E=t._offsetAttribute===y.GeometryOffsetAttribute.NONE?0:1,i=i.fill(E)),g.geometry.attributes.applyOffset=new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}m.push(g)}else for(A=0;A<f.length;A++){if(g=v(i,f[A],h,l,p),g.geometry.attributes.position.values=d.PolygonPipeline.scaleToGeodeticHeight(g.geometry.attributes.position.values,b,i,!l),e.defined(t._offsetAttribute)){const e=g.geometry.attributes.position.values.length;E=t._offsetAttribute===y.GeometryOffsetAttribute.NONE?0:1;const i=new Uint8Array(e/3).fill(E);g.geometry.attributes.applyOffset=new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}m.push(g)}const _=u.GeometryPipeline.combineInstances(m)[0],G=o.BoundingSphere.fromVertices(_.attributes.position.values);return new a.Geometry({attributes:_.attributes,indices:_.indices,primitiveType:_.primitiveType,boundingSphere:G,offsetAttribute:t._offsetAttribute})},function(i,o){return e.defined(o)&&(i=O.unpack(i,o)),i._ellipsoid=t.Ellipsoid.clone(i._ellipsoid),O.createGeometry(i)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './ArcType-ce2e50ab', './Transforms-40229881', './Check-666ab1a0', './ComponentDatatype-f7b11d02', './EllipsoidTangentPlane-214683dc', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryInstance-451dc1cd', './GeometryOffsetAttribute-04332ce7', './GeometryPipeline-ce4339ed', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './PolygonGeometryLibrary-a8680d96', './PolygonPipeline-844aab0a', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './AxisAlignedBoundingBox-ff186ccc', './IntersectionTests-f6e6bd8a', './Plane-900aa728', './AttributeCompression-b646d393', './EncodedCartesian3-81f70735', './arrayRemoveDuplicates-c2038105', './EllipsoidRhumbLine-19756602'], (function (defaultValue, Matrix3, ArcType, Transforms, Check, ComponentDatatype, EllipsoidTangentPlane, GeometryAttribute, GeometryAttributes, GeometryInstance, GeometryOffsetAttribute, GeometryPipeline, IndexDatatype, Math$1, PolygonGeometryLibrary, PolygonPipeline, Matrix2, RuntimeError, combine, WebGLConstants, AxisAlignedBoundingBox, IntersectionTests, Plane, AttributeCompression, EncodedCartesian3, arrayRemoveDuplicates, EllipsoidRhumbLine) { 'use strict';
+
+  const createGeometryFromPositionsPositions = [];
+  const createGeometryFromPositionsSubdivided = [];
+
+  function createGeometryFromPositions(
+    ellipsoid,
+    positions,
+    minDistance,
+    perPositionHeight,
+    arcType
+  ) {
+    const tangentPlane = EllipsoidTangentPlane.EllipsoidTangentPlane.fromPoints(positions, ellipsoid);
+    const positions2D = tangentPlane.projectPointsOntoPlane(
+      positions,
+      createGeometryFromPositionsPositions
+    );
+
+    const originalWindingOrder = PolygonPipeline.PolygonPipeline.computeWindingOrder2D(
+      positions2D
+    );
+    if (originalWindingOrder === PolygonPipeline.WindingOrder.CLOCKWISE) {
+      positions2D.reverse();
+      positions = positions.slice().reverse();
+    }
+
+    let subdividedPositions;
+    let i;
+
+    let length = positions.length;
+    let index = 0;
+
+    if (!perPositionHeight) {
+      let numVertices = 0;
+      if (arcType === ArcType.ArcType.GEODESIC) {
+        for (i = 0; i < length; i++) {
+          numVertices += PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideLineCount(
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance
+          );
+        }
+      } else if (arcType === ArcType.ArcType.RHUMB) {
+        for (i = 0; i < length; i++) {
+          numVertices += PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideRhumbLineCount(
+            ellipsoid,
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance
+          );
+        }
+      }
+      subdividedPositions = new Float64Array(numVertices * 3);
+      for (i = 0; i < length; i++) {
+        let tempPositions;
+        if (arcType === ArcType.ArcType.GEODESIC) {
+          tempPositions = PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideLine(
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance,
+            createGeometryFromPositionsSubdivided
+          );
+        } else if (arcType === ArcType.ArcType.RHUMB) {
+          tempPositions = PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideRhumbLine(
+            ellipsoid,
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance,
+            createGeometryFromPositionsSubdivided
+          );
+        }
+        const tempPositionsLength = tempPositions.length;
+        for (let j = 0; j < tempPositionsLength; ++j) {
+          subdividedPositions[index++] = tempPositions[j];
+        }
+      }
+    } else {
+      subdividedPositions = new Float64Array(length * 2 * 3);
+      for (i = 0; i < length; i++) {
+        const p0 = positions[i];
+        const p1 = positions[(i + 1) % length];
+        subdividedPositions[index++] = p0.x;
+        subdividedPositions[index++] = p0.y;
+        subdividedPositions[index++] = p0.z;
+        subdividedPositions[index++] = p1.x;
+        subdividedPositions[index++] = p1.y;
+        subdividedPositions[index++] = p1.z;
+      }
+    }
+
+    length = subdividedPositions.length / 3;
+    const indicesSize = length * 2;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(length, indicesSize);
+    index = 0;
+    for (i = 0; i < length - 1; i++) {
+      indices[index++] = i;
+      indices[index++] = i + 1;
+    }
+    indices[index++] = length - 1;
+    indices[index++] = 0;
+
+    return new GeometryInstance.GeometryInstance({
+      geometry: new GeometryAttribute.Geometry({
+        attributes: new GeometryAttributes.GeometryAttributes({
+          position: new GeometryAttribute.GeometryAttribute({
+            componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+            componentsPerAttribute: 3,
+            values: subdividedPositions,
+          }),
+        }),
+        indices: indices,
+        primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      }),
+    });
+  }
+
+  function createGeometryFromPositionsExtruded(
+    ellipsoid,
+    positions,
+    minDistance,
+    perPositionHeight,
+    arcType
+  ) {
+    const tangentPlane = EllipsoidTangentPlane.EllipsoidTangentPlane.fromPoints(positions, ellipsoid);
+    const positions2D = tangentPlane.projectPointsOntoPlane(
+      positions,
+      createGeometryFromPositionsPositions
+    );
+
+    const originalWindingOrder = PolygonPipeline.PolygonPipeline.computeWindingOrder2D(
+      positions2D
+    );
+    if (originalWindingOrder === PolygonPipeline.WindingOrder.CLOCKWISE) {
+      positions2D.reverse();
+      positions = positions.slice().reverse();
+    }
+
+    let subdividedPositions;
+    let i;
+
+    let length = positions.length;
+    const corners = new Array(length);
+    let index = 0;
+
+    if (!perPositionHeight) {
+      let numVertices = 0;
+      if (arcType === ArcType.ArcType.GEODESIC) {
+        for (i = 0; i < length; i++) {
+          numVertices += PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideLineCount(
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance
+          );
+        }
+      } else if (arcType === ArcType.ArcType.RHUMB) {
+        for (i = 0; i < length; i++) {
+          numVertices += PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideRhumbLineCount(
+            ellipsoid,
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance
+          );
+        }
+      }
+
+      subdividedPositions = new Float64Array(numVertices * 3 * 2);
+      for (i = 0; i < length; ++i) {
+        corners[i] = index / 3;
+        let tempPositions;
+        if (arcType === ArcType.ArcType.GEODESIC) {
+          tempPositions = PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideLine(
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance,
+            createGeometryFromPositionsSubdivided
+          );
+        } else if (arcType === ArcType.ArcType.RHUMB) {
+          tempPositions = PolygonGeometryLibrary.PolygonGeometryLibrary.subdivideRhumbLine(
+            ellipsoid,
+            positions[i],
+            positions[(i + 1) % length],
+            minDistance,
+            createGeometryFromPositionsSubdivided
+          );
+        }
+        const tempPositionsLength = tempPositions.length;
+        for (let j = 0; j < tempPositionsLength; ++j) {
+          subdividedPositions[index++] = tempPositions[j];
+        }
+      }
+    } else {
+      subdividedPositions = new Float64Array(length * 2 * 3 * 2);
+      for (i = 0; i < length; ++i) {
+        corners[i] = index / 3;
+        const p0 = positions[i];
+        const p1 = positions[(i + 1) % length];
+
+        subdividedPositions[index++] = p0.x;
+        subdividedPositions[index++] = p0.y;
+        subdividedPositions[index++] = p0.z;
+        subdividedPositions[index++] = p1.x;
+        subdividedPositions[index++] = p1.y;
+        subdividedPositions[index++] = p1.z;
+      }
+    }
+
+    length = subdividedPositions.length / (3 * 2);
+    const cornersLength = corners.length;
+
+    const indicesSize = (length * 2 + cornersLength) * 2;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(
+      length + cornersLength,
+      indicesSize
+    );
+
+    index = 0;
+    for (i = 0; i < length; ++i) {
+      indices[index++] = i;
+      indices[index++] = (i + 1) % length;
+      indices[index++] = i + length;
+      indices[index++] = ((i + 1) % length) + length;
+    }
+
+    for (i = 0; i < cornersLength; i++) {
+      const corner = corners[i];
+      indices[index++] = corner;
+      indices[index++] = corner + length;
+    }
+
+    return new GeometryInstance.GeometryInstance({
+      geometry: new GeometryAttribute.Geometry({
+        attributes: new GeometryAttributes.GeometryAttributes({
+          position: new GeometryAttribute.GeometryAttribute({
+            componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+            componentsPerAttribute: 3,
+            values: subdividedPositions,
+          }),
+        }),
+        indices: indices,
+        primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      }),
+    });
+  }
+
+  /**
+   * A description of the outline of a polygon on the ellipsoid. The polygon is defined by a polygon hierarchy.
+   *
+   * @alias PolygonOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {PolygonHierarchy} options.polygonHierarchy A polygon hierarchy that can include holes.
+   * @param {Number} [options.height=0.0] The distance in meters between the polygon and the ellipsoid surface.
+   * @param {Number} [options.extrudedHeight] The distance in meters between the polygon's extruded face and the ellipsoid surface.
+   * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+   * @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 {Boolean} [options.perPositionHeight=false] Use the height of options.positions for each position instead of using options.height to determine the height.
+   * @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of path the outline must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
+   *
+   * @see PolygonOutlineGeometry#createGeometry
+   * @see PolygonOutlineGeometry#fromPositions
+   *
+   * @example
+   * // 1. create a polygon outline from points
+   * const polygon = new Cesium.PolygonOutlineGeometry({
+   *   polygonHierarchy : new Cesium.PolygonHierarchy(
+   *     Cesium.Cartesian3.fromDegreesArray([
+   *       -72.0, 40.0,
+   *       -70.0, 35.0,
+   *       -75.0, 30.0,
+   *       -70.0, 30.0,
+   *       -68.0, 40.0
+   *     ])
+   *   )
+   * });
+   * const geometry = Cesium.PolygonOutlineGeometry.createGeometry(polygon);
+   *
+   * // 2. create a nested polygon with holes outline
+   * const polygonWithHole = new Cesium.PolygonOutlineGeometry({
+   *   polygonHierarchy : new Cesium.PolygonHierarchy(
+   *     Cesium.Cartesian3.fromDegreesArray([
+   *       -109.0, 30.0,
+   *       -95.0, 30.0,
+   *       -95.0, 40.0,
+   *       -109.0, 40.0
+   *     ]),
+   *     [new Cesium.PolygonHierarchy(
+   *       Cesium.Cartesian3.fromDegreesArray([
+   *         -107.0, 31.0,
+   *         -107.0, 39.0,
+   *         -97.0, 39.0,
+   *         -97.0, 31.0
+   *       ]),
+   *       [new Cesium.PolygonHierarchy(
+   *         Cesium.Cartesian3.fromDegreesArray([
+   *           -105.0, 33.0,
+   *           -99.0, 33.0,
+   *           -99.0, 37.0,
+   *           -105.0, 37.0
+   *         ]),
+   *         [new Cesium.PolygonHierarchy(
+   *           Cesium.Cartesian3.fromDegreesArray([
+   *             -103.0, 34.0,
+   *             -101.0, 34.0,
+   *             -101.0, 36.0,
+   *             -103.0, 36.0
+   *           ])
+   *         )]
+   *       )]
+   *     )]
+   *   )
+   * });
+   * const geometry = Cesium.PolygonOutlineGeometry.createGeometry(polygonWithHole);
+   *
+   * // 3. create extruded polygon outline
+   * const extrudedPolygon = new Cesium.PolygonOutlineGeometry({
+   *   polygonHierarchy : new Cesium.PolygonHierarchy(
+   *     Cesium.Cartesian3.fromDegreesArray([
+   *       -72.0, 40.0,
+   *       -70.0, 35.0,
+   *       -75.0, 30.0,
+   *       -70.0, 30.0,
+   *       -68.0, 40.0
+   *     ])
+   *   ),
+   *   extrudedHeight: 300000
+   * });
+   * const geometry = Cesium.PolygonOutlineGeometry.createGeometry(extrudedPolygon);
+   */
+  function PolygonOutlineGeometry(options) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("options", options);
+    Check.Check.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
+
+    if (options.perPositionHeight && defaultValue.defined(options.height)) {
+      throw new Check.DeveloperError(
+        "Cannot use both options.perPositionHeight and options.height"
+      );
+    }
+    if (
+      defaultValue.defined(options.arcType) &&
+      options.arcType !== ArcType.ArcType.GEODESIC &&
+      options.arcType !== ArcType.ArcType.RHUMB
+    ) {
+      throw new Check.DeveloperError(
+        "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
+      );
+    }
+    //>>includeEnd('debug');
+
+    const polygonHierarchy = options.polygonHierarchy;
+    const ellipsoid = defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84);
+    const granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math$1.CesiumMath.RADIANS_PER_DEGREE
+    );
+    const perPositionHeight = defaultValue.defaultValue(options.perPositionHeight, false);
+    const perPositionHeightExtrude =
+      perPositionHeight && defaultValue.defined(options.extrudedHeight);
+    const arcType = defaultValue.defaultValue(options.arcType, ArcType.ArcType.GEODESIC);
+
+    let height = defaultValue.defaultValue(options.height, 0.0);
+    let extrudedHeight = defaultValue.defaultValue(options.extrudedHeight, height);
+
+    if (!perPositionHeightExtrude) {
+      const h = Math.max(height, extrudedHeight);
+      extrudedHeight = Math.min(height, extrudedHeight);
+      height = h;
+    }
+
+    this._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid);
+    this._granularity = granularity;
+    this._height = height;
+    this._extrudedHeight = extrudedHeight;
+    this._arcType = arcType;
+    this._polygonHierarchy = polygonHierarchy;
+    this._perPositionHeight = perPositionHeight;
+    this._perPositionHeightExtrude = perPositionHeightExtrude;
+    this._offsetAttribute = options.offsetAttribute;
+    this._workerName = "createPolygonOutlineGeometry";
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength =
+      PolygonGeometryLibrary.PolygonGeometryLibrary.computeHierarchyPackedLength(
+        polygonHierarchy,
+        Matrix3.Cartesian3
+      ) +
+      Matrix3.Ellipsoid.packedLength +
+      8;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {PolygonOutlineGeometry} 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
+   */
+  PolygonOutlineGeometry.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);
+
+    startingIndex = PolygonGeometryLibrary.PolygonGeometryLibrary.packPolygonHierarchy(
+      value._polygonHierarchy,
+      array,
+      startingIndex,
+      Matrix3.Cartesian3
+    );
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    array[startingIndex++] = value._height;
+    array[startingIndex++] = value._extrudedHeight;
+    array[startingIndex++] = value._granularity;
+    array[startingIndex++] = value._perPositionHeightExtrude ? 1.0 : 0.0;
+    array[startingIndex++] = value._perPositionHeight ? 1.0 : 0.0;
+    array[startingIndex++] = value._arcType;
+    array[startingIndex++] = defaultValue.defaultValue(value._offsetAttribute, -1);
+    array[startingIndex] = value.packedLength;
+
+    return array;
+  };
+
+  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
+  const dummyOptions = {
+    polygonHierarchy: {},
+  };
+
+  /**
+   * 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 {PolygonOutlineGeometry} [result] The object into which to store the result.
+   * @returns {PolygonOutlineGeometry} The modified result parameter or a new PolygonOutlineGeometry instance if one was not provided.
+   */
+  PolygonOutlineGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    const polygonHierarchy = PolygonGeometryLibrary.PolygonGeometryLibrary.unpackPolygonHierarchy(
+      array,
+      startingIndex,
+      Matrix3.Cartesian3
+    );
+    startingIndex = polygonHierarchy.startingIndex;
+    delete polygonHierarchy.startingIndex;
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const height = array[startingIndex++];
+    const extrudedHeight = array[startingIndex++];
+    const granularity = array[startingIndex++];
+    const perPositionHeightExtrude = array[startingIndex++] === 1.0;
+    const perPositionHeight = array[startingIndex++] === 1.0;
+    const arcType = array[startingIndex++];
+    const offsetAttribute = array[startingIndex++];
+    const packedLength = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      result = new PolygonOutlineGeometry(dummyOptions);
+    }
+
+    result._polygonHierarchy = polygonHierarchy;
+    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
+    result._height = height;
+    result._extrudedHeight = extrudedHeight;
+    result._granularity = granularity;
+    result._perPositionHeight = perPositionHeight;
+    result._perPositionHeightExtrude = perPositionHeightExtrude;
+    result._arcType = arcType;
+    result._offsetAttribute =
+      offsetAttribute === -1 ? undefined : offsetAttribute;
+    result.packedLength = packedLength;
+
+    return result;
+  };
+
+  /**
+   * A description of a polygon outline from an array of positions.
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of positions that defined the corner points of the polygon.
+   * @param {Number} [options.height=0.0] The height of the polygon.
+   * @param {Number} [options.extrudedHeight] The height of the polygon extrusion.
+   * @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 {Boolean} [options.perPositionHeight=false] Use the height of options.positions for each position instead of using options.height to determine the height.
+   * @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of path the outline must follow. Valid options are {@link LinkType.GEODESIC} and {@link ArcType.RHUMB}.
+   * @returns {PolygonOutlineGeometry}
+   *
+   *
+   * @example
+   * // create a polygon from points
+   * const polygon = Cesium.PolygonOutlineGeometry.fromPositions({
+   *   positions : Cesium.Cartesian3.fromDegreesArray([
+   *     -72.0, 40.0,
+   *     -70.0, 35.0,
+   *     -75.0, 30.0,
+   *     -70.0, 30.0,
+   *     -68.0, 40.0
+   *   ])
+   * });
+   * const geometry = Cesium.PolygonOutlineGeometry.createGeometry(polygon);
+   *
+   * @see PolygonOutlineGeometry#createGeometry
+   */
+  PolygonOutlineGeometry.fromPositions = function (options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("options.positions", options.positions);
+    //>>includeEnd('debug');
+
+    const newOptions = {
+      polygonHierarchy: {
+        positions: options.positions,
+      },
+      height: options.height,
+      extrudedHeight: options.extrudedHeight,
+      ellipsoid: options.ellipsoid,
+      granularity: options.granularity,
+      perPositionHeight: options.perPositionHeight,
+      arcType: options.arcType,
+      offsetAttribute: options.offsetAttribute,
+    };
+    return new PolygonOutlineGeometry(newOptions);
+  };
+
+  /**
+   * Computes the geometric representation of a polygon outline, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {PolygonOutlineGeometry} polygonGeometry A description of the polygon outline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  PolygonOutlineGeometry.createGeometry = function (polygonGeometry) {
+    const ellipsoid = polygonGeometry._ellipsoid;
+    const granularity = polygonGeometry._granularity;
+    const polygonHierarchy = polygonGeometry._polygonHierarchy;
+    const perPositionHeight = polygonGeometry._perPositionHeight;
+    const arcType = polygonGeometry._arcType;
+
+    const polygons = PolygonGeometryLibrary.PolygonGeometryLibrary.polygonOutlinesFromHierarchy(
+      polygonHierarchy,
+      !perPositionHeight,
+      ellipsoid
+    );
+
+    if (polygons.length === 0) {
+      return undefined;
+    }
+
+    let geometryInstance;
+    const geometries = [];
+    const minDistance = Math$1.CesiumMath.chordLength(
+      granularity,
+      ellipsoid.maximumRadius
+    );
+
+    const height = polygonGeometry._height;
+    const extrudedHeight = polygonGeometry._extrudedHeight;
+    const extrude =
+      polygonGeometry._perPositionHeightExtrude ||
+      !Math$1.CesiumMath.equalsEpsilon(height, extrudedHeight, 0, Math$1.CesiumMath.EPSILON2);
+    let offsetValue;
+    let i;
+    if (extrude) {
+      for (i = 0; i < polygons.length; i++) {
+        geometryInstance = createGeometryFromPositionsExtruded(
+          ellipsoid,
+          polygons[i],
+          minDistance,
+          perPositionHeight,
+          arcType
+        );
+        geometryInstance.geometry = PolygonGeometryLibrary.PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(
+          geometryInstance.geometry,
+          height,
+          extrudedHeight,
+          ellipsoid,
+          perPositionHeight
+        );
+        if (defaultValue.defined(polygonGeometry._offsetAttribute)) {
+          const size =
+            geometryInstance.geometry.attributes.position.values.length / 3;
+          let offsetAttribute = new Uint8Array(size);
+          if (polygonGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.TOP) {
+            offsetAttribute = offsetAttribute.fill(1, 0, size / 2);
+          } else {
+            offsetValue =
+              polygonGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE
+                ? 0
+                : 1;
+            offsetAttribute = offsetAttribute.fill(offsetValue);
+          }
+
+          geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute.GeometryAttribute(
+            {
+              componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+              componentsPerAttribute: 1,
+              values: offsetAttribute,
+            }
+          );
+        }
+        geometries.push(geometryInstance);
+      }
+    } else {
+      for (i = 0; i < polygons.length; i++) {
+        geometryInstance = createGeometryFromPositions(
+          ellipsoid,
+          polygons[i],
+          minDistance,
+          perPositionHeight,
+          arcType
+        );
+        geometryInstance.geometry.attributes.position.values = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+          geometryInstance.geometry.attributes.position.values,
+          height,
+          ellipsoid,
+          !perPositionHeight
+        );
+
+        if (defaultValue.defined(polygonGeometry._offsetAttribute)) {
+          const length =
+            geometryInstance.geometry.attributes.position.values.length;
+          offsetValue =
+            polygonGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE
+              ? 0
+              : 1;
+          const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+          geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute.GeometryAttribute(
+            {
+              componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+              componentsPerAttribute: 1,
+              values: applyOffset,
+            }
+          );
+        }
+
+        geometries.push(geometryInstance);
+      }
+    }
+
+    const geometry = GeometryPipeline.GeometryPipeline.combineInstances(geometries)[0];
+    const boundingSphere = Transforms.BoundingSphere.fromVertices(
+      geometry.attributes.position.values
+    );
+
+    return new GeometryAttribute.Geometry({
+      attributes: geometry.attributes,
+      indices: geometry.indices,
+      primitiveType: geometry.primitiveType,
+      boundingSphere: boundingSphere,
+      offsetAttribute: polygonGeometry._offsetAttribute,
+    });
+  };
+
+  function createPolygonOutlineGeometry(polygonGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      polygonGeometry = PolygonOutlineGeometry.unpack(polygonGeometry, offset);
+    }
+    polygonGeometry._ellipsoid = Matrix3.Ellipsoid.clone(polygonGeometry._ellipsoid);
+    return PolygonOutlineGeometry.createGeometry(polygonGeometry);
+  }
+
+  return createPolygonOutlineGeometry;
+
+}));