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

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

@@ -1,25 +1,535 @@
-/**
- * @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","./GeometryOffsetAttribute-08ae0c50","./IndexDatatype-e713bfd2","./PolygonPipeline-eb527514","./RectangleGeometryLibrary-ae8bf8a5","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./EllipsoidRhumbLine-03528f73"],(function(e,t,i,n,o,a,r,l,s,u,c,p,d,f,g){"use strict";const h=new i.BoundingSphere,y=new i.BoundingSphere,b=new t.Cartesian3,m=new t.Rectangle;function _(e,t){const i=e._ellipsoid,r=t.height,s=t.width,c=t.northCap,p=t.southCap;let d=r,f=2,g=0,h=4;c&&(f-=1,d-=1,g+=1,h-=2),p&&(f-=1,d-=1,g+=1,h-=2),g+=f*s+2*d-h;const y=new Float64Array(3*g);let m,_=0,E=0;const A=b;if(c)u.RectangleGeometryLibrary.computePosition(t,i,!1,E,0,A),y[_++]=A.x,y[_++]=A.y,y[_++]=A.z;else for(m=0;m<s;m++)u.RectangleGeometryLibrary.computePosition(t,i,!1,E,m,A),y[_++]=A.x,y[_++]=A.y,y[_++]=A.z;for(m=s-1,E=1;E<r;E++)u.RectangleGeometryLibrary.computePosition(t,i,!1,E,m,A),y[_++]=A.x,y[_++]=A.y,y[_++]=A.z;if(E=r-1,!p)for(m=s-2;m>=0;m--)u.RectangleGeometryLibrary.computePosition(t,i,!1,E,m,A),y[_++]=A.x,y[_++]=A.y,y[_++]=A.z;for(m=0,E=r-2;E>0;E--)u.RectangleGeometryLibrary.computePosition(t,i,!1,E,m,A),y[_++]=A.x,y[_++]=A.y,y[_++]=A.z;const G=y.length/3*2,R=l.IndexDatatype.createTypedArray(y.length/3,G);let P=0;for(let e=0;e<y.length/3-1;e++)R[P++]=e,R[P++]=e+1;R[P++]=y.length/3-1,R[P++]=0;const L=new o.Geometry({attributes:new a.GeometryAttributes,primitiveType:o.PrimitiveType.LINES});return L.attributes.position=new o.GeometryAttribute({componentDatatype:n.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:y}),L.indices=R,L}function E(i){const o=(i=e.defaultValue(i,e.defaultValue.EMPTY_OBJECT)).rectangle,a=e.defaultValue(i.granularity,n.CesiumMath.RADIANS_PER_DEGREE),r=e.defaultValue(i.ellipsoid,t.Ellipsoid.WGS84),l=e.defaultValue(i.rotation,0),s=e.defaultValue(i.height,0),u=e.defaultValue(i.extrudedHeight,s);this._rectangle=t.Rectangle.clone(o),this._granularity=a,this._ellipsoid=r,this._surfaceHeight=Math.max(s,u),this._rotation=l,this._extrudedHeight=Math.min(s,u),this._offsetAttribute=i.offsetAttribute,this._workerName="createRectangleOutlineGeometry"}E.packedLength=t.Rectangle.packedLength+t.Ellipsoid.packedLength+5,E.pack=function(i,n,o){return o=e.defaultValue(o,0),t.Rectangle.pack(i._rectangle,n,o),o+=t.Rectangle.packedLength,t.Ellipsoid.pack(i._ellipsoid,n,o),o+=t.Ellipsoid.packedLength,n[o++]=i._granularity,n[o++]=i._surfaceHeight,n[o++]=i._rotation,n[o++]=i._extrudedHeight,n[o]=e.defaultValue(i._offsetAttribute,-1),n};const A=new t.Rectangle,G=t.Ellipsoid.clone(t.Ellipsoid.UNIT_SPHERE),R={rectangle:A,ellipsoid:G,granularity:void 0,height:void 0,rotation:void 0,extrudedHeight:void 0,offsetAttribute:void 0};E.unpack=function(i,n,o){n=e.defaultValue(n,0);const a=t.Rectangle.unpack(i,n,A);n+=t.Rectangle.packedLength;const r=t.Ellipsoid.unpack(i,n,G);n+=t.Ellipsoid.packedLength;const l=i[n++],s=i[n++],u=i[n++],c=i[n++],p=i[n];return e.defined(o)?(o._rectangle=t.Rectangle.clone(a,o._rectangle),o._ellipsoid=t.Ellipsoid.clone(r,o._ellipsoid),o._surfaceHeight=s,o._rotation=u,o._extrudedHeight=c,o._offsetAttribute=-1===p?void 0:p,o):(R.granularity=l,R.height=s,R.rotation=u,R.extrudedHeight=c,R.offsetAttribute=-1===p?void 0:p,new E(R))};const P=new t.Cartographic;return E.createGeometry=function(t){const a=t._rectangle,c=t._ellipsoid,p=u.RectangleGeometryLibrary.computeOptions(a,t._granularity,t._rotation,0,m,P);let d,f;if(n.CesiumMath.equalsEpsilon(a.north,a.south,n.CesiumMath.EPSILON10)||n.CesiumMath.equalsEpsilon(a.east,a.west,n.CesiumMath.EPSILON10))return;const g=t._surfaceHeight,b=t._extrudedHeight;let E;if(!n.CesiumMath.equalsEpsilon(g,b,0,n.CesiumMath.EPSILON2)){if(d=function(e,t){const i=e._surfaceHeight,n=e._extrudedHeight,o=e._ellipsoid,a=n,r=i,u=_(e,t),c=t.height,p=t.width,d=s.PolygonPipeline.scaleToGeodeticHeight(u.attributes.position.values,r,o,!1);let f=d.length;const g=new Float64Array(2*f);g.set(d);const h=s.PolygonPipeline.scaleToGeodeticHeight(u.attributes.position.values,a,o);g.set(h,f),u.attributes.position.values=g;const y=t.northCap,b=t.southCap;let m=4;y&&(m-=1),b&&(m-=1);const E=2*(g.length/3+m),A=l.IndexDatatype.createTypedArray(g.length/3,E);f=g.length/6;let G,R=0;for(let e=0;e<f-1;e++)A[R++]=e,A[R++]=e+1,A[R++]=e+f,A[R++]=e+f+1;if(A[R++]=f-1,A[R++]=0,A[R++]=f+f-1,A[R++]=f,A[R++]=0,A[R++]=f,y)G=c-1;else{const e=p-1;A[R++]=e,A[R++]=e+f,G=p+c-2}if(A[R++]=G,A[R++]=G+f,!b){const e=p+G-1;A[R++]=e,A[R]=e+f}return u.indices=A,u}(t,p),e.defined(t._offsetAttribute)){const e=d.attributes.position.values.length/3;let i=new Uint8Array(e);t._offsetAttribute===r.GeometryOffsetAttribute.TOP?i=i.fill(1,0,e/2):(E=t._offsetAttribute===r.GeometryOffsetAttribute.NONE?0:1,i=i.fill(E)),d.attributes.applyOffset=new o.GeometryAttribute({componentDatatype:n.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}const u=i.BoundingSphere.fromRectangle3D(a,c,g,y),m=i.BoundingSphere.fromRectangle3D(a,c,b,h);f=i.BoundingSphere.union(u,m)}else{if(d=_(t,p),d.attributes.position.values=s.PolygonPipeline.scaleToGeodeticHeight(d.attributes.position.values,g,c,!1),e.defined(t._offsetAttribute)){const e=d.attributes.position.values.length;E=t._offsetAttribute===r.GeometryOffsetAttribute.NONE?0:1;const i=new Uint8Array(e/3).fill(E);d.attributes.applyOffset=new o.GeometryAttribute({componentDatatype:n.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}f=i.BoundingSphere.fromRectangle3D(a,c,g)}return new o.Geometry({attributes:d.attributes,indices:d.indices,primitiveType:o.PrimitiveType.LINES,boundingSphere:f,offsetAttribute:t._offsetAttribute})},function(i,n){return e.defined(n)&&(i=E.unpack(i,n)),i._ellipsoid=t.Ellipsoid.clone(i._ellipsoid),i._rectangle=t.Rectangle.clone(i._rectangle),E.createGeometry(i)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './Matrix2-13178034', './Transforms-40229881', './ComponentDatatype-f7b11d02', './Check-666ab1a0', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './PolygonPipeline-844aab0a', './RectangleGeometryLibrary-bdba697e', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './EllipsoidRhumbLine-19756602'], (function (defaultValue, Matrix3, Matrix2, Transforms, ComponentDatatype, Check, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype, Math$1, PolygonPipeline, RectangleGeometryLibrary, RuntimeError, combine, WebGLConstants, EllipsoidRhumbLine) { 'use strict';
+
+  const bottomBoundingSphere = new Transforms.BoundingSphere();
+  const topBoundingSphere = new Transforms.BoundingSphere();
+  const positionScratch = new Matrix3.Cartesian3();
+  const rectangleScratch = new Matrix2.Rectangle();
+
+  function constructRectangle(geometry, computedOptions) {
+    const ellipsoid = geometry._ellipsoid;
+    const height = computedOptions.height;
+    const width = computedOptions.width;
+    const northCap = computedOptions.northCap;
+    const southCap = computedOptions.southCap;
+
+    let rowHeight = height;
+    let widthMultiplier = 2;
+    let size = 0;
+    let corners = 4;
+    if (northCap) {
+      widthMultiplier -= 1;
+      rowHeight -= 1;
+      size += 1;
+      corners -= 2;
+    }
+    if (southCap) {
+      widthMultiplier -= 1;
+      rowHeight -= 1;
+      size += 1;
+      corners -= 2;
+    }
+    size += widthMultiplier * width + 2 * rowHeight - corners;
+
+    const positions = new Float64Array(size * 3);
+
+    let posIndex = 0;
+    let row = 0;
+    let col;
+    const position = positionScratch;
+    if (northCap) {
+      RectangleGeometryLibrary.RectangleGeometryLibrary.computePosition(
+        computedOptions,
+        ellipsoid,
+        false,
+        row,
+        0,
+        position
+      );
+      positions[posIndex++] = position.x;
+      positions[posIndex++] = position.y;
+      positions[posIndex++] = position.z;
+    } else {
+      for (col = 0; col < width; col++) {
+        RectangleGeometryLibrary.RectangleGeometryLibrary.computePosition(
+          computedOptions,
+          ellipsoid,
+          false,
+          row,
+          col,
+          position
+        );
+        positions[posIndex++] = position.x;
+        positions[posIndex++] = position.y;
+        positions[posIndex++] = position.z;
+      }
+    }
+
+    col = width - 1;
+    for (row = 1; row < height; row++) {
+      RectangleGeometryLibrary.RectangleGeometryLibrary.computePosition(
+        computedOptions,
+        ellipsoid,
+        false,
+        row,
+        col,
+        position
+      );
+      positions[posIndex++] = position.x;
+      positions[posIndex++] = position.y;
+      positions[posIndex++] = position.z;
+    }
+
+    row = height - 1;
+    if (!southCap) {
+      // if southCap is true, we dont need to add any more points because the south pole point was added by the iteration above
+      for (col = width - 2; col >= 0; col--) {
+        RectangleGeometryLibrary.RectangleGeometryLibrary.computePosition(
+          computedOptions,
+          ellipsoid,
+          false,
+          row,
+          col,
+          position
+        );
+        positions[posIndex++] = position.x;
+        positions[posIndex++] = position.y;
+        positions[posIndex++] = position.z;
+      }
+    }
+
+    col = 0;
+    for (row = height - 2; row > 0; row--) {
+      RectangleGeometryLibrary.RectangleGeometryLibrary.computePosition(
+        computedOptions,
+        ellipsoid,
+        false,
+        row,
+        col,
+        position
+      );
+      positions[posIndex++] = position.x;
+      positions[posIndex++] = position.y;
+      positions[posIndex++] = position.z;
+    }
+
+    const indicesSize = (positions.length / 3) * 2;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(
+      positions.length / 3,
+      indicesSize
+    );
+
+    let index = 0;
+    for (let i = 0; i < positions.length / 3 - 1; i++) {
+      indices[index++] = i;
+      indices[index++] = i + 1;
+    }
+    indices[index++] = positions.length / 3 - 1;
+    indices[index++] = 0;
+
+    const geo = new GeometryAttribute.Geometry({
+      attributes: new GeometryAttributes.GeometryAttributes(),
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+    });
+
+    geo.attributes.position = new GeometryAttribute.GeometryAttribute({
+      componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions,
+    });
+    geo.indices = indices;
+
+    return geo;
+  }
+
+  function constructExtrudedRectangle(rectangleGeometry, computedOptions) {
+    const surfaceHeight = rectangleGeometry._surfaceHeight;
+    const extrudedHeight = rectangleGeometry._extrudedHeight;
+    const ellipsoid = rectangleGeometry._ellipsoid;
+    const minHeight = extrudedHeight;
+    const maxHeight = surfaceHeight;
+    const geo = constructRectangle(rectangleGeometry, computedOptions);
+
+    const height = computedOptions.height;
+    const width = computedOptions.width;
+
+    const topPositions = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+      geo.attributes.position.values,
+      maxHeight,
+      ellipsoid,
+      false
+    );
+    let length = topPositions.length;
+    const positions = new Float64Array(length * 2);
+    positions.set(topPositions);
+    const bottomPositions = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+      geo.attributes.position.values,
+      minHeight,
+      ellipsoid
+    );
+    positions.set(bottomPositions, length);
+    geo.attributes.position.values = positions;
+
+    const northCap = computedOptions.northCap;
+    const southCap = computedOptions.southCap;
+    let corners = 4;
+    if (northCap) {
+      corners -= 1;
+    }
+    if (southCap) {
+      corners -= 1;
+    }
+
+    const indicesSize = (positions.length / 3 + corners) * 2;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(
+      positions.length / 3,
+      indicesSize
+    );
+    length = positions.length / 6;
+    let index = 0;
+    for (let i = 0; i < length - 1; i++) {
+      indices[index++] = i;
+      indices[index++] = i + 1;
+      indices[index++] = i + length;
+      indices[index++] = i + length + 1;
+    }
+    indices[index++] = length - 1;
+    indices[index++] = 0;
+    indices[index++] = length + length - 1;
+    indices[index++] = length;
+
+    indices[index++] = 0;
+    indices[index++] = length;
+
+    let bottomCorner;
+    if (northCap) {
+      bottomCorner = height - 1;
+    } else {
+      const topRightCorner = width - 1;
+      indices[index++] = topRightCorner;
+      indices[index++] = topRightCorner + length;
+      bottomCorner = width + height - 2;
+    }
+
+    indices[index++] = bottomCorner;
+    indices[index++] = bottomCorner + length;
+
+    if (!southCap) {
+      const bottomLeftCorner = width + bottomCorner - 1;
+      indices[index++] = bottomLeftCorner;
+      indices[index] = bottomLeftCorner + length;
+    }
+
+    geo.indices = indices;
+
+    return geo;
+  }
+
+  /**
+   * A description of the outline of a a cartographic rectangle on an ellipsoid centered at the origin.
+   *
+   * @alias RectangleOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Rectangle} options.rectangle A cartographic rectangle with north, south, east and west properties in radians.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the rectangle lies.
+   * @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.height=0.0] The distance in meters between the rectangle and the ellipsoid surface.
+   * @param {Number} [options.rotation=0.0] The rotation of the rectangle, in radians. A positive rotation is counter-clockwise.
+   * @param {Number} [options.extrudedHeight] The distance in meters between the rectangle's extruded face and the ellipsoid surface.
+   *
+   * @exception {DeveloperError} <code>options.rectangle.north</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
+   * @exception {DeveloperError} <code>options.rectangle.south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
+   * @exception {DeveloperError} <code>options.rectangle.east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+   * @exception {DeveloperError} <code>options.rectangle.west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+   * @exception {DeveloperError} <code>options.rectangle.north</code> must be greater than <code>rectangle.south</code>.
+   *
+   * @see RectangleOutlineGeometry#createGeometry
+   *
+   * @example
+   * const rectangle = new Cesium.RectangleOutlineGeometry({
+   *   ellipsoid : Cesium.Ellipsoid.WGS84,
+   *   rectangle : Cesium.Rectangle.fromDegrees(-80.0, 39.0, -74.0, 42.0),
+   *   height : 10000.0
+   * });
+   * const geometry = Cesium.RectangleOutlineGeometry.createGeometry(rectangle);
+   */
+  function RectangleOutlineGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+
+    const rectangle = options.rectangle;
+    const granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math$1.CesiumMath.RADIANS_PER_DEGREE
+    );
+    const ellipsoid = defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84);
+    const rotation = defaultValue.defaultValue(options.rotation, 0.0);
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(rectangle)) {
+      throw new Check.DeveloperError("rectangle is required.");
+    }
+    Matrix2.Rectangle.validate(rectangle);
+    if (rectangle.north < rectangle.south) {
+      throw new Check.DeveloperError(
+        "options.rectangle.north must be greater than options.rectangle.south"
+      );
+    }
+    //>>includeEnd('debug');
+
+    const height = defaultValue.defaultValue(options.height, 0.0);
+    const extrudedHeight = defaultValue.defaultValue(options.extrudedHeight, height);
+
+    this._rectangle = Matrix2.Rectangle.clone(rectangle);
+    this._granularity = granularity;
+    this._ellipsoid = ellipsoid;
+    this._surfaceHeight = Math.max(height, extrudedHeight);
+    this._rotation = rotation;
+    this._extrudedHeight = Math.min(height, extrudedHeight);
+    this._offsetAttribute = options.offsetAttribute;
+    this._workerName = "createRectangleOutlineGeometry";
+  }
+
+  /**
+   * The number of elements used to pack the object into an array.
+   * @type {Number}
+   */
+  RectangleOutlineGeometry.packedLength =
+    Matrix2.Rectangle.packedLength + Matrix3.Ellipsoid.packedLength + 5;
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {RectangleOutlineGeometry} 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
+   */
+  RectangleOutlineGeometry.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);
+
+    Matrix2.Rectangle.pack(value._rectangle, array, startingIndex);
+    startingIndex += Matrix2.Rectangle.packedLength;
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    array[startingIndex++] = value._granularity;
+    array[startingIndex++] = value._surfaceHeight;
+    array[startingIndex++] = value._rotation;
+    array[startingIndex++] = value._extrudedHeight;
+    array[startingIndex] = defaultValue.defaultValue(value._offsetAttribute, -1);
+
+    return array;
+  };
+
+  const scratchRectangle = new Matrix2.Rectangle();
+  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
+  const scratchOptions = {
+    rectangle: scratchRectangle,
+    ellipsoid: scratchEllipsoid,
+    granularity: undefined,
+    height: undefined,
+    rotation: undefined,
+    extrudedHeight: undefined,
+    offsetAttribute: 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 {RectangleOutlineGeometry} [result] The object into which to store the result.
+   * @returns {RectangleOutlineGeometry} The modified result parameter or a new Quaternion instance if one was not provided.
+   */
+  RectangleOutlineGeometry.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);
+
+    const rectangle = Matrix2.Rectangle.unpack(array, startingIndex, scratchRectangle);
+    startingIndex += Matrix2.Rectangle.packedLength;
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const granularity = array[startingIndex++];
+    const height = array[startingIndex++];
+    const rotation = array[startingIndex++];
+    const extrudedHeight = array[startingIndex++];
+    const offsetAttribute = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.granularity = granularity;
+      scratchOptions.height = height;
+      scratchOptions.rotation = rotation;
+      scratchOptions.extrudedHeight = extrudedHeight;
+      scratchOptions.offsetAttribute =
+        offsetAttribute === -1 ? undefined : offsetAttribute;
+
+      return new RectangleOutlineGeometry(scratchOptions);
+    }
+
+    result._rectangle = Matrix2.Rectangle.clone(rectangle, result._rectangle);
+    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
+    result._surfaceHeight = height;
+    result._rotation = rotation;
+    result._extrudedHeight = extrudedHeight;
+    result._offsetAttribute =
+      offsetAttribute === -1 ? undefined : offsetAttribute;
+
+    return result;
+  };
+
+  const nwScratch = new Matrix3.Cartographic();
+  /**
+   * Computes the geometric representation of an outline of a rectangle, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {RectangleOutlineGeometry} rectangleGeometry A description of the rectangle outline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   *
+   * @exception {DeveloperError} Rotated rectangle is invalid.
+   */
+  RectangleOutlineGeometry.createGeometry = function (rectangleGeometry) {
+    const rectangle = rectangleGeometry._rectangle;
+    const ellipsoid = rectangleGeometry._ellipsoid;
+    const computedOptions = RectangleGeometryLibrary.RectangleGeometryLibrary.computeOptions(
+      rectangle,
+      rectangleGeometry._granularity,
+      rectangleGeometry._rotation,
+      0,
+      rectangleScratch,
+      nwScratch
+    );
+
+    let geometry;
+    let boundingSphere;
+
+    if (
+      Math$1.CesiumMath.equalsEpsilon(
+        rectangle.north,
+        rectangle.south,
+        Math$1.CesiumMath.EPSILON10
+      ) ||
+      Math$1.CesiumMath.equalsEpsilon(
+        rectangle.east,
+        rectangle.west,
+        Math$1.CesiumMath.EPSILON10
+      )
+    ) {
+      return undefined;
+    }
+
+    const surfaceHeight = rectangleGeometry._surfaceHeight;
+    const extrudedHeight = rectangleGeometry._extrudedHeight;
+    const extrude = !Math$1.CesiumMath.equalsEpsilon(
+      surfaceHeight,
+      extrudedHeight,
+      0,
+      Math$1.CesiumMath.EPSILON2
+    );
+    let offsetValue;
+    if (extrude) {
+      geometry = constructExtrudedRectangle(rectangleGeometry, computedOptions);
+      if (defaultValue.defined(rectangleGeometry._offsetAttribute)) {
+        const size = geometry.attributes.position.values.length / 3;
+        let offsetAttribute = new Uint8Array(size);
+        if (rectangleGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.TOP) {
+          offsetAttribute = offsetAttribute.fill(1, 0, size / 2);
+        } else {
+          offsetValue =
+            rectangleGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE
+              ? 0
+              : 1;
+          offsetAttribute = offsetAttribute.fill(offsetValue);
+        }
+
+        geometry.attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
+          componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+          componentsPerAttribute: 1,
+          values: offsetAttribute,
+        });
+      }
+      const topBS = Transforms.BoundingSphere.fromRectangle3D(
+        rectangle,
+        ellipsoid,
+        surfaceHeight,
+        topBoundingSphere
+      );
+      const bottomBS = Transforms.BoundingSphere.fromRectangle3D(
+        rectangle,
+        ellipsoid,
+        extrudedHeight,
+        bottomBoundingSphere
+      );
+      boundingSphere = Transforms.BoundingSphere.union(topBS, bottomBS);
+    } else {
+      geometry = constructRectangle(rectangleGeometry, computedOptions);
+      geometry.attributes.position.values = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+        geometry.attributes.position.values,
+        surfaceHeight,
+        ellipsoid,
+        false
+      );
+
+      if (defaultValue.defined(rectangleGeometry._offsetAttribute)) {
+        const length = geometry.attributes.position.values.length;
+        offsetValue =
+          rectangleGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE
+            ? 0
+            : 1;
+        const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+        geometry.attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
+          componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+          componentsPerAttribute: 1,
+          values: applyOffset,
+        });
+      }
+
+      boundingSphere = Transforms.BoundingSphere.fromRectangle3D(
+        rectangle,
+        ellipsoid,
+        surfaceHeight
+      );
+    }
+
+    return new GeometryAttribute.Geometry({
+      attributes: geometry.attributes,
+      indices: geometry.indices,
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      boundingSphere: boundingSphere,
+      offsetAttribute: rectangleGeometry._offsetAttribute,
+    });
+  };
+
+  function createRectangleOutlineGeometry(rectangleGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      rectangleGeometry = RectangleOutlineGeometry.unpack(
+        rectangleGeometry,
+        offset
+      );
+    }
+    rectangleGeometry._ellipsoid = Matrix3.Ellipsoid.clone(rectangleGeometry._ellipsoid);
+    rectangleGeometry._rectangle = Matrix2.Rectangle.clone(rectangleGeometry._rectangle);
+    return RectangleOutlineGeometry.createGeometry(rectangleGeometry);
+  }
+
+  return createRectangleOutlineGeometry;
+
+}));