@performant-software/geospatial 3.1.25-beta.1 → 3.1.25

package/dist/index.es421.js

@@ -0,0 +1,64 @@
+import { distance as o, rms as e } from "./index.es275.js";
+class u {
+  sourcePoints;
+  destinationPoints;
+  destinationTransformedSourcePoints;
+  type;
+  pointCount;
+  pointCountMinimum;
+  errors;
+  destinationRmse;
+  /**
+   * Create a transformation
+   *
+   * @param sourcePoints - The source points
+   * @param destinationPoints - The destination points
+   * @param type - The transformation type
+   * @param pointCountMinimum - The minimum number of points for the transformation type
+   */
+  constructor(t, i, s, n) {
+    if (this.sourcePoints = t, this.destinationPoints = i, this.pointCount = this.sourcePoints.length, this.type = s, this.pointCountMinimum = n, this.pointCount < this.pointCountMinimum)
+      throw new Error("Not enough control points. A " + this.type + " transformation requires a minimum of " + this.pointCountMinimum + " points, but " + this.pointCount + " are given.");
+  }
+  /**
+   * Set weights.
+   *
+   * The weights might be obtained in other ways then through solving
+   * (e.g. through solving multiple transformation together when staping).
+   * This function can be used to set weights computed elsewhere.
+   */
+  setWeightsArrays(t) {
+    this.weightsArrays = t, this.processWeightsArrays();
+  }
+  processWeightsArrays() {
+  }
+  /**
+   * Get the destination-transformed source points.
+   *
+   * @returns source points, transformed to destination domain
+   */
+  getDestinationTransformedSourcePoints() {
+    return this.destinationTransformedSourcePoints || (this.destinationTransformedSourcePoints = this.sourcePoints.map((t) => this.evaluateFunction(t))), this.destinationTransformedSourcePoints;
+  }
+  getMeasures() {
+    return {};
+  }
+  getErrors() {
+    if (!this.errors) {
+      const t = this.getDestinationTransformedSourcePoints();
+      this.errors = this.destinationPoints.map((i, s) => o(i, t[s]));
+    }
+    return this.errors;
+  }
+  getDestinationRmse() {
+    if (!this.destinationRmse) {
+      const t = this.getDestinationTransformedSourcePoints();
+      this.destinationTransformedSourcePoints || this.getDestinationTransformedSourcePoints(), this.destinationRmse = e(this.destinationPoints, t);
+    }
+    return this.destinationRmse;
+  }
+}
+export {
+  u as BaseTransformation
+};
+//# sourceMappingURL=index.es421.js.map

