@performant-software/geospatial 3.1.25-beta.0 → 3.1.25-beta.2

package/dist/index.es367.js

@@ -0,0 +1,92 @@
+import { arrayMatrixSize as h, newArrayMatrix as e, pasteArrayMatrix as a } from "./index.es333.js";
+import { BaseLinearWeightsTransformation as o } from "./index.es363.js";
+import { solveJointlyPseudoInverse as n } from "./index.es366.js";
+class c extends o {
+  coefsArrayMatrices;
+  coefsArrayMatricesSize;
+  weightsArray;
+  weightsArrays;
+  constructor(t, r) {
+    super(t, r, "helmert", 2), this.coefsArrayMatrices = this.getCoefsArrayMatrices(), this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((s) => h(s));
+  }
+  getDestinationPointsArrays() {
+    return [
+      this.destinationPoints.map((t) => t[0]),
+      this.destinationPoints.map((t) => t[1])
+    ];
+  }
+  getCoefsArrayMatrices() {
+    let t = e(this.pointCount, 4, 0), r = e(this.pointCount, 4, 0);
+    for (let s = 0; s < this.pointCount; s++) {
+      const i = this.getSourcePointCoefsArrays(this.sourcePoints[s]);
+      t = a(t, s, 0, [
+        i[0]
+      ]), r = a(r, s, 0, [
+        i[1]
+      ]);
+    }
+    return [t, r];
+  }
+  /**
+   * Get two 1x4 coefsArrays, populating the 2Nx4 coefsArrayMatrices
+   * 1 0 x0 -y0
+   * 1 0 x1 -y1
+   * ...
+   * 0 1 y0 x0
+   * 0 1 y1 x1
+   * ...
+   *
+   * @param sourcePoint
+   */
+  getSourcePointCoefsArrays(t) {
+    return [
+      [1, 0, t[0], -t[1]],
+      [0, 1, t[1], t[0]]
+    ];
+  }
+  solve() {
+    this.weightsArray = n(this.coefsArrayMatrices, this.destinationPointsArrays), this.weightsArrays = [this.weightsArray, this.weightsArray];
+  }
+  getMeasures() {
+    if (this.weightsArrays || this.solve(), !this.weightsArray)
+      throw new Error("Helmert weights not computed");
+    const t = {};
+    return t.scale = Math.sqrt(this.weightsArray[2] ** 2 + this.weightsArray[3] ** 2), t.rotation = Math.atan2(this.weightsArray[3], this.weightsArray[2]), t.translation = [this.weightsArray[0], this.weightsArray[1]], t;
+  }
+  evaluateFunction(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArray)
+      throw new Error("Helmert weights not computed");
+    return [
+      this.weightsArray[0] + this.weightsArray[2] * t[0] - this.weightsArray[3] * t[1],
+      this.weightsArray[1] + this.weightsArray[2] * t[1] + this.weightsArray[3] * t[0]
+    ];
+  }
+  evaluatePartialDerivativeX(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArray)
+      throw new Error("Helmert weights not computed");
+    return [
+      this.weightsArray[2],
+      this.weightsArray[3]
+    ];
+  }
+  evaluatePartialDerivativeY(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArray)
+      throw new Error("Helmert weights not computed");
+    return [
+      -this.weightsArray[3],
+      this.weightsArray[2]
+    ];
+  }
+  getTransformationDataAsFloat64Array() {
+    if (this.weightsArray || this.solve(), !this.weightsArray)
+      throw new Error("Helmert weights not computed");
+    return {
+      weights: new Float64Array(this.weightsArray),
+      sourcePoints: new Float64Array(0)
+    };
+  }
+}
+export {
+  c as Helmert
+};
+//# sourceMappingURL=index.es367.js.map

