@eopf-dggs/healpix-geo 0.1.0

package/healpix_wasm.d.ts

@@ -0,0 +1,36 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Returns the depth (level) for a given nside value.
+ * nside must be a power of 2.
+ */
+export function nside_to_depth(nside: number): number;
+/**
+ * Returns the 4 corner vertices of a HEALPix cell as [lon0,lat0, lon1,lat1, ...].
+ *
+ * Corners are in order: S, E, N, W (south, east, north, west).
+ * Coordinates are in radians.
+ */
+export function vertices_nest(depth: number, hash: bigint): Float64Array;
+/**
+ * Morton/Z-order bit interleaving: combines i and j into a single index.
+ *
+ * Used for HEALPix nested-to-texture mapping (Morton order unshuffling).
+ */
+export function bit_combine(x: number, y: number): bigint;
+/**
+ * Returns [x, y, z] unit vector for a position within a HEALPix nested cell.
+ *
+ * `depth` is the HEALPix depth (level), where nside = 2^depth.
+ * `hash` is the cell index in nested ordering.
+ * `dx` and `dy` are fractional positions within the cell, both in [0, 1].
+ *
+ * This is the equivalent of `@hscmap/healpix`'s `pixcoord2vec_nest(nside, ipix, u, v)`
+ * but uses depth instead of nside, and supports 64-bit cell indices.
+ */
+export function pixcoord2vec_nest(depth: number, hash: bigint, dx: number, dy: number): Float64Array;
+/**
+ * Convenience wrapper that takes nside instead of depth.
+ * nside must be a power of 2 (nside = 2^depth).
+ */
+export function pixcoord2vec_nest_nside(nside: number, hash: bigint, dx: number, dy: number): Float64Array;

package/healpix_wasm.js

@@ -0,0 +1,5 @@
+import * as wasm from "./healpix_wasm_bg.wasm";
+export * from "./healpix_wasm_bg.js";
+import { __wbg_set_wasm } from "./healpix_wasm_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/healpix_wasm_bg.js

@@ -0,0 +1,141 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+/**
+ * Returns the depth (level) for a given nside value.
+ * nside must be a power of 2.
+ * @param {number} nside
+ * @returns {number}
+ */
+export function nside_to_depth(nside) {
+    const ret = wasm.nside_to_depth(nside);
+    return ret;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+/**
+ * Returns the 4 corner vertices of a HEALPix cell as [lon0,lat0, lon1,lat1, ...].
+ *
+ * Corners are in order: S, E, N, W (south, east, north, west).
+ * Coordinates are in radians.
+ * @param {number} depth
+ * @param {bigint} hash
+ * @returns {Float64Array}
+ */
+export function vertices_nest(depth, hash) {
+    const ret = wasm.vertices_nest(depth, hash);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Morton/Z-order bit interleaving: combines i and j into a single index.
+ *
+ * Used for HEALPix nested-to-texture mapping (Morton order unshuffling).
+ * @param {number} x
+ * @param {number} y
+ * @returns {bigint}
+ */
+export function bit_combine(x, y) {
+    const ret = wasm.bit_combine(x, y);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * Returns [x, y, z] unit vector for a position within a HEALPix nested cell.
+ *
+ * `depth` is the HEALPix depth (level), where nside = 2^depth.
+ * `hash` is the cell index in nested ordering.
+ * `dx` and `dy` are fractional positions within the cell, both in [0, 1].
+ *
+ * This is the equivalent of `@hscmap/healpix`'s `pixcoord2vec_nest(nside, ipix, u, v)`
+ * but uses depth instead of nside, and supports 64-bit cell indices.
+ * @param {number} depth
+ * @param {bigint} hash
+ * @param {number} dx
+ * @param {number} dy
+ * @returns {Float64Array}
+ */
+export function pixcoord2vec_nest(depth, hash, dx, dy) {
+    const ret = wasm.pixcoord2vec_nest(depth, hash, dx, dy);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Convenience wrapper that takes nside instead of depth.
+ * nside must be a power of 2 (nside = 2^depth).
+ * @param {number} nside
+ * @param {bigint} hash
+ * @param {number} dx
+ * @param {number} dy
+ * @returns {Float64Array}
+ */
+export function pixcoord2vec_nest_nside(nside, hash, dx, dy) {
+    const ret = wasm.pixcoord2vec_nest_nside(nside, hash, dx, dy);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@eopf-dggs/healpix-geo",
+  "type": "module",
+  "description": "HEALPix geometry for JavaScript/WASM \u2014 cell vertex positions and Z-order curve",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "files": [
+    "healpix_wasm_bg.wasm",
+    "healpix_wasm.js",
+    "healpix_wasm_bg.js",
+    "healpix_wasm.d.ts"
+  ],
+  "main": "healpix_wasm.js",
+  "types": "healpix_wasm.d.ts",
+  "sideEffects": [
+    "./healpix_wasm.js",
+    "./snippets/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EOPF-DGGS/healpix-geo"
+  }
+}