package/dist/index.es421.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es421.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseTransformation.js"],"sourcesContent":["import { distance, rms } from '@allmaps/stdlib';\n/**\n * Base class for transformation.\n */\nexport class BaseTransformation {\n    sourcePoints;\n    destinationPoints;\n    destinationTransformedSourcePoints;\n    type;\n    pointCount;\n    pointCountMinimum;\n    errors;\n    destinationRmse;\n    /**\n     * Create a transformation\n     *\n     * @param sourcePoints - The source points\n     * @param destinationPoints - The destination points\n     * @param type - The transformation type\n     * @param pointCountMinimum - The minimum number of points for the transformation type\n     */\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        this.sourcePoints = sourcePoints;\n        this.destinationPoints = destinationPoints;\n        this.pointCount = this.sourcePoints.length;\n        this.type = type;\n        this.pointCountMinimum = pointCountMinimum;\n        if (this.pointCount < this.pointCountMinimum) {\n            throw new Error('Not enough control points. A ' +\n                this.type +\n                ' transformation requires a minimum of ' +\n                this.pointCountMinimum +\n                ' points, but ' +\n                this.pointCount +\n                ' are given.');\n        }\n    }\n    /**\n     * Set weights.\n     *\n     * The weights might be obtained in other ways then through solving\n     * (e.g. through solving multiple transformation together when staping).\n     * This function can be used to set weights computed elsewhere.\n     */\n    setWeightsArrays(weightsArrays) {\n        this.weightsArrays = weightsArrays;\n        this.processWeightsArrays();\n    }\n    processWeightsArrays() {\n        return;\n    }\n    /**\n     * Get the destination-transformed source points.\n     *\n     * @returns source points, transformed to destination domain\n     */\n    getDestinationTransformedSourcePoints() {\n        if (!this.destinationTransformedSourcePoints) {\n            this.destinationTransformedSourcePoints = this.sourcePoints.map((sourcePoint) => this.evaluateFunction(sourcePoint));\n        }\n        return this.destinationTransformedSourcePoints;\n    }\n    getMeasures() {\n        return {};\n    }\n    getErrors() {\n        if (!this.errors) {\n            const destinationTransformedSourcePoints = this.getDestinationTransformedSourcePoints();\n            this.errors = this.destinationPoints.map((destinationPoint, index) => distance(destinationPoint, destinationTransformedSourcePoints[index]));\n        }\n        return this.errors;\n    }\n    getDestinationRmse() {\n        if (!this.destinationRmse) {\n            const destinationTransformedSourcePoints = this.getDestinationTransformedSourcePoints();\n            if (!this.destinationTransformedSourcePoints) {\n                this.getDestinationTransformedSourcePoints();\n            }\n            this.destinationRmse = rms(this.destinationPoints, destinationTransformedSourcePoints);\n        }\n        return this.destinationRmse;\n    }\n}\n"],"names":["BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum","weightsArrays","sourcePoint","destinationTransformedSourcePoints","destinationPoint","index","distance","rms"],"mappings":";AAIO,MAAMA,EAAmB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,YAAYC,GAAcC,GAAmBC,GAAMC,GAAmB;AAMlE,QALA,KAAK,eAAeH,GACpB,KAAK,oBAAoBC,GACzB,KAAK,aAAa,KAAK,aAAa,QACpC,KAAK,OAAOC,GACZ,KAAK,oBAAoBC,GACrB,KAAK,aAAa,KAAK;AACvB,YAAM,IAAI,MAAM,kCACZ,KAAK,OACL,2CACA,KAAK,oBACL,kBACA,KAAK,aACL,aAAa;AAAA,EAEzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,iBAAiBC,GAAe;AAC5B,SAAK,gBAAgBA,GACrB,KAAK,qBAAA;AAAA,EACT;AAAA,EACA,uBAAuB;AAAA,EAEvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,wCAAwC;AACpC,WAAK,KAAK,uCACN,KAAK,qCAAqC,KAAK,aAAa,IAAI,CAACC,MAAgB,KAAK,iBAAiBA,CAAW,CAAC,IAEhH,KAAK;AAAA,EAChB;AAAA,EACA,cAAc;AACV,WAAO,CAAA;AAAA,EACX;AAAA,EACA,YAAY;AACR,QAAI,CAAC,KAAK,QAAQ;AACd,YAAMC,IAAqC,KAAK,sCAAA;AAChD,WAAK,SAAS,KAAK,kBAAkB,IAAI,CAACC,GAAkBC,MAAUC,EAASF,GAAkBD,EAAmCE,CAAK,CAAC,CAAC;AAAA,IAC/I;AACA,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,qBAAqB;AACjB,QAAI,CAAC,KAAK,iBAAiB;AACvB,YAAMF,IAAqC,KAAK,sCAAA;AAChD,MAAK,KAAK,sCACN,KAAK,sCAAA,GAET,KAAK,kBAAkBI,EAAI,KAAK,mBAAmBJ,CAAkC;AAAA,IACzF;AACA,WAAO,KAAK;AAAA,EAChB;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es422.js