package/dist/index.es367.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es367.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Helmert.js"],"sourcesContent":["import { newArrayMatrix, pasteArrayMatrix, arrayMatrixSize } from '@allmaps/stdlib';\nimport { BaseLinearWeightsTransformation } from './BaseLinearWeightsTransformation.js';\nimport { solveJointlyPseudoInverse } from '../shared/solve-functions.js';\n/**\n * 2D Helmert transformation (= similarity transformation)\n *\n * This transformation is a composition of a translation, rotation and scaling. There is no shearing.\n *\n * For this transformations, the system of equations is solved for x and y jointly.\n */\nexport class Helmert extends BaseLinearWeightsTransformation {\n    coefsArrayMatrices;\n    coefsArrayMatricesSize;\n    weightsArray;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'helmert', 2);\n        this.coefsArrayMatrices = this.getCoefsArrayMatrices();\n        this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((coefsArrayMatrix) => arrayMatrixSize(coefsArrayMatrix));\n    }\n    getDestinationPointsArrays() {\n        return [\n            this.destinationPoints.map((value) => value[0]),\n            this.destinationPoints.map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrices() {\n        let coefsArrayMatrix0 = newArrayMatrix(this.pointCount, 4, 0);\n        let coefsArrayMatrix1 = newArrayMatrix(this.pointCount, 4, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            const sourcePointCoefsArrays = this.getSourcePointCoefsArrays(this.sourcePoints[i]);\n            coefsArrayMatrix0 = pasteArrayMatrix(coefsArrayMatrix0, i, 0, [\n                sourcePointCoefsArrays[0]\n            ]);\n            coefsArrayMatrix1 = pasteArrayMatrix(coefsArrayMatrix1, i, 0, [\n                sourcePointCoefsArrays[1]\n            ]);\n        }\n        return [coefsArrayMatrix0, coefsArrayMatrix1];\n    }\n    /**\n     * Get two 1x4 coefsArrays, populating the 2Nx4 coefsArrayMatrices\n     * 1 0 x0 -y0\n     * 1 0 x1 -y1\n     * ...\n     * 0 1 y0 x0\n     * 0 1 y1 x1\n     * ...\n     *\n     * @param sourcePoint\n     */\n    getSourcePointCoefsArrays(sourcePoint) {\n        return [\n            [1, 0, sourcePoint[0], -sourcePoint[1]],\n            [0, 1, sourcePoint[1], sourcePoint[0]]\n        ];\n    }\n    solve() {\n        this.weightsArray = solveJointlyPseudoInverse(this.coefsArrayMatrices, this.destinationPointsArrays);\n        this.weightsArrays = [this.weightsArray, this.weightsArray];\n    }\n    getMeasures() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const measures = {};\n        measures.scale = Math.sqrt(this.weightsArray[2] ** 2 + this.weightsArray[3] ** 2);\n        measures.rotation = Math.atan2(this.weightsArray[3], this.weightsArray[2]);\n        measures.translation = [this.weightsArray[0], this.weightsArray[1]];\n        return measures;\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPoint = [\n            this.weightsArray[0] +\n                this.weightsArray[2] * newSourcePoint[0] -\n                this.weightsArray[3] * newSourcePoint[1],\n            this.weightsArray[1] +\n                this.weightsArray[2] * newSourcePoint[1] +\n                this.weightsArray[3] * newSourcePoint[0]\n        ];\n        // Alternatively, using derived helmert measures\n        // this.translation[0] +\n        //   this.scale * Math.cos(rotation) * newSourcePoint[0] -\n        //   this.scale * Math.sin(rotation) * newSourcePoint[1],\n        // this.translation[1] +\n        //   this.scale * Math.cos(rotation) * newSourcePoint[1] +\n        //   this.scale * Math.sin(rotation) * newSourcePoint[0]\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPointPartDerX = [\n            this.weightsArray[2],\n            this.weightsArray[3]\n        ];\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPointPartDerY = [\n            -this.weightsArray[3],\n            this.weightsArray[2]\n        ];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArray) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        // Helmert: [w0, w1, w2, w3]\n        return {\n            weights: new Float64Array(this.weightsArray),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Helmert","BaseLinearWeightsTransformation","sourcePoints","destinationPoints","coefsArrayMatrix","arrayMatrixSize","value","coefsArrayMatrix0","newArrayMatrix","coefsArrayMatrix1","i","sourcePointCoefsArrays","pasteArrayMatrix","sourcePoint","solveJointlyPseudoInverse","measures","newSourcePoint","_newSourcePoint"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es368.js

@@ -0,0 +1,89 @@
+import { BasePolynomialTransformation as n } from "./index.es365.js";
+class o extends n {
+  constructor(t, r) {
+    super(t, r, 1);
+  }
+  getSourcePointCoefsArray(t) {
+    return o.getPolynomial1SourcePointCoefsArray(t);
+  }
+  /**
+   * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix
+   * 1 x0 y0
+   * 1 x1 y1
+   * 1 x2 y2
+   * ...
+   *
+   * @param sourcePoint
+   */
+  static getPolynomial1SourcePointCoefsArray(t) {
+    return [1, t[0], t[1]];
+  }
+  getHomogeneousTransform() {
+    if (this.weightsArrays)
+      return [
+        this.weightsArrays[0][1],
+        this.weightsArrays[1][1],
+        this.weightsArrays[0][2],
+        this.weightsArrays[1][2],
+        this.weightsArrays[0][0],
+        this.weightsArrays[1][0]
+      ];
+  }
+  setWeightsArraysFromHomogeneousTransform(t) {
+    this.weightsArrays = [
+      [
+        t[4],
+        t[0],
+        t[2]
+      ],
+      [
+        t[5],
+        t[1],
+        t[3]
+      ]
+    ];
+  }
+  getMeasures() {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const t = {};
+    t.translation = [this.weightsArrays[0][0], this.weightsArrays[1][0]];
+    const r = this.weightsArrays[0][1], s = this.weightsArrays[1][1], e = this.weightsArrays[0][2], a = this.weightsArrays[1][2], h = r * a - s * e;
+    if (r != 0 || s != 0) {
+      const i = Math.sqrt(r * r + s * s);
+      t.rotation = s > 0 ? Math.acos(r / i) : -Math.acos(r / i), t.scales = [i, h / i], t.shears = [Math.atan((r * e + s * a) / (i * i)), 0];
+    } else if (e != 0 || a != 0) {
+      const i = Math.sqrt(e * e + a * a);
+      t.rotation = Math.PI / 2 - (a > 0 ? Math.acos(-e / i) : -Math.acos(e / i)), t.scales = [h / i, i], t.shears = [0, Math.atan((r * e + s * a) / (i * i))];
+    }
+    return t;
+  }
+  evaluateFunction(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let s = 0; s < 2; s++)
+      r[s] += this.weightsArrays[s][0] + this.weightsArrays[s][1] * t[0] + this.weightsArrays[s][2] * t[1];
+    return r;
+  }
+  evaluatePartialDerivativeX(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let s = 0; s < 2; s++)
+      r[s] += this.weightsArrays[s][1];
+    return r;
+  }
+  evaluatePartialDerivativeY(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let s = 0; s < 2; s++)
+      r[s] += this.weightsArrays[s][2];
+    return r;
+  }
+}
+export {
+  o as Polynomial1
+};
+//# sourceMappingURL=index.es368.js.map

package/dist/index.es368.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es368.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial1.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D First-order Polynomial transformation\n *\n * This transformation is a composition of a translation, rotation, scaling and shearing.\n */\nexport class Polynomial1 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 1);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial1.getPolynomial1SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0\n     * 1 x1 y1\n     * 1 x2 y2\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial1SourcePointCoefsArray(sourcePoint) {\n        return [1, sourcePoint[0], sourcePoint[1]];\n    }\n    getHomogeneousTransform() {\n        if (!this.weightsArrays) {\n            return undefined;\n        }\n        return [\n            this.weightsArrays[0][1],\n            this.weightsArrays[1][1],\n            this.weightsArrays[0][2],\n            this.weightsArrays[1][2],\n            this.weightsArrays[0][0],\n            this.weightsArrays[1][0]\n        ];\n    }\n    setWeightsArraysFromHomogeneousTransform(homogeneousTransform) {\n        this.weightsArrays = [\n            [\n                homogeneousTransform[4],\n                homogeneousTransform[0],\n                homogeneousTransform[2]\n            ],\n            [\n                homogeneousTransform[5],\n                homogeneousTransform[1],\n                homogeneousTransform[3]\n            ]\n        ];\n    }\n    getMeasures() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const measures = {};\n        // From: https://stackoverflow.com/questions/12469770/get-skew-or-rotation-value-from-affine-transformation-matrix\n        measures.translation = [this.weightsArrays[0][0], this.weightsArrays[1][0]];\n        const a = this.weightsArrays[0][1];\n        const b = this.weightsArrays[1][1];\n        const c = this.weightsArrays[0][2];\n        const d = this.weightsArrays[1][2];\n        const delta = a * d - b * c;\n        // Apply the QR-like decomposition.\n        if (a != 0 || b != 0) {\n            const r = Math.sqrt(a * a + b * b);\n            measures.rotation = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);\n            measures.scales = [r, delta / r];\n            measures.shears = [Math.atan((a * c + b * d) / (r * r)), 0];\n        }\n        else if (c != 0 || d != 0) {\n            const s = Math.sqrt(c * c + d * d);\n            measures.rotation =\n                Math.PI / 2 - (d > 0 ? Math.acos(-c / s) : -Math.acos(c / s));\n            measures.scales = [delta / s, s];\n            measures.shears = [0, Math.atan((a * c + b * d) / (s * s))];\n        }\n        else {\n            // a = b = c = d = 0\n        }\n        return measures;\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1];\n        }\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] += this.weightsArrays[i][1];\n        }\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] += this.weightsArrays[i][2];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial1","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","homogeneousTransform","measures","a","b","c","d","delta","r","s","newSourcePoint","newDestinationPoint","i","_newSourcePoint","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es369.js

