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

package/dist/index.es360.js

@@ -0,0 +1,206 @@
+import { computeBbox as w } from "./index.es215.js";
+import { flipY as m, isPoint as d, isLineString as u, isPolygon as I, isMultiPoint as F, isMultiLineString as c, isMultiPolygon as v } from "./index.es275.js";
+import { mergeOptions as l } from "./index.es217.js";
+import { computeDistortionsFromPartialDerivatives as k } from "./index.es317.js";
+import { Straight as R } from "./index.es373.js";
+import { Helmert as L } from "./index.es367.js";
+import { Polynomial1 as E } from "./index.es368.js";
+import { Polynomial2 as H } from "./index.es369.js";
+import { Polynomial3 as N } from "./index.es370.js";
+import { Projective as T } from "./index.es371.js";
+import { RBF as B } from "./index.es372.js";
+import { thinPlateKernel as Y, linearKernel as W } from "./index.es506.js";
+import { euclideanNorm as P } from "./index.es507.js";
+import { defaultGeneralGcpTransformerOptions as X, refinementOptionsFromForwardTransformOptions as p, refinementOptionsFromBackwardTransformOptions as h, nonWarpingTransformationTypes as b } from "./index.es224.js";
+import { refineLineString as g, refineRing as y, getSourceRefinementResolution as O } from "./index.es374.js";
+import { generalGcpToPointForForward as S, generalGcpToPointForBackward as M, invertGeneralGcp as D } from "./index.es361.js";
+class nr {
+  generalGcpsInternal;
+  sourcePointsInternal;
+  destinationPointsInternal;
+  type;
+  transformerOptions;
+  forwardTransformation;
+  backwardTransformation;
+  /**
+   * Create a BaseGcpTransformer
+   *
+   * @param generalGcps - An array of General Ground Control Points (GCPs)
+   * @param type - The transformation type
+   * @param partialGeneralGcpTransformerOptions - General GCP Transformer options
+   */
+  constructor(r, n = "polynomial", a) {
+    if (this.transformerOptions = l(X, a), r.length === 0)
+      throw new Error("No control points");
+    this.generalGcpsInternal = r, this.sourcePointsInternal = this.generalGcpsInternal.map((t) => {
+      const i = this.transformerOptions.differentHandedness ? m(t.source) : t.source;
+      return this.transformerOptions.preForward(i);
+    }), this.destinationPointsInternal = this.generalGcpsInternal.map((t) => this.transformerOptions.preBackward(t.destination)), this.type = n;
+  }
+  /**
+   * Get the forward transformation. Create if it doesn't exist yet.
+   */
+  getForwardTransformationInternal() {
+    return this.forwardTransformation || (this.forwardTransformation = this.createTransformation(this.sourcePointsInternal, this.destinationPointsInternal)), this.forwardTransformation;
+  }
+  /**
+   * Get the backward transformation. Create if it doesn't exist yet.
+   */
+  getBackwardTransformationInternal() {
+    return this.backwardTransformation || (this.backwardTransformation = this.createTransformation(this.destinationPointsInternal, this.sourcePointsInternal)), this.backwardTransformation;
+  }
+  /**
+   * Create the (forward or backward) transformation.
+   *
+   * Results in forward transformation if source and destination points are entered as such.
+   * Results in backward if source points are entered for destination points and vice versa.
+   *
+   * Results in a transformation of this instance's transformation type.
+   *
+   * @param sourcePoints - source points
+   * @param destinationPoints - destination points
+   * @returns Transformation
+   */
+  createTransformation(r, n) {
+    if (this.type === "straight")
+      return new R(r, n);
+    if (this.type === "helmert")
+      return new L(r, n);
+    if (this.type === "polynomial1" || this.type === "polynomial")
+      return new E(r, n);
+    if (this.type === "polynomial2")
+      return new H(r, n);
+    if (this.type === "polynomial3")
+      return new N(r, n);
+    if (this.type === "projective")
+      return new T(r, n);
+    if (this.type === "thinPlateSpline")
+      return new B(r, n, Y, P, "thinPlateSpline");
+    if (this.type === "linear")
+      return new B(r, n, W, P, "linear");
+    throw new Error(`Unsupported transformation type: ${this.type}`);
+  }
+  /**
+   * Transform a geometry forward from source space to destination space
+   *
+   * @param sourceGeometry - Geometry to transform
+   * @param partialGeneralGcpTransformOptions - General GCP Transform options
+   * @param generalGcpToP - Return type function
+   * @returns Forward transform of input geometry
+   */
+  transformForwardInternal(r, n, a = S) {
+    let t = l(this.transformerOptions, n);
+    if (this.isNonWarping() && (t = l(t, { maxDepth: 0 })), t.isMultiGeometry) {
+      if (t && (t = l(t, {
+        isMultiGeometry: !1
+      })), F(r))
+        return r.map((i) => this.transformPointForwardInternal(i, t, a));
+      if (c(r))
+        return r.map((i) => this.transformLineStringForwardInternal(i, t, a));
+      if (v(r))
+        return r.map((i) => this.transformPolygonForwardInternal(i, t, a));
+      throw new Error("Geometry type not supported");
+    } else {
+      if (d(r))
+        return this.transformPointForwardInternal(r, t, a);
+      if (u(r))
+        return this.transformLineStringForwardInternal(r, t, a);
+      if (I(r))
+        return this.transformPolygonForwardInternal(r, t, a);
+      throw new Error("Geometry type not supported");
+    }
+  }
+  /**
+   * Transform a geometry backward from destination space to source space
+   *
+   * @param destinationGeometry - Geometry to transform
+   * @param partialGeneralGcpTransformOptions - General GCP Transform options
+   * @param generalGcpToP - Return type function
+   * @returns Backward transform of input geometry
+   */
+  transformBackwardInternal(r, n, a = M) {
+    let t = l(this.transformerOptions, n);
+    if (this.isNonWarping() && (t = l(t, { maxDepth: 0 })), t.isMultiGeometry) {
+      if (t && (t = l(t, {
+        isMultiGeometry: !1
+      })), F(r))
+        return r.map((i) => this.transformPointBackwardInternal(i, t, a));
+      if (c(r))
+        return r.map((i) => this.transformLineStringBackwardInternal(i, t, a));
+      if (v(r))
+        return r.map((i) => this.transformPolygonBackwardInternal(i, t, a));
+      throw new Error("Geometry type not supported");
+    } else {
+      if (d(r))
+        return this.transformPointBackwardInternal(r, t, a);
+      if (u(r))
+        return this.transformLineStringBackwardInternal(r, t, a);
+      if (I(r))
+        return this.transformPolygonBackwardInternal(r, t, a);
+      throw new Error("Geometry type not supported");
+    }
+  }
+  // Handle specific geometries
+  transformPointForwardInternal(r, n, a = S) {
+    const t = this.getForwardTransformationInternal();
+    let i = this.transformerOptions.differentHandedness ? m(r) : r;
+    i = n.preForward(i);
+    let e = t.evaluateFunction(i);
+    e = n.postForward(e);
+    let o, s, f = /* @__PURE__ */ new Map();
+    return n.distortionMeasures.length > 0 && (o = t.evaluatePartialDerivativeX(i), s = t.evaluatePartialDerivativeY(i), f = k(n.distortionMeasures, o, s, n.referenceScale)), a({
+      source: r,
+      // don't apply differentHandedness here, this is only internally.
+      destination: e,
+      partialDerivativeX: o,
+      partialDerivativeY: s,
+      distortions: f
+    });
+  }
+  transformPointBackwardInternal(r, n, a = M) {
+    const t = this.getBackwardTransformationInternal(), i = n.preBackward(r);
+    let e = t.evaluateFunction(i);
+    e = n.postBackward(e), e = this.transformerOptions.differentHandedness ? m(e) : e;
+    let o, s, f = /* @__PURE__ */ new Map();
+    return n.distortionMeasures.length > 0 && (o = t.evaluatePartialDerivativeX(i), o = this.transformerOptions.differentHandedness ? m(o) : o, s = t.evaluatePartialDerivativeY(i), s = this.transformerOptions.differentHandedness ? m(s) : s, f = k(n.distortionMeasures, o, s, n.referenceScale)), a({
+      source: e,
+      destination: i,
+      partialDerivativeX: o,
+      partialDerivativeY: s,
+      distortions: f
+    });
+  }
+  transformLineStringForwardInternal(r, n, a) {
+    return g(r, (t) => this.transformPointForwardInternal(t, n), p(n)).map((t) => a(t));
+  }
+  transformLineStringBackwardInternal(r, n, a) {
+    return g(r, (t) => this.transformPointBackwardInternal(t, n), h(n)).map((t) => a(D(t)));
+  }
+  transformRingForwardInternal(r, n, a) {
+    return y(r, (t) => this.transformPointForwardInternal(t, n), p(n)).map((t) => a(t));
+  }
+  transformRingBackwardInternal(r, n, a) {
+    return y(r, (t) => this.transformPointBackwardInternal(t, n), h(n)).map((t) => a(D(t)));
+  }
+  transformPolygonForwardInternal(r, n, a) {
+    return r.map((t) => this.transformRingForwardInternal(t, n, a));
+  }
+  transformPolygonBackwardInternal(r, n, a) {
+    return r.map((t) => this.transformRingBackwardInternal(t, n, a));
+  }
+  isNonWarping() {
+    return this.transformerOptions.postForward === this.transformerOptions.preBackward && this.transformerOptions.postBackward === this.transformerOptions.preForward && b.includes(this.type);
+  }
+  getForwardTransformationResolutionInternal(r, n) {
+    const a = l(this.transformerOptions, n);
+    return r = r ?? w(this.sourcePointsInternal), O(r, (t) => this.transformPointForwardInternal(t, a), p(a));
+  }
+  getBackwardTransformationResolutionInternal(r, n) {
+    const a = l(this.transformerOptions, n);
+    return r = r ?? w(this.destinationPointsInternal), O(r, (t) => this.transformPointBackwardInternal(t, a), h(a));
+  }
+}
+export {
+  nr as BaseGcpTransformer
+};
+//# sourceMappingURL=index.es360.js.map