@@ -0,0 +1,50 @@
+import { arrayMatrixSize as i, newArrayMatrix as a, pasteArrayMatrix as n } from "./index.es315.js";
+import { BaseIndependentLinearWeightsTransformation as h } from "./index.es419.js";
+import { solveIndependentlyPseudoInverse as y } from "./index.es423.js";
+class p extends h {
+  coefsArrayMatrices;
+  coefsArrayMatrix;
+  coefsArrayMatricesSize;
+  coefsArrayMatrixSize;
+  order;
+  weightsArrays;
+  constructor(r, t, s) {
+    s = s || 1;
+    const o = (s + 1) * (s + 2) / 2;
+    if (super(r, t, "polynomial" + s, o), this.order = s, this.order < 1 || this.order > 3)
+      throw new Error("Only polynomial transformations of order 1, 2 or 3 are supported");
+    this.coefsArrayMatrices = this.getCoefsArrayMatrices(), this.coefsArrayMatrix = this.coefsArrayMatrices[0], this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((e) => i(e)), this.coefsArrayMatrixSize = i(this.coefsArrayMatrix);
+  }
+  getDestinationPointsArrays() {
+    return [
+      this.destinationPoints.map((r) => r[0]),
+      this.destinationPoints.map((r) => r[1])
+    ];
+  }
+  getCoefsArrayMatrix() {
+    let r = a(this.pointCount, this.pointCountMinimum, 0);
+    for (let t = 0; t < this.pointCount; t++)
+      r = n(r, t, 0, [
+        this.getSourcePointCoefsArray(this.sourcePoints[t])
+      ]);
+    return r;
+  }
+  solve() {
+    this.weightsArrays = y(this.coefsArrayMatrix, this.destinationPointsArrays);
+  }
+  getTransformationDataAsFloat64Array() {
+    if (this.weightsArrays || this.solve(), !this.weightsArrays)
+      throw new Error("Polynomial transformation weights not computed");
+    return {
+      weights: new Float64Array([
+        ...this.weightsArrays[0],
+        ...this.weightsArrays[1]
+      ]),
+      sourcePoints: new Float64Array(0)
+    };
+  }
+}
+export {
+  p as BasePolynomialTransformation
+};
+//# sourceMappingURL=index.es422.js.map

