Agriculture-front-end/dist/CesiumUnminified/Workers/createPolygonOutlineGeometry.js

542 lines
19 KiB
JavaScript

/**
* @license
* Cesium - https://github.com/CesiumGS/cesium
* Version 1.117
*
* 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.
*/
import {
PolygonGeometryLibrary_default
} from "./chunk-LVJCR7DH.js";
import {
ArcType_default
} from "./chunk-YLZTCEBJ.js";
import {
GeometryInstance_default
} from "./chunk-AOIKO5Y7.js";
import {
GeometryPipeline_default
} from "./chunk-PK7TEP3J.js";
import "./chunk-PS6AEMBR.js";
import "./chunk-AOFMPKUB.js";
import {
GeometryOffsetAttribute_default
} from "./chunk-S4XDCPKD.js";
import {
EllipsoidTangentPlane_default
} from "./chunk-CE6GTZ4I.js";
import "./chunk-6HCAQOVK.js";
import {
PolygonPipeline_default,
WindingOrder_default
} from "./chunk-RR7EOKGZ.js";
import "./chunk-V7JB576Q.js";
import "./chunk-CYAJYEKW.js";
import "./chunk-G7CJQKKD.js";
import "./chunk-FOZQIHZK.js";
import {
IndexDatatype_default
} from "./chunk-WWP3I7R5.js";
import {
GeometryAttributes_default
} from "./chunk-RL73GOEF.js";
import {
GeometryAttribute_default,
Geometry_default,
PrimitiveType_default
} from "./chunk-34DGOKCO.js";
import {
BoundingSphere_default
} from "./chunk-NI2R52QD.js";
import "./chunk-I5TDPPC4.js";
import {
ComponentDatatype_default
} from "./chunk-TMMOULW3.js";
import {
Cartesian3_default,
Ellipsoid_default
} from "./chunk-C5CE4OG6.js";
import {
Math_default
} from "./chunk-4PHPQRSH.js";
import "./chunk-PEABJLCK.js";
import "./chunk-WFICTTOE.js";
import {
defaultValue_default
} from "./chunk-UCPPWV64.js";
import {
Check_default,
DeveloperError_default
} from "./chunk-U4IMCOF5.js";
import {
defined_default
} from "./chunk-BDUJXBVF.js";
// packages/engine/Source/Core/PolygonOutlineGeometry.js
var createGeometryFromPositionsPositions = [];
var createGeometryFromPositionsSubdivided = [];
function createGeometryFromPositions(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
const positions2D = tangentPlane.projectPointsOntoPlane(
positions,
createGeometryFromPositionsPositions
);
const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
positions2D
);
if (originalWindingOrder === WindingOrder_default.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_default.GEODESIC) {
for (i = 0; i < length; i++) {
numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
positions[i],
positions[(i + 1) % length],
minDistance
);
}
} else if (arcType === ArcType_default.RHUMB) {
for (i = 0; i < length; i++) {
numVertices += PolygonGeometryLibrary_default.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_default.GEODESIC) {
tempPositions = PolygonGeometryLibrary_default.subdivideLine(
positions[i],
positions[(i + 1) % length],
minDistance,
createGeometryFromPositionsSubdivided
);
} else if (arcType === ArcType_default.RHUMB) {
tempPositions = PolygonGeometryLibrary_default.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_default.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_default({
geometry: new Geometry_default({
attributes: new GeometryAttributes_default({
position: new GeometryAttribute_default({
componentDatatype: ComponentDatatype_default.DOUBLE,
componentsPerAttribute: 3,
values: subdividedPositions
})
}),
indices,
primitiveType: PrimitiveType_default.LINES
})
});
}
function createGeometryFromPositionsExtruded(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
const positions2D = tangentPlane.projectPointsOntoPlane(
positions,
createGeometryFromPositionsPositions
);
const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(
positions2D
);
if (originalWindingOrder === WindingOrder_default.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_default.GEODESIC) {
for (i = 0; i < length; i++) {
numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
positions[i],
positions[(i + 1) % length],
minDistance
);
}
} else if (arcType === ArcType_default.RHUMB) {
for (i = 0; i < length; i++) {
numVertices += PolygonGeometryLibrary_default.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_default.GEODESIC) {
tempPositions = PolygonGeometryLibrary_default.subdivideLine(
positions[i],
positions[(i + 1) % length],
minDistance,
createGeometryFromPositionsSubdivided
);
} else if (arcType === ArcType_default.RHUMB) {
tempPositions = PolygonGeometryLibrary_default.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_default.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_default({
geometry: new Geometry_default({
attributes: new GeometryAttributes_default({
position: new GeometryAttribute_default({
componentDatatype: ComponentDatatype_default.DOUBLE,
componentsPerAttribute: 3,
values: subdividedPositions
})
}),
indices,
primitiveType: PrimitiveType_default.LINES
})
});
}
function PolygonOutlineGeometry(options) {
Check_default.typeOf.object("options", options);
Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
if (options.perPositionHeight && defined_default(options.height)) {
throw new DeveloperError_default(
"Cannot use both options.perPositionHeight and options.height"
);
}
if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
throw new DeveloperError_default(
"Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
);
}
const polygonHierarchy = options.polygonHierarchy;
const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
const granularity = defaultValue_default(
options.granularity,
Math_default.RADIANS_PER_DEGREE
);
const perPositionHeight = defaultValue_default(options.perPositionHeight, false);
const perPositionHeightExtrude = perPositionHeight && defined_default(options.extrudedHeight);
const arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
let height = defaultValue_default(options.height, 0);
let extrudedHeight = defaultValue_default(options.extrudedHeight, height);
if (!perPositionHeightExtrude) {
const h = Math.max(height, extrudedHeight);
extrudedHeight = Math.min(height, extrudedHeight);
height = h;
}
this._ellipsoid = Ellipsoid_default.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";
this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(
polygonHierarchy,
Cartesian3_default
) + Ellipsoid_default.packedLength + 8;
}
PolygonOutlineGeometry.pack = function(value, array, startingIndex) {
Check_default.typeOf.object("value", value);
Check_default.defined("array", array);
startingIndex = defaultValue_default(startingIndex, 0);
startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
value._polygonHierarchy,
array,
startingIndex,
Cartesian3_default
);
Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
startingIndex += Ellipsoid_default.packedLength;
array[startingIndex++] = value._height;
array[startingIndex++] = value._extrudedHeight;
array[startingIndex++] = value._granularity;
array[startingIndex++] = value._perPositionHeightExtrude ? 1 : 0;
array[startingIndex++] = value._perPositionHeight ? 1 : 0;
array[startingIndex++] = value._arcType;
array[startingIndex++] = defaultValue_default(value._offsetAttribute, -1);
array[startingIndex] = value.packedLength;
return array;
};
var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
var dummyOptions = {
polygonHierarchy: {}
};
PolygonOutlineGeometry.unpack = function(array, startingIndex, result) {
Check_default.defined("array", array);
startingIndex = defaultValue_default(startingIndex, 0);
const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
array,
startingIndex,
Cartesian3_default
);
startingIndex = polygonHierarchy.startingIndex;
delete polygonHierarchy.startingIndex;
const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
startingIndex += Ellipsoid_default.packedLength;
const height = array[startingIndex++];
const extrudedHeight = array[startingIndex++];
const granularity = array[startingIndex++];
const perPositionHeightExtrude = array[startingIndex++] === 1;
const perPositionHeight = array[startingIndex++] === 1;
const arcType = array[startingIndex++];
const offsetAttribute = array[startingIndex++];
const packedLength = array[startingIndex];
if (!defined_default(result)) {
result = new PolygonOutlineGeometry(dummyOptions);
}
result._polygonHierarchy = polygonHierarchy;
result._ellipsoid = Ellipsoid_default.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 ? void 0 : offsetAttribute;
result.packedLength = packedLength;
return result;
};
PolygonOutlineGeometry.fromPositions = function(options) {
options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
Check_default.defined("options.positions", options.positions);
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);
};
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_default.polygonOutlinesFromHierarchy(
polygonHierarchy,
!perPositionHeight,
ellipsoid
);
if (polygons.length === 0) {
return void 0;
}
let geometryInstance;
const geometries = [];
const minDistance = Math_default.chordLength(
granularity,
ellipsoid.maximumRadius
);
const height = polygonGeometry._height;
const extrudedHeight = polygonGeometry._extrudedHeight;
const extrude = polygonGeometry._perPositionHeightExtrude || !Math_default.equalsEpsilon(height, extrudedHeight, 0, Math_default.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_default.scaleToGeodeticHeightExtruded(
geometryInstance.geometry,
height,
extrudedHeight,
ellipsoid,
perPositionHeight
);
if (defined_default(polygonGeometry._offsetAttribute)) {
const size = geometryInstance.geometry.attributes.position.values.length / 3;
let offsetAttribute = new Uint8Array(size);
if (polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.TOP) {
offsetAttribute = offsetAttribute.fill(1, 0, size / 2);
} else {
offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
offsetAttribute = offsetAttribute.fill(offsetValue);
}
geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
{
componentDatatype: ComponentDatatype_default.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_default.scaleToGeodeticHeight(
geometryInstance.geometry.attributes.position.values,
height,
ellipsoid,
!perPositionHeight
);
if (defined_default(polygonGeometry._offsetAttribute)) {
const length = geometryInstance.geometry.attributes.position.values.length;
offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default(
{
componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
componentsPerAttribute: 1,
values: applyOffset
}
);
}
geometries.push(geometryInstance);
}
}
const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
const boundingSphere = BoundingSphere_default.fromVertices(
geometry.attributes.position.values
);
return new Geometry_default({
attributes: geometry.attributes,
indices: geometry.indices,
primitiveType: geometry.primitiveType,
boundingSphere,
offsetAttribute: polygonGeometry._offsetAttribute
});
};
var PolygonOutlineGeometry_default = PolygonOutlineGeometry;
// packages/engine/Source/Workers/createPolygonOutlineGeometry.js
function createPolygonOutlineGeometry(polygonGeometry, offset) {
if (defined_default(offset)) {
polygonGeometry = PolygonOutlineGeometry_default.unpack(polygonGeometry, offset);
}
polygonGeometry._ellipsoid = Ellipsoid_default.clone(polygonGeometry._ellipsoid);
return PolygonOutlineGeometry_default.createGeometry(polygonGeometry);
}
var createPolygonOutlineGeometry_default = createPolygonOutlineGeometry;
export {
createPolygonOutlineGeometry_default as default
};