@@ -0,0 +1,57 @@
+import { BasePolynomialTransformation as e } from "./index.es365.js";
+class i extends e {
+  constructor(t, r) {
+    super(t, r, 2);
+  }
+  getSourcePointCoefsArray(t) {
+    return i.getPolynomial2SourcePointCoefsArray(t);
+  }
+  /**
+   * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix
+   * 1 x0 y0 x0^2 y0^2 x0*y0
+   * ...
+   *
+   * @param sourcePoint
+   */
+  static getPolynomial2SourcePointCoefsArray(t) {
+    return [
+      1,
+      t[0],
+      t[1],
+      t[0] ** 2,
+      t[1] ** 2,
+      t[0] * t[1]
+    ];
+  }
+  // Evaluate the transformation function at a new point
+  evaluateFunction(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let s = 0; s < 2; s++)
+      r[s] += this.weightsArrays[s][0] + this.weightsArrays[s][1] * t[0] + this.weightsArrays[s][2] * t[1] + this.weightsArrays[s][3] * t[0] ** 2 + this.weightsArrays[s][4] * t[1] ** 2 + this.weightsArrays[s][5] * t[0] * t[1];
+    return r;
+  }
+  // Evaluate the transformation function's partial derivative to x at a new point
+  evaluatePartialDerivativeX(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let s = 0; s < 2; s++)
+      r[s] += this.weightsArrays[s][1] + 2 * this.weightsArrays[s][3] * t[0] + this.weightsArrays[s][5] * t[1];
+    return r;
+  }
+  // Evaluate the transformation function's partial derivative to x at a new point
+  evaluatePartialDerivativeY(t) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let s = 0; s < 2; s++)
+      r[s] += this.weightsArrays[s][2] + 2 * this.weightsArrays[s][4] * t[1] + this.weightsArrays[s][5] * t[0];
+    return r;
+  }
+}
+export {
+  i as Polynomial2
+};
+//# sourceMappingURL=index.es369.js.map

package/dist/index.es369.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es369.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial2.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D Second-order Polynomial transformation\n */\nexport class Polynomial2 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 2);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial2.getPolynomial2SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0 x0^2 y0^2 x0*y0\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial2SourcePointCoefsArray(sourcePoint) {\n        return [\n            1,\n            sourcePoint[0],\n            sourcePoint[1],\n            sourcePoint[0] ** 2,\n            sourcePoint[1] ** 2,\n            sourcePoint[0] * sourcePoint[1]\n        ];\n    }\n    // Evaluate the transformation function at a new point\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Apply the helmert coefficients to the input point\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1] +\n                    this.weightsArrays[i][3] * newSourcePoint[0] ** 2 +\n                    this.weightsArrays[i][4] * newSourcePoint[1] ** 2 +\n                    this.weightsArrays[i][5] * newSourcePoint[0] * newSourcePoint[1];\n        }\n        return newDestinationPoint;\n    }\n    // Evaluate the transformation function's partial derivative to x at a new point\n    evaluatePartialDerivativeX(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] +=\n                this.weightsArrays[i][1] +\n                    2 * this.weightsArrays[i][3] * newSourcePoint[0] +\n                    this.weightsArrays[i][5] * newSourcePoint[1];\n        }\n        return newDestinationPointPartDerX;\n    }\n    // Evaluate the transformation function's partial derivative to x at a new point\n    evaluatePartialDerivativeY(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] +=\n                this.weightsArrays[i][2] +\n                    2 * this.weightsArrays[i][4] * newSourcePoint[1] +\n                    this.weightsArrays[i][5] * newSourcePoint[0];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial2","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","newSourcePoint","newDestinationPoint","i","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":";AAIO,MAAMA,UAAoBC,EAA6B;AAAA,EAC1D,YAAYC,GAAcC,GAAmB;AACzC,UAAMD,GAAcC,GAAmB,CAAC;AAAA,EAC5C;AAAA,EACA,yBAAyBC,GAAa;AAClC,WAAOJ,EAAY,oCAAoCI,CAAW;AAAA,EACtE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,oCAAoCA,GAAa;AACpD,WAAO;AAAA,MACH;AAAA,MACAA,EAAY,CAAC;AAAA,MACbA,EAAY,CAAC;AAAA,MACbA,EAAY,CAAC,KAAK;AAAA,MAClBA,EAAY,CAAC,KAAK;AAAA,MAClBA,EAAY,CAAC,IAAIA,EAAY,CAAC;AAAA,IAAA;AAAA,EAEtC;AAAA;AAAA,EAEA,iBAAiBC,GAAgB;AAI7B,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAG1C,UAAMC,IAAsB,CAAC,GAAG,CAAC;AACjC,aAASC,IAAI,GAAGA,IAAI,GAAGA;AACnB,MAAAD,EAAoBC,CAAC,KACjB,KAAK,cAAcA,CAAC,EAAE,CAAC,IACnB,KAAK,cAAcA,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,IAC3C,KAAK,cAAcE,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,IAC3C,KAAK,cAAcE,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,KAAK,IAChD,KAAK,cAAcE,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,KAAK,IAChD,KAAK,cAAcE,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,IAAIA,EAAe,CAAC;AAE3E,WAAOC;AAAA,EACX;AAAA;AAAA,EAEA,2BAA2BD,GAAgB;AAIvC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAG1C,UAAMG,IAA8B,CAAC,GAAG,CAAC;AACzC,aAASD,IAAI,GAAGA,IAAI,GAAGA;AACnB,MAAAC,EAA4BD,CAAC,KACzB,KAAK,cAAcA,CAAC,EAAE,CAAC,IACnB,IAAI,KAAK,cAAcA,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,IAC/C,KAAK,cAAcE,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC;AAEvD,WAAOG;AAAA,EACX;AAAA;AAAA,EAEA,2BAA2BH,GAAgB;AAIvC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,sBAAsB;AAG1C,UAAMI,IAA8B,CAAC,GAAG,CAAC;AACzC,aAASF,IAAI,GAAGA,IAAI,GAAGA;AACnB,MAAAE,EAA4BF,CAAC,KACzB,KAAK,cAAcA,CAAC,EAAE,CAAC,IACnB,IAAI,KAAK,cAAcA,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC,IAC/C,KAAK,cAAcE,CAAC,EAAE,CAAC,IAAIF,EAAe,CAAC;AAEvD,WAAOI;AAAA,EACX;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es370.js

