洪水淹没

guoshilong

2023-02-27 4d8c6dd77427e8e581fda17b6b65ba86bfb7a815

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/**
 * Cesium - https://github.com/CesiumGS/cesium
 *
 * Copyright 2011-2020 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/master/LICENSE.md for full licensing details.
 */
 
define(['./when-c2e8ef35', './Check-c4f3a3fc', './Math-a06249ed', './Cartesian2-a4e73c05', './AttributeCompression-6b12d004', './createTaskProcessorWorker'], function (when, Check, _Math, Cartesian2, AttributeCompression, createTaskProcessorWorker) { 'use strict';
 
    var maxShort = 32767;
 
        var scratchBVCartographic = new Cartesian2.Cartographic();
        var scratchEncodedPosition = new Cartesian2.Cartesian3();
 
        var scratchRectangle = new Cartesian2.Rectangle();
        var scratchEllipsoid = new Cartesian2.Ellipsoid();
        var scratchMinMaxHeights = {
            min : undefined,
            max : undefined
        };
 
        function unpackBuffer(packedBuffer) {
            packedBuffer = new Float64Array(packedBuffer);
 
            var offset = 0;
            scratchMinMaxHeights.min = packedBuffer[offset++];
            scratchMinMaxHeights.max = packedBuffer[offset++];
 
            Cartesian2.Rectangle.unpack(packedBuffer, offset, scratchRectangle);
            offset += Cartesian2.Rectangle.packedLength;
 
            Cartesian2.Ellipsoid.unpack(packedBuffer, offset, scratchEllipsoid);
        }
 
        function createVectorTilePoints(parameters, transferableObjects) {
            var positions = new Uint16Array(parameters.positions);
 
            unpackBuffer(parameters.packedBuffer);
            var rectangle = scratchRectangle;
            var ellipsoid = scratchEllipsoid;
            var minimumHeight = scratchMinMaxHeights.min;
            var maximumHeight = scratchMinMaxHeights.max;
 
            var positionsLength = positions.length / 3;
            var uBuffer = positions.subarray(0, positionsLength);
            var vBuffer = positions.subarray(positionsLength, 2 * positionsLength);
            var heightBuffer = positions.subarray(2 * positionsLength, 3 * positionsLength);
            AttributeCompression.AttributeCompression.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
 
            var decoded = new Float64Array(positions.length);
            for (var i = 0; i < positionsLength; ++i) {
                var u = uBuffer[i];
                var v = vBuffer[i];
                var h = heightBuffer[i];
 
                var lon = _Math.CesiumMath.lerp(rectangle.west, rectangle.east, u / maxShort);
                var lat = _Math.CesiumMath.lerp(rectangle.south, rectangle.north, v / maxShort);
                var alt = _Math.CesiumMath.lerp(minimumHeight, maximumHeight, h / maxShort);
 
                var cartographic = Cartesian2.Cartographic.fromRadians(lon, lat, alt, scratchBVCartographic);
                var decodedPosition = ellipsoid.cartographicToCartesian(cartographic, scratchEncodedPosition);
                Cartesian2.Cartesian3.pack(decodedPosition, decoded, i * 3);
            }
 
            transferableObjects.push(decoded.buffer);
 
            return {
                positions : decoded.buffer
            };
        }
    var createVectorTilePoints$1 = createTaskProcessorWorker(createVectorTilePoints);
 
    return createVectorTilePoints$1;
 
});
//# sourceMappingURL=createVectorTilePoints.js.map