package/dist/index.es360.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es360.js","sources":["../../../node_modules/@allmaps/transform/dist/transformers/BaseGcpTransformer.js"],"sourcesContent":["import { isPoint, isLineString, isPolygon, isMultiPoint, isMultiLineString, isMultiPolygon, flipY, mergeOptions, computeBbox } from '@allmaps/stdlib';\nimport { computeDistortionsFromPartialDerivatives } from '../shared/distortion.js';\nimport { Straight } from '../transformation-types/Straight.js';\nimport { Helmert } from '../transformation-types/Helmert.js';\nimport { Polynomial1 } from '../transformation-types/Polynomial1.js';\nimport { Polynomial2 } from '../transformation-types/Polynomial2.js';\nimport { Polynomial3 } from '../transformation-types/Polynomial3.js';\nimport { Projective } from '../transformation-types/Projective.js';\nimport { RBF } from '../transformation-types/RBF.js';\nimport { linearKernel, thinPlateKernel } from '../shared/kernel-functions.js';\nimport { euclideanNorm } from '../shared/norm-functions.js';\nimport { defaultGeneralGcpTransformerOptions, nonWarpingTransformationTypes, refinementOptionsFromBackwardTransformOptions, refinementOptionsFromForwardTransformOptions } from '../shared/transform-functions.js';\nimport { refineLineString, refineRing, getSourceRefinementResolution } from '../shared/refinement-functions.js';\nimport { generalGcpToPointForForward, generalGcpToPointForBackward, invertGeneralGcp } from '../shared/conversion-functions.js';\n/**\n * Abstract class for Ground Control Point Transformers.\n *\n * This class contains all logic to transform geometries\n * made available trough the GeneralGcpTransform and GcpTransform classes.\n *\n * The extending GeneralGcpTransform class handles the general case where:\n * - We read in Ground Control Points using the GeneralGcp type, with `source` and `destination` fields.\n * - We use the terms 'forward' and 'backward' for the two transformations.\n * - Both source and destination space are exected to be 2D cartesian spaces with the same handedness (x- and y-axes have the same orientations).\n *\n * The extending GcpTransform class handles the typical Allmaps case where:\n * - We read in Ground Control Points using the Gcp type, with `resource` and `geo` fields.\n * - We use the terms 'toGeo' for the 'forward' transformation and 'toResource' for the 'backward' transformation.\n * - The `differentHandedness` setting is `true` by default, since we expect the resource coordinates to identify pixels on an image, with origin in the top left and the y-axis pointing down.\n * */\nexport class BaseGcpTransformer {\n    generalGcpsInternal;\n    sourcePointsInternal;\n    destinationPointsInternal;\n    type;\n    transformerOptions;\n    forwardTransformation;\n    backwardTransformation;\n    /**\n     * Create a BaseGcpTransformer\n     *\n     * @param generalGcps - An array of General Ground Control Points (GCPs)\n     * @param type - The transformation type\n     * @param partialGeneralGcpTransformerOptions - General GCP Transformer options\n     */ constructor(generalGcps, type = 'polynomial', partialGeneralGcpTransformerOptions) {\n        this.transformerOptions = mergeOptions(defaultGeneralGcpTransformerOptions, partialGeneralGcpTransformerOptions);\n        if (generalGcps.length === 0) {\n            throw new Error('No control points');\n        }\n        this.generalGcpsInternal = generalGcps;\n        this.sourcePointsInternal = this.generalGcpsInternal.map((generalGcp) => {\n            const source = this.transformerOptions.differentHandedness\n                ? flipY(generalGcp.source)\n                : generalGcp.source;\n            return this.transformerOptions.preForward(source);\n        });\n        this.destinationPointsInternal = this.generalGcpsInternal.map((generalGcp) => this.transformerOptions.preBackward(generalGcp.destination));\n        this.type = type;\n    }\n    /**\n     * Get the forward transformation. Create if it doesn't exist yet.\n     */\n    getForwardTransformationInternal() {\n        if (!this.forwardTransformation) {\n            this.forwardTransformation = this.createTransformation(this.sourcePointsInternal, this.destinationPointsInternal);\n        }\n        return this.forwardTransformation;\n    }\n    /**\n     * Get the backward transformation. Create if it doesn't exist yet.\n     */\n    getBackwardTransformationInternal() {\n        if (!this.backwardTransformation) {\n            this.backwardTransformation = this.createTransformation(this.destinationPointsInternal, this.sourcePointsInternal);\n        }\n        return this.backwardTransformation;\n    }\n    /**\n     * Create the (forward or backward) transformation.\n     *\n     * Results in forward transformation if source and destination points are entered as such.\n     * Results in backward if source points are entered for destination points and vice versa.\n     *\n     * Results in a transformation of this instance's transformation type.\n     *\n     * @param sourcePoints - source points\n     * @param destinationPoints - destination points\n     * @returns Transformation\n     */\n    createTransformation(sourcePoints, destinationPoints) {\n        if (this.type === 'straight') {\n            return new Straight(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'helmert') {\n            return new Helmert(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'polynomial1' || this.type === 'polynomial') {\n            return new Polynomial1(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'polynomial2') {\n            return new Polynomial2(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'polynomial3') {\n            return new Polynomial3(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'projective') {\n            return new Projective(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'thinPlateSpline') {\n            return new RBF(sourcePoints, destinationPoints, thinPlateKernel, euclideanNorm, 'thinPlateSpline');\n        }\n        else if (this.type === 'linear') {\n            return new RBF(sourcePoints, destinationPoints, linearKernel, euclideanNorm, 'linear');\n        }\n        else {\n            throw new Error(`Unsupported transformation type: ${this.type}`);\n        }\n    }\n    /**\n     * Transform a geometry forward from source space to destination space\n     *\n     * @param sourceGeometry - Geometry to transform\n     * @param partialGeneralGcpTransformOptions - General GCP Transform options\n     * @param generalGcpToP - Return type function\n     * @returns Forward transform of input geometry\n     */\n    transformForwardInternal(sourceGeometry, partialGeneralGcpTransformOptions, generalGcpToP = generalGcpToPointForForward) {\n        let transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        if (this.isNonWarping()) {\n            transformOptions = mergeOptions(transformOptions, { maxDepth: 0 });\n        }\n        if (!transformOptions.isMultiGeometry) {\n            if (isPoint(sourceGeometry)) {\n                return this.transformPointForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isLineString(sourceGeometry)) {\n                return this.transformLineStringForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isPolygon(sourceGeometry)) {\n                return this.transformPolygonForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n        else {\n            if (transformOptions) {\n                transformOptions = mergeOptions(transformOptions, {\n                    isMultiGeometry: false\n                }); // false for piecewise single geometries\n            }\n            if (isMultiPoint(sourceGeometry)) {\n                return sourceGeometry.map((sourcePoint) => this.transformPointForwardInternal(sourcePoint, transformOptions, generalGcpToP));\n            }\n            else if (isMultiLineString(sourceGeometry)) {\n                return sourceGeometry.map((sourceLineString) => this.transformLineStringForwardInternal(sourceLineString, transformOptions, generalGcpToP));\n            }\n            else if (isMultiPolygon(sourceGeometry)) {\n                return sourceGeometry.map((sourcePolygon) => this.transformPolygonForwardInternal(sourcePolygon, transformOptions, generalGcpToP));\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n    }\n    /**\n     * Transform a geometry backward from destination space to source space\n     *\n     * @param destinationGeometry - Geometry to transform\n     * @param partialGeneralGcpTransformOptions - General GCP Transform options\n     * @param generalGcpToP - Return type function\n     * @returns Backward transform of input geometry\n     */\n    transformBackwardInternal(destinationGeometry, partialGeneralGcpTransformOptions, generalGcpToP = generalGcpToPointForBackward) {\n        let transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        if (this.isNonWarping()) {\n            transformOptions = mergeOptions(transformOptions, { maxDepth: 0 });\n        }\n        if (!transformOptions.isMultiGeometry) {\n            if (isPoint(destinationGeometry)) {\n                return this.transformPointBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isLineString(destinationGeometry)) {\n                return this.transformLineStringBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isPolygon(destinationGeometry)) {\n                return this.transformPolygonBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n        else {\n            if (transformOptions) {\n                transformOptions = mergeOptions(transformOptions, {\n                    isMultiGeometry: false\n                }); // false for piecewise single geometries\n            }\n            if (isMultiPoint(destinationGeometry)) {\n                return destinationGeometry.map((destinationPoint) => this.transformPointBackwardInternal(destinationPoint, transformOptions, generalGcpToP));\n            }\n            else if (isMultiLineString(destinationGeometry)) {\n                return destinationGeometry.map((destinationLineString) => this.transformLineStringBackwardInternal(destinationLineString, transformOptions, generalGcpToP));\n            }\n            else if (isMultiPolygon(destinationGeometry)) {\n                return destinationGeometry.map((destinationPolygon) => this.transformPolygonBackwardInternal(destinationPolygon, transformOptions, generalGcpToP));\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n    }\n    // Handle specific geometries\n    transformPointForwardInternal(point, generalGcpTransformOptions, generalGcpToP = generalGcpToPointForForward) {\n        const forwardTransformation = this.getForwardTransformationInternal();\n        let source = this.transformerOptions.differentHandedness\n            ? flipY(point)\n            : point;\n        source = generalGcpTransformOptions.preForward(source);\n        let destination = forwardTransformation.evaluateFunction(source);\n        destination = generalGcpTransformOptions.postForward(destination);\n        let partialDerivativeX = undefined;\n        let partialDerivativeY = undefined;\n        let distortions = new Map();\n        if (generalGcpTransformOptions.distortionMeasures.length > 0) {\n            partialDerivativeX =\n                forwardTransformation.evaluatePartialDerivativeX(source);\n            partialDerivativeY =\n                forwardTransformation.evaluatePartialDerivativeY(source);\n            distortions = computeDistortionsFromPartialDerivatives(generalGcpTransformOptions.distortionMeasures, partialDerivativeX, partialDerivativeY, generalGcpTransformOptions.referenceScale);\n        }\n        return generalGcpToP({\n            source: point, // don't apply differentHandedness here, this is only internally.\n            destination,\n            partialDerivativeX,\n            partialDerivativeY,\n            distortions\n        });\n    }\n    transformPointBackwardInternal(point, generalGcpTransformOptions, generalGcpToP = generalGcpToPointForBackward) {\n        const backwardTransformation = this.getBackwardTransformationInternal();\n        const destination = generalGcpTransformOptions.preBackward(point);\n        let source = backwardTransformation.evaluateFunction(destination);\n        // apply differentHandedness here again, so it has been applied twice in total and is undone now.\n        source = generalGcpTransformOptions.postBackward(source);\n        source = this.transformerOptions.differentHandedness\n            ? flipY(source)\n            : source;\n        let partialDerivativeX = undefined;\n        let partialDerivativeY = undefined;\n        let distortions = new Map();\n        if (generalGcpTransformOptions.distortionMeasures.length > 0) {\n            partialDerivativeX =\n                backwardTransformation.evaluatePartialDerivativeX(destination);\n            partialDerivativeX = this.transformerOptions.differentHandedness\n                ? flipY(partialDerivativeX)\n                : partialDerivativeX;\n            partialDerivativeY =\n                backwardTransformation.evaluatePartialDerivativeY(destination);\n            partialDerivativeY = this.transformerOptions.differentHandedness\n                ? flipY(partialDerivativeY)\n                : partialDerivativeY;\n            distortions = computeDistortionsFromPartialDerivatives(generalGcpTransformOptions.distortionMeasures, partialDerivativeX, partialDerivativeY, generalGcpTransformOptions.referenceScale);\n        }\n        return generalGcpToP({\n            source,\n            destination,\n            partialDerivativeX,\n            partialDerivativeY,\n            distortions\n        });\n    }\n    transformLineStringForwardInternal(lineString, generalGcpTransformOptions, generalGcpToP) {\n        return refineLineString(lineString, (p) => this.transformPointForwardInternal(p, generalGcpTransformOptions), refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(generalGcp));\n    }\n    transformLineStringBackwardInternal(lineString, generalGcpTransformOptions, generalGcpToP) {\n        return refineLineString(lineString, (p) => this.transformPointBackwardInternal(p, generalGcpTransformOptions), refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(invertGeneralGcp(generalGcp)));\n    }\n    transformRingForwardInternal(ring, generalGcpTransformOptions, generalGcpToP) {\n        return refineRing(ring, (p) => this.transformPointForwardInternal(p, generalGcpTransformOptions), refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(generalGcp));\n    }\n    transformRingBackwardInternal(ring, generalGcpTransformOptions, generalGcpToP) {\n        return refineRing(ring, (p) => this.transformPointBackwardInternal(p, generalGcpTransformOptions), refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(invertGeneralGcp(generalGcp)));\n    }\n    transformPolygonForwardInternal(polygon, generalGcpTransformOptions, generalGcpToP) {\n        return polygon.map((ring) => {\n            return this.transformRingForwardInternal(ring, generalGcpTransformOptions, generalGcpToP);\n        });\n    }\n    transformPolygonBackwardInternal(polygon, generalGcpTransformOptions, generalGcpToP) {\n        return polygon.map((ring) => {\n            return this.transformRingBackwardInternal(ring, generalGcpTransformOptions, generalGcpToP);\n        });\n    }\n    isNonWarping() {\n        return (this.transformerOptions.postForward ===\n            this.transformerOptions.preBackward &&\n            this.transformerOptions.postBackward ===\n                this.transformerOptions.preForward &&\n            nonWarpingTransformationTypes.includes(this.type));\n    }\n    getForwardTransformationResolutionInternal(sourceBbox, partialGeneralGcpTransformOptions) {\n        const transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        sourceBbox = sourceBbox ?? computeBbox(this.sourcePointsInternal);\n        return getSourceRefinementResolution(sourceBbox, (p) => this.transformPointForwardInternal(p, transformOptions), refinementOptionsFromForwardTransformOptions(transformOptions));\n    }\n    getBackwardTransformationResolutionInternal(destinationBbox, partialGeneralGcpTransformOptions) {\n        const transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        destinationBbox =\n            destinationBbox ?? computeBbox(this.destinationPointsInternal);\n        return getSourceRefinementResolution(destinationBbox, (p) => this.transformPointBackwardInternal(p, transformOptions), refinementOptionsFromBackwardTransformOptions(transformOptions));\n    }\n}\n"],"names":["BaseGcpTransformer","generalGcps","type","partialGeneralGcpTransformerOptions","mergeOptions","defaultGeneralGcpTransformerOptions","generalGcp","source","flipY","sourcePoints","destinationPoints","Straight","Helmert","Polynomial1","Polynomial2","Polynomial3","Projective","RBF","thinPlateKernel","euclideanNorm","linearKernel","sourceGeometry","partialGeneralGcpTransformOptions","generalGcpToP","generalGcpToPointForForward","transformOptions","isMultiPoint","sourcePoint","isMultiLineString","sourceLineString","isMultiPolygon","sourcePolygon","isPoint","isLineString","isPolygon","destinationGeometry","generalGcpToPointForBackward","destinationPoint","destinationLineString","destinationPolygon","point","generalGcpTransformOptions","forwardTransformation","destination","partialDerivativeX","partialDerivativeY","distortions","computeDistortionsFromPartialDerivatives","backwardTransformation","lineString","refineLineString","p","refinementOptionsFromForwardTransformOptions","refinementOptionsFromBackwardTransformOptions","invertGeneralGcp","ring","refineRing","polygon","nonWarpingTransformationTypes","sourceBbox","computeBbox","getSourceRefinementResolution","destinationBbox"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es361.js

@@ -0,0 +1,45 @@
+function t(i) {
+  return { source: i.destination, destination: i.source };
+}
+function o(i) {
+  return i.destination;
+}
+function r(i) {
+  return i.source;
+}
+function e(i) {
+  return i.geo;
+}
+function n(i) {
+  return i.resource;
+}
+function a(i) {
+  return {
+    resource: i.source,
+    geo: i.destination,
+    partialDerivativeX: i.partialDerivativeX,
+    partialDerivativeY: i.partialDerivativeY,
+    distortions: i.distortions,
+    distortion: i.distortion
+  };
+}
+function s(i) {
+  return {
+    source: i.resource,
+    destination: i.geo,
+    partialDerivativeX: i.partialDerivativeX,
+    partialDerivativeY: i.partialDerivativeY,
+    distortions: i.distortions,
+    distortion: i.distortion
+  };
+}
+export {
+  s as gcpToGeneralGcp,
+  e as gcpToPointForToGeo,
+  n as gcpToPointForToResource,
+  a as generalGcpToGcp,
+  r as generalGcpToPointForBackward,
+  o as generalGcpToPointForForward,
+  t as invertGeneralGcp
+};
+//# sourceMappingURL=index.es361.js.map

package/dist/index.es361.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es361.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/conversion-functions.js"],"sourcesContent":["// Invert\nexport function invertGeneralGcp(generalGcp) {\n    return { source: generalGcp.destination, destination: generalGcp.source };\n}\nexport function invertGcp(gcp) {\n    return { resource: gcp.geo, geo: gcp.resource };\n}\n// Select\nexport function generalGcpToPointForForward(generalGcp) {\n    return generalGcp.destination;\n}\nexport function generalGcpToPointForBackward(generalGcp) {\n    return generalGcp.source;\n}\nexport function gcpToPointForToGeo(gcp) {\n    return gcp.geo;\n}\nexport function gcpToPointForToResource(gcp) {\n    return gcp.resource;\n}\n// GeneralGcp <> G\nexport function generalGcpToGcp(generalGcp) {\n    return {\n        resource: generalGcp.source,\n        geo: generalGcp.destination,\n        partialDerivativeX: generalGcp.partialDerivativeX,\n        partialDerivativeY: generalGcp.partialDerivativeY,\n        distortions: generalGcp.distortions,\n        distortion: generalGcp.distortion\n    };\n}\nexport function gcpToGeneralGcp(gcp) {\n    return {\n        source: gcp.resource,\n        destination: gcp.geo,\n        partialDerivativeX: gcp.partialDerivativeX,\n        partialDerivativeY: gcp.partialDerivativeY,\n        distortions: gcp.distortions,\n        distortion: gcp.distortion\n    };\n}\n// TransformationType\n// TODO: implement this as a separate, callable function in @allmaps/annotation?\nexport function transformationTypeToTypeAndOrder(transformationType) {\n    if (transformationType === 'polynomial' ||\n        transformationType === 'polynomial1') {\n        return {\n            type: 'polynomial',\n            options: {\n                order: 1\n            }\n        };\n    }\n    else if (transformationType === 'polynomial2') {\n        return {\n            type: 'polynomial',\n            options: {\n                order: 2\n            }\n        };\n    }\n    else if (transformationType === 'polynomial3') {\n        return {\n            type: 'polynomial',\n            options: {\n                order: 3\n            }\n        };\n    }\n    else {\n        return {\n            type: transformationType\n        };\n    }\n}\nexport function typeAndOrderToTransformationType(transformation) {\n    const type = transformation.type;\n    const order = transformation.options?.order;\n    let transformationType;\n    if (type == 'polynomial1' || type === 'polynomial') {\n        transformationType = 'polynomial1';\n    }\n    else if (type == 'polynomial2' || (type === 'polynomial' && order === 2)) {\n        transformationType = 'polynomial2';\n    }\n    else if (type == 'polynomial3' || (type === 'polynomial' && order === 3)) {\n        transformationType = 'polynomial3';\n    }\n    else if (type === 'thinPlateSpline') {\n        transformationType = type;\n    }\n    else if (type === 'linear') {\n        transformationType = type;\n    }\n    else if (type === 'helmert') {\n        transformationType = type;\n    }\n    else if (type === 'projective') {\n        transformationType = type;\n    }\n    else {\n        throw new Error('Unrecognised transformationType.');\n    }\n    return transformationType;\n}\n"],"names":["invertGeneralGcp","generalGcp","generalGcpToPointForForward","generalGcpToPointForBackward","gcpToPointForToGeo","gcp","gcpToPointForToResource","generalGcpToGcp","gcpToGeneralGcp"],"mappings":"AACO,SAASA,EAAiBC,GAAY;AACzC,SAAO,EAAE,QAAQA,EAAW,aAAa,aAAaA,EAAW,OAAA;AACrE;AAKO,SAASC,EAA4BD,GAAY;AACpD,SAAOA,EAAW;AACtB;AACO,SAASE,EAA6BF,GAAY;AACrD,SAAOA,EAAW;AACtB;AACO,SAASG,EAAmBC,GAAK;AACpC,SAAOA,EAAI;AACf;AACO,SAASC,EAAwBD,GAAK;AACzC,SAAOA,EAAI;AACf;AAEO,SAASE,EAAgBN,GAAY;AACxC,SAAO;AAAA,IACH,UAAUA,EAAW;AAAA,IACrB,KAAKA,EAAW;AAAA,IAChB,oBAAoBA,EAAW;AAAA,IAC/B,oBAAoBA,EAAW;AAAA,IAC/B,aAAaA,EAAW;AAAA,IACxB,YAAYA,EAAW;AAAA,EAAA;AAE/B;AACO,SAASO,EAAgBH,GAAK;AACjC,SAAO;AAAA,IACH,QAAQA,EAAI;AAAA,IACZ,aAAaA,EAAI;AAAA,IACjB,oBAAoBA,EAAI;AAAA,IACxB,oBAAoBA,EAAI;AAAA,IACxB,aAAaA,EAAI;AAAA,IACjB,YAAYA,EAAI;AAAA,EAAA;AAExB;","x_google_ignoreList":[0]}

package/dist/index.es362.js

@@ -0,0 +1,18 @@
+import { BaseLinearWeightsTransformation as o } from "./index.es363.js";
+class i extends o {
+  constructor(r, e, t, s) {
+    super(r, e, t, s);
+  }
+  getCoefsArrayMatrices() {
+    const r = this.getCoefsArrayMatrix();
+    return [r, r];
+  }
+  getSourcePointCoefsArrays(r) {
+    const e = this.getSourcePointCoefsArray(r);
+    return [e, e];
+  }
+}
+export {
+  i as BaseIndependentLinearWeightsTransformation
+};
+//# sourceMappingURL=index.es362.js.map

package/dist/index.es362.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es362.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseIndependentLinearWeightsTransformation.js"],"sourcesContent":["import { BaseLinearWeightsTransformation } from './BaseLinearWeightsTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights,\n * where the system of equations for x and y are independent and can hence be solved separately.\n */\nexport class BaseIndependentLinearWeightsTransformation extends BaseLinearWeightsTransformation {\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        super(sourcePoints, destinationPoints, type, pointCountMinimum);\n    }\n    getCoefsArrayMatrices() {\n        const coefsArrayMatrix = this.getCoefsArrayMatrix();\n        return [coefsArrayMatrix, coefsArrayMatrix];\n    }\n    getSourcePointCoefsArrays(sourcePoint) {\n        const sourcePointCoefsArray = this.getSourcePointCoefsArray(sourcePoint);\n        return [sourcePointCoefsArray, sourcePointCoefsArray];\n    }\n}\n"],"names":["BaseIndependentLinearWeightsTransformation","BaseLinearWeightsTransformation","sourcePoints","destinationPoints","type","pointCountMinimum","coefsArrayMatrix","sourcePoint","sourcePointCoefsArray"],"mappings":";AAKO,MAAMA,UAAmDC,EAAgC;AAAA,EAC5F,YAAYC,GAAcC,GAAmBC,GAAMC,GAAmB;AAClE,UAAMH,GAAcC,GAAmBC,GAAMC,CAAiB;AAAA,EAClE;AAAA,EACA,wBAAwB;AACpB,UAAMC,IAAmB,KAAK,oBAAA;AAC9B,WAAO,CAACA,GAAkBA,CAAgB;AAAA,EAC9C;AAAA,EACA,0BAA0BC,GAAa;AACnC,UAAMC,IAAwB,KAAK,yBAAyBD,CAAW;AACvE,WAAO,CAACC,GAAuBA,CAAqB;AAAA,EACxD;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es363.js

@@ -0,0 +1,11 @@
+import { BaseTransformation as n } from "./index.es364.js";
+class e extends n {
+  destinationPointsArrays;
+  constructor(s, t, r, i) {
+    super(s, t, r, i), this.destinationPointsArrays = this.getDestinationPointsArrays();
+  }
+}
+export {
+  e as BaseLinearWeightsTransformation
+};
+//# sourceMappingURL=index.es363.js.map

package/dist/index.es363.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es363.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseLinearWeightsTransformation.js"],"sourcesContent":["import { BaseTransformation } from './BaseTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights.\n *\n * In general, the system of equations for x and y are dependent on each other, and they are thus solved jointly.\n * For transformations where the system of equations for x and y are independent and can hence be solved separately, a dedicated class exists.\n */\nexport class BaseLinearWeightsTransformation extends BaseTransformation {\n    destinationPointsArrays;\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        super(sourcePoints, destinationPoints, type, pointCountMinimum);\n        this.destinationPointsArrays = this.getDestinationPointsArrays();\n    }\n}\n"],"names":["BaseLinearWeightsTransformation","BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum"],"mappings":";AAOO,MAAMA,UAAwCC,EAAmB;AAAA,EACpE;AAAA,EACA,YAAYC,GAAcC,GAAmBC,GAAMC,GAAmB;AAClE,UAAMH,GAAcC,GAAmBC,GAAMC,CAAiB,GAC9D,KAAK,0BAA0B,KAAK,2BAAA;AAAA,EACxC;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es364.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.es364.js.map

package/dist/index.es364.js.map

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

@@ -0,0 +1,50 @@
+import { arrayMatrixSize as i, newArrayMatrix as a, pasteArrayMatrix as n } from "./index.es333.js";
+import { BaseIndependentLinearWeightsTransformation as h } from "./index.es362.js";
+import { solveIndependentlyPseudoInverse as y } from "./index.es366.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.es365.js.map

package/dist/index.es365.js.map

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

@@ -0,0 +1,45 @@
+import r, { pseudoInverse as u, SingularValueDecomposition as l, inverse as m } from "./index.es375.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.es366.js.map

package/dist/index.es366.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es366.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]}