@@ -0,0 +1,61 @@
+import { BasePolynomialTransformation as i } from "./index.es365.js";
+class h extends i {
+  constructor(s, r) {
+    super(s, r, 3);
+  }
+  getSourcePointCoefsArray(s) {
+    return h.getPolynomial3SourcePointCoefsArray(s);
+  }
+  /**
+   * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix
+   * 1 x0 y0 x0^2 y0^2 x0*y0 x0^3 y0^3 x0^2*y0 x0*y0^2
+   * ...
+   *
+   * @param sourcePoint
+   */
+  static getPolynomial3SourcePointCoefsArray(s) {
+    return [
+      1,
+      s[0],
+      s[1],
+      s[0] ** 2,
+      s[1] ** 2,
+      s[0] * s[1],
+      s[0] ** 3,
+      s[1] ** 3,
+      s[0] ** 2 * s[1],
+      s[0] * s[1] ** 2
+    ];
+  }
+  // Evaluate the transformation function at a new point
+  evaluateFunction(s) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let t = 0; t < 2; t++)
+      r[t] += this.weightsArrays[t][0] + this.weightsArrays[t][1] * s[0] + this.weightsArrays[t][2] * s[1] + this.weightsArrays[t][3] * s[0] ** 2 + this.weightsArrays[t][4] * s[1] ** 2 + this.weightsArrays[t][5] * s[0] * s[1] + this.weightsArrays[t][6] * s[0] ** 3 + this.weightsArrays[t][7] * s[1] ** 3 + this.weightsArrays[t][8] * s[0] ** 2 * s[1] + this.weightsArrays[t][9] * s[0] * s[1] ** 2;
+    return r;
+  }
+  // Evaluate the transformation function's partial derivative to x at a new point
+  evaluatePartialDerivativeX(s) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let t = 0; t < 2; t++)
+      r[t] += this.weightsArrays[t][1] + 2 * this.weightsArrays[t][3] * s[0] + this.weightsArrays[t][5] * s[1] + 3 * this.weightsArrays[t][6] * s[0] ** 2 + 2 * this.weightsArrays[t][8] * s[0] * s[1] + this.weightsArrays[t][9] * s[1] ** 2;
+    return r;
+  }
+  // Evaluate the transformation function's partial derivative to x at a new point
+  evaluatePartialDerivativeY(s) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const r = [0, 0];
+    for (let t = 0; t < 2; t++)
+      r[t] += this.weightsArrays[t][2] + 2 * this.weightsArrays[t][4] * s[1] + this.weightsArrays[t][5] * s[0] + 3 * this.weightsArrays[t][7] * s[1] ** 2 + this.weightsArrays[t][8] * s[0] ** 2 + 2 * this.weightsArrays[t][9] * s[0] * s[1];
+    return r;
+  }
+}
+export {
+  h as Polynomial3
+};
+//# sourceMappingURL=index.es370.js.map

package/dist/index.es370.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es370.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial3.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D Third-order Polynomial transformation\n */\nexport class Polynomial3 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 3);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial3.getPolynomial3SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0 x0^2 y0^2 x0*y0 x0^3 y0^3 x0^2*y0 x0*y0^2\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial3SourcePointCoefsArray(sourcePoint) {\n        return [\n            1,\n            sourcePoint[0],\n            sourcePoint[1],\n            sourcePoint[0] ** 2,\n            sourcePoint[1] ** 2,\n            sourcePoint[0] * sourcePoint[1],\n            sourcePoint[0] ** 3,\n            sourcePoint[1] ** 3,\n            sourcePoint[0] ** 2 * sourcePoint[1],\n            sourcePoint[0] * sourcePoint[1] ** 2\n        ];\n    }\n    // Evaluate the transformation function at a new point\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Apply the helmert coefficients to the input point\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1] +\n                    this.weightsArrays[i][3] * newSourcePoint[0] ** 2 +\n                    this.weightsArrays[i][4] * newSourcePoint[1] ** 2 +\n                    this.weightsArrays[i][5] * newSourcePoint[0] * newSourcePoint[1] +\n                    this.weightsArrays[i][6] * newSourcePoint[0] ** 3 +\n                    this.weightsArrays[i][7] * newSourcePoint[1] ** 3 +\n                    this.weightsArrays[i][8] * newSourcePoint[0] ** 2 * newSourcePoint[1] +\n                    this.weightsArrays[i][9] * newSourcePoint[0] * newSourcePoint[1] ** 2;\n        }\n        return newDestinationPoint;\n    }\n    // Evaluate the transformation function's partial derivative to x at a new point\n    evaluatePartialDerivativeX(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] +=\n                this.weightsArrays[i][1] +\n                    2 * this.weightsArrays[i][3] * newSourcePoint[0] +\n                    this.weightsArrays[i][5] * newSourcePoint[1] +\n                    3 * this.weightsArrays[i][6] * newSourcePoint[0] ** 2 +\n                    2 * this.weightsArrays[i][8] * newSourcePoint[0] * newSourcePoint[1] +\n                    this.weightsArrays[i][9] * newSourcePoint[1] ** 2;\n        }\n        return newDestinationPointPartDerX;\n    }\n    // Evaluate the transformation function's partial derivative to x at a new point\n    evaluatePartialDerivativeY(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Apply the helmert coefficients to the input point\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] +=\n                this.weightsArrays[i][2] +\n                    2 * this.weightsArrays[i][4] * newSourcePoint[1] +\n                    this.weightsArrays[i][5] * newSourcePoint[0] +\n                    3 * this.weightsArrays[i][7] * newSourcePoint[1] ** 2 +\n                    this.weightsArrays[i][8] * newSourcePoint[0] ** 2 +\n                    2 * this.weightsArrays[i][9] * newSourcePoint[0] * newSourcePoint[1];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial3","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","newSourcePoint","newDestinationPoint","i","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es371.js

