1 | "use strict";
|
2 |
|
3 | var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
4 |
|
5 | Object.defineProperty(exports, "__esModule", {
|
6 | value: true
|
7 | });
|
8 | exports.extent = extent;
|
9 | exports.tranfrormCoord = tranfrormCoord;
|
10 | exports.lngLatToMeters = lngLatToMeters;
|
11 | exports.metersToLngLat = metersToLngLat;
|
12 | exports.longitude = longitude;
|
13 | exports.latitude = latitude;
|
14 | exports.validateLngLat = validateLngLat;
|
15 | exports.aProjectFlat = aProjectFlat;
|
16 | exports.unProjectFlat = unProjectFlat;
|
17 | exports.lnglatDistance = lnglatDistance;
|
18 | exports.project = project;
|
19 | exports.padBounds = padBounds;
|
20 | exports.boundsContains = boundsContains;
|
21 | exports.bBoxToBounds = bBoxToBounds;
|
22 |
|
23 | var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
|
24 |
|
25 | var _helpers = require("@turf/helpers");
|
26 |
|
27 | var originShift = 2 * Math.PI * 6378137 / 2.0;
|
28 |
|
29 | function extent(data) {
|
30 | var dataExtent = [Infinity, Infinity, -Infinity, -Infinity];
|
31 | data.forEach(function (item) {
|
32 | var coordinates = item.coordinates;
|
33 | caculExtent(dataExtent, coordinates);
|
34 | });
|
35 | return dataExtent;
|
36 | }
|
37 |
|
38 | function caculExtent(dataExtent, coords) {
|
39 | if (Array.isArray(coords[0])) {
|
40 | coords.forEach(function (coord) {
|
41 | caculExtent(dataExtent, coord);
|
42 | });
|
43 | } else {
|
44 | if (dataExtent[0] > coords[0]) {
|
45 | dataExtent[0] = coords[0];
|
46 | }
|
47 |
|
48 | if (dataExtent[1] > coords[1]) {
|
49 | dataExtent[1] = coords[1];
|
50 | }
|
51 |
|
52 | if (dataExtent[2] < coords[0]) {
|
53 | dataExtent[2] = coords[0];
|
54 | }
|
55 |
|
56 | if (dataExtent[3] < coords[1]) {
|
57 | dataExtent[3] = coords[1];
|
58 | }
|
59 | }
|
60 |
|
61 | return dataExtent;
|
62 | }
|
63 |
|
64 | function tranfrormCoord(data, cb) {
|
65 | return transform(data, cb);
|
66 | }
|
67 |
|
68 | function transform(item, cb) {
|
69 | if (Array.isArray(item[0])) {
|
70 | return item.map(function (coord) {
|
71 | return transform(coord, cb);
|
72 | });
|
73 | }
|
74 |
|
75 | return cb(item);
|
76 | }
|
77 |
|
78 | function lngLatToMeters(lnglat) {
|
79 | var validate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
80 | var accuracy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
|
81 | enable: true,
|
82 | decimal: 1
|
83 | };
|
84 | lnglat = validateLngLat(lnglat, validate);
|
85 | var lng = lnglat[0];
|
86 | var lat = lnglat[1];
|
87 | var x = lng * originShift / 180.0;
|
88 | var y = Math.log(Math.tan((90 + lat) * Math.PI / 360.0)) / (Math.PI / 180.0);
|
89 | y = y * originShift / 180.0;
|
90 |
|
91 | if (accuracy.enable) {
|
92 | x = Number(x.toFixed(accuracy.decimal));
|
93 | y = Number(y.toFixed(accuracy.decimal));
|
94 | }
|
95 |
|
96 | return lnglat.length === 3 ? [x, y, lnglat[2]] : [x, y];
|
97 | }
|
98 |
|
99 | function metersToLngLat(meters) {
|
100 | var decimal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;
|
101 | var x = meters[0];
|
102 | var y = meters[1];
|
103 | var lng = x / originShift * 180.0;
|
104 | var lat = y / originShift * 180.0;
|
105 | lat = 180 / Math.PI * (2 * Math.atan(Math.exp(lat * Math.PI / 180.0)) - Math.PI / 2.0);
|
106 |
|
107 | if (decimal !== undefined && decimal !== null) {
|
108 | lng = Number(lng.toFixed(decimal));
|
109 | lat = Number(lat.toFixed(decimal));
|
110 | }
|
111 |
|
112 | return meters.length === 3 ? [lng, lat, meters[2]] : [lng, lat];
|
113 | }
|
114 |
|
115 | function longitude(lng) {
|
116 | if (lng === undefined || lng === null) {
|
117 | throw new Error('lng is required');
|
118 | }
|
119 |
|
120 | if (lng > 180 || lng < -180) {
|
121 | lng = lng % 360;
|
122 |
|
123 | if (lng > 180) {
|
124 | lng = -360 + lng;
|
125 | }
|
126 |
|
127 | if (lng < -180) {
|
128 | lng = 360 + lng;
|
129 | }
|
130 |
|
131 | if (lng === 0) {
|
132 | lng = 0;
|
133 | }
|
134 | }
|
135 |
|
136 | return lng;
|
137 | }
|
138 |
|
139 | function latitude(lat) {
|
140 | if (lat === undefined || lat === null) {
|
141 | throw new Error('lat is required');
|
142 | }
|
143 |
|
144 | if (lat > 90 || lat < -90) {
|
145 | lat = lat % 180;
|
146 |
|
147 | if (lat > 90) {
|
148 | lat = -180 + lat;
|
149 | }
|
150 |
|
151 | if (lat < -90) {
|
152 | lat = 180 + lat;
|
153 | }
|
154 |
|
155 | if (lat === 0) {
|
156 | lat = 0;
|
157 | }
|
158 | }
|
159 |
|
160 | return lat;
|
161 | }
|
162 |
|
163 | function validateLngLat(lnglat, validate) {
|
164 | if (validate === false) {
|
165 | return lnglat;
|
166 | }
|
167 |
|
168 | var lng = longitude(lnglat[0]);
|
169 | var lat = latitude(lnglat[1]);
|
170 |
|
171 | if (lat > 85) {
|
172 | lat = 85;
|
173 | }
|
174 |
|
175 | if (lat < -85) {
|
176 | lat = -85;
|
177 | }
|
178 |
|
179 | return lnglat.length === 3 ? [lng, lat, lnglat[2]] : [lng, lat];
|
180 | }
|
181 |
|
182 | function aProjectFlat(lnglat) {
|
183 | var maxs = 85.0511287798;
|
184 | var lat = Math.max(Math.min(maxs, lnglat[1]), -maxs);
|
185 | var scale = 256 << 20;
|
186 | var d = Math.PI / 180;
|
187 | var x = lnglat[0] * d;
|
188 | var y = lat * d;
|
189 | y = Math.log(Math.tan(Math.PI / 4 + y / 2));
|
190 | var a = 0.5 / Math.PI;
|
191 | var b = 0.5;
|
192 | var c = -0.5 / Math.PI;
|
193 | d = 0.5;
|
194 | x = scale * (a * x + b);
|
195 | y = scale * (c * y + d);
|
196 | return [Math.floor(x), Math.floor(y)];
|
197 | }
|
198 |
|
199 | function unProjectFlat(px) {
|
200 | var a = 0.5 / Math.PI;
|
201 | var b = 0.5;
|
202 | var c = -0.5 / Math.PI;
|
203 | var d = 0.5;
|
204 | var scale = 256 << 20;
|
205 |
|
206 | var _px = (0, _slicedToArray2.default)(px, 2),
|
207 | x = _px[0],
|
208 | y = _px[1];
|
209 |
|
210 | x = (x / scale - b) / a;
|
211 | y = (y / scale - d) / c;
|
212 | y = (Math.atan(Math.pow(Math.E, y)) - Math.PI / 4) * 2;
|
213 | d = Math.PI / 180;
|
214 | var lat = y / d;
|
215 | var lng = x / d;
|
216 | return [lng, lat];
|
217 | }
|
218 |
|
219 | function lnglatDistance(coordinates1, coordinates2, units) {
|
220 | var dLat = (0, _helpers.degreesToRadians)(coordinates2[1] - coordinates1[1]);
|
221 | var dLon = (0, _helpers.degreesToRadians)(coordinates2[0] - coordinates1[0]);
|
222 | var lat1 = (0, _helpers.degreesToRadians)(coordinates1[1]);
|
223 | var lat2 = (0, _helpers.degreesToRadians)(coordinates2[1]);
|
224 | var a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
|
225 | return (0, _helpers.radiansToLength)(2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)), units = 'meters');
|
226 | }
|
227 |
|
228 | function project(lnglat) {
|
229 | var d = Math.PI / 180;
|
230 | var max = 85.0511287798;
|
231 | var earthRadius = 6378137;
|
232 | var lat = Math.max(Math.min(max, lnglat[1]), -max);
|
233 | var sin = Math.sin(lat * d);
|
234 | var x = earthRadius * lnglat[0] * d;
|
235 | var y = earthRadius * Math.log((1 + sin) / (1 - sin)) / 2;
|
236 | return [x, y];
|
237 | }
|
238 |
|
239 | function padBounds(b, bufferRatio) {
|
240 | var heightBuffer = Math.abs(b[1][1] - b[0][1]) * bufferRatio;
|
241 | var widthBuffer = Math.abs(b[1][0] - b[0][0]) * bufferRatio;
|
242 | return [[b[0][0] - widthBuffer, b[0][1] - heightBuffer], [b[1][0] + widthBuffer, b[1][1] + heightBuffer]];
|
243 | }
|
244 |
|
245 | function boundsContains(b1, b2) {
|
246 | return b1[0][0] <= b2[0][0] && b1[0][1] <= b2[0][1] && b1[1][0] >= b2[1][0] && b1[1][1] >= b2[1][1];
|
247 | }
|
248 |
|
249 | function bBoxToBounds(b1) {
|
250 | return [[b1[0], b1[1]], [b1[2], b1[3]]];
|
251 | }
|
252 |
|
\ | No newline at end of file |