package/dist/index.es422.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es422.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BasePolynomialTransformation.js"],"sourcesContent":["import { arrayMatrixSize, newArrayMatrix, pasteArrayMatrix } from '@allmaps/stdlib';\nimport { BaseIndependentLinearWeightsTransformation } from './BaseIndependentLinearWeightsTransformation.js';\nimport { solveIndependentlyPseudoInverse } from '../shared/solve-functions.js';\nexport class BasePolynomialTransformation extends BaseIndependentLinearWeightsTransformation {\n    coefsArrayMatrices;\n    coefsArrayMatrix;\n    coefsArrayMatricesSize;\n    coefsArrayMatrixSize;\n    order;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints, order) {\n        order = order || 1;\n        const pointsCountMinimum = ((order + 1) * (order + 2)) / 2;\n        // If there are less control points than there are coefficients to be determined (for each dimension),\n        // the system can not be solved\n        super(sourcePoints, destinationPoints, ('polynomial' + order), pointsCountMinimum);\n        this.order = order;\n        if (this.order < 1 || this.order > 3) {\n            throw new Error('Only polynomial transformations of order 1, 2 or 3 are supported');\n        }\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.map((value) => value[0]),\n            this.destinationPoints.map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrix() {\n        let coefsArrayArray = newArrayMatrix(this.pointCount, this.pointCountMinimum, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            coefsArrayArray = pasteArrayMatrix(coefsArrayArray, i, 0, [\n                this.getSourcePointCoefsArray(this.sourcePoints[i])\n            ]);\n        }\n        return coefsArrayArray;\n    }\n    solve() {\n        this.weightsArrays = solveIndependentlyPseudoInverse(this.coefsArrayMatrix, this.destinationPointsArrays);\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Polynomial transformation weights not computed');\n        }\n        // Polynomial: [wx[0], wx[1], ..., wy[0], wy[1], ...]\n        return {\n            weights: new Float64Array([\n                ...this.weightsArrays[0],\n                ...this.weightsArrays[1]\n            ]),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["BasePolynomialTransformation","BaseIndependentLinearWeightsTransformation","sourcePoints","destinationPoints","order","pointsCountMinimum","coefsArrayMatrix","arrayMatrixSize","value","coefsArrayArray","newArrayMatrix","i","pasteArrayMatrix","solveIndependentlyPseudoInverse"],"mappings":";;;AAGO,MAAMA,UAAqCC,EAA2C;AAAA,EACzF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAYC,GAAcC,GAAmBC,GAAO;AAChD,IAAAA,IAAQA,KAAS;AACjB,UAAMC,KAAuBD,IAAQ,MAAMA,IAAQ,KAAM;AAKzD,QAFA,MAAMF,GAAcC,GAAoB,eAAeC,GAAQC,CAAkB,GACjF,KAAK,QAAQD,GACT,KAAK,QAAQ,KAAK,KAAK,QAAQ;AAC/B,YAAM,IAAI,MAAM,kEAAkE;AAEtF,SAAK,qBAAqB,KAAK,sBAAA,GAC/B,KAAK,mBAAmB,KAAK,mBAAmB,CAAC,GACjD,KAAK,yBAAyB,KAAK,mBAAmB,IAAI,CAACE,MAAqBC,EAAgBD,CAAgB,CAAC,GACjH,KAAK,uBAAuBC,EAAgB,KAAK,gBAAgB;AAAA,EACrE;AAAA,EACA,6BAA6B;AACzB,WAAO;AAAA,MACH,KAAK,kBAAkB,IAAI,CAACC,MAAUA,EAAM,CAAC,CAAC;AAAA,MAC9C,KAAK,kBAAkB,IAAI,CAACA,MAAUA,EAAM,CAAC,CAAC;AAAA,IAAA;AAAA,EAEtD;AAAA,EACA,sBAAsB;AAClB,QAAIC,IAAkBC,EAAe,KAAK,YAAY,KAAK,mBAAmB,CAAC;AAC/E,aAASC,IAAI,GAAGA,IAAI,KAAK,YAAYA;AACjC,MAAAF,IAAkBG,EAAiBH,GAAiBE,GAAG,GAAG;AAAA,QACtD,KAAK,yBAAyB,KAAK,aAAaA,CAAC,CAAC;AAAA,MAAA,CACrD;AAEL,WAAOF;AAAA,EACX;AAAA,EACA,QAAQ;AACJ,SAAK,gBAAgBI,EAAgC,KAAK,kBAAkB,KAAK,uBAAuB;AAAA,EAC5G;AAAA,EACA,sCAAsC;AAIlC,QAHK,KAAK,iBACN,KAAK,MAAA,GAEL,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,gDAAgD;AAGpE,WAAO;AAAA,MACH,SAAS,IAAI,aAAa;AAAA,QACtB,GAAG,KAAK,cAAc,CAAC;AAAA,QACvB,GAAG,KAAK,cAAc,CAAC;AAAA,MAAA,CAC1B;AAAA,MACD,cAAc,IAAI,aAAa,CAAC;AAAA,IAAA;AAAA,EAExC;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es423.js

@@ -0,0 +1,45 @@
+import r, { pseudoInverse as u, SingularValueDecomposition as l, inverse as m } from "./index.es432.js";
+function w(e, t) {
+  const s = new r([
+    ...e[0],
+    ...e[1]
+  ]), o = r.columnVector([
+    ...t[0],
+    ...t[1]
+  ]);
+  return u(s).mmul(o).to1DArray();
+}
+function h(e, t) {
+  const s = new r(e), o = [
+    r.columnVector(t[0]),
+    r.columnVector(t[1])
+  ], n = u(s);
+  return [
+    n.mmul(o[0]),
+    n.mmul(o[1])
+  ].map((a) => a.to1DArray());
+}
+function M(e, t) {
+  const s = new r(e), o = [
+    r.columnVector(t[0]),
+    r.columnVector(t[1])
+  ], n = m(s);
+  return [
+    n.mmul(o[0]),
+    n.mmul(o[1])
+  ].map((a) => a.to1DArray());
+}
+function x(e, t) {
+  const s = [];
+  for (let i = 0; i < t; i++)
+    s.push(e[0][i]), s.push(e[1][i]);
+  const o = new l(s);
+  return r.from1DArray(3, 3, o.rightSingularVectors.getColumn(8)).transpose().to2DArray();
+}
+export {
+  M as solveIndependentlyInverse,
+  h as solveIndependentlyPseudoInverse,
+  w as solveJointlyPseudoInverse,
+  x as solveJointlySvd
+};
+//# sourceMappingURL=index.es423.js.map

package/dist/index.es423.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es423.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/solve-functions.js"],"sourcesContent":["import Matrix, { inverse, pseudoInverse, SingularValueDecomposition } from 'ml-matrix';\n/**\n * Solve the x and y components jointly using PseudoInverse.\n *\n * This uses the 'Pseudo Inverse' to compute a 'best fit' (least squares) approximate solution\n * for the system of linear equations, which is (in general) over-defined and hence lacks an exact solution.\n * See https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse\n *\n * This will result weightsArray shared by both components: [t_x, t_y, m, n]\n */\nexport function solveJointlyPseudoInverse(coefsArrayMatrices, destinationPointsArrays) {\n    const coefsMatrix = new Matrix([\n        ...coefsArrayMatrices[0],\n        ...coefsArrayMatrices[1]\n    ]);\n    const destinationPointsMatrix = Matrix.columnVector([\n        ...destinationPointsArrays[0],\n        ...destinationPointsArrays[1]\n    ]);\n    const pseudoInverseCoefsMatrix = pseudoInverse(coefsMatrix);\n    const weightsMatrix = pseudoInverseCoefsMatrix.mmul(destinationPointsMatrix);\n    const weightsArray = weightsMatrix.to1DArray();\n    return weightsArray;\n}\n/**\n * Solve the x and y components independently using PseudoInverse.\n *\n * This uses the 'Pseudo Inverse' to compute (for each component, using the same coefs for both)\n * a 'best fit' (least squares) approximate solution for the system of linear equations\n * which is (in general) over-defined and hence lacks an exact solution.\n *\n * See https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse\n *\n * This wil result in a weights array for each component:\n * For order = 1: this.weight = [[a0_x, ax_x, ay_x], [a0_y, ax_y, ay_y]]\n * For order = 2: ... (similar, following the same order as in coefsArrayMatrix)\n * For order = 3: ... (similar, following the same order as in coefsArrayMatrix)\n */\nexport function solveIndependentlyPseudoInverse(coefsArrayMatrix, destinationPointsArrays) {\n    const coefsMatrix = new Matrix(coefsArrayMatrix);\n    const destinationPointsMatrices = [\n        Matrix.columnVector(destinationPointsArrays[0]),\n        Matrix.columnVector(destinationPointsArrays[1])\n    ];\n    const pseudoInverseCoefsMatrix = pseudoInverse(coefsMatrix);\n    const weightsMatrices = [\n        pseudoInverseCoefsMatrix.mmul(destinationPointsMatrices[0]),\n        pseudoInverseCoefsMatrix.mmul(destinationPointsMatrices[1])\n    ];\n    const weightsArrays = weightsMatrices.map((matrix) => matrix.to1DArray());\n    return weightsArrays;\n}\n/**\n * Solve the x and y components independently using exact inverse.\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 */\nexport function solveIndependentlyInverse(coefsArrayMatrix, destinationPointsArrays) {\n    const coefsMatrix = new Matrix(coefsArrayMatrix);\n    const destinationPointsMatrices = [\n        Matrix.columnVector(destinationPointsArrays[0]),\n        Matrix.columnVector(destinationPointsArrays[1])\n    ];\n    const inverseCoefsMatrix = inverse(coefsMatrix);\n    const weightsMatrices = [\n        inverseCoefsMatrix.mmul(destinationPointsMatrices[0]),\n        inverseCoefsMatrix.mmul(destinationPointsMatrices[1])\n    ];\n    const weightsArrays = weightsMatrices.map((matrix) => matrix.to1DArray());\n    return weightsArrays;\n}\n/**\n * Solve the x and y components jointly using singular value decomposition.\n *\n * This uses a singular value decomposition to compute the last (i.e. 9th) 'right singular vector',\n * i.e. the one with the smallest singular value, wich holds the weights for the solution.\n * Note that for a set of gcps that exactly follow a projective transformations,\n * the singular value is null and this vector spans the null-space.\n *\n * This wil result in a weights array for each component with rbf weights and affine weights.\n */\nexport function solveJointlySvd(coefsArrayMatrices, pointCount) {\n    // Joint coefs in the same order as in the paper\n    // (Otherwise the weights may differ in sign, even though this should not affect the result)\n    const coefsMatrix = [];\n    for (let i = 0; i < pointCount; i++) {\n        coefsMatrix.push(coefsArrayMatrices[0][i]);\n        coefsMatrix.push(coefsArrayMatrices[1][i]);\n    }\n    const svdCoefsMatrix = new SingularValueDecomposition(coefsMatrix);\n    const weightsMatrix = Matrix.from1DArray(3, 3, svdCoefsMatrix.rightSingularVectors.getColumn(8)).transpose();\n    const weightsArrays = weightsMatrix.to2DArray();\n    return weightsArrays;\n}\n"],"names":["solveJointlyPseudoInverse","coefsArrayMatrices","destinationPointsArrays","coefsMatrix","Matrix","destinationPointsMatrix","pseudoInverse","solveIndependentlyPseudoInverse","coefsArrayMatrix","destinationPointsMatrices","pseudoInverseCoefsMatrix","matrix","solveIndependentlyInverse","inverseCoefsMatrix","inverse","solveJointlySvd","pointCount","svdCoefsMatrix","SingularValueDecomposition"],"mappings":";AAUO,SAASA,EAA0BC,GAAoBC,GAAyB;AACnF,QAAMC,IAAc,IAAIC,EAAO;AAAA,IAC3B,GAAGH,EAAmB,CAAC;AAAA,IACvB,GAAGA,EAAmB,CAAC;AAAA,EAAA,CAC1B,GACKI,IAA0BD,EAAO,aAAa;AAAA,IAChD,GAAGF,EAAwB,CAAC;AAAA,IAC5B,GAAGA,EAAwB,CAAC;AAAA,EAAA,CAC/B;AAID,SAHiCI,EAAcH,CAAW,EACX,KAAKE,CAAuB,EACxC,UAAA;AAEvC;AAeO,SAASE,EAAgCC,GAAkBN,GAAyB;AACvF,QAAMC,IAAc,IAAIC,EAAOI,CAAgB,GACzCC,IAA4B;AAAA,IAC9BL,EAAO,aAAaF,EAAwB,CAAC,CAAC;AAAA,IAC9CE,EAAO,aAAaF,EAAwB,CAAC,CAAC;AAAA,EAAA,GAE5CQ,IAA2BJ,EAAcH,CAAW;AAM1D,SALwB;AAAA,IACpBO,EAAyB,KAAKD,EAA0B,CAAC,CAAC;AAAA,IAC1DC,EAAyB,KAAKD,EAA0B,CAAC,CAAC;AAAA,EAAA,EAExB,IAAI,CAACE,MAAWA,EAAO,WAAW;AAE5E;AAUO,SAASC,EAA0BJ,GAAkBN,GAAyB;AACjF,QAAMC,IAAc,IAAIC,EAAOI,CAAgB,GACzCC,IAA4B;AAAA,IAC9BL,EAAO,aAAaF,EAAwB,CAAC,CAAC;AAAA,IAC9CE,EAAO,aAAaF,EAAwB,CAAC,CAAC;AAAA,EAAA,GAE5CW,IAAqBC,EAAQX,CAAW;AAM9C,SALwB;AAAA,IACpBU,EAAmB,KAAKJ,EAA0B,CAAC,CAAC;AAAA,IACpDI,EAAmB,KAAKJ,EAA0B,CAAC,CAAC;AAAA,EAAA,EAElB,IAAI,CAACE,MAAWA,EAAO,WAAW;AAE5E;AAWO,SAASI,EAAgBd,GAAoBe,GAAY;AAG5D,QAAMb,IAAc,CAAA;AACpB,WAAS,IAAI,GAAG,IAAIa,GAAY;AAC5B,IAAAb,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,GACzCE,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC;AAE7C,QAAMgB,IAAiB,IAAIC,EAA2Bf,CAAW;AAGjE,SAFsBC,EAAO,YAAY,GAAG,GAAGa,EAAe,qBAAqB,UAAU,CAAC,CAAC,EAAE,UAAA,EAC7D,UAAA;AAExC;","x_google_ignoreList":[0]}

package/dist/index.es424.js

@@ -0,0 +1,92 @@
+import { arrayMatrixSize as h, newArrayMatrix as e, pasteArrayMatrix as a } from "./index.es315.js";
+import { BaseLinearWeightsTransformation as o } from "./index.es420.js";
+import { solveJointlyPseudoInverse as n } from "./index.es423.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.es424.js.map

package/dist/index.es424.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es424.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.es425.js

@@ -0,0 +1,89 @@
+import { BasePolynomialTransformation as n } from "./index.es422.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.es425.js.map

package/dist/index.es425.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es425.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.es426.js

@@ -0,0 +1,57 @@
+import { BasePolynomialTransformation as e } from "./index.es422.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.es426.js.map

package/dist/index.es426.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es426.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.es427.js

@@ -0,0 +1,61 @@
+import { BasePolynomialTransformation as i } from "./index.es422.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.es427.js.map

package/dist/index.es427.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es427.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.es428.js

@@ -0,0 +1,58 @@
+import { newArrayMatrix as a } from "./index.es315.js";
+import { BaseTransformation as e } from "./index.es421.js";
+import { solveJointlySvd as y } from "./index.es423.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.es428.js.map