@@ -0,0 +1,58 @@
+import { newArrayMatrix as a } from "./index.es333.js";
+import { BaseTransformation as e } from "./index.es364.js";
+import { solveJointlySvd as y } from "./index.es366.js";
+class o extends e {
+  coefsArrayMatrices;
+  weightsArrays;
+  constructor(r, t) {
+    super(r, t, "projective", 4), this.coefsArrayMatrices = [
+      a(this.pointCount, 9, 0),
+      a(this.pointCount, 9, 0)
+    ];
+    for (let s = 0; s < this.pointCount; s++)
+      this.coefsArrayMatrices[0][s][0] = -r[s][0], this.coefsArrayMatrices[0][s][1] = -r[s][1], this.coefsArrayMatrices[0][s][2] = -1, this.coefsArrayMatrices[0][s][3] = 0, this.coefsArrayMatrices[0][s][4] = 0, this.coefsArrayMatrices[0][s][5] = 0, this.coefsArrayMatrices[0][s][6] = t[s][0] * r[s][0], this.coefsArrayMatrices[0][s][7] = t[s][0] * r[s][1], this.coefsArrayMatrices[0][s][8] = t[s][0], this.coefsArrayMatrices[1][s][0] = 0, this.coefsArrayMatrices[1][s][1] = 0, this.coefsArrayMatrices[1][s][2] = 0, this.coefsArrayMatrices[1][s][3] = -r[s][0], this.coefsArrayMatrices[1][s][4] = -r[s][1], this.coefsArrayMatrices[1][s][5] = -1, this.coefsArrayMatrices[1][s][6] = t[s][1] * r[s][0], this.coefsArrayMatrices[1][s][7] = t[s][1] * r[s][1], this.coefsArrayMatrices[1][s][8] = t[s][1];
+  }
+  solve() {
+    this.weightsArrays = y(this.coefsArrayMatrices, this.pointCount);
+  }
+  evaluateFunction(r) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const t = this.weightsArrays[0][2] * r[0] + this.weightsArrays[1][2] * r[1] + this.weightsArrays[2][2], s = this.weightsArrays[0][0] * r[0] + this.weightsArrays[1][0] * r[1] + this.weightsArrays[2][0], i = this.weightsArrays[0][1] * r[0] + this.weightsArrays[1][1] * r[1] + this.weightsArrays[2][1];
+    return [s / t, i / t];
+  }
+  evaluatePartialDerivativeX(r) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const t = this.weightsArrays[0][2] * r[0] + this.weightsArrays[1][2] * r[1] + this.weightsArrays[2][2], s = this.weightsArrays[0][0] * r[0] + this.weightsArrays[1][0] * r[1] + this.weightsArrays[2][0], i = this.weightsArrays[0][1] * r[0] + this.weightsArrays[1][1] * r[1] + this.weightsArrays[2][1];
+    return [
+      (t * this.weightsArrays[0][0] - this.weightsArrays[0][2] * s) / t ** 2,
+      (t * this.weightsArrays[0][1] - this.weightsArrays[0][2] * i) / t ** 2
+    ];
+  }
+  evaluatePartialDerivativeY(r) {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Weights not computed");
+    const t = this.weightsArrays[0][2] * r[0] + this.weightsArrays[1][2] * r[1] + this.weightsArrays[2][2], s = this.weightsArrays[0][0] * r[0] + this.weightsArrays[1][0] * r[1] + this.weightsArrays[2][0], i = this.weightsArrays[0][1] * r[0] + this.weightsArrays[1][1] * r[1] + this.weightsArrays[2][1];
+    return [
+      (t * this.weightsArrays[1][0] - this.weightsArrays[1][2] * s) / t ** 2,
+      (t * this.weightsArrays[1][1] - this.weightsArrays[1][2] * i) / t ** 2
+    ];
+  }
+  getTransformationDataAsFloat64Array() {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Projective transformation weights not computed");
+    const r = [];
+    for (let t = 0; t < 3; t++)
+      for (let s = 0; s < 3; s++)
+        r.push(this.weightsArrays[t][s]);
+    return {
+      weights: new Float64Array(r),
+      sourcePoints: new Float64Array(0)
+    };
+  }
+}
+export {
+  o as Projective
+};
+//# sourceMappingURL=index.es371.js.map

package/dist/index.es371.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es371.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Projective.js"],"sourcesContent":["import { newArrayMatrix } from '@allmaps/stdlib';\nimport { BaseTransformation } from './BaseTransformation.js';\nimport { solveJointlySvd } from '../shared/solve-functions.js';\n/**\n * 2D projective (= perspective) transformation\n *\n * For this transformations, the system of equations is solved for x and y jointly.\n *\n * See for more information:\n * Dubrofsky, Elan. \"Homography estimation.\" Diplomová práce. Vancouver: Univerzita Britské Kolumbie 5 (2009).\n * https://citeseerx.ist.psu.edu/doc/10.1.1.186.4411\n * https://www.cs.ubc.ca/sites/default/files/2022-12/Dubrofsky_Elan.pdf\n */\nexport class Projective extends BaseTransformation {\n    coefsArrayMatrices;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'projective', 4);\n        // Construct two Nx9 Matrix projectiveCoefsMatrix\n        // −x0 −y0 −1  0   0   0  x'0x0 x'0y0 x'0\n        // ...\n        // 0   0   0   −x0 −y0 −1 y'0x0 y'0y0 y'0\n        // ...\n        this.coefsArrayMatrices = [\n            newArrayMatrix(this.pointCount, 9, 0),\n            newArrayMatrix(this.pointCount, 9, 0)\n        ];\n        for (let i = 0; i < this.pointCount; i++) {\n            this.coefsArrayMatrices[0][i][0] = -sourcePoints[i][0];\n            this.coefsArrayMatrices[0][i][1] = -sourcePoints[i][1];\n            this.coefsArrayMatrices[0][i][2] = -1;\n            this.coefsArrayMatrices[0][i][3] = 0;\n            this.coefsArrayMatrices[0][i][4] = 0;\n            this.coefsArrayMatrices[0][i][5] = 0;\n            this.coefsArrayMatrices[0][i][6] =\n                destinationPoints[i][0] * sourcePoints[i][0];\n            this.coefsArrayMatrices[0][i][7] =\n                destinationPoints[i][0] * sourcePoints[i][1];\n            this.coefsArrayMatrices[0][i][8] = destinationPoints[i][0];\n            this.coefsArrayMatrices[1][i][0] = 0;\n            this.coefsArrayMatrices[1][i][1] = 0;\n            this.coefsArrayMatrices[1][i][2] = 0;\n            this.coefsArrayMatrices[1][i][3] = -sourcePoints[i][0];\n            this.coefsArrayMatrices[1][i][4] = -sourcePoints[i][1];\n            this.coefsArrayMatrices[1][i][5] = -1;\n            this.coefsArrayMatrices[1][i][6] =\n                destinationPoints[i][1] * sourcePoints[i][0];\n            this.coefsArrayMatrices[1][i][7] =\n                destinationPoints[i][1] * sourcePoints[i][1];\n            this.coefsArrayMatrices[1][i][8] = destinationPoints[i][1];\n        }\n    }\n    solve() {\n        this.weightsArrays = solveJointlySvd(this.coefsArrayMatrices, this.pointCount);\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const c = this.weightsArrays[0][2] * newSourcePoint[0] +\n            this.weightsArrays[1][2] * newSourcePoint[1] +\n            this.weightsArrays[2][2];\n        const num1 = this.weightsArrays[0][0] * newSourcePoint[0] +\n            this.weightsArrays[1][0] * newSourcePoint[1] +\n            this.weightsArrays[2][0];\n        const num2 = this.weightsArrays[0][1] * newSourcePoint[0] +\n            this.weightsArrays[1][1] * newSourcePoint[1] +\n            this.weightsArrays[2][1];\n        const newDestinationPoint = [num1 / c, num2 / c];\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const c = this.weightsArrays[0][2] * newSourcePoint[0] +\n            this.weightsArrays[1][2] * newSourcePoint[1] +\n            this.weightsArrays[2][2];\n        const num1 = this.weightsArrays[0][0] * newSourcePoint[0] +\n            this.weightsArrays[1][0] * newSourcePoint[1] +\n            this.weightsArrays[2][0];\n        const num2 = this.weightsArrays[0][1] * newSourcePoint[0] +\n            this.weightsArrays[1][1] * newSourcePoint[1] +\n            this.weightsArrays[2][1];\n        const newDestinationPointPartDerX = [\n            (c * this.weightsArrays[0][0] - this.weightsArrays[0][2] * num1) / c ** 2,\n            (c * this.weightsArrays[0][1] - this.weightsArrays[0][2] * num2) / c ** 2\n        ];\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const c = this.weightsArrays[0][2] * newSourcePoint[0] +\n            this.weightsArrays[1][2] * newSourcePoint[1] +\n            this.weightsArrays[2][2];\n        const num1 = this.weightsArrays[0][0] * newSourcePoint[0] +\n            this.weightsArrays[1][0] * newSourcePoint[1] +\n            this.weightsArrays[2][0];\n        const num2 = this.weightsArrays[0][1] * newSourcePoint[0] +\n            this.weightsArrays[1][1] * newSourcePoint[1] +\n            this.weightsArrays[2][1];\n        const newDestinationPointPartDerY = [\n            (c * this.weightsArrays[1][0] - this.weightsArrays[1][2] * num1) / c ** 2,\n            (c * this.weightsArrays[1][1] - this.weightsArrays[1][2] * num2) / c ** 2\n        ];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Projective transformation weights not computed');\n        }\n        // Projective: 3x3 matrix flattened column-major\n        const flatWeights = [];\n        for (let col = 0; col < 3; col++) {\n            for (let row = 0; row < 3; row++) {\n                flatWeights.push(this.weightsArrays[col][row]);\n            }\n        }\n        return {\n            weights: new Float64Array(flatWeights),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Projective","BaseTransformation","sourcePoints","destinationPoints","newArrayMatrix","i","solveJointlySvd","newSourcePoint","c","num1","num2","flatWeights","col","row"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es372.js

@@ -0,0 +1,147 @@
+import { arrayMatrixSize as c, newArrayMatrix as f, pasteArrayMatrix as u, newBlockArrayMatrix as A, transposeArrayMatrix as l } from "./index.es333.js";
+import { Polynomial1 as y } from "./index.es368.js";
+import { BaseIndependentLinearWeightsTransformation as p } from "./index.es362.js";
+import { solveIndependentlyInverse as g } from "./index.es366.js";
+class C extends p {
+  kernelFunction;
+  normFunction;
+  epsilon;
+  coefsArrayMatrices;
+  coefsArrayMatrix;
+  coefsArrayMatricesSize;
+  coefsArrayMatrixSize;
+  weightsArrays;
+  rbfWeightsArrays;
+  affineWeightsArrays;
+  constructor(s, r, e, i, n, t) {
+    super(s, r, n, 3), this.kernelFunction = e, this.normFunction = i, this.epsilon = t, this.coefsArrayMatrices = this.getCoefsArrayMatrices(), this.coefsArrayMatrix = this.coefsArrayMatrices[0], this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((o) => c(o)), this.coefsArrayMatrixSize = c(this.coefsArrayMatrix);
+  }
+  getDestinationPointsArrays() {
+    return [
+      [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((s) => s[0]),
+      [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((s) => s[1])
+    ];
+  }
+  getCoefsArrayMatrix() {
+    const s = f(this.pointCount, this.pointCount, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      for (let o = 0; o < this.pointCount; o++)
+        s[t][o] = this.normFunction(this.sourcePoints[t], this.sourcePoints[o]);
+    if (this.epsilon === void 0) {
+      const t = s.map((o) => o.reduce((a, h) => a + h, 0)).reduce((o, a) => o + a, 0);
+      this.epsilon = t / (Math.pow(this.pointCount, 2) - this.pointCount);
+    }
+    const r = f(this.pointCount, this.pointCount, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      for (let o = 0; o < this.pointCount; o++)
+        r[t][o] = this.kernelFunction(s[t][o], {
+          epsilon: this.epsilon
+        });
+    let e = f(this.pointCount, 3, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      e = u(e, t, 0, [
+        y.getPolynomial1SourcePointCoefsArray(this.sourcePoints[t])
+      ]);
+    const i = f(3, 3, 0);
+    return A([
+      [r, e],
+      [l(e), i]
+    ]);
+  }
+  /**
+   * Get 1x(N+3) coefsArray, populating the (N+3)x(N+3) coefsArrayMatrix
+   *
+   * The coefsArray has a 1xN kernel part and a 1x3 affine part.
+   *
+   * @param sourcePoint
+   */
+  getSourcePointCoefsArray(s) {
+    return [
+      ...this.getRbfKernelSourcePointCoefsArray(s),
+      ...y.getPolynomial1SourcePointCoefsArray(s)
+    ];
+  }
+  getRbfKernelSourcePointCoefsArray(s) {
+    const r = [];
+    for (let e = 0; e < this.pointCount; e++)
+      r.push(this.kernelFunction(this.normFunction(this.sourcePoints[e], s), {
+        epsilon: this.epsilon
+      }));
+    return r;
+  }
+  setWeightsArrays(s, r) {
+    r && (this.epsilon = r), super.setWeightsArrays(s);
+  }
+  /**
+   * Solve the x and y components independently.
+   *
+   * This uses the exact inverse to compute (for each component, using the same coefs for both)
+   * the exact solution for the system of linear equations
+   * which is (in general) invertable to an exact solution.
+   *
+   * This wil result in a weights array for each component with rbf weights and affine weights.
+   */
+  solve() {
+    this.weightsArrays = g(this.coefsArrayMatrix, this.destinationPointsArrays), this.processWeightsArrays();
+  }
+  processWeightsArrays() {
+    if (!this.weightsArrays)
+      throw new Error("Weights not computed");
+    this.rbfWeightsArrays = this.weightsArrays.map((s) => s.slice(0, this.pointCount)), this.affineWeightsArrays = this.weightsArrays.map((s) => s.slice(this.pointCount));
+  }
+  evaluateFunction(s) {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("RBF weights not computed");
+    const r = this.rbfWeightsArrays, e = this.affineWeightsArrays, i = this.sourcePoints.map((t) => this.normFunction(s, t)), n = [0, 0];
+    for (let t = 0; t < 2; t++)
+      n[t] = i.reduce((o, a, h) => o + this.kernelFunction(a, { epsilon: this.epsilon }) * r[t][h], 0), n[t] += e[t][0] + e[t][1] * s[0] + e[t][2] * s[1];
+    return n;
+  }
+  evaluatePartialDerivativeX(s) {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("RBF weights not computed");
+    const r = this.rbfWeightsArrays, e = this.affineWeightsArrays, i = this.sourcePoints.map((t) => this.normFunction(s, t)), n = [0, 0];
+    for (let t = 0; t < 2; t++)
+      n[t] = i.reduce((o, a, h) => o + (a === 0 ? 0 : this.kernelFunction(a, {
+        derivative: 1,
+        epsilon: this.epsilon
+      }) * ((s[0] - this.sourcePoints[h][0]) / a) * r[t][h]), 0), n[t] += e[t][1];
+    return n;
+  }
+  evaluatePartialDerivativeY(s) {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("RBF weights not computed");
+    const r = this.rbfWeightsArrays, e = this.affineWeightsArrays, i = this.sourcePoints.map((t) => this.normFunction(s, t)), n = [0, 0];
+    for (let t = 0; t < 2; t++)
+      n[t] = i.reduce((o, a, h) => o + (a === 0 ? 0 : this.kernelFunction(a, {
+        derivative: 1,
+        epsilon: this.epsilon
+      }) * ((s[1] - this.sourcePoints[h][1]) / a) * r[t][h]), 0), n[t] += e[t][2];
+    return n;
+  }
+  getTransformationDataAsFloat64Array() {
+    if (this.weightsArrays || this.solve(), !this.rbfWeightsArrays || !this.affineWeightsArrays)
+      throw new Error("ThinPlateSpline transformation weights not computed");
+    const s = this.sourcePoints.length, r = new Float64Array(1 + 2 * s + 6);
+    r[0] = s;
+    for (let i = 0; i < s; i++)
+      r[1 + i] = this.rbfWeightsArrays[0][i];
+    for (let i = 0; i < s; i++)
+      r[1 + s + i] = this.rbfWeightsArrays[1][i];
+    for (let i = 0; i < 3; i++)
+      r[1 + 2 * s + i] = this.affineWeightsArrays[0][i];
+    for (let i = 0; i < 3; i++)
+      r[1 + 2 * s + 3 + i] = this.affineWeightsArrays[1][i];
+    const e = new Float64Array(s * 2);
+    for (let i = 0; i < s; i++)
+      e[i * 2] = this.sourcePoints[i][0], e[i * 2 + 1] = this.sourcePoints[i][1];
+    return {
+      weights: r,
+      sourcePoints: e
+    };
+  }
+}
+export {
+  C as RBF
+};
+//# sourceMappingURL=index.es372.js.map

package/dist/index.es372.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es372.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/RBF.js"],"sourcesContent":["import { arrayMatrixSize, newArrayMatrix, newBlockArrayMatrix, pasteArrayMatrix, transposeArrayMatrix } from '@allmaps/stdlib';\nimport { Polynomial1 } from './Polynomial1.js';\nimport { BaseIndependentLinearWeightsTransformation } from './BaseIndependentLinearWeightsTransformation.js';\nimport { solveIndependentlyInverse } from '../shared/solve-functions.js';\n/**\n * 2D Radial Basis Functions transformation\n *\n * See notebook https://observablehq.com/d/0b57d3b587542794 for code source and explanation\n */\nexport class RBF extends BaseIndependentLinearWeightsTransformation {\n    kernelFunction;\n    normFunction;\n    epsilon;\n    coefsArrayMatrices;\n    coefsArrayMatrix;\n    coefsArrayMatricesSize;\n    coefsArrayMatrixSize;\n    weightsArrays;\n    rbfWeightsArrays;\n    affineWeightsArrays;\n    constructor(sourcePoints, destinationPoints, kernelFunction, normFunction, type, epsilon) {\n        super(sourcePoints, destinationPoints, type, 3);\n        this.kernelFunction = kernelFunction;\n        this.normFunction = normFunction;\n        this.epsilon = epsilon;\n        // Note: getCoefsArrayMatrices can not be moved to the parent class's constructor\n        // since for this class it uses properties (normFunction, kernelFunction, epsilon)\n        // which are only defined after super()\n        this.coefsArrayMatrices = this.getCoefsArrayMatrices();\n        this.coefsArrayMatrix = this.coefsArrayMatrices[0];\n        this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((coefsArrayMatrix) => arrayMatrixSize(coefsArrayMatrix));\n        this.coefsArrayMatrixSize = arrayMatrixSize(this.coefsArrayMatrix);\n    }\n    getDestinationPointsArrays() {\n        return [\n            [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((value) => value[0]),\n            [...this.destinationPoints, [0, 0], [0, 0], [0, 0]].map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrix() {\n        // Pre-compute kernelsArrayMatrix: fill normsArrayMatrix\n        // with the point to point distances between all control points\n        const normsArrayMatrix = newArrayMatrix(this.pointCount, this.pointCount, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            for (let j = 0; j < this.pointCount; j++) {\n                normsArrayMatrix[i][j] = this.normFunction(this.sourcePoints[i], this.sourcePoints[j]);\n            }\n        }\n        // If it's not provided, and if it's an input to the kernelFunction,\n        // compute epsilon as the average distance between the control points\n        if (this.epsilon === undefined) {\n            const normsSum = normsArrayMatrix\n                .map((row) => row.reduce((a, c) => a + c, 0))\n                .reduce((a, c) => a + c, 0);\n            this.epsilon = normsSum / (Math.pow(this.pointCount, 2) - this.pointCount);\n        }\n        // Finish the computation of kernelsArrayMatrix by applying the requested kernel function\n        const kernelCoefsArrayMatrix = newArrayMatrix(this.pointCount, this.pointCount, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            for (let j = 0; j < this.pointCount; j++) {\n                kernelCoefsArrayMatrix[i][j] = this.kernelFunction(normsArrayMatrix[i][j], {\n                    epsilon: this.epsilon\n                });\n            }\n        }\n        // Construct Nx3 affineCoefsArrayMatrix\n        // 1 x0 y0\n        // 1 x1 y1\n        // 1 x2 y2\n        // ...\n        let affineCoefsArrayMatrix = newArrayMatrix(this.pointCount, 3, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            affineCoefsArrayMatrix = pasteArrayMatrix(affineCoefsArrayMatrix, i, 0, [\n                Polynomial1.getPolynomial1SourcePointCoefsArray(this.sourcePoints[i])\n            ]);\n        }\n        // Construct 3x3 zerosArrayMatrix\n        const zerosArrayMatrix = newArrayMatrix(3, 3, 0);\n        // Combine kernelsArrayMatrix and affineCoefsArrayMatrix\n        // into new coefsArrayMatrix, to include the affine transformation\n        const coefsArrayMatrix = newBlockArrayMatrix([\n            [kernelCoefsArrayMatrix, affineCoefsArrayMatrix],\n            [transposeArrayMatrix(affineCoefsArrayMatrix), zerosArrayMatrix]\n        ]);\n        return coefsArrayMatrix;\n    }\n    /**\n     * Get 1x(N+3) coefsArray, populating the (N+3)x(N+3) coefsArrayMatrix\n     *\n     * The coefsArray has a 1xN kernel part and a 1x3 affine part.\n     *\n     * @param sourcePoint\n     */\n    getSourcePointCoefsArray(sourcePoint) {\n        return [\n            ...this.getRbfKernelSourcePointCoefsArray(sourcePoint),\n            ...Polynomial1.getPolynomial1SourcePointCoefsArray(sourcePoint)\n        ];\n    }\n    getRbfKernelSourcePointCoefsArray(sourcePoint) {\n        const kernelSourcePointCoefsArray = [];\n        for (let i = 0; i < this.pointCount; i++) {\n            kernelSourcePointCoefsArray.push(this.kernelFunction(this.normFunction(this.sourcePoints[i], sourcePoint), {\n                epsilon: this.epsilon\n            }));\n        }\n        return kernelSourcePointCoefsArray;\n    }\n    setWeightsArrays(weightsArrays, epsilon) {\n        if (epsilon) {\n            this.epsilon = epsilon;\n        }\n        super.setWeightsArrays(weightsArrays);\n    }\n    /**\n     * Solve the x and y components independently.\n     *\n     * This uses the exact inverse to compute (for each component, using the same coefs for both)\n     * the exact solution for the system of linear equations\n     * which is (in general) invertable to an exact solution.\n     *\n     * This wil result in a weights array for each component with rbf weights and affine weights.\n     */\n    solve() {\n        this.weightsArrays = solveIndependentlyInverse(this.coefsArrayMatrix, this.destinationPointsArrays);\n        this.processWeightsArrays();\n    }\n    processWeightsArrays() {\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        this.rbfWeightsArrays = this.weightsArrays.map((array) => array.slice(0, this.pointCount));\n        this.affineWeightsArrays = this.weightsArrays.map((array) => array.slice(this.pointCount));\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('RBF weights not computed');\n        }\n        const rbfWeights = this.rbfWeightsArrays;\n        const affineWeights = this.affineWeightsArrays;\n        // Compute the distances of that point to all control points\n        const newDistances = this.sourcePoints.map((sourcePoint) => this.normFunction(newSourcePoint, sourcePoint));\n        // Sum the weighted contributions of the input point\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            // Apply the weights to the new distances\n            newDestinationPoint[i] = newDistances.reduce((sum, dist, index) => sum +\n                this.kernelFunction(dist, { epsilon: this.epsilon }) *\n                    rbfWeights[i][index], 0);\n            // Add the affine part\n            newDestinationPoint[i] +=\n                affineWeights[i][0] +\n                    affineWeights[i][1] * newSourcePoint[0] +\n                    affineWeights[i][2] * newSourcePoint[1];\n        }\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('RBF weights not computed');\n        }\n        const rbfWeights = this.rbfWeightsArrays;\n        const affineWeights = this.affineWeightsArrays;\n        // Compute the distances of that point to all control points\n        const newDistances = this.sourcePoints.map((sourcePoint) => this.normFunction(newSourcePoint, sourcePoint));\n        // Sum the weighted contributions of the input point\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            // Apply the weights to the new distances\n            newDestinationPointPartDerX[i] = newDistances.reduce((sum, dist, index) => sum +\n                (dist === 0\n                    ? 0\n                    : this.kernelFunction(dist, {\n                        derivative: 1,\n                        epsilon: this.epsilon\n                    }) *\n                        ((newSourcePoint[0] - this.sourcePoints[index][0]) / dist) *\n                        rbfWeights[i][index]), 0);\n            // Add the affine part\n            newDestinationPointPartDerX[i] += affineWeights[i][1];\n        }\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('RBF weights not computed');\n        }\n        const rbfWeights = this.rbfWeightsArrays;\n        const affineWeights = this.affineWeightsArrays;\n        // Compute the distances of that point to all control points\n        const newDistances = this.sourcePoints.map((sourcePoint) => this.normFunction(newSourcePoint, sourcePoint));\n        // Sum the weighted contributions of the input point\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            // Apply the weights to the new distances\n            newDestinationPointPartDerY[i] = newDistances.reduce((sum, dist, index) => sum +\n                (dist === 0\n                    ? 0\n                    : this.kernelFunction(dist, {\n                        derivative: 1,\n                        epsilon: this.epsilon\n                    }) *\n                        ((newSourcePoint[1] - this.sourcePoints[index][1]) / dist) *\n                        rbfWeights[i][index]), 0);\n            // Add the affine part\n            newDestinationPointPartDerY[i] += affineWeights[i][2];\n        }\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.rbfWeightsArrays || !this.affineWeightsArrays) {\n            throw new Error('ThinPlateSpline transformation weights not computed');\n        }\n        const n = this.sourcePoints.length;\n        // Format: [n, rbfWx[n], rbfWy[n], affineWx[3], affineWy[3]]\n        const weights = new Float64Array(1 + 2 * n + 6);\n        weights[0] = n;\n        for (let i = 0; i < n; i++) {\n            weights[1 + i] = this.rbfWeightsArrays[0][i];\n        }\n        for (let i = 0; i < n; i++) {\n            weights[1 + n + i] = this.rbfWeightsArrays[1][i];\n        }\n        for (let i = 0; i < 3; i++) {\n            weights[1 + 2 * n + i] = this.affineWeightsArrays[0][i];\n        }\n        for (let i = 0; i < 3; i++) {\n            weights[1 + 2 * n + 3 + i] = this.affineWeightsArrays[1][i];\n        }\n        // Flatten source points\n        const flatSourcePoints = new Float64Array(n * 2);\n        for (let i = 0; i < n; i++) {\n            flatSourcePoints[i * 2] = this.sourcePoints[i][0];\n            flatSourcePoints[i * 2 + 1] = this.sourcePoints[i][1];\n        }\n        return {\n            weights,\n            sourcePoints: flatSourcePoints\n        };\n    }\n}\n"],"names":["RBF","BaseIndependentLinearWeightsTransformation","sourcePoints","destinationPoints","kernelFunction","normFunction","type","epsilon","coefsArrayMatrix","arrayMatrixSize","value","normsArrayMatrix","newArrayMatrix","i","j","normsSum","row","c","a","kernelCoefsArrayMatrix","affineCoefsArrayMatrix","pasteArrayMatrix","Polynomial1","zerosArrayMatrix","newBlockArrayMatrix","transposeArrayMatrix","sourcePoint","kernelSourcePointCoefsArray","weightsArrays","solveIndependentlyInverse","array","newSourcePoint","rbfWeights","affineWeights","newDistances","newDestinationPoint","sum","dist","index","newDestinationPointPartDerX","newDestinationPointPartDerY","n","weights","flatSourcePoints"],"mappings":"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","x_google_ignoreList":[0]}