webdggrid 1.0.4 → 1.0.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/webdggrid.js +1 -1
- package/dist/webdggrid.js.map +1 -1
- package/dist/webdggrid.umd.js +1 -1
- package/dist/webdggrid.umd.js.map +1 -1
- package/lib-esm/libdggrid.wasm.js +1 -1
- package/lib-esm/webdggrid.js +414 -71
- package/lib-esm/webdggrid.js.map +1 -1
- package/lib-wasm/Makefile +3205 -0
- package/lib-wasm/libdggrid.js +6 -6
- package/lib-wasm/libdggrid.wasm +0 -0
- package/package.json +8 -5
- package/readme.md +72 -2
- package/src-ts/webdggrid.ts +541 -88
- package/types/webdggrid.d.ts +431 -45
- package/types/webdggrid.d.ts.map +1 -1
- package/lib-wasm/libdggrid.html +0 -1
package/lib-esm/webdggrid.js
CHANGED
|
@@ -1,64 +1,159 @@
|
|
|
1
1
|
// @ts-ignore
|
|
2
2
|
import { loadWasm, unloadWasm } from './libdggrid.wasm.js';
|
|
3
3
|
/**
|
|
4
|
-
*
|
|
4
|
+
* The shape of each cell in the Discrete Global Grid System.
|
|
5
|
+
*
|
|
6
|
+
* DGGRID supports four cell topologies. The most common choice for geospatial
|
|
7
|
+
* analysis is `HEXAGON` because hexagonal cells have equal adjacency (every
|
|
8
|
+
* neighbour shares an edge), uniform area, and minimal boundary-to-area ratio.
|
|
5
9
|
*
|
|
6
10
|
* @export
|
|
7
|
-
* @enum {
|
|
11
|
+
* @enum {string}
|
|
12
|
+
*
|
|
13
|
+
* @example
|
|
14
|
+
* ```ts
|
|
15
|
+
* import { Topology } from 'webdggrid';
|
|
16
|
+
*
|
|
17
|
+
* dggs.setDggs({ topology: Topology.HEXAGON, ... }, 4);
|
|
18
|
+
* ```
|
|
8
19
|
*/
|
|
9
20
|
export var Topology;
|
|
10
21
|
(function (Topology) {
|
|
22
|
+
/** Six-sided cells — the default and most widely used topology. */
|
|
11
23
|
Topology["HEXAGON"] = "HEXAGON";
|
|
24
|
+
/** Three-sided cells. */
|
|
12
25
|
Topology["TRIANGLE"] = "TRIANGLE";
|
|
26
|
+
/** Four-sided square cells. */
|
|
13
27
|
Topology["SQUARE"] = "SQUARE";
|
|
28
|
+
/** Four-sided diamond cells (squares rotated 45°). */
|
|
14
29
|
Topology["DIAMOND"] = "DIAMOND";
|
|
15
30
|
})(Topology || (Topology = {}));
|
|
16
31
|
/**
|
|
17
|
-
*
|
|
32
|
+
* The map projection used to place the polyhedron faces onto the sphere.
|
|
33
|
+
*
|
|
34
|
+
* - **ISEA** (Icosahedral Snyder Equal Area) — preserves cell area at the cost
|
|
35
|
+
* of shape distortion. Recommended for most analytical use-cases.
|
|
36
|
+
* - **FULLER** (Fuller/Dymaxion) — minimises shape distortion but does not
|
|
37
|
+
* preserve equal area.
|
|
18
38
|
*
|
|
19
39
|
* @export
|
|
20
|
-
* @enum {
|
|
40
|
+
* @enum {string}
|
|
41
|
+
*
|
|
42
|
+
* @example
|
|
43
|
+
* ```ts
|
|
44
|
+
* import { Projection } from 'webdggrid';
|
|
45
|
+
*
|
|
46
|
+
* dggs.setDggs({ projection: Projection.ISEA, ... }, 4);
|
|
47
|
+
* ```
|
|
21
48
|
*/
|
|
22
49
|
export var Projection;
|
|
23
50
|
(function (Projection) {
|
|
51
|
+
/** Icosahedral Snyder Equal Area projection — equal-area cells. */
|
|
24
52
|
Projection["ISEA"] = "ISEA";
|
|
53
|
+
/** Fuller/Dymaxion projection — shape-preserving cells. */
|
|
25
54
|
Projection["FULLER"] = "FULLER";
|
|
26
55
|
})(Projection || (Projection = {}));
|
|
56
|
+
/**
|
|
57
|
+
* Rewraps a polygon ring that crosses the antimeridian so that all longitudes
|
|
58
|
+
* are in a contiguous range (some may exceed 180°). This is the format
|
|
59
|
+
* expected by MapLibre GL / Mapbox GL globe projection for antimeridian cells.
|
|
60
|
+
* For renderers that require standard [-180, 180] coordinates, use the raw
|
|
61
|
+
* output from {@link Webdggrid.sequenceNumToGrid} directly.
|
|
62
|
+
*/
|
|
63
|
+
export function unwrapAntimeridianRing(ring) {
|
|
64
|
+
const lons = ring.map((p) => p[0]);
|
|
65
|
+
const minLon = Math.min(...lons);
|
|
66
|
+
const maxLon = Math.max(...lons);
|
|
67
|
+
if (maxLon - minLon <= 180)
|
|
68
|
+
return ring;
|
|
69
|
+
return ring.map(([lon, lat]) => [lon < 0 ? lon + 360 : lon, lat]);
|
|
70
|
+
}
|
|
27
71
|
const DEFAULT_RESOLUTION = 1;
|
|
28
72
|
const DEFAULT_DGGS = {
|
|
29
73
|
poleCoordinates: { lat: 0, lng: 0 },
|
|
30
74
|
azimuth: 0,
|
|
31
75
|
topology: Topology.HEXAGON,
|
|
32
76
|
projection: Projection.ISEA,
|
|
33
|
-
aperture:
|
|
77
|
+
aperture: 4
|
|
34
78
|
};
|
|
79
|
+
/**
|
|
80
|
+
* Main entry point for the WebDggrid library.
|
|
81
|
+
*
|
|
82
|
+
* `Webdggrid` wraps the DGGRID C++ library compiled to WebAssembly and exposes
|
|
83
|
+
* methods for:
|
|
84
|
+
* - **Grid configuration** — choose topology, projection, aperture, and
|
|
85
|
+
* resolution via {@link setDggs} / {@link setResolution}.
|
|
86
|
+
* - **Coordinate conversion** — convert between geographic coordinates and
|
|
87
|
+
* DGGS cell IDs (sequence numbers) with {@link geoToSequenceNum} and
|
|
88
|
+
* {@link sequenceNumToGeo}.
|
|
89
|
+
* - **Grid geometry** — retrieve the polygon boundary of any cell with
|
|
90
|
+
* {@link sequenceNumToGrid} or export a ready-to-render GeoJSON
|
|
91
|
+
* `FeatureCollection` with {@link sequenceNumToGridFeatureCollection}.
|
|
92
|
+
* - **Grid statistics** — query cell counts, areas, and spacings with
|
|
93
|
+
* {@link nCells}, {@link cellAreaKM}, and {@link cellDistKM}.
|
|
94
|
+
*
|
|
95
|
+
* ## Quick start
|
|
96
|
+
*
|
|
97
|
+
* ```ts
|
|
98
|
+
* import { Webdggrid } from 'webdggrid';
|
|
99
|
+
*
|
|
100
|
+
* const dggs = await Webdggrid.load();
|
|
101
|
+
*
|
|
102
|
+
* // Convert a geographic point to its DGGS cell ID at resolution 5
|
|
103
|
+
* const [cellId] = dggs.geoToSequenceNum([[-73.9857, 40.7484]], 5);
|
|
104
|
+
*
|
|
105
|
+
* // Get the polygon boundary of that cell as GeoJSON
|
|
106
|
+
* const geojson = dggs.sequenceNumToGridFeatureCollection([cellId], 5);
|
|
107
|
+
* ```
|
|
108
|
+
*
|
|
109
|
+
* ## Lifecycle
|
|
110
|
+
*
|
|
111
|
+
* The WASM module is a singleton. Call {@link Webdggrid.load} once and reuse
|
|
112
|
+
* the returned instance throughout your application. Call
|
|
113
|
+
* {@link Webdggrid.unload} when you are completely done to free memory.
|
|
114
|
+
*/
|
|
35
115
|
export class Webdggrid {
|
|
36
116
|
constructor(_module) {
|
|
37
117
|
this._module = _module;
|
|
118
|
+
/**
|
|
119
|
+
* The active DGGS configuration used by all conversion and statistics
|
|
120
|
+
* methods. Change it at any time via {@link setDggs}.
|
|
121
|
+
*
|
|
122
|
+
* Defaults to ISEA4H (ISEA projection, aperture 4, hexagon topology,
|
|
123
|
+
* pole at 0° N 0° E, azimuth 0°).
|
|
124
|
+
*/
|
|
38
125
|
this.dggs = DEFAULT_DGGS;
|
|
126
|
+
/**
|
|
127
|
+
* The active grid resolution. Higher values produce finer, smaller cells.
|
|
128
|
+
* The valid range depends on the aperture — for aperture 4 the practical
|
|
129
|
+
* limit is around resolution 15 before cell counts become unwieldy.
|
|
130
|
+
*
|
|
131
|
+
* Change via {@link setResolution} or pass an explicit `resolution`
|
|
132
|
+
* argument to any conversion method.
|
|
133
|
+
*
|
|
134
|
+
* Defaults to `1`.
|
|
135
|
+
*/
|
|
39
136
|
this.resolution = DEFAULT_RESOLUTION;
|
|
40
|
-
this._wVectorToArray = (vector) => {
|
|
41
|
-
if (vector.size() === 0) {
|
|
42
|
-
return [];
|
|
43
|
-
}
|
|
44
|
-
const objectType = vector.$$.ptrType.name;
|
|
45
|
-
switch (objectType) {
|
|
46
|
-
case 'BigIntegerVector*':
|
|
47
|
-
return this._vectorToArray(vector);
|
|
48
|
-
default:
|
|
49
|
-
return [];
|
|
50
|
-
}
|
|
51
|
-
};
|
|
52
137
|
this._module = _module;
|
|
53
138
|
}
|
|
54
139
|
/**
|
|
55
|
-
* Compiles and instantiates the
|
|
140
|
+
* Compiles and instantiates the DGGRID WebAssembly module.
|
|
141
|
+
*
|
|
142
|
+
* This is the only way to construct a `Webdggrid` instance. The method is
|
|
143
|
+
* asynchronous because WebAssembly compilation is prohibited on the main
|
|
144
|
+
* thread for buffers larger than 4 KB.
|
|
145
|
+
*
|
|
146
|
+
* ```ts
|
|
147
|
+
* const dggs = await Webdggrid.load();
|
|
148
|
+
* ```
|
|
56
149
|
*
|
|
57
150
|
* ::: info
|
|
58
|
-
* In general WebAssembly compilation is disallowed on the main thread if
|
|
151
|
+
* In general WebAssembly compilation is disallowed on the main thread if
|
|
152
|
+
* the buffer size is larger than 4 KB, hence forcing `load` to be
|
|
153
|
+
* asynchronous.
|
|
59
154
|
* :::
|
|
60
155
|
*
|
|
61
|
-
* @returns A promise to
|
|
156
|
+
* @returns A promise that resolves to a fully initialised `Webdggrid` instance.
|
|
62
157
|
*/
|
|
63
158
|
static load() {
|
|
64
159
|
return loadWasm().then((module) => {
|
|
@@ -66,99 +161,232 @@ export class Webdggrid {
|
|
|
66
161
|
}).catch(console.log);
|
|
67
162
|
}
|
|
68
163
|
/**
|
|
69
|
-
*
|
|
164
|
+
* Releases the compiled WASM instance and frees its memory.
|
|
165
|
+
*
|
|
166
|
+
* Call this when your application no longer needs the library. After
|
|
167
|
+
* calling `unload`, any existing `Webdggrid` instances become unusable —
|
|
168
|
+
* you must call {@link load} again to create a new one.
|
|
70
169
|
*/
|
|
71
170
|
static unload() {
|
|
72
171
|
unloadWasm();
|
|
73
172
|
}
|
|
74
173
|
/**
|
|
75
|
-
*
|
|
174
|
+
* Returns the version string of the underlying DGGRID C++ library.
|
|
175
|
+
*
|
|
176
|
+
* ```ts
|
|
177
|
+
* console.log(dggs.version()); // e.g. "8.3b"
|
|
178
|
+
* ```
|
|
179
|
+
*
|
|
180
|
+
* @returns The DGGRID C++ library version string.
|
|
76
181
|
*/
|
|
77
182
|
version() {
|
|
78
183
|
return this._module.Webdggrid.prototype.version();
|
|
79
184
|
}
|
|
80
185
|
/**
|
|
81
|
-
*
|
|
82
|
-
*
|
|
186
|
+
* Sets both the DGGS configuration and the resolution in one call.
|
|
187
|
+
*
|
|
188
|
+
* All subsequent conversion and statistics methods will use this
|
|
189
|
+
* configuration unless they receive an explicit `resolution` argument.
|
|
190
|
+
*
|
|
191
|
+
* ```ts
|
|
192
|
+
* dggs.setDggs({
|
|
193
|
+
* poleCoordinates: { lat: 0, lng: 0 },
|
|
194
|
+
* azimuth: 0,
|
|
195
|
+
* aperture: 4,
|
|
196
|
+
* topology: Topology.HEXAGON,
|
|
197
|
+
* projection: Projection.ISEA,
|
|
198
|
+
* }, 5);
|
|
199
|
+
* ```
|
|
200
|
+
*
|
|
201
|
+
* @param dggs - The new DGGS configuration. Defaults to ISEA4H at pole (0,0).
|
|
202
|
+
* @param resolution - The new resolution level. Defaults to `1`.
|
|
83
203
|
*/
|
|
84
204
|
setDggs(dggs = DEFAULT_DGGS, resolution = DEFAULT_RESOLUTION) {
|
|
85
205
|
this.dggs = dggs;
|
|
86
206
|
this.resolution = resolution;
|
|
87
207
|
}
|
|
88
208
|
/**
|
|
89
|
-
*
|
|
90
|
-
*
|
|
91
|
-
*
|
|
209
|
+
* Returns the currently active grid resolution.
|
|
210
|
+
*
|
|
211
|
+
* ```ts
|
|
212
|
+
* dggs.setResolution(7);
|
|
213
|
+
* console.log(dggs.getResolution()); // 7
|
|
214
|
+
* ```
|
|
215
|
+
*
|
|
216
|
+
* @returns The current resolution level.
|
|
92
217
|
*/
|
|
93
218
|
getResolution() {
|
|
94
219
|
return this.resolution;
|
|
95
220
|
}
|
|
96
221
|
/**
|
|
97
|
-
*
|
|
98
|
-
*
|
|
99
|
-
*
|
|
222
|
+
* Sets the grid resolution used by default in all conversion and
|
|
223
|
+
* statistics methods.
|
|
224
|
+
*
|
|
225
|
+
* ```ts
|
|
226
|
+
* dggs.setResolution(5);
|
|
227
|
+
* const count = dggs.nCells(); // uses resolution 5
|
|
228
|
+
* ```
|
|
229
|
+
*
|
|
230
|
+
* @param resolution - The new resolution level. Must be a positive integer.
|
|
100
231
|
*/
|
|
101
232
|
setResolution(resolution) {
|
|
102
233
|
this.resolution = resolution;
|
|
103
234
|
}
|
|
104
235
|
/**
|
|
105
|
-
* test
|
|
106
|
-
*
|
|
107
|
-
* @
|
|
108
|
-
* @memberof WebDggrid
|
|
236
|
+
* Internal test helper that invokes the WASM module's `_main` entry point.
|
|
237
|
+
* Not intended for production use.
|
|
238
|
+
* @internal
|
|
109
239
|
*/
|
|
110
240
|
_main() {
|
|
111
241
|
return this._module._main();
|
|
112
242
|
}
|
|
113
243
|
/**
|
|
114
|
-
*
|
|
115
|
-
*
|
|
116
|
-
*
|
|
117
|
-
*
|
|
118
|
-
*
|
|
244
|
+
* Returns the total number of cells that tile the entire globe at the
|
|
245
|
+
* given resolution under the current DGGS configuration.
|
|
246
|
+
*
|
|
247
|
+
* Cell counts grow exponentially with resolution. For the default ISEA4H
|
|
248
|
+
* grid:
|
|
249
|
+
*
|
|
250
|
+
* | Resolution | Approx. cell count |
|
|
251
|
+
* |---|---|
|
|
252
|
+
* | 1 | 42 |
|
|
253
|
+
* | 2 | 162 |
|
|
254
|
+
* | 3 | 642 |
|
|
255
|
+
* | 4 | 2 562 |
|
|
256
|
+
* | 5 | 10 242 |
|
|
257
|
+
* | 6 | 40 962 |
|
|
258
|
+
*
|
|
259
|
+
* ```ts
|
|
260
|
+
* const total = dggs.nCells(3); // 642
|
|
261
|
+
* ```
|
|
262
|
+
*
|
|
263
|
+
* @param resolution - Resolution level to query. Defaults to the instance's
|
|
264
|
+
* current {@link resolution}.
|
|
265
|
+
* @returns Total number of cells at the given resolution.
|
|
119
266
|
*/
|
|
120
267
|
nCells(resolution = DEFAULT_RESOLUTION) {
|
|
121
268
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
122
|
-
const cellCount = this._module.nCells(
|
|
269
|
+
const cellCount = this._module.nCells(lng, lat, azimuth, aperture, resolution, topology, projection);
|
|
123
270
|
return cellCount;
|
|
124
271
|
}
|
|
272
|
+
/**
|
|
273
|
+
* Returns the average area of a single cell in square kilometres at the
|
|
274
|
+
* given resolution.
|
|
275
|
+
*
|
|
276
|
+
* Because ISEA guarantees equal-area cells, all cells have the same area
|
|
277
|
+
* when using the `ISEA` projection. With `FULLER` the value is an average.
|
|
278
|
+
*
|
|
279
|
+
* ```ts
|
|
280
|
+
* const areakm2 = dggs.cellAreaKM(5);
|
|
281
|
+
* ```
|
|
282
|
+
*
|
|
283
|
+
* @param resolution - Resolution level to query. Defaults to the instance's
|
|
284
|
+
* current {@link resolution}.
|
|
285
|
+
* @returns Average cell area in km².
|
|
286
|
+
*/
|
|
125
287
|
cellAreaKM(resolution = DEFAULT_RESOLUTION) {
|
|
126
288
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
127
|
-
const cellCount = this._module.
|
|
289
|
+
const cellCount = this._module.cellAreaKM(lng, lat, azimuth, aperture, resolution, topology, projection);
|
|
128
290
|
return cellCount;
|
|
129
291
|
}
|
|
292
|
+
/**
|
|
293
|
+
* Returns the average centre-to-centre distance between neighbouring cells
|
|
294
|
+
* in kilometres at the given resolution.
|
|
295
|
+
*
|
|
296
|
+
* This is useful for estimating spatial join radii or selecting a
|
|
297
|
+
* resolution that matches a target spatial scale.
|
|
298
|
+
*
|
|
299
|
+
* ```ts
|
|
300
|
+
* const spacingKm = dggs.cellDistKM(5);
|
|
301
|
+
* ```
|
|
302
|
+
*
|
|
303
|
+
* @param resolution - Resolution level to query. Defaults to the instance's
|
|
304
|
+
* current {@link resolution}.
|
|
305
|
+
* @returns Average cell spacing in km.
|
|
306
|
+
*/
|
|
130
307
|
cellDistKM(resolution = DEFAULT_RESOLUTION) {
|
|
131
308
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
132
|
-
const cellCount = this._module.
|
|
309
|
+
const cellCount = this._module.cellDistKM(lng, lat, azimuth, aperture, resolution, topology, projection);
|
|
133
310
|
return cellCount;
|
|
134
311
|
}
|
|
312
|
+
/**
|
|
313
|
+
* Returns the characteristic length scale (CLS) of the grid at the given
|
|
314
|
+
* resolution — defined as the square root of the average cell area.
|
|
315
|
+
*
|
|
316
|
+
* CLS provides a single scalar that summarises the spatial granularity of
|
|
317
|
+
* the grid, useful for comparing resolutions across different DGGS
|
|
318
|
+
* configurations.
|
|
319
|
+
*
|
|
320
|
+
* ```ts
|
|
321
|
+
* const cls = dggs.gridStatCLS(4);
|
|
322
|
+
* ```
|
|
323
|
+
*
|
|
324
|
+
* @param resolution - Resolution level to query. Defaults to the instance's
|
|
325
|
+
* current {@link resolution}.
|
|
326
|
+
* @returns Grid CLS value.
|
|
327
|
+
*/
|
|
135
328
|
gridStatCLS(resolution = DEFAULT_RESOLUTION) {
|
|
136
329
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
137
|
-
const cellCount = this._module.
|
|
330
|
+
const cellCount = this._module.gridStatCLS(lng, lat, azimuth, aperture, resolution, topology, projection);
|
|
138
331
|
return cellCount;
|
|
139
332
|
}
|
|
140
333
|
/**
|
|
141
|
-
* Converts an array of
|
|
142
|
-
*
|
|
143
|
-
*
|
|
144
|
-
*
|
|
334
|
+
* Converts an array of geographic coordinates to their corresponding DGGS
|
|
335
|
+
* cell sequence numbers (cell IDs) at the given resolution.
|
|
336
|
+
*
|
|
337
|
+
* Each coordinate is mapped to the single cell whose boundary contains it.
|
|
338
|
+
* Multiple coordinates that fall within the same cell will return the same
|
|
339
|
+
* sequence number.
|
|
340
|
+
*
|
|
341
|
+
* Coordinates must be supplied in **`[lng, lat]`** order (GeoJSON
|
|
342
|
+
* convention), **not** `[lat, lng]`.
|
|
343
|
+
*
|
|
344
|
+
* ```ts
|
|
345
|
+
* // New York City
|
|
346
|
+
* const ids = dggs.geoToSequenceNum([[-74.006, 40.7128]], 5);
|
|
347
|
+
* console.log(ids); // [12345n]
|
|
348
|
+
*
|
|
349
|
+
* // Multiple points at once
|
|
350
|
+
* const ids2 = dggs.geoToSequenceNum(
|
|
351
|
+
* [[-74.006, 40.7128], [2.3522, 48.8566]],
|
|
352
|
+
* 5
|
|
353
|
+
* );
|
|
354
|
+
* ```
|
|
355
|
+
*
|
|
356
|
+
* @param coordinates - Array of `[lng, lat]` pairs in decimal degrees.
|
|
357
|
+
* @param resolution - Resolution at which to perform the lookup. Defaults
|
|
358
|
+
* to the instance's current {@link resolution}.
|
|
359
|
+
* @returns Array of `BigInt` sequence numbers, one per input coordinate,
|
|
360
|
+
* in the same order.
|
|
145
361
|
*/
|
|
146
362
|
geoToSequenceNum(coordinates, resolution = DEFAULT_RESOLUTION) {
|
|
147
363
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
148
364
|
const xCoords = coordinates.map((coord) => coord[0]);
|
|
149
365
|
const yCoords = coordinates.map((coord) => coord[1]);
|
|
150
|
-
const resultArray = this._module.DgGEO_to_SEQNUM(
|
|
366
|
+
const resultArray = this._module.DgGEO_to_SEQNUM(lng, lat, azimuth, aperture, resolution, topology, projection, xCoords, yCoords);
|
|
151
367
|
return resultArray;
|
|
152
368
|
}
|
|
153
369
|
/**
|
|
154
|
-
*
|
|
155
|
-
*
|
|
156
|
-
*
|
|
157
|
-
*
|
|
370
|
+
* Converts an array of DGGS cell sequence numbers to the geographic
|
|
371
|
+
* coordinates of their centroids.
|
|
372
|
+
*
|
|
373
|
+
* The returned coordinates are in **`[lng, lat]`** order (GeoJSON
|
|
374
|
+
* convention).
|
|
375
|
+
*
|
|
376
|
+
* ```ts
|
|
377
|
+
* const centroids = dggs.sequenceNumToGeo([1n, 2n, 3n], 3);
|
|
378
|
+
* // [[lng0, lat0], [lng1, lat1], [lng2, lat2]]
|
|
379
|
+
* ```
|
|
380
|
+
*
|
|
381
|
+
* @param sequenceNum - Array of `BigInt` cell IDs to look up.
|
|
382
|
+
* @param resolution - Resolution at which the IDs were generated. Defaults
|
|
383
|
+
* to the instance's current {@link resolution}.
|
|
384
|
+
* @returns Array of `[lng, lat]` centroid positions, one per input ID, in
|
|
385
|
+
* the same order.
|
|
158
386
|
*/
|
|
159
387
|
sequenceNumToGeo(sequenceNum, resolution = DEFAULT_RESOLUTION) {
|
|
160
388
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
161
|
-
const resultArray = this._module.SEQNUM_to_GEO(
|
|
389
|
+
const resultArray = this._module.SEQNUM_to_GEO(lng, lat, azimuth, aperture, resolution, topology, projection, sequenceNum);
|
|
162
390
|
const size = resultArray.length / 2;
|
|
163
391
|
const arrayOfArrays = [];
|
|
164
392
|
for (let i = 0; i < size; i += 1) {
|
|
@@ -167,16 +395,37 @@ export class Webdggrid {
|
|
|
167
395
|
return arrayOfArrays;
|
|
168
396
|
}
|
|
169
397
|
/**
|
|
170
|
-
*
|
|
171
|
-
*
|
|
172
|
-
*
|
|
173
|
-
*
|
|
398
|
+
* Snaps an array of geographic coordinates to the centroid of the DGGS
|
|
399
|
+
* cell that contains each point.
|
|
400
|
+
*
|
|
401
|
+
* This is equivalent to calling {@link geoToSequenceNum} followed by
|
|
402
|
+
* {@link sequenceNumToGeo} but is more efficient because it avoids
|
|
403
|
+
* returning the intermediate sequence numbers.
|
|
404
|
+
*
|
|
405
|
+
* Useful for spatial aggregation: all points that fall within the same
|
|
406
|
+
* cell will map to the identical centroid coordinate.
|
|
407
|
+
*
|
|
408
|
+
* Coordinates must be in **`[lng, lat]`** order.
|
|
409
|
+
*
|
|
410
|
+
* ```ts
|
|
411
|
+
* const snapped = dggs.geoToGeo(
|
|
412
|
+
* [[-74.006, 40.7128], [-74.010, 40.720]],
|
|
413
|
+
* 5
|
|
414
|
+
* );
|
|
415
|
+
* // Both points snap to the same centroid if they share a cell
|
|
416
|
+
* ```
|
|
417
|
+
*
|
|
418
|
+
* @param coordinates - Array of `[lng, lat]` pairs in decimal degrees.
|
|
419
|
+
* @param resolution - Resolution at which to perform the snapping. Defaults
|
|
420
|
+
* to the instance's current {@link resolution}.
|
|
421
|
+
* @returns Array of `[lng, lat]` cell centroid positions, one per input
|
|
422
|
+
* coordinate, in the same order.
|
|
174
423
|
*/
|
|
175
424
|
geoToGeo(coordinates, resolution = DEFAULT_RESOLUTION) {
|
|
176
425
|
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
177
426
|
const xCoords = coordinates.map((coord) => coord[0]);
|
|
178
427
|
const yCoords = coordinates.map((coord) => coord[1]);
|
|
179
|
-
const resultArray = this._module.GEO_to_GEO(
|
|
428
|
+
const resultArray = this._module.GEO_to_GEO(lng, lat, azimuth, aperture, resolution, topology, projection, xCoords, yCoords);
|
|
180
429
|
const size = resultArray.length / 2;
|
|
181
430
|
const arrayOfArrays = [];
|
|
182
431
|
for (let i = 0; i < size; i += 1) {
|
|
@@ -184,20 +433,114 @@ export class Webdggrid {
|
|
|
184
433
|
}
|
|
185
434
|
return arrayOfArrays;
|
|
186
435
|
}
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
436
|
+
/**
|
|
437
|
+
* Returns the polygon boundary vertices for each cell in `sequenceNum`.
|
|
438
|
+
*
|
|
439
|
+
* Each cell is represented as an array of `[lng, lat]` vertex positions.
|
|
440
|
+
* The ring is **not** automatically closed (the first and last vertex are
|
|
441
|
+
* different) — close it yourself if your renderer requires it.
|
|
442
|
+
*
|
|
443
|
+
* Prefer {@link sequenceNumToGridFeatureCollection} when you need
|
|
444
|
+
* GeoJSON output ready for a mapping library.
|
|
445
|
+
*
|
|
446
|
+
* ```ts
|
|
447
|
+
* const rings = dggs.sequenceNumToGrid([1n, 2n], 3);
|
|
448
|
+
* // rings[0] = [[lng0,lat0], [lng1,lat1], ..., [lng5,lat5]] (hexagon)
|
|
449
|
+
* ```
|
|
450
|
+
*
|
|
451
|
+
* @param sequenceNum - Array of `BigInt` cell IDs whose boundaries to
|
|
452
|
+
* retrieve.
|
|
453
|
+
* @param resolution - Resolution at which the IDs were generated. Defaults
|
|
454
|
+
* to the instance's current {@link resolution}.
|
|
455
|
+
* @returns A 2-D array: `result[i]` is the vertex ring of `sequenceNum[i]`.
|
|
456
|
+
* Each vertex is a `[lng, lat]` position.
|
|
457
|
+
* @throws If the WASM module encounters an invalid cell ID.
|
|
458
|
+
*/
|
|
459
|
+
sequenceNumToGrid(sequenceNum, resolution = DEFAULT_RESOLUTION) {
|
|
460
|
+
const { poleCoordinates: { lat, lng }, azimuth, topology, projection, aperture, } = this.dggs;
|
|
461
|
+
const inputSize = sequenceNum.length;
|
|
462
|
+
let resultArray = [];
|
|
463
|
+
try {
|
|
464
|
+
resultArray = this._module.SeqNumGrid(lng, lat, azimuth, aperture, resolution, topology, projection, sequenceNum);
|
|
465
|
+
}
|
|
466
|
+
catch (e) {
|
|
467
|
+
console.error(this._module.getExceptionMessage(e).toString());
|
|
468
|
+
throw (e);
|
|
469
|
+
}
|
|
470
|
+
const allShapeVertexes = resultArray.slice(0, inputSize);
|
|
471
|
+
const sumVertexes = allShapeVertexes.reduce((accumulator, currentValue) => {
|
|
472
|
+
return accumulator + currentValue;
|
|
473
|
+
}, 0);
|
|
474
|
+
const featureSet = [];
|
|
475
|
+
let xOffset = inputSize;
|
|
476
|
+
let yOffset = inputSize + sumVertexes;
|
|
477
|
+
for (let i = 0; i < allShapeVertexes.length; i += 1) {
|
|
478
|
+
const numVertexes = allShapeVertexes[i];
|
|
479
|
+
const currentShapeXVertexes = resultArray.slice(xOffset, xOffset + numVertexes);
|
|
480
|
+
const currentShapeYVertexes = resultArray.slice(yOffset, yOffset + numVertexes);
|
|
481
|
+
const coordinates = [];
|
|
482
|
+
for (let i = 0; i < numVertexes; i += 1) {
|
|
483
|
+
coordinates.push([currentShapeXVertexes[i], currentShapeYVertexes[i]]);
|
|
484
|
+
}
|
|
485
|
+
featureSet.push(unwrapAntimeridianRing(coordinates));
|
|
486
|
+
xOffset += numVertexes;
|
|
487
|
+
yOffset += numVertexes;
|
|
199
488
|
}
|
|
489
|
+
return featureSet;
|
|
490
|
+
}
|
|
491
|
+
/**
|
|
492
|
+
* Converts an array of DGGS cell IDs into a GeoJSON `FeatureCollection`
|
|
493
|
+
* where each `Feature` is a `Polygon` representing the cell boundary.
|
|
494
|
+
*
|
|
495
|
+
* This is the primary method for rendering DGGS cells with mapping
|
|
496
|
+
* libraries such as MapLibre GL JS, Leaflet, or deck.gl.
|
|
497
|
+
*
|
|
498
|
+
* Each feature includes:
|
|
499
|
+
* - `geometry` — a closed `Polygon` in `[lng, lat]` coordinate order.
|
|
500
|
+
* - `id` — the cell sequence number (converted to `string` recommended
|
|
501
|
+
* before passing to MapLibre to avoid BigInt serialisation errors).
|
|
502
|
+
* - `properties.id` — same value as `id`, accessible inside layer
|
|
503
|
+
* expressions.
|
|
504
|
+
*
|
|
505
|
+
* ```ts
|
|
506
|
+
* const ids = dggs.geoToSequenceNum([[-74.006, 40.7128]], 5);
|
|
507
|
+
* const fc = dggs.sequenceNumToGridFeatureCollection(ids, 5);
|
|
508
|
+
*
|
|
509
|
+
* // MapLibre / structured-clone safe: convert BigInt → string
|
|
510
|
+
* fc.features.forEach(f => {
|
|
511
|
+
* if (typeof f.id === 'bigint') f.id = f.id.toString();
|
|
512
|
+
* if (f.properties?.id) f.properties.id = f.properties.id.toString();
|
|
513
|
+
* });
|
|
514
|
+
*
|
|
515
|
+
* map.getSource('grid').setData(fc);
|
|
516
|
+
* ```
|
|
517
|
+
*
|
|
518
|
+
* @param sequenceNum - Array of `BigInt` cell IDs to convert.
|
|
519
|
+
* @param resolution - Resolution at which the IDs were generated. Defaults
|
|
520
|
+
* to the instance's current {@link resolution}.
|
|
521
|
+
* @returns A GeoJSON `FeatureCollection` of `Polygon` features, one per
|
|
522
|
+
* input cell ID.
|
|
523
|
+
*/
|
|
524
|
+
sequenceNumToGridFeatureCollection(sequenceNum, resolution = DEFAULT_RESOLUTION) {
|
|
525
|
+
const coordinatesArray = this.sequenceNumToGrid(sequenceNum, resolution);
|
|
526
|
+
const features = coordinatesArray.map((coordinates, index) => {
|
|
527
|
+
const seqNum = sequenceNum[index];
|
|
528
|
+
return {
|
|
529
|
+
type: 'Feature',
|
|
530
|
+
geometry: {
|
|
531
|
+
type: 'Polygon',
|
|
532
|
+
coordinates: [coordinates]
|
|
533
|
+
},
|
|
534
|
+
id: seqNum,
|
|
535
|
+
properties: {
|
|
536
|
+
id: seqNum
|
|
537
|
+
}
|
|
538
|
+
};
|
|
539
|
+
});
|
|
540
|
+
return {
|
|
541
|
+
type: 'FeatureCollection',
|
|
542
|
+
features,
|
|
543
|
+
};
|
|
200
544
|
}
|
|
201
|
-
_vectorToArray(vector) { return new Array(vector.size()).fill(0).map((_, id) => vector.get(id)); }
|
|
202
545
|
}
|
|
203
546
|
//# sourceMappingURL=webdggrid.js.map
|
package/lib-esm/webdggrid.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"webdggrid.js","sourceRoot":"","sources":["../src-ts/webdggrid.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;
|
|
1
|
+
{"version":3,"file":"webdggrid.js","sourceRoot":"","sources":["../src-ts/webdggrid.ts"],"names":[],"mappings":"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"}
|