@woosh/meep-engine 2.106.1 → 2.108.0

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -1,173 +1,28 @@
-import {mat3, vec3} from "gl-matrix";
-import {assert} from "../../../../assert.js";
-import {array_copy} from "../../../../collection/array/array_copy.js";
-import {min2} from "../../../../math/min2.js";
+import { mat3, vec3 } from "gl-matrix";
+import { assert } from "../../../../assert.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
+import { min2 } from "../../../../math/min2.js";
+import { SH3_COEFFICIENTS } from "./SH3_COEFFICIENTS.js";
+import { sh3_rotate } from "./sh3_rotate.js";
+import { sh_index } from "./sh_index.js";
 
 /*
 @see https://github.com/Bestmaker602/olacziy/blob/212b64ea5f1856b390cdf7629801243f76a4466d/libs/ibl/src/CubemapSH.cpp
  */
 
 
-const F_PI = 3.14159265358979323846264338327950288;
-const F_SQRT1_2 = 0.707106781186547524400844362104849039;
-const M_SQRT_3 = 1.7320508076;
-
-const M_SQRT_PI = 1.7724538509;
-const M_SQRT_5 = 2.2360679775;
-const M_SQRT_15 = 3.8729833462;
-
-/**
- *
- * @param {number[]} M 5x5 matrix
- * @param {number[]} x vec5
- * @return {number[]} vec5
- */
-function multiply_5d(M, x) {
-    return [
-        M[0] * x[0] + M[5] * x[1] + M[10] * x[2] + M[15] * x[3] + M[20] * x[4],
-        M[1] * x[0] + M[6] * x[1] + M[11] * x[2] + M[16] * x[3] + M[21] * x[4],
-        M[2] * x[0] + M[7] * x[1] + M[12] * x[2] + M[17] * x[3] + M[22] * x[4],
-        M[3] * x[0] + M[8] * x[1] + M[13] * x[2] + M[18] * x[3] + M[23] * x[4],
-        M[4] * x[0] + M[9] * x[1] + M[14] * x[2] + M[19] * x[3] + M[24] * x[4]
-    ];
-}
-
-/**
- * compute Index of spherical harmonics coefficient
- * @param {number} m signed offset from zonal harmonic
- * @param {number} l band
- * @return {number}
- */
-function SHindex(m, l) {
-    return l * (l + 1) + m;
-}
-
-
-/*
- * utilities to rotate very low order spherical harmonics (up to 3rd band)
- * @param {number[]} band1
- * @param {number[]} M 3x3 matrix
- * @returns {number[]}
- */
-function rotateShericalHarmonicBand1(band1, M) {
-
-    // inverse() is not constexpr -- so we pre-calculate it in mathematica
-    //
-    //    constexpr float3 N0{ 1, 0, 0 };
-    //    constexpr float3 N1{ 0, 1, 0 };
-    //    constexpr float3 N2{ 0, 0, 1 };
-    //
-    //    constexpr mat3f A1 = { // this is the projection of N0, N1, N2 to SH space
-    //            float3{ -N0.y, N0.z, -N0.x },
-    //            float3{ -N1.y, N1.z, -N1.x },
-    //            float3{ -N2.y, N2.z, -N2.x }
-    //    };
-    //
-    //    const mat3f invA1 = inverse(A1);
-
-    const invA1TimesK = [
-        0, -1, 0,
-        0, 0, 1,
-        -1, 0, 0
-    ];
-
-    const R1OverK = [
-        -M[1], M[2], -M[0],
-        -M[4], M[5], -M[3],
-        -M[7], M[8], -M[6]
-    ];
-
-
-    mat3.scale(invA1TimesK, invA1TimesK, band1);
-
-
-    mat3.multiply(R1OverK, R1OverK, invA1TimesK);
-
-    return R1OverK;
-}
-
-/**
- *  This projects a vec3 to SH2/k space (i.e. we premultiply by 1/k)
- *  below can't be constexpr
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @return {number[]} vec5
- */
-function project_v3_to_sh(x, y, z) {
-    return [
-        (y * x),
-        -(y * z),
-        1 / (2 * M_SQRT_3) * ((3 * z * z - 1)),
-        -(z * x),
-        0.5 * ((x * x - y * y))
-    ];
-}
-
-/**
- *
- * @param {number[]} band2 vec5
- * @param {number[]} M mat3
- * @return {number[]} vec5
- */
-function rotateShericalHarmonicBand2(band2, M) {
-    const n = F_SQRT1_2;
-
-    //  Below we precompute (with help of Mathematica):
-    //    constexpr float3 N0{ 1, 0, 0 };
-    //    constexpr float3 N1{ 0, 0, 1 };
-    //    constexpr float3 N2{ n, n, 0 };
-    //    constexpr float3 N3{ n, 0, n };
-    //    constexpr float3 N4{ 0, n, n };
-    //    constexpr float M_SQRT_PI = 1.7724538509f;
-    //    constexpr float M_SQRT_15 = 3.8729833462f;
-    //    constexpr float k = M_SQRT_15 / (2.0f * M_SQRT_PI);
-    //    --> k * inverse(mat5{project(N0), project(N1), project(N2), project(N3), project(N4)})
-    const invATimesK = [
-        0, 1, 2, 0, 0,
-        -1, 0, 0, 0, -2,
-        0, M_SQRT_3, 0, 0, 0,
-        1, 1, 0, -2, 0,
-        2, 1, 0, 0, 0
-    ];
-
-    // this is: invA * k * band2
-    // 5x5 matrix by vec5 (this a lot of zeroes and constants, which the compiler should eliminate)
-    const invATimesKTimesBand2 = multiply_5d(invATimesK, band2);
-
-    // this is: mat5{project(N0), project(N1), project(N2), project(N3), project(N4)} / k
-    // (the 1/k comes from project(), see above)
-    const ROverK =
-        project_v3_to_sh(M[0], M[1], M[2])                  // M * N0
-            .concat(project_v3_to_sh(M[6], M[7], M[8]))                  // M * N1
-            .concat(project_v3_to_sh(n * (M[0] + M[3]), n * (M[1] + M[4]), n * (M[2] + M[5])))     // M * N2
-            .concat(project_v3_to_sh(n * (M[0] + M[6]), n * (M[1] + M[7]), n * (M[2] + M[8])))     // M * N3
-            .concat(project_v3_to_sh(n * (M[3] + M[6]), n * (M[4] + M[7]), n * (M[5] + M[8])))      // M * N4
-    ;
-
-    // notice how "k" disappears
-    // this is: (R / k) * (invA * k) * band2 == R * invA * band2
-    const result = multiply_5d(ROverK, invATimesKTimesBand2);
-
-    return result;
-}
-
 /**
  * SH from environment with high dynamic range (or high frequencies -- high dynamic range creates
  * high frequencies) exhibit "ringing" and negative values when reconstructed.
  * To mitigate this, we need to low-pass the input image -- or equivalently window the SH by
  * coefficient that tapper towards zero with the band.
  *
- * We use ideas and techniques from
- *    Stupid Spherical Harmonics (SH)
- *    Deringing Spherical Harmonics
- * by Peter-Pike Sloan
- * https://www.ppsloan.org/publications/shdering.pdf
- * @param {number} w
+ * We use ideas and techniques from Stupid Spherical Harmonics (SH) Deringing Spherical Harmonics by Peter-Pike Sloan ( see https://www.ppsloan.org/publications/shdering.pdf )
+ * @param {number} w cutoff
  * @param {number} l
  * @returns {number}
  */
-function sincWindow(l, w) {
+function sinc_window(l, w) {
     if (l === 0) {
         return 1.0;
     } else if (l >= w) {
@@ -176,7 +31,7 @@ function sincWindow(l, w) {
 
     // we use a sinc window scaled to the desired window size in bands units
     // a sinc window only has zonal harmonics
-    let x = ((F_PI) * l) / w;
+    let x = (Math.PI * l) / w;
 
     x = Math.sin(x) / x;
 
@@ -188,52 +43,15 @@ function sincWindow(l, w) {
 }
 
 /**
- *
- * @param {number[]|Float32Array} result sh3
- * @param {number[]} sh input
- * @param {number[]} M mat3
- */
-function rotate_sh3_bands(result, sh, M) {
-
-    const b0 = sh[0];
-    const band1 = [sh[1], sh[2], sh[3]];
-    const b1 = rotateShericalHarmonicBand1(band1, M);
-    const band2 = [sh[4], sh[5], sh[6], sh[7], sh[8]];
-    const b2 = rotateShericalHarmonicBand2(band2, M);
-
-    result[0] = b0;
-
-    result[1] = b1[0];
-    result[2] = b1[1];
-    result[3] = b1[2];
-
-    result[4] = b2[0];
-    result[5] = b2[1];
-    result[6] = b2[2];
-    result[7] = b2[3];
-    result[8] = b2[4];
-}
-
-/**
- *
- * @param {number[]} input_sh3 sh3
+ * Minimum values encoded on the spherical harmonics
+ * Lets us find ringing artifacts, which are cases where harmonics encode a negative value
+ * @param {number[]|Float32Array} input_sh3 sh3
  * @returns {number}
  */
-function shmin(input_sh3) {
+function sh3_min(input_sh3) {
     // See "Deringing Spherical Harmonics" by Peter-Pike Sloan
     // https://www.ppsloan.org/publications/shdering.pdf
 
-    const A = [
-        1.0 / (2.0 * M_SQRT_PI),    // 0: 0  0
-        -M_SQRT_3 / (2.0 * M_SQRT_PI),    // 1: 1 -1
-        M_SQRT_3 / (2.0 * M_SQRT_PI),    // 2: 1  0
-        -M_SQRT_3 / (2.0 * M_SQRT_PI),    // 3: 1  1
-        M_SQRT_15 / (2.0 * M_SQRT_PI),    // 4: 2 -2
-        -M_SQRT_15 / (2.0 * M_SQRT_PI),    // 5: 2 -1
-        M_SQRT_5 / (4.0 * M_SQRT_PI),    // 6: 2  0
-        -M_SQRT_15 / (2.0 * M_SQRT_PI),    // 7: 2  1
-        M_SQRT_15 / (4.0 * M_SQRT_PI)     // 8: 2  2
-    ];
 
     // first this to do is to rotate the SH to align Z with the optimal linear direction
     const dir = vec3.fromValues(-input_sh3[3], -input_sh3[1], input_sh3[2]);
@@ -259,7 +77,7 @@ function shmin(input_sh3) {
 
     const f = new Float32Array(9);
 
-    rotate_sh3_bands(f, input_sh3, M);
+    sh3_rotate(f, input_sh3, M);
     // here we're guaranteed to have normalize(float3{ -f[3], -f[1], f[2] }) == { 0, 0, 1 }
 
 
@@ -270,7 +88,7 @@ function shmin(input_sh3) {
     // of z such as:  m2min = -m2max * (1 - z^2) =  m2max * z^2 - m2max
     //      with m2max = A[8] * std::sqrt(f[8] * f[8] + f[4] * f[4]);
     // We can therefore include this in the ZH min computation (which is function of z^2 as well)
-    const m2max = A[8] * Math.sqrt(f[8] * f[8] + f[4] * f[4]);
+    const m2max = SH3_COEFFICIENTS[8] * Math.sqrt(f[8] * f[8] + f[4] * f[4]);
 
     // Find the min of the zonal harmonics
     // -----------------------------------
@@ -286,9 +104,9 @@ function shmin(input_sh3) {
     //
     // We also needs to check that -1 < z < 1, otherwise the min is either in z = -1 or 1
     //
-    const a = 3 * A[6] * f[6] + m2max;
-    const b = A[2] * f[2];
-    const c = A[0] * f[0] - A[6] * f[6] - m2max;
+    const a = 3 * SH3_COEFFICIENTS[6] * f[6] + m2max;
+    const b = SH3_COEFFICIENTS[2] * f[2];
+    const c = SH3_COEFFICIENTS[0] * f[0] - SH3_COEFFICIENTS[6] * f[6] - m2max;
 
     const zmin = -b / (2.0 * a);
     const m0min_z = a * zmin * zmin + b * zmin + c;
@@ -304,7 +122,7 @@ function shmin(input_sh3) {
     // The function considered is:
     //        Y(x, y, z) = A[5] * f[5] * s.y * s.z
     //                   + A[7] * f[7] * s.z * s.x
-    const d = A[4] * Math.sqrt(f[5] * f[5] + f[7] * f[7]);
+    const d = SH3_COEFFICIENTS[4] * Math.sqrt(f[5] * f[5] + f[7] * f[7]);
 
     // the |m|=1 function is minimal in -0.5 -- use that to skip the Newton's loop when possible
     let minimum = m0min - 0.5 * d;
@@ -315,7 +133,7 @@ function shmin(input_sh3) {
 
 
         let dz;
-        let z = -F_SQRT1_2;   // we start guessing at the min of |m|=1 function
+        let z = -Math.SQRT1_2;   // we start guessing at the min of |m|=1 function
         do {
             minimum = func_(z, a, b, c, d); // evaluate our function
             dz = increment_(z, a, b, d); // refine our guess by this amount
@@ -366,14 +184,22 @@ function increment_(x, a, b, d) {
  * @param {number} numBands
  */
 function windowing(f, cutoff, numBands) {
+
     for (let l = 0; l < numBands; l++) {
-        const w = sincWindow(l, cutoff);
-        f[SHindex(0, l)] *= w;
+
+        const w = sinc_window(l, cutoff);
+
+        f[sh_index(0, l)] *= w;
+
         for (let m = 1; m <= l; m++) {
-            f[SHindex(-m, l)] *= w;
-            f[SHindex(m, l)] *= w;
+
+            f[sh_index(-m, l)] *= w;
+            f[sh_index(m, l)] *= w;
+
         }
+
     }
+
     return f;
 }
 
@@ -390,7 +216,8 @@ function windowing(f, cutoff, numBands) {
 function windowSH(
     output, output_offset,
     input, input_offset,
-    numBands, channel_count, cutoff = 0
+    numBands, channel_count,
+    cutoff = 0
 ) {
     assert.isNonNegativeInteger(channel_count, 'channel_count');
     assert.greaterThan(channel_count, 0, 'channel_count must be greater than 0');
@@ -424,7 +251,9 @@ function windowSH(
 
                 const m = 0.5 * (l + r);
 
-                if (shmin(windowing(SH, m, numBands)) < 0) {
+                windowing(SH, m, numBands);
+
+                if (sh3_min(SH) < 0) {
                     r = m;
                 } else {
                     l = m;
@@ -442,18 +271,18 @@ function windowSH(
 
     for (let l = 0; l < numBands; l++) {
         // scale each band individually
-        let w = sincWindow(l, cutoff);
+        const w = sinc_window(l, cutoff);
 
         // write zonal harmonic
         for (let i = 0; i < channel_count; i++) {
-            output[output_offset + SHindex(0, l) * channel_count + i] *= w;
+            output[output_offset + sh_index(0, l) * channel_count + i] *= w;
         }
 
         // write the rest of the band
         for (let m = 1; m <= l; m++) {
             for (let i = 0; i < channel_count; i++) {
-                output[output_offset + SHindex(-m, l) * channel_count + i] *= w;
-                output[output_offset + SHindex(m, l) * channel_count + i] *= w;
+                output[output_offset + sh_index(-m, l) * channel_count + i] *= w;
+                output[output_offset + sh_index(m, l) * channel_count + i] *= w;
             }
         }
     }
@@ -461,9 +290,9 @@ function windowSH(
 
 /**
  *
- * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
- * @param {number[]|Float32Array} harmonics
+ * @param {number[]|Float32Array|Float64Array} harmonics
  * @param {number} harmonics_offset
  * @param {number} dimension_count
  */

package/src/core/geom/3d/sphere/harmonics/sh3_rotate.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate(result: number[] | Float32Array, sh: number[], rotation: number[]): void;
+//# sourceMappingURL=sh3_rotate.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_rotate.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_rotate.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,mCAJW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,EAAE,YACR,MAAM,EAAE,QAqBlB"}

package/src/core/geom/3d/sphere/harmonics/sh3_rotate.js

@@ -0,0 +1,29 @@
+import { sh_rotate_band1 } from "./sh_rotate_band1.js";
+import { sh_rotate_band2 } from "./sh_rotate_band2.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate(result, sh, rotation) {
+
+    const b0 = sh[0];
+    const band1 = [sh[1], sh[2], sh[3]];
+    const b1 = sh_rotate_band1(band1, rotation);
+    const band2 = [sh[4], sh[5], sh[6], sh[7], sh[8]];
+    const b2 = sh_rotate_band2(band2, rotation);
+
+    result[0] = b0;
+
+    result[1] = b1[0];
+    result[2] = b1[1];
+    result[3] = b1[2];
+
+    result[4] = b2[0];
+    result[5] = b2[1];
+    result[6] = b2[2];
+    result[7] = b2[3];
+    result[8] = b2[4];
+}

package/src/core/geom/3d/sphere/harmonics/sh3_sample_by_direction.js

@@ -1,4 +1,4 @@
-//
+import { SH3_COEFFICIENTS } from "./SH3_COEFFICIENTS.js";
 
 /**
  * Sample value from a 3-band spherical harmonic defined by 9 coefficients
@@ -30,19 +30,19 @@ export function sh3_sample_by_direction(
         const offset = harmonics_offset + dimension_count * i;
 
         // band 0
-        channel_value = harmonics[offset] * 0.282095;
+        channel_value = harmonics[offset] * SH3_COEFFICIENTS[0];
 
         // band 1
-        channel_value += harmonics[offset + 1] * 0.488603 * y;
-        channel_value += harmonics[offset + 2] * 0.488603 * z;
-        channel_value += harmonics[offset + 3] * 0.488603 * x;
+        channel_value += harmonics[offset + 1] * SH3_COEFFICIENTS[1] * y;
+        channel_value += harmonics[offset + 2] * SH3_COEFFICIENTS[2] * z;
+        channel_value += harmonics[offset + 3] * SH3_COEFFICIENTS[3] * x;
 
         // band 2
-        channel_value += harmonics[offset + 4] * 1.092548 * (x * y);
-        channel_value += harmonics[offset + 5] * 1.092548 * (y * z);
-        channel_value += harmonics[offset + 6] * 0.315392 * (3.0 * z * z - 1.0);
-        channel_value += harmonics[offset + 7] * 1.092548 * (x * z);
-        channel_value += harmonics[offset + 8] * 0.546274 * (x * x - y * y);
+        channel_value += harmonics[offset + 4] * SH3_COEFFICIENTS[4] * (x * y);
+        channel_value += harmonics[offset + 5] * SH3_COEFFICIENTS[5] * (y * z);
+        channel_value += harmonics[offset + 6] * SH3_COEFFICIENTS[6] * (3.0 * z * z - 1.0);
+        channel_value += harmonics[offset + 7] * SH3_COEFFICIENTS[7] * (x * z);
+        channel_value += harmonics[offset + 8] * SH3_COEFFICIENTS[8] * (x * x - y * y);
 
         // write out
         result[result_offset + i] = channel_value;

package/src/core/geom/3d/sphere/harmonics/sh_index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * compute index of spherical harmonics coefficient
+ * @param {number} m signed offset from zonal harmonic
+ * @param {number} l band
+ * @return {number}
+ */
+export function sh_index(m: number, l: number): number;
+//# sourceMappingURL=sh_index.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh_index.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_index.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,4BAJW,MAAM,KACN,MAAM,GACL,MAAM,CAIjB"}

package/src/core/geom/3d/sphere/harmonics/sh_index.js

@@ -0,0 +1,9 @@
+/**
+ * compute index of spherical harmonics coefficient
+ * @param {number} m signed offset from zonal harmonic
+ * @param {number} l band
+ * @return {number}
+ */
+export function sh_index(m, l) {
+    return l * (l + 1) + m;
+}

package/src/core/geom/3d/sphere/harmonics/sh_rotate_band1.d.ts

@@ -0,0 +1,8 @@
+/**
+ * utilities to rotate very low order spherical harmonics (up to 3rd band)
+ * @param {number[]} band1 vec3
+ * @param {number[]} M 3x3 matrix
+ * @returns {number[]}
+ */
+export function sh_rotate_band1(band1: number[], M: number[]): number[];
+//# sourceMappingURL=sh_rotate_band1.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh_rotate_band1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh_rotate_band1.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_rotate_band1.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,uCAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACN,MAAM,EAAE,CAoCpB"}

package/src/core/geom/3d/sphere/harmonics/sh_rotate_band1.js

@@ -0,0 +1,44 @@
+import { mat3 } from "gl-matrix";
+import { m3_multiply_vec3 } from "../../../mat3/m3_multiply_vec3.js";
+
+/**
+ * utilities to rotate very low order spherical harmonics (up to 3rd band)
+ * @param {number[]} band1 vec3
+ * @param {number[]} M 3x3 matrix
+ * @returns {number[]}
+ */
+export function sh_rotate_band1(band1, M) {
+
+    // inverse() is not constexpr -- so we pre-calculate it in mathematica
+    //
+    //    constexpr float3 N0{ 1, 0, 0 };
+    //    constexpr float3 N1{ 0, 1, 0 };
+    //    constexpr float3 N2{ 0, 0, 1 };
+    //
+    //    constexpr mat3f A1 = { // this is the projection of N0, N1, N2 to SH space
+    //            float3{ -N0.y, N0.z, -N0.x },
+    //            float3{ -N1.y, N1.z, -N1.x },
+    //            float3{ -N2.y, N2.z, -N2.x }
+    //    };
+    //
+    //    const mat3f invA1 = inverse(A1);
+
+    const invA1TimesK = [
+        0, -1, 0,
+        0, 0, 1,
+        -1, 0, 0
+    ];
+
+    const R1OverK = [
+        -M[1], M[2], -M[0],
+        -M[4], M[5], -M[3],
+        -M[7], M[8], -M[6]
+    ];
+
+
+    m3_multiply_vec3(invA1TimesK, invA1TimesK, band1);
+
+    mat3.multiply(R1OverK, R1OverK, invA1TimesK);
+
+    return R1OverK;
+}

package/src/core/geom/3d/sphere/harmonics/sh_rotate_band2.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]} band2 vec5
+ * @param {number[]} M mat3
+ * @return {number[]} vec5
+ */
+export function sh_rotate_band2(band2: number[], M: number[]): number[];
+//# sourceMappingURL=sh_rotate_band2.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh_rotate_band2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh_rotate_band2.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_rotate_band2.js"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,uCAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACP,MAAM,EAAE,CA0CnB"}

package/src/core/geom/3d/sphere/harmonics/sh_rotate_band2.js

@@ -0,0 +1,86 @@
+/**
+ * Math.sqrt(3)
+ * @type {number}
+ */
+const SQRT_3 = 1.7320508075688772;
+
+/**
+ *
+ * @param {number[]|Float32Array} M 5x5 matrix
+ * @param {number[]} x vec5
+ * @return {number[]} vec5
+ */
+function multiply_5d(M, x) {
+    return [
+        M[0] * x[0] + M[5] * x[1] + M[10] * x[2] + M[15] * x[3] + M[20] * x[4],
+        M[1] * x[0] + M[6] * x[1] + M[11] * x[2] + M[16] * x[3] + M[21] * x[4],
+        M[2] * x[0] + M[7] * x[1] + M[12] * x[2] + M[17] * x[3] + M[22] * x[4],
+        M[3] * x[0] + M[8] * x[1] + M[13] * x[2] + M[18] * x[3] + M[23] * x[4],
+        M[4] * x[0] + M[9] * x[1] + M[14] * x[2] + M[19] * x[3] + M[24] * x[4]
+    ];
+}
+
+/**
+ * This projects a vec3 to SH2/k space (i.e. we premultiply by 1/k)
+ * these are second band SH factors, multiplied by 1/K ( K = Math.sqrt(15) / (2*Math.sqrt(Math.PI)) )
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function project_v3_to_sh2k(output, output_offset, x, y, z) {
+    output[output_offset] = (y * x)
+    output[output_offset + 1] = -(y * z)
+    output[output_offset + 2] = 0.28867513459481287 * (3 * z * z - 1)
+    output[output_offset + 3] = -(z * x)
+    output[output_offset + 4] = 0.5 * (x * x - y * y)
+}
+
+/**
+ *
+ * @param {number[]} band2 vec5
+ * @param {number[]} M mat3
+ * @return {number[]} vec5
+ */
+export function sh_rotate_band2(band2, M) {
+    const n = Math.SQRT1_2;
+
+    //  Below we precompute (with help of Mathematica):
+    //    constexpr float3 N0{ 1, 0, 0 };
+    //    constexpr float3 N1{ 0, 0, 1 };
+    //    constexpr float3 N2{ n, n, 0 };
+    //    constexpr float3 N3{ n, 0, n };
+    //    constexpr float3 N4{ 0, n, n };
+    //    constexpr float M_SQRT_PI = 1.7724538509f;
+    //    constexpr float M_SQRT_15 = 3.8729833462f;
+    //    constexpr float k = M_SQRT_15 / (2.0f * M_SQRT_PI);
+    //    --> k * inverse(mat5{project(N0), project(N1), project(N2), project(N3), project(N4)})
+    const invATimesK = [
+        0, 1, 2, 0, 0,
+        -1, 0, 0, 0, -2,
+        0, SQRT_3, 0, 0, 0,
+        1, 1, 0, -2, 0,
+        2, 1, 0, 0, 0
+    ];
+
+    // this is: invA * k * band2
+    // 5x5 matrix by vec5 (this a lot of zeroes and constants, which the compiler should eliminate)
+    const invATimesKTimesBand2 = multiply_5d(invATimesK, band2);
+
+    // this is: mat5{project(N0), project(N1), project(N2), project(N3), project(N4)} / k
+    // (the 1/k comes from project(), see above)
+    const ROverK = new Float32Array(25);
+
+    project_v3_to_sh2k(ROverK, 0, M[0], M[1], M[2])                  // M * N0
+    project_v3_to_sh2k(ROverK, 5, M[6], M[7], M[8])                  // M * N1
+    project_v3_to_sh2k(ROverK, 10, n * (M[0] + M[3]), n * (M[1] + M[4]), n * (M[2] + M[5]))     // M * N2
+    project_v3_to_sh2k(ROverK, 15, n * (M[0] + M[6]), n * (M[1] + M[7]), n * (M[2] + M[8]))     // M * N3
+    project_v3_to_sh2k(ROverK, 20, n * (M[3] + M[6]), n * (M[4] + M[7]), n * (M[5] + M[8]))      // M * N4;
+
+    // notice how "k" disappears
+    // this is: (R / k) * (invA * k) * band2 == R * invA * band2
+    const result = multiply_5d(ROverK, invATimesKTimesBand2);
+
+    return result;
+}

package/src/core/geom/3d/sphere/in_sphere3d_robust.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in_sphere3d_robust.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/in_sphere3d_robust.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,2CARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAwClB"}
+{"version":3,"file":"in_sphere3d_robust.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/in_sphere3d_robust.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,2CARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAyClB"}

package/src/core/geom/3d/sphere/in_sphere3d_robust.js

@@ -14,7 +14,8 @@ import { insphere } from "robust-predicates";
  */
 export function in_sphere3d_robust(
     points,
-    a, b, c, d, e
+    a, b, c, d,
+    e
 ) {
 
     const a3 